hasura/graphql-engine
1
0
Fork 0
mirror of https://github.com/hasura/graphql-engine.git synced 2024-10-26 10:20:54 +03:00
Code Issues Projects Releases Wiki Activity

Split metadata-resolve into own crate (#543)

Browse Source 
<!-- Thank you for submitting this PR! :) -->

## Description

Now that metadata resolve has a clear interface with the rest of the
engine, let's take it out into it's own crate. This will make it easier
to maintain a strong boundary between things.

To simplify imports etc, removed nested layers of modules, so now we
import `use metadata_resolve::Qualified` instead of `use
crate::metadata::resolved::Qualified`.

The changes in `engine` crate are all just updating imports.

Functional no-op.

V3_GIT_ORIGIN_REV_ID: fb94304f7ed8883287c18bd6870045dfd69e3fe3
This commit is contained in:
Daniel Harvey 2024-05-02 13:28:27 +01:00 committed by hasura-bot
parent 3f74f2e93d
commit 11240e2bff
82 changed files with 526 additions and 468 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
v3/Cargo.lock generated
View File

@ -957,7 +957,7 @@ dependencies = [
"indexmap 2.2.6",
"json_value_merge",
"lang-graphql",
"lazy_static",
"metadata-resolve",
"mockito",
"ndc-models",
"nonempty",
@ -1781,6 +1781,25 @@ dependencies = [
"autocfg",
]
[[package]]
name = "metadata-resolve"
version = "0.1.0"
dependencies = [
"derive_more",
"hasura-authn-core",
"indexmap 2.2.6",
"lang-graphql",
"lazy_static",
"ndc-models",
"nonempty",
"open-dds",
"reqwest",
"serde",
"serde_json",
"thiserror",
"url",
]
[[package]]
name = "metadata-schema-generator"
version = "0.1.0"

1
v3/Cargo.toml
View File

@ -10,6 +10,7 @@ members = [
"crates/custom-connector",
"crates/engine",
"crates/lang-graphql",
"crates/metadata-resolve",
"crates/metadata-schema-generator",
"crates/open-dds",
"crates/utils/*",

2
v3/crates/engine/Cargo.toml
View File

@ -30,6 +30,7 @@ lang-graphql = { path = "../lang-graphql" }
open-dds = { path = "../open-dds" }
opendds-derive = { path = "../utils/opendds-derive" }
tracing-util = { path = "../utils/tracing-util" }
metadata-resolve = {path = "../metadata-resolve" }
anyhow = "1"
async-recursion = "1.0.5"
@ -42,7 +43,6 @@ derive_more = "0.99.17"
futures-util = "0.3"
indexmap = { version = "2", features = ["serde"] }
json_value_merge = "2.0"
lazy_static = "1.4.0"
ndc-models = { git = "https://github.com/hasura/ndc-spec.git", tag = "v0.1.2" }
nonempty = "0.10"
reqwest = { version = "0.11", features = ["json", "multipart"] }

4
v3/crates/engine/src/build.rs
View File

@ -1,13 +1,13 @@
use crate::metadata;
use crate::schema;
use crate::schema::GDS;
use lang_graphql::schema as gql_schema;
use metadata_resolve;
use thiserror::Error;
#[derive(Error, Debug)]
pub enum BuildError {
#[error("invalid metadata: {0}")]
InvalidMetadata(#[from] metadata::resolved::Error),
InvalidMetadata(#[from] metadata_resolve::Error),
#[error("unable to build schema: {0}")]
UnableToBuildSchema(#[from] schema::Error),
#[error("unable to encode schema: {0}")]

6
v3/crates/engine/src/execute/explain.rs
View File

@ -4,12 +4,12 @@ use crate::execute::ndc::client as ndc_client;
use crate::execute::plan::{ApolloFederationSelect, NodeQueryPlan, ProcessResponseAs};
use crate::execute::remote_joins::types::{JoinId, JoinLocations, RemoteJoin};
use crate::execute::{error, plan};
use crate::metadata::resolved;
use crate::schema::GDS;
use async_recursion::async_recursion;
use hasura_authn_core::Session;
use lang_graphql as gql;
use lang_graphql::{http::RawRequest, schema::Schema};
use metadata_resolve;
use nonempty::NonEmpty;
use tracing_util::SpanVisibility;
pub mod types;
@ -160,7 +160,7 @@ async fn get_execution_steps<'s>(
process_response_as: &ProcessResponseAs<'s>,
join_locations: JoinLocations<(RemoteJoin<'s, '_>, JoinId)>,
ndc_request: types::NDCRequest,
data_connector: &resolved::DataConnectorLink,
data_connector: &metadata_resolve::DataConnectorLink,
) -> NonEmpty<Box<types::Step>> {
let mut sequence_steps = match process_response_as {
ProcessResponseAs::CommandResponse { .. } => {
@ -278,7 +278,7 @@ fn simplify_step(step: Box<types::Step>) -> Box<types::Step> {
async fn fetch_explain_from_data_connector(
http_context: &HttpContext,
ndc_request: &types::NDCRequest,
data_connector: &resolved::DataConnectorLink,
data_connector: &metadata_resolve::DataConnectorLink,
) -> types::NDCExplainResponse {
let tracer = tracing_util::global_tracer();
let response = tracer

6
v3/crates/engine/src/execute/ir/arguments.rs
View File

@ -9,14 +9,12 @@ use open_dds::types::{CustomTypeName, InbuiltType};
use crate::execute::ir::arguments;
use crate::execute::ir::error;
use crate::metadata::resolved::TypeMapping;
use crate::metadata::resolved::{
Qualified, QualifiedBaseType, QualifiedTypeName, QualifiedTypeReference,
};
use crate::schema::types::{
Annotation, ArgumentNameAndPath, ArgumentPresets, InputAnnotation, ModelInputAnnotation,
};
use crate::schema::GDS;
use metadata_resolve::TypeMapping;
use metadata_resolve::{Qualified, QualifiedBaseType, QualifiedTypeName, QualifiedTypeReference};
use super::permissions;

6
v3/crates/engine/src/execute/ir/commands.rs
View File

@ -20,13 +20,13 @@ use super::selection_set;
use crate::execute::ir::error;
use crate::execute::ir::permissions;
use crate::execute::model_tracking::{count_command, UsagesCounts};
use crate::metadata::resolved;
use crate::metadata::resolved::{Qualified, QualifiedTypeReference};
use crate::schema::types::ArgumentNameAndPath;
use crate::schema::types::ArgumentPresets;
use crate::schema::types::CommandSourceDetail;
use crate::schema::types::TypeKind;
use crate::schema::GDS;
use metadata_resolve;
use metadata_resolve::{Qualified, QualifiedTypeReference};
/// IR for the 'command' operations
#[derive(Serialize, Debug)]
@ -38,7 +38,7 @@ pub struct CommandInfo<'s> {
pub field_name: ast::Name,
/// The data connector backing this model.
pub data_connector: &'s resolved::DataConnectorLink,
pub data_connector: &'s metadata_resolve::DataConnectorLink,
/// Arguments for the NDC table
pub(crate) arguments: BTreeMap<String, json::Value>,

2
v3/crates/engine/src/execute/ir/error.rs
View File

@ -11,7 +11,7 @@ use tracing_util::{ErrorVisibility, TraceableError};
use transitive::Transitive;
use crate::execute::types::{Annotation, NamespaceAnnotation};
use crate::metadata::resolved::Qualified;
use metadata_resolve::Qualified;
#[derive(Error, Debug, Transitive)]
#[transitive(from(json::Error, InternalError))]

16
v3/crates/engine/src/execute/ir/model_selection.rs
View File

@ -13,15 +13,15 @@ use super::permissions;
use super::selection_set;
use crate::execute::ir::error;
use crate::execute::model_tracking::UsagesCounts;
use crate::metadata::resolved;
use crate::metadata::resolved::Qualified;
use crate::schema::GDS;
use metadata_resolve;
use metadata_resolve::Qualified;
/// IR fragment for any 'select' operation on a model
#[derive(Debug, Serialize)]
pub struct ModelSelection<'s> {
// The data connector backing this model.
pub data_connector: &'s resolved::DataConnectorLink,
pub data_connector: &'s metadata_resolve::DataConnectorLink,
// Source collection in the data connector for this model
pub(crate) collection: &'s String,
@ -50,10 +50,10 @@ pub struct ModelSelection<'s> {
pub(crate) fn model_selection_ir<'s>(
selection_set: &normalized_ast::SelectionSet<'s, GDS>,
data_type: &Qualified<CustomTypeName>,
model_source: &'s resolved::ModelSource,
model_source: &'s metadata_resolve::ModelSource,
arguments: BTreeMap<String, ndc_models::Argument>,
mut filter_clauses: ResolvedFilterExpression<'s>,
permissions_predicate: &'s resolved::FilterPermission,
permissions_predicate: &'s metadata_resolve::FilterPermission,
limit: Option<u32>,
offset: Option<u32>,
order_by: Option<ResolvedOrderBy<'s>>,
@ -61,8 +61,8 @@ pub(crate) fn model_selection_ir<'s>(
usage_counts: &mut UsagesCounts,
) -> Result<ModelSelection<'s>, error::Error> {
match permissions_predicate {
resolved::FilterPermission::AllowAll => {}
resolved::FilterPermission::Filter(predicate) => {
metadata_resolve::FilterPermission::AllowAll => {}
metadata_resolve::FilterPermission::Filter(predicate) => {
let permissions_predicate_relationship_paths = Vec::new();
let mut permissions_predicate_relationships = BTreeMap::new();
let processed_model_perdicate = permissions::process_model_predicate(
@ -87,7 +87,7 @@ pub(crate) fn model_selection_ir<'s>(
.type_mappings
.get(data_type)
.map(|type_mapping| {
let resolved::TypeMapping::Object { field_mappings, .. } = type_mapping;
let metadata_resolve::TypeMapping::Object { field_mappings, .. } = type_mapping;
field_mappings
})
.ok_or_else(|| error::InternalEngineError::InternalGeneric {

30
v3/crates/engine/src/execute/ir/permissions.rs
View File

@ -8,11 +8,11 @@ use open_dds::types::InbuiltType;
use crate::execute::ir::error;
use crate::execute::model_tracking::{count_model, UsagesCounts};
use crate::metadata::resolved;
use metadata_resolve;
use crate::metadata::resolved::{QualifiedBaseType, QualifiedTypeName, QualifiedTypeReference};
use crate::schema::types;
use crate::schema::GDS;
use metadata_resolve::{QualifiedBaseType, QualifiedTypeName, QualifiedTypeReference};
use super::relationship::LocalModelRelationshipInfo;
use super::selection_set::NDCRelationshipName;
@ -22,7 +22,7 @@ use super::selection_set::NDCRelationshipName;
/// is not found, then an error will be thrown.
pub(crate) fn get_select_filter_predicate<'s>(
field_call: &normalized_ast::FieldCall<'s, GDS>,
) -> Result<&'s resolved::FilterPermission, error::Error> {
) -> Result<&'s metadata_resolve::FilterPermission, error::Error> {
field_call
.info
.namespaced
@ -73,14 +73,14 @@ pub(crate) fn get_argument_presets(
}
pub(crate) fn process_model_predicate<'s>(
model_predicate: &'s resolved::ModelPredicate,
model_predicate: &'s metadata_resolve::ModelPredicate,
session_variables: &SessionVariables,
mut relationship_paths: Vec<NDCRelationshipName>,
relationships: &mut BTreeMap<NDCRelationshipName, LocalModelRelationshipInfo<'s>>,
usage_counts: &mut UsagesCounts,
) -> Result<ndc_models::Expression, error::Error> {
match model_predicate {
resolved::ModelPredicate::UnaryFieldComparison {
metadata_resolve::ModelPredicate::UnaryFieldComparison {
field: _,
ndc_column,
operator,
@ -89,7 +89,7 @@ pub(crate) fn process_model_predicate<'s>(
*operator,
&relationship_paths,
)?),
resolved::ModelPredicate::BinaryFieldComparison {
metadata_resolve::ModelPredicate::BinaryFieldComparison {
field: _,
ndc_column,
argument_type,
@ -103,7 +103,7 @@ pub(crate) fn process_model_predicate<'s>(
session_variables,
&relationship_paths,
)?),
resolved::ModelPredicate::Not(predicate) => {
metadata_resolve::ModelPredicate::Not(predicate) => {
let expr = process_model_predicate(
predicate,
session_variables,
@ -115,7 +115,7 @@ pub(crate) fn process_model_predicate<'s>(
expression: Box::new(expr),
})
}
resolved::ModelPredicate::And(predicates) => {
metadata_resolve::ModelPredicate::And(predicates) => {
let exprs = predicates
.iter()
.map(|p| {
@ -130,7 +130,7 @@ pub(crate) fn process_model_predicate<'s>(
.collect::<Result<Vec<_>, error::Error>>()?;
Ok(ndc_models::Expression::And { expressions: exprs })
}
resolved::ModelPredicate::Or(predicates) => {
metadata_resolve::ModelPredicate::Or(predicates) => {
let exprs = predicates
.iter()
.map(|p| {
@ -145,7 +145,7 @@ pub(crate) fn process_model_predicate<'s>(
.collect::<Result<Vec<_>, error::Error>>()?;
Ok(ndc_models::Expression::Or { expressions: exprs })
}
resolved::ModelPredicate::Relationship {
metadata_resolve::ModelPredicate::Relationship {
relationship_info,
predicate,
} => {
@ -187,7 +187,7 @@ fn make_permission_binary_boolean_expression(
ndc_column: String,
argument_type: &QualifiedTypeReference,
operator: &str,
value_expression: &resolved::ValueExpression,
value_expression: &metadata_resolve::ValueExpression,
session_variables: &SessionVariables,
relationship_paths: &Vec<NDCRelationshipName>,
) -> Result<ndc_models::Expression, error::Error> {
@ -222,13 +222,13 @@ fn make_permission_unary_boolean_expression(
}
pub(crate) fn make_value_from_value_expression(
val_expr: &resolved::ValueExpression,
val_expr: &metadata_resolve::ValueExpression,
value_type: &QualifiedTypeReference,
session_variables: &SessionVariables,
) -> Result<serde_json::Value, error::Error> {
match val_expr {
resolved::ValueExpression::Literal(val) => Ok(val.clone()),
resolved::ValueExpression::SessionVariable(session_var) => {
metadata_resolve::ValueExpression::Literal(val) => Ok(val.clone()),
metadata_resolve::ValueExpression::SessionVariable(session_var) => {
let value = session_variables.get(session_var).ok_or_else(|| {
error::InternalDeveloperError::MissingSessionVariable {
session_variable: session_var.clone(),
@ -237,7 +237,7 @@ pub(crate) fn make_value_from_value_expression(
typecast_session_variable(value, value_type)
}
resolved::ValueExpression::BooleanExpression(_model_predicate) => {
metadata_resolve::ValueExpression::BooleanExpression(_model_predicate) => {
Err(error::InternalDeveloperError::BooleanExpressionNotImplemented.into())
}
}

12
v3/crates/engine/src/execute/ir/query_root.rs
View File

@ -11,7 +11,6 @@ use std::collections::HashMap;
use super::commands;
use super::error;
use super::root_field;
use crate::metadata::resolved;
use crate::schema::types::ApolloFederationRootFields;
use crate::schema::types::CommandSourceDetail;
use crate::schema::types::EntityFieldTypeNameMapping;
@ -21,6 +20,7 @@ use crate::schema::types::{
Annotation, NodeFieldTypeNameMapping, OutputAnnotation, RootFieldAnnotation,
};
use crate::schema::{mk_typename, GDS};
use metadata_resolve;
pub mod apollo_federation;
pub mod node_field;
@ -168,13 +168,13 @@ fn generate_type_field_ir<'n, 's>(
#[allow(clippy::too_many_arguments)]
fn generate_model_rootfield_ir<'n, 's>(
type_name: &ast::TypeName,
source: &'s Option<resolved::ModelSource>,
data_type: &resolved::Qualified<CustomTypeName>,
source: &'s Option<metadata_resolve::ModelSource>,
data_type: &metadata_resolve::Qualified<CustomTypeName>,
kind: &RootFieldKind,
field: &'n gql::normalized_ast::Field<'s, GDS>,
field_call: &'s gql::normalized_ast::FieldCall<'s, GDS>,
session: &Session,
model_name: &'s resolved::Qualified<models::ModelName>,
model_name: &'s metadata_resolve::Qualified<models::ModelName>,
) -> Result<root_field::QueryRootField<'n, 's>, error::Error> {
let source =
source
@ -211,11 +211,11 @@ fn generate_model_rootfield_ir<'n, 's>(
}
fn generate_command_rootfield_ir<'n, 's>(
name: &'s resolved::Qualified<CommandName>,
name: &'s metadata_resolve::Qualified<CommandName>,
type_name: &ast::TypeName,
function_name: &'s Option<open_dds::commands::FunctionName>,
source: &'s Option<CommandSourceDetail>,
result_type: &'s resolved::QualifiedTypeReference,
result_type: &'s metadata_resolve::QualifiedTypeReference,
result_base_type_kind: &'s TypeKind,
field: &'n gql::normalized_ast::Field<'s, GDS>,
field_call: &'s gql::normalized_ast::FieldCall<'s, GDS>,

10
v3/crates/engine/src/execute/ir/query_root/apollo_federation.rs
View File

@ -10,12 +10,12 @@ use crate::execute::ir::error;
use crate::execute::ir::filter::ResolvedFilterExpression;
use crate::execute::ir::model_selection;
use crate::execute::model_tracking::UsagesCounts;
use crate::metadata::resolved;
use crate::metadata::resolved::mk_name;
use crate::metadata::resolved::Qualified;
use crate::schema::types::{EntityFieldTypeNameMapping, NamespaceAnnotation};
use crate::schema::GDS;
use crate::utils::HashMapWithJsonKey;
use metadata_resolve;
use metadata_resolve::mk_name;
use metadata_resolve::Qualified;
/// IR for the '_entities' operation for a model
#[derive(Serialize, Debug)]
@ -38,7 +38,7 @@ pub struct EntitySelect<'n, 's> {
fn get_entity_namespace_typename_mappings<'s>(
field_call: &normalized_ast::FieldCall<'s, GDS>,
) -> Result<
&'s HashMapWithJsonKey<Qualified<CustomTypeName>, resolved::FilterPermission>,
&'s HashMapWithJsonKey<Qualified<CustomTypeName>, metadata_resolve::FilterPermission>,
error::Error,
> {
field_call
@ -115,7 +115,7 @@ pub(crate) fn entities_ir<'n, 's>(
// Get the permissions for the typename
let typename_permissions: &'s HashMap<
Qualified<CustomTypeName>,
resolved::FilterPermission,
metadata_resolve::FilterPermission,
> = &get_entity_namespace_typename_mappings(field_call)?.0;
let typename_mapping = typename_mappings.get(&typename).ok_or(
error::InternalDeveloperError::TypenameMappingNotFound {

12
v3/crates/engine/src/execute/ir/query_root/node_field.rs
View File

@ -13,11 +13,11 @@ use crate::execute::ir::error;
use crate::execute::ir::filter::ResolvedFilterExpression;
use crate::execute::ir::model_selection;
use crate::execute::model_tracking::UsagesCounts;
use crate::metadata::resolved;
use crate::metadata::resolved::Qualified;
use crate::schema::types::{GlobalID, NamespaceAnnotation, NodeFieldTypeNameMapping};
use crate::schema::GDS;
use crate::utils::HashMapWithJsonKey;
use metadata_resolve;
use metadata_resolve::Qualified;
/// IR for the 'select_one' operation on a model
#[derive(Serialize, Debug)]
@ -42,7 +42,7 @@ pub struct NodeSelect<'n, 's> {
fn get_relay_node_namespace_typename_mappings<'s>(
field_call: &normalized_ast::FieldCall<'s, GDS>,
) -> Result<
&'s HashMapWithJsonKey<Qualified<CustomTypeName>, resolved::FilterPermission>,
&'s HashMapWithJsonKey<Qualified<CustomTypeName>, metadata_resolve::FilterPermission>,
error::Error,
> {
field_call
@ -89,8 +89,10 @@ pub(crate) fn relay_node_ir<'n, 's>(
decoding_error: e.to_string(),
})?;
let global_id: GlobalID = serde_json::from_slice(decoded_id_value.as_slice())?;
let typename_permissions: &'s HashMap<Qualified<CustomTypeName>, resolved::FilterPermission> =
&get_relay_node_namespace_typename_mappings(field_call)?.0;
let typename_permissions: &'s HashMap<
Qualified<CustomTypeName>,
metadata_resolve::FilterPermission,
> = &get_relay_node_namespace_typename_mappings(field_call)?.0;
let typename_mapping = typename_mappings.get(&global_id.typename).ok_or(
error::InternalDeveloperError::TypenameMappingNotFound {
type_name: global_id.typename.clone(),

6
v3/crates/engine/src/execute/ir/query_root/select_many.rs
View File

@ -19,10 +19,10 @@ use crate::execute::ir::model_selection;
use crate::execute::ir::order_by::build_ndc_order_by;
use crate::execute::ir::permissions;
use crate::execute::model_tracking::{count_model, UsagesCounts};
use crate::metadata::resolved;
use crate::metadata::resolved::Qualified;
use crate::schema::types::{self, Annotation, BooleanExpressionAnnotation, ModelInputAnnotation};
use crate::schema::GDS;
use metadata_resolve;
use metadata_resolve::Qualified;
/// IR for the 'select_many' operation on a model
#[derive(Debug, Serialize)]
@ -45,7 +45,7 @@ pub(crate) fn select_many_generate_ir<'n, 's>(
field: &'n normalized_ast::Field<'s, GDS>,
field_call: &'n normalized_ast::FieldCall<'s, GDS>,
data_type: &Qualified<open_dds::types::CustomTypeName>,
model_source: &'s resolved::ModelSource,
model_source: &'s metadata_resolve::ModelSource,
session_variables: &SessionVariables,
model_name: &'s Qualified<open_dds::models::ModelName>,
) -> Result<ModelSelectMany<'n, 's>, error::Error> {

6
v3/crates/engine/src/execute/ir/query_root/select_one.rs
View File

@ -18,8 +18,8 @@ use crate::execute::ir::filter::ResolvedFilterExpression;
use crate::execute::ir::model_selection;
use crate::execute::ir::permissions;
use crate::execute::model_tracking::{count_model, UsagesCounts};
use crate::metadata::resolved;
use crate::metadata::resolved::Qualified;
use metadata_resolve;
use metadata_resolve::Qualified;
use crate::schema::types::{self, Annotation, ModelInputAnnotation};
use crate::schema::GDS;
@ -45,7 +45,7 @@ pub(crate) fn select_one_generate_ir<'n, 's>(
field: &'n normalized_ast::Field<'s, GDS>,
field_call: &'s normalized_ast::FieldCall<'s, GDS>,
data_type: &Qualified<open_dds::types::CustomTypeName>,
model_source: &'s resolved::ModelSource,
model_source: &'s metadata_resolve::ModelSource,
session_variables: &SessionVariables,
model_name: &'s Qualified<open_dds::models::ModelName>,
) -> Result<ModelSelectOne<'n, 's>, error::Error> {

106
v3/crates/engine/src/execute/ir/relationship.rs
View File

@ -23,41 +23,41 @@ use super::{
};
use crate::execute::model_tracking::{count_model, UsagesCounts};
use crate::metadata::resolved::{serialize_qualified_btreemap, Qualified};
use crate::schema::types::output_type::relationship::ModelRelationshipAnnotation;
use crate::schema::{
types::{Annotation, BooleanExpressionAnnotation, InputAnnotation, ModelInputAnnotation},
GDS,
};
use crate::{
execute::{ir::error, model_tracking::count_command},
schema::types::output_type::relationship::{
CommandRelationshipAnnotation, CommandTargetSource,
},
};
use crate::{
metadata::resolved,
schema::{
types::{Annotation, BooleanExpressionAnnotation, InputAnnotation, ModelInputAnnotation},
GDS,
},
};
use metadata_resolve;
use metadata_resolve::{serialize_qualified_btreemap, Qualified};
#[derive(Debug, Serialize)]
pub(crate) struct LocalModelRelationshipInfo<'s> {
pub relationship_name: &'s RelationshipName,
pub relationship_type: &'s RelationshipType,
pub source_type: &'s Qualified<CustomTypeName>,
pub source_data_connector: &'s resolved::DataConnectorLink,
pub source_data_connector: &'s metadata_resolve::DataConnectorLink,
#[serde(serialize_with = "serialize_qualified_btreemap")]
pub source_type_mappings: &'s BTreeMap<Qualified<CustomTypeName>, resolved::TypeMapping>,
pub target_source: &'s resolved::ModelTargetSource,
pub source_type_mappings:
&'s BTreeMap<Qualified<CustomTypeName>, metadata_resolve::TypeMapping>,
pub target_source: &'s metadata_resolve::ModelTargetSource,
pub target_type: &'s Qualified<CustomTypeName>,
pub mappings: &'s Vec<resolved::RelationshipModelMapping>,
pub mappings: &'s Vec<metadata_resolve::RelationshipModelMapping>,
}
#[derive(Debug, Serialize)]
pub(crate) struct LocalCommandRelationshipInfo<'s> {
pub annotation: &'s CommandRelationshipAnnotation,
pub source_data_connector: &'s resolved::DataConnectorLink,
pub source_data_connector: &'s metadata_resolve::DataConnectorLink,
#[serde(serialize_with = "serialize_qualified_btreemap")]
pub source_type_mappings: &'s BTreeMap<Qualified<CustomTypeName>, resolved::TypeMapping>,
pub source_type_mappings:
&'s BTreeMap<Qualified<CustomTypeName>, metadata_resolve::TypeMapping>,
pub target_source: &'s CommandTargetSource,
}
@ -66,7 +66,7 @@ pub struct RemoteModelRelationshipInfo<'s> {
pub annotation: &'s ModelRelationshipAnnotation,
/// This contains processed information about the mappings.
/// `RelationshipMapping` only contains mapping of field names. This
/// contains mapping of field names and `resolved::FieldMapping`.
/// contains mapping of field names and `metadata_resolve::FieldMapping`.
/// Also see `build_remote_relationship`.
pub join_mapping: Vec<(SourceField, TargetField)>,
}
@ -77,14 +77,14 @@ pub(crate) struct RemoteCommandRelationshipInfo<'s> {
pub join_mapping: Vec<(SourceField, ArgumentName)>,
}
pub type SourceField = (FieldName, resolved::FieldMapping);
pub type TargetField = (FieldName, resolved::NdcColumnForComparison);
pub type SourceField = (FieldName, metadata_resolve::FieldMapping);
pub type TargetField = (FieldName, metadata_resolve::NdcColumnForComparison);
pub(crate) fn generate_model_relationship_ir<'s>(
field: &Field<'s, GDS>,
annotation: &'s ModelRelationshipAnnotation,
source_data_connector: &'s resolved::DataConnectorLink,
type_mappings: &'s BTreeMap<Qualified<CustomTypeName>, resolved::TypeMapping>,
source_data_connector: &'s metadata_resolve::DataConnectorLink,
type_mappings: &'s BTreeMap<Qualified<CustomTypeName>, metadata_resolve::TypeMapping>,
session_variables: &SessionVariables,
usage_counts: &mut UsagesCounts,
) -> Result<FieldSelection<'s>, error::Error> {
@ -161,12 +161,12 @@ pub(crate) fn generate_model_relationship_ir<'s>(
}
None => error::Error::from(normalized_ast::Error::NoTypenameFound),
})?;
match resolved::relationship_execution_category(
match metadata_resolve::relationship_execution_category(
source_data_connector,
&target_source.model.data_connector,
&target_source.capabilities,
) {
resolved::RelationshipExecutionCategory::Local => build_local_model_relationship(
metadata_resolve::RelationshipExecutionCategory::Local => build_local_model_relationship(
field,
field_call,
annotation,
@ -180,27 +180,29 @@ pub(crate) fn generate_model_relationship_ir<'s>(
session_variables,
usage_counts,
),
resolved::RelationshipExecutionCategory::RemoteForEach => build_remote_relationship(
field,
field_call,
annotation,
type_mappings,
target_source,
filter_clause,
limit,
offset,
order_by,
session_variables,
usage_counts,
),
metadata_resolve::RelationshipExecutionCategory::RemoteForEach => {
build_remote_relationship(
field,
field_call,
annotation,
type_mappings,
target_source,
filter_clause,
limit,
offset,
order_by,
session_variables,
usage_counts,
)
}
}
}
pub(crate) fn generate_command_relationship_ir<'s>(
field: &Field<'s, GDS>,
annotation: &'s CommandRelationshipAnnotation,
source_data_connector: &'s resolved::DataConnectorLink,
type_mappings: &'s BTreeMap<Qualified<CustomTypeName>, resolved::TypeMapping>,
source_data_connector: &'s metadata_resolve::DataConnectorLink,
type_mappings: &'s BTreeMap<Qualified<CustomTypeName>, metadata_resolve::TypeMapping>,
session_variables: &SessionVariables,
usage_counts: &mut UsagesCounts,
) -> Result<FieldSelection<'s>, error::Error> {
@ -221,12 +223,12 @@ pub(crate) fn generate_command_relationship_ir<'s>(
None => error::Error::from(normalized_ast::Error::NoTypenameFound),
})?;
match resolved::relationship_execution_category(
match metadata_resolve::relationship_execution_category(
source_data_connector,
&target_source.details.data_connector,
&target_source.capabilities,
) {
resolved::RelationshipExecutionCategory::Local => build_local_command_relationship(
metadata_resolve::RelationshipExecutionCategory::Local => build_local_command_relationship(
field,
field_call,
annotation,
@ -235,7 +237,7 @@ pub(crate) fn generate_command_relationship_ir<'s>(
target_source,
session_variables,
),
resolved::RelationshipExecutionCategory::RemoteForEach => {
metadata_resolve::RelationshipExecutionCategory::RemoteForEach => {
build_remote_command_relationship(
field,
field_call,
@ -253,9 +255,9 @@ pub(crate) fn build_local_model_relationship<'s>(
field: &normalized_ast::Field<'s, GDS>,
field_call: &normalized_ast::FieldCall<'s, GDS>,
annotation: &'s ModelRelationshipAnnotation,
data_connector: &'s resolved::DataConnectorLink,
type_mappings: &'s BTreeMap<Qualified<CustomTypeName>, resolved::TypeMapping>,
target_source: &'s resolved::ModelTargetSource,
data_connector: &'s metadata_resolve::DataConnectorLink,
type_mappings: &'s BTreeMap<Qualified<CustomTypeName>, metadata_resolve::TypeMapping>,
target_source: &'s metadata_resolve::ModelTargetSource,
filter_clause: ResolvedFilterExpression<'s>,
limit: Option<u32>,
offset: Option<u32>,
@ -299,8 +301,8 @@ pub(crate) fn build_local_command_relationship<'s>(
field: &normalized_ast::Field<'s, GDS>,
field_call: &normalized_ast::FieldCall<'s, GDS>,
annotation: &'s CommandRelationshipAnnotation,
data_connector: &'s resolved::DataConnectorLink,
type_mappings: &'s BTreeMap<Qualified<CustomTypeName>, resolved::TypeMapping>,
data_connector: &'s metadata_resolve::DataConnectorLink,
type_mappings: &'s BTreeMap<Qualified<CustomTypeName>, metadata_resolve::TypeMapping>,
target_source: &'s CommandTargetSource,
session_variables: &SessionVariables,
) -> Result<FieldSelection<'s>, error::Error> {
@ -341,8 +343,8 @@ pub(crate) fn build_remote_relationship<'n, 's>(
field: &'n normalized_ast::Field<'s, GDS>,
field_call: &'n normalized_ast::FieldCall<'s, GDS>,
annotation: &'s ModelRelationshipAnnotation,
type_mappings: &'s BTreeMap<Qualified<CustomTypeName>, resolved::TypeMapping>,
target_source: &'s resolved::ModelTargetSource,
type_mappings: &'s BTreeMap<Qualified<CustomTypeName>, metadata_resolve::TypeMapping>,
target_source: &'s metadata_resolve::ModelTargetSource,
filter_clause: ResolvedFilterExpression<'s>,
limit: Option<u32>,
offset: Option<u32>,
@ -351,7 +353,7 @@ pub(crate) fn build_remote_relationship<'n, 's>(
usage_counts: &mut UsagesCounts,
) -> Result<FieldSelection<'s>, error::Error> {
let mut join_mapping: Vec<(SourceField, TargetField)> = vec![];
for resolved::RelationshipModelMapping {
for metadata_resolve::RelationshipModelMapping {
source_field: source_field_path,
target_field: target_field_path,
target_ndc_column,
@ -426,12 +428,12 @@ pub(crate) fn build_remote_command_relationship<'n, 's>(
field: &'n normalized_ast::Field<'s, GDS>,
field_call: &'n normalized_ast::FieldCall<'s, GDS>,
annotation: &'s CommandRelationshipAnnotation,
type_mappings: &'s BTreeMap<Qualified<CustomTypeName>, resolved::TypeMapping>,
type_mappings: &'s BTreeMap<Qualified<CustomTypeName>, metadata_resolve::TypeMapping>,
target_source: &'s CommandTargetSource,
session_variables: &SessionVariables,
) -> Result<FieldSelection<'s>, error::Error> {
let mut join_mapping: Vec<(SourceField, ArgumentName)> = vec![];
for resolved::RelationshipCommandMapping {
for metadata_resolve::RelationshipCommandMapping {
source_field: source_field_path,
argument_name: target_argument_name,
} in annotation.mappings.iter()
@ -476,11 +478,11 @@ pub(crate) fn build_remote_command_relationship<'n, 's>(
}
pub(crate) fn get_field_mapping_of_field_name(
type_mappings: &BTreeMap<Qualified<CustomTypeName>, resolved::TypeMapping>,
type_mappings: &BTreeMap<Qualified<CustomTypeName>, metadata_resolve::TypeMapping>,
type_name: &Qualified<CustomTypeName>,
relationship_name: &RelationshipName,
field_name: &FieldName,
) -> Result<resolved::FieldMapping, error::Error> {
) -> Result<metadata_resolve::FieldMapping, error::Error> {
let type_mapping = type_mappings.get(type_name).ok_or_else(|| {
error::InternalDeveloperError::TypeMappingNotFoundForRelationship {
type_name: type_name.clone(),
@ -488,7 +490,7 @@ pub(crate) fn get_field_mapping_of_field_name(
}
})?;
match type_mapping {
resolved::TypeMapping::Object { field_mappings, .. } => Ok(field_mappings
metadata_resolve::TypeMapping::Object { field_mappings, .. } => Ok(field_mappings
.get(field_name)
.ok_or_else(
|| error::InternalDeveloperError::FieldMappingNotFoundForRelationship {

73
v3/crates/engine/src/execute/ir/selection_set.rs
View File

@ -17,12 +17,12 @@ use super::relationship::{
use crate::execute::global_id;
use crate::execute::ir::error;
use crate::execute::model_tracking::UsagesCounts;
use crate::metadata::resolved;
use crate::schema::types::TypeKind;
use crate::schema::{
types::{Annotation, OutputAnnotation, RootFieldAnnotation},
GDS,
};
use metadata_resolve;
#[derive(Debug, Serialize)]
pub(crate) enum NestedSelection<'s> {
@ -83,7 +83,7 @@ pub struct NDCRelationshipName(pub(crate) String);
impl NDCRelationshipName {
pub fn new(
source_type: &resolved::Qualified<CustomTypeName>,
source_type: &metadata_resolve::Qualified<CustomTypeName>,
relationship_name: &RelationshipName,
) -> Result<Self, error::Error> {
let name = serde_json::to_string(&(source_type, relationship_name))?;
@ -103,7 +103,7 @@ pub(crate) struct ResultSelectionSet<'s> {
impl<'s> ResultSelectionSet<'s> {
/// Takes a 'FieldMapping' and returns the alias, if the field is found in
/// existing fields
pub(crate) fn contains(&self, other_field: &resolved::FieldMapping) -> Option<String> {
pub(crate) fn contains(&self, other_field: &metadata_resolve::FieldMapping) -> Option<String> {
self.fields.iter().find_map(|(alias, field)| match field {
FieldSelection::Column { column, .. } => {
if *column == other_field.column {
@ -119,7 +119,7 @@ impl<'s> ResultSelectionSet<'s> {
fn build_global_id_fields(
global_id_fields: &Vec<FieldName>,
field_mappings: &BTreeMap<FieldName, resolved::FieldMapping>,
field_mappings: &BTreeMap<FieldName, metadata_resolve::FieldMapping>,
field_alias: &Alias,
fields: &mut IndexMap<String, FieldSelection>,
) -> Result<(), error::Error> {
@ -147,16 +147,19 @@ fn build_global_id_fields(
}
pub(crate) fn generate_nested_selection<'s>(
qualified_type_reference: &resolved::QualifiedTypeReference,
qualified_type_reference: &metadata_resolve::QualifiedTypeReference,
field_base_type_kind: TypeKind,
field: &normalized_ast::Field<'s, GDS>,
data_connector: &'s resolved::DataConnectorLink,
type_mappings: &'s BTreeMap<resolved::Qualified<CustomTypeName>, resolved::TypeMapping>,
data_connector: &'s metadata_resolve::DataConnectorLink,
type_mappings: &'s BTreeMap<
metadata_resolve::Qualified<CustomTypeName>,
metadata_resolve::TypeMapping,
>,
session_variables: &SessionVariables,
usage_counts: &mut UsagesCounts,
) -> Result<Option<NestedSelection<'s>>, error::Error> {
match &qualified_type_reference.underlying_type {
resolved::QualifiedBaseType::List(element_type) => {
metadata_resolve::QualifiedBaseType::List(element_type) => {
let array_selection = generate_nested_selection(
element_type,
field_base_type_kind,
@ -168,28 +171,33 @@ pub(crate) fn generate_nested_selection<'s>(
)?;
Ok(array_selection.map(|a| NestedSelection::Array(Box::new(a))))
}
resolved::QualifiedBaseType::Named(qualified_type_name) => {
metadata_resolve::QualifiedBaseType::Named(qualified_type_name) => {
match qualified_type_name {
resolved::QualifiedTypeName::Inbuilt(_) => Ok(None), // Inbuilt types are all scalars so there should be no subselections.
resolved::QualifiedTypeName::Custom(data_type) => match field_base_type_kind {
TypeKind::Scalar => Ok(None),
TypeKind::Object => {
let resolved::TypeMapping::Object { field_mappings, .. } = type_mappings
.get(data_type)
.ok_or(error::InternalEngineError::InternalGeneric {
description: format!("no type mapping found for type {data_type}"),
})?;
let nested_selection = generate_selection_set_ir(
&field.selection_set,
data_connector,
type_mappings,
field_mappings,
session_variables,
usage_counts,
)?;
Ok(Some(NestedSelection::Object(nested_selection)))
metadata_resolve::QualifiedTypeName::Inbuilt(_) => Ok(None), // Inbuilt types are all scalars so there should be no subselections.
metadata_resolve::QualifiedTypeName::Custom(data_type) => {
match field_base_type_kind {
TypeKind::Scalar => Ok(None),
TypeKind::Object => {
let metadata_resolve::TypeMapping::Object { field_mappings, .. } =
type_mappings.get(data_type).ok_or(
error::InternalEngineError::InternalGeneric {
description: format!(
"no type mapping found for type {data_type}"
),
},
)?;
let nested_selection = generate_selection_set_ir(
&field.selection_set,
data_connector,
type_mappings,
field_mappings,
session_variables,
usage_counts,
)?;
Ok(Some(NestedSelection::Object(nested_selection)))
}
}
},
}
}
}
}
@ -201,9 +209,12 @@ pub(crate) fn generate_nested_selection<'s>(
/// sources depending on the model being queried.
pub(crate) fn generate_selection_set_ir<'s>(
selection_set: &normalized_ast::SelectionSet<'s, GDS>,
data_connector: &'s resolved::DataConnectorLink,
type_mappings: &'s BTreeMap<resolved::Qualified<CustomTypeName>, resolved::TypeMapping>,
field_mappings: &BTreeMap<FieldName, resolved::FieldMapping>,
data_connector: &'s metadata_resolve::DataConnectorLink,
type_mappings: &'s BTreeMap<
metadata_resolve::Qualified<CustomTypeName>,
metadata_resolve::TypeMapping,
>,
field_mappings: &BTreeMap<FieldName, metadata_resolve::FieldMapping>,
session_variables: &SessionVariables,
usage_counts: &mut UsagesCounts,
) -> Result<ResultSelectionSet<'s>, error::Error> {

13
v3/crates/engine/src/execute/model_tracking.rs
View File

@ -1,9 +1,9 @@
//! Track the models that were used in query.
use super::ir::root_field::{self, RootField};
use crate::metadata::resolved::Qualified;
use indexmap::IndexMap;
use lang_graphql::ast::common::Alias;
use metadata_resolve::Qualified;
use open_dds::{commands::CommandName, models::ModelName};
use serde::{Deserialize, Serialize};
@ -171,14 +171,11 @@ pub fn count_command(command: &Qualified<CommandName>, all_usage_counts: &mut Us
#[cfg(test)]
mod tests {
use open_dds::{commands::CommandName, identifier, models::ModelName};
use crate::{
execute::model_tracking::{
count_command, count_model, extend_usage_count, CommandCount, ModelCount, UsagesCounts,
},
metadata::resolved::Qualified,
use crate::execute::model_tracking::{
count_command, count_model, extend_usage_count, CommandCount, ModelCount, UsagesCounts,
};
use metadata_resolve::Qualified;
use open_dds::{commands::CommandName, identifier, models::ModelName};
#[test]
fn test_extend_usage_count() {

10
v3/crates/engine/src/execute/ndc.rs
View File

@ -13,8 +13,8 @@ use super::error;
use super::plan::ProcessResponseAs;
use super::process_response::process_command_mutation_response;
use super::{HttpContext, ProjectId};
use crate::metadata::resolved;
use crate::schema::GDS;
use metadata_resolve;
pub mod client;
@ -24,7 +24,7 @@ pub const FUNCTION_IR_VALUE_COLUMN_NAME: &str = "__value";
pub async fn execute_ndc_query<'n, 's>(
http_context: &HttpContext,
query: &ndc_models::QueryRequest,
data_connector: &resolved::DataConnectorLink,
data_connector: &metadata_resolve::DataConnectorLink,
execution_span_attribute: &'static str,
field_span_attribute: String,
project_id: Option<&ProjectId>,
@ -63,7 +63,7 @@ pub async fn execute_ndc_query<'n, 's>(
pub(crate) async fn fetch_from_data_connector<'s>(
http_context: &HttpContext,
query_request: &ndc_models::QueryRequest,
data_connector: &resolved::DataConnectorLink,
data_connector: &metadata_resolve::DataConnectorLink,
project_id: Option<&ProjectId>,
) -> Result<ndc_models::QueryResponse, client::Error> {
let tracer = tracing_util::global_tracer();
@ -113,7 +113,7 @@ pub fn append_project_id_to_headers(
pub(crate) async fn execute_ndc_mutation<'n, 's, 'ir>(
http_context: &HttpContext,
query: &ndc_models::MutationRequest,
data_connector: &resolved::DataConnectorLink,
data_connector: &metadata_resolve::DataConnectorLink,
selection_set: &'n normalized_ast::SelectionSet<'s, GDS>,
execution_span_attribute: String,
field_span_attribute: String,
@ -190,7 +190,7 @@ pub(crate) async fn execute_ndc_mutation<'n, 's, 'ir>(
pub(crate) async fn fetch_from_data_connector_mutation<'s>(
http_context: &HttpContext,
query_request: &ndc_models::MutationRequest,
data_connector: &resolved::DataConnectorLink,
data_connector: &metadata_resolve::DataConnectorLink,
project_id: Option<&ProjectId>,
) -> Result<ndc_models::MutationResponse, client::Error> {
let tracer = tracing_util::global_tracer();

10
v3/crates/engine/src/execute/plan.rs
View File

@ -23,8 +23,8 @@ use super::remote_joins::types::{
};
use super::{HttpContext, ProjectId};
use crate::execute::error::FieldError;
use crate::metadata::resolved;
use crate::schema::GDS;
use metadata_resolve;
pub type QueryPlan<'n, 's, 'ir> = IndexMap<ast::Alias, NodeQueryPlan<'n, 's, 'ir>>;
@ -36,7 +36,7 @@ pub type QueryPlan<'n, 's, 'ir> = IndexMap<ast::Alias, NodeQueryPlan<'n, 's, 'ir
/// Otherwise, we can just send them one-by-one (though still sequentially).
pub struct MutationPlan<'n, 's, 'ir> {
pub nodes: IndexMap<
resolved::DataConnectorLink,
metadata_resolve::DataConnectorLink,
IndexMap<ast::Alias, NDCMutationExecution<'n, 's, 'ir>>,
>,
pub type_names: IndexMap<ast::Alias, ast::TypeName>,
@ -101,7 +101,7 @@ pub enum ApolloFederationSelect<'n, 's, 'ir> {
pub struct NDCMutationExecution<'n, 's, 'ir> {
pub query: ndc_models::MutationRequest,
pub join_locations: JoinLocations<(RemoteJoin<'s, 'ir>, JoinId)>,
pub data_connector: &'s resolved::DataConnectorLink,
pub data_connector: &'s metadata_resolve::DataConnectorLink,
pub execution_span_attribute: String,
pub field_span_attribute: String,
pub process_response_as: ProcessResponseAs<'ir>,
@ -117,7 +117,7 @@ pub struct ExecutionTree<'s, 'ir> {
#[derive(Debug)]
pub struct ExecutionNode<'s> {
pub query: ndc_models::QueryRequest,
pub data_connector: &'s resolved::DataConnectorLink,
pub data_connector: &'s metadata_resolve::DataConnectorLink,
}
#[derive(Clone, Copy, Debug, PartialEq)]
@ -129,7 +129,7 @@ pub enum ProcessResponseAs<'ir> {
is_nullable: bool,
},
CommandResponse {
command_name: &'ir resolved::Qualified<open_dds::commands::CommandName>,
command_name: &'ir metadata_resolve::Qualified<open_dds::commands::CommandName>,
type_container: &'ir ast::TypeContainer<ast::TypeName>,
},
}

14
v3/crates/engine/src/execute/plan/relationships.rs
View File

@ -11,7 +11,7 @@ use crate::execute::ir::relationship::{
self, LocalCommandRelationshipInfo, LocalModelRelationshipInfo,
};
use crate::execute::ir::selection_set::FieldSelection;
use crate::metadata::resolved;
use metadata_resolve;
/// collect relationships recursively from IR components containing relationships,
/// and create NDC relationship definitions which will be added to the `relationships`
@ -90,19 +90,19 @@ pub(crate) fn process_model_relationship_definition(
} = relationship_info;
let mut column_mapping = BTreeMap::new();
for resolved::RelationshipModelMapping {
for metadata_resolve::RelationshipModelMapping {
source_field: source_field_path,
target_field: _,
target_ndc_column,
} in mappings.iter()
{
if !matches!(
resolved::relationship_execution_category(
metadata_resolve::relationship_execution_category(
source_data_connector,
&target_source.model.data_connector,
&target_source.capabilities
),
resolved::RelationshipExecutionCategory::Local
metadata_resolve::RelationshipExecutionCategory::Local
) {
Err(error::InternalError::RemoteRelationshipsAreNotSupported)?
} else {
@ -160,18 +160,18 @@ pub(crate) fn process_command_relationship_definition(
} = relationship_info;
let mut arguments = BTreeMap::new();
for resolved::RelationshipCommandMapping {
for metadata_resolve::RelationshipCommandMapping {
source_field: source_field_path,
argument_name: target_argument,
} in annotation.mappings.iter()
{
if !matches!(
resolved::relationship_execution_category(
metadata_resolve::relationship_execution_category(
source_data_connector,
&target_source.details.data_connector,
&target_source.capabilities
),
resolved::RelationshipExecutionCategory::Local
metadata_resolve::RelationshipExecutionCategory::Local
) {
Err(error::InternalError::RemoteRelationshipsAreNotSupported)?
} else {

2
v3/crates/engine/src/execute/plan/selection_set.rs
View File

@ -12,7 +12,7 @@ use crate::execute::remote_joins::types::{
JoinLocations, JoinNode, LocationKind, MonotonicCounter, RemoteJoinType, TargetField,
};
use crate::execute::remote_joins::types::{Location, RemoteJoin};
use crate::metadata::resolved::FieldMapping;
use metadata_resolve::FieldMapping;
pub(crate) fn process_nested_selection<'s, 'ir>(
nested_selection: &'ir NestedSelection<'s>,

2
v3/crates/engine/src/execute/process_response.rs
View File

@ -16,11 +16,11 @@ use super::global_id::{global_id_col_format, GLOBAL_ID_VERSION};
use super::ndc::FUNCTION_IR_VALUE_COLUMN_NAME;
use super::plan::ProcessResponseAs;
use crate::execute::error;
use crate::metadata::resolved::Qualified;
use crate::schema::{
types::{Annotation, GlobalID, OutputAnnotation},
GDS,
};
use metadata_resolve::Qualified;
trait KeyValueResponse {
fn remove(&mut self, key: &str) -> Option<json::Value>;

6
v3/crates/engine/src/execute/remote_joins/types.rs
View File

@ -8,8 +8,8 @@ use open_dds::types::FieldName;
use std::collections::{BTreeMap, HashMap};
use crate::execute::plan::ProcessResponseAs;
use crate::metadata::resolved;
use crate::utils::json_ext::ValueExt;
use metadata_resolve;
/// This tree structure captures all the locations (in the selection set IR) where
/// remote joins are found.
@ -117,7 +117,7 @@ pub struct Location<T> {
#[derive(Debug, Clone, PartialEq)]
pub struct RemoteJoin<'s, 'ir> {
/// target data connector to execute query on
pub target_data_connector: &'s resolved::DataConnectorLink,
pub target_data_connector: &'s metadata_resolve::DataConnectorLink,
/// NDC IR to execute on a data connector
pub target_ndc_ir: ndc_models::QueryRequest,
/// Mapping of the fields in source to fields in target.
@ -141,7 +141,7 @@ pub type SourceFieldAlias = String;
#[derive(Debug, Clone, PartialEq)]
pub enum TargetField {
ModelField((FieldName, resolved::NdcColumnForComparison)),
ModelField((FieldName, metadata_resolve::NdcColumnForComparison)),
CommandField(ArgumentName),
}

1
v3/crates/engine/src/lib.rs
View File

@ -1,7 +1,6 @@
pub mod authentication;
pub mod build;
pub mod execute;
pub mod metadata;
pub mod schema;
pub mod utils;

1
v3/crates/engine/src/metadata.rs
View File

@ -1 +0,0 @@
pub mod resolved;

5
v3/crates/engine/src/schema.rs
View File

@ -12,10 +12,7 @@ use serde::{Deserialize, Serialize};
use std::str::FromStr;
use thiserror::Error;
use crate::metadata::{
resolved::resolve, resolved::Error as ResolveMetadataError, resolved::Metadata,
resolved::Qualified,
};
use metadata_resolve::{resolve, Error as ResolveMetadataError, Metadata, Qualified};
use self::types::{PossibleApolloFederationTypes, RootFieldAnnotation};

23
v3/crates/engine/src/schema/boolean_expression.rs
View File

@ -7,9 +7,9 @@ use std::collections::{BTreeMap, HashMap};
use super::types::output_type::get_object_type_representation;
use super::types::output_type::relationship::FilterRelationshipAnnotation;
use super::types::{BooleanExpressionAnnotation, InputAnnotation, TypeId};
use crate::metadata::resolved;
use crate::metadata::resolved::mk_name;
use crate::metadata::resolved::Qualified;
use metadata_resolve;
use metadata_resolve::mk_name;
use metadata_resolve::Qualified;
use crate::schema::permissions;
use crate::schema::types;
@ -141,7 +141,7 @@ pub fn build_boolean_expression_input_schema(
// relationship fields
// TODO(naveen): Add support for command relationships
for (rel_name, relationship) in object_type_representation.relationships.iter() {
if let resolved::RelationshipTarget::Model {
if let metadata_resolve::RelationshipTarget::Model {
model_name,
relationship_type,
target_typename,
@ -160,14 +160,15 @@ pub fn build_boolean_expression_input_schema(
// Build relationship field in filter expression only when
// the target_model is backed by a source
if let Some(target_source) = &target_model.model.source {
let target_model_source = resolved::ModelTargetSource::from_model_source(
target_source,
relationship,
)?;
let target_model_source =
metadata_resolve::ModelTargetSource::from_model_source(
target_source,
relationship,
)?;
// filter expression with relationships is currently only supported for local relationships
if let resolved::RelationshipExecutionCategory::Local =
resolved::relationship_execution_category(
if let metadata_resolve::RelationshipExecutionCategory::Local =
metadata_resolve::relationship_execution_category(
&boolean_expression_type.data_connector_link,
&target_source.data_connector,
&target_model_source.capabilities,
@ -257,7 +258,7 @@ pub fn build_boolean_expression_input_schema(
fn get_scalar_comparison_input_type(
builder: &mut gql_schema::Builder<GDS>,
comparison_expression: &resolved::ComparisonExpressionInfo,
comparison_expression: &metadata_resolve::ComparisonExpressionInfo,
) -> Result<gql_schema::RegisteredTypeName, Error> {
let graphql_type_name = comparison_expression.type_name.clone();
let mut operators = Vec::new();

12
v3/crates/engine/src/schema/commands.rs
View File

@ -2,7 +2,6 @@
//!
//! A 'command' executes a function/procedure and returns back the result of the execution.
use crate::metadata::resolved;
use crate::schema::permissions;
use crate::schema::types::{self, output_type::get_output_type, Annotation};
use crate::schema::GDS;
@ -10,6 +9,7 @@ use lang_graphql::ast::common as ast;
use lang_graphql::schema as gql_schema;
use lang_graphql::schema::InputField;
use lang_graphql::schema::Namespaced;
use metadata_resolve;
use ndc_models;
use open_dds::arguments::ArgumentName;
use open_dds::commands::DataConnectorCommand;
@ -31,9 +31,9 @@ pub enum Response {
pub(crate) fn generate_command_argument(
gds: &GDS,
builder: &mut gql_schema::Builder<GDS>,
command: &resolved::CommandWithPermissions,
command: &metadata_resolve::CommandWithPermissions,
argument_name: &ArgumentName,
argument_type: &crate::schema::commands::resolved::ArgumentInfo,
argument_type: &crate::schema::commands::metadata_resolve::ArgumentInfo,
) -> Result<(ast::Name, Namespaced<GDS, InputField<GDS>>), crate::schema::Error> {
let field_name = ast::Name::new(argument_name.0.as_str())?;
let input_type = types::input_type::get_input_type(gds, builder, &argument_type.argument_type)?;
@ -75,7 +75,7 @@ pub(crate) fn generate_command_argument(
pub(crate) fn command_field(
gds: &GDS,
builder: &mut gql_schema::Builder<GDS>,
command: &resolved::CommandWithPermissions,
command: &metadata_resolve::CommandWithPermissions,
command_field_name: ast::Name,
command_annotation: Annotation,
deprecation_status: gql_schema::DeprecationStatus,
@ -112,7 +112,7 @@ pub(crate) fn command_field(
pub(crate) fn function_command_field(
gds: &GDS,
builder: &mut gql_schema::Builder<GDS>,
command: &resolved::CommandWithPermissions,
command: &metadata_resolve::CommandWithPermissions,
command_field_name: ast::Name,
deprecation_status: gql_schema::DeprecationStatus,
) -> Result<
@ -165,7 +165,7 @@ pub(crate) fn function_command_field(
pub(crate) fn procedure_command_field(
gds: &GDS,
builder: &mut gql_schema::Builder<GDS>,
command: &resolved::CommandWithPermissions,
command: &metadata_resolve::CommandWithPermissions,
command_field_name: ast::Name,
deprecation_status: gql_schema::DeprecationStatus,
) -> Result<

8
v3/crates/engine/src/schema/model_arguments.rs
View File

@ -1,20 +1,20 @@
use lang_graphql::ast::common as ast;
use crate::metadata::resolved;
use crate::schema::GDS;
use lang_graphql::schema as gql_schema;
use metadata_resolve;
use open_dds::models::ModelName;
use std::collections::{BTreeMap, HashMap};
use super::types::input_type::get_input_type;
use super::types::{Annotation, InputAnnotation, ModelInputAnnotation, TypeId};
use crate::metadata::resolved::Qualified;
use metadata_resolve::Qualified;
/// Creates the `args` input object within which the model
/// arguments fields will live.
pub fn get_model_arguments_input_field(
builder: &mut gql_schema::Builder<GDS>,
model: &resolved::ModelWithPermissions,
model: &metadata_resolve::ModelWithPermissions,
) -> Result<gql_schema::InputField<GDS>, crate::schema::Error> {
model
.model
@ -50,7 +50,7 @@ pub fn get_model_arguments_input_field(
pub fn build_model_argument_fields(
gds: &GDS,
builder: &mut gql_schema::Builder<GDS>,
model: &resolved::ModelWithPermissions,
model: &metadata_resolve::ModelWithPermissions,
) -> Result<
BTreeMap<ast::Name, gql_schema::Namespaced<GDS, gql_schema::InputField<GDS>>>,
crate::schema::Error,

6
v3/crates/engine/src/schema/model_filter.rs
View File

@ -4,9 +4,9 @@ use open_dds::types::CustomTypeName;
use std::collections::BTreeMap;
use super::types::input_type;
use crate::metadata::resolved;
use metadata_resolve;
use crate::metadata::resolved::{Qualified, QualifiedTypeReference};
use metadata_resolve::{Qualified, QualifiedTypeReference};
use crate::schema::types;
use crate::schema::GDS;
@ -16,7 +16,7 @@ type Error = crate::schema::Error;
pub fn get_where_expression_input_field(
builder: &mut gql_schema::Builder<GDS>,
gds_type_name: Qualified<CustomTypeName>,
boolean_expression_info: &resolved::BooleanExpressionInfo,
boolean_expression_info: &metadata_resolve::BooleanExpressionInfo,
) -> gql_schema::InputField<GDS> {
gql_schema::InputField::new(
boolean_expression_info

23
v3/crates/engine/src/schema/model_order_by.rs
View File

@ -7,12 +7,12 @@ use std::collections::{BTreeMap, HashMap};
use super::types::output_type::relationship::OrderByRelationshipAnnotation;
use super::types::{output_type::get_object_type_representation, Annotation, TypeId};
use crate::metadata::resolved;
use crate::metadata::resolved::mk_name;
use crate::metadata::resolved::Qualified;
use crate::schema::permissions;
use crate::schema::types;
use crate::schema::GDS;
use metadata_resolve;
use metadata_resolve::mk_name;
use metadata_resolve::Qualified;
type Error = crate::schema::Error;
@ -79,7 +79,7 @@ pub fn build_order_by_enum_type_schema(
pub fn get_order_by_expression_input_field(
builder: &mut gql_schema::Builder<GDS>,
model_name: Qualified<ModelName>,
order_by_expression_info: &resolved::ModelOrderByExpression,
order_by_expression_info: &metadata_resolve::ModelOrderByExpression,
) -> gql_schema::InputField<GDS> {
gql_schema::InputField::new(
order_by_expression_info.order_by_field_name.clone(),
@ -157,7 +157,7 @@ pub fn build_model_order_by_input_schema(
// relationship fields
// TODO(naveen): Add support for command relationships.
for (rel_name, relationship) in object_type_representation.relationships.iter() {
if let resolved::RelationshipTarget::Model {
if let metadata_resolve::RelationshipTarget::Model {
model_name,
relationship_type,
target_typename,
@ -178,13 +178,14 @@ pub fn build_model_order_by_input_schema(
if let (Some(target_source), Some(model_source)) =
(&target_model.model.source, &model.model.source)
{
let target_model_source = resolved::ModelTargetSource::from_model_source(
target_source,
relationship,
)?;
let target_model_source =
metadata_resolve::ModelTargetSource::from_model_source(
target_source,
relationship,
)?;
// order_by expression with relationships is currently only supported for local relationships
if let resolved::RelationshipExecutionCategory::Local =
resolved::relationship_execution_category(
if let metadata_resolve::RelationshipExecutionCategory::Local =
metadata_resolve::relationship_execution_category(
&model_source.data_connector,
&target_source.data_connector,
&target_model_source.capabilities,

90
v3/crates/engine/src/schema/permissions.rs
View File

@ -1,19 +1,22 @@
use open_dds::types::{CustomTypeName, FieldName};
use std::collections::{BTreeMap, HashMap};
use crate::metadata::resolved::ValueExpression;
use crate::metadata::resolved::{self};
use crate::metadata::resolved::{object_type_exists, unwrap_custom_type_name};
use crate::metadata::resolved::{Qualified, QualifiedTypeReference};
use crate::schema::Role;
use crate::schema::{self, types};
use metadata_resolve::ValueExpression;
use metadata_resolve::{self};
use metadata_resolve::{object_type_exists, unwrap_custom_type_name};
use metadata_resolve::{Qualified, QualifiedTypeReference};
use super::types::ArgumentNameAndPath;
/// Build namespace annotation for select permissions
pub(crate) fn get_select_permissions_namespace_annotations(
model: &resolved::ModelWithPermissions,
object_types: &HashMap<Qualified<CustomTypeName>, resolved::ObjectTypeWithRelationships>,
model: &metadata_resolve::ModelWithPermissions,
object_types: &HashMap<
Qualified<CustomTypeName>,
metadata_resolve::ObjectTypeWithRelationships,
>,
) -> Result<HashMap<Role, Option<types::NamespaceAnnotation>>, schema::Error> {
let mut permissions: HashMap<Role, Option<types::NamespaceAnnotation>> = model
.select_permissions
@ -96,10 +99,13 @@ pub(crate) fn get_select_permissions_namespace_annotations(
/// This is different from generating permissions for select_many etc,
/// as we need to check the permissions of the arguments used in the selection.
pub(crate) fn get_select_one_namespace_annotations(
model: &resolved::ModelWithPermissions,
object_type_representation: &resolved::ObjectTypeWithRelationships,
select_unique: &resolved::SelectUniqueGraphQlDefinition,
object_types: &HashMap<Qualified<CustomTypeName>, resolved::ObjectTypeWithRelationships>,
model: &metadata_resolve::ModelWithPermissions,
object_type_representation: &metadata_resolve::ObjectTypeWithRelationships,
select_unique: &metadata_resolve::SelectUniqueGraphQlDefinition,
object_types: &HashMap<
Qualified<CustomTypeName>,
metadata_resolve::ObjectTypeWithRelationships,
>,
) -> Result<HashMap<Role, Option<types::NamespaceAnnotation>>, schema::Error> {
let select_permissions = get_select_permissions_namespace_annotations(model, object_types)?;
@ -119,11 +125,14 @@ pub(crate) fn get_select_one_namespace_annotations(
/// We need to check the permissions of the source and target fields
/// in the relationship mappings.
pub(crate) fn get_model_relationship_namespace_annotations(
target_model: &resolved::ModelWithPermissions,
source_object_type_representation: &resolved::ObjectTypeWithRelationships,
target_object_type_representation: &resolved::ObjectTypeWithRelationships,
mappings: &[resolved::RelationshipModelMapping],
object_types: &HashMap<Qualified<CustomTypeName>, resolved::ObjectTypeWithRelationships>,
target_model: &metadata_resolve::ModelWithPermissions,
source_object_type_representation: &metadata_resolve::ObjectTypeWithRelationships,
target_object_type_representation: &metadata_resolve::ObjectTypeWithRelationships,
mappings: &[metadata_resolve::RelationshipModelMapping],
object_types: &HashMap<
Qualified<CustomTypeName>,
metadata_resolve::ObjectTypeWithRelationships,
>,
) -> Result<HashMap<Role, Option<types::NamespaceAnnotation>>, schema::Error> {
let select_permissions =
get_select_permissions_namespace_annotations(target_model, object_types)?;
@ -146,8 +155,11 @@ pub(crate) fn get_model_relationship_namespace_annotations(
/// Build namespace annotation for commands
pub(crate) fn get_command_namespace_annotations(
command: &resolved::CommandWithPermissions,
object_types: &HashMap<Qualified<CustomTypeName>, resolved::ObjectTypeWithRelationships>,
command: &metadata_resolve::CommandWithPermissions,
object_types: &HashMap<
Qualified<CustomTypeName>,
metadata_resolve::ObjectTypeWithRelationships,
>,
) -> Result<HashMap<Role, Option<types::NamespaceAnnotation>>, crate::schema::Error> {
let mut permissions = HashMap::new();
@ -220,8 +232,11 @@ fn build_annotations_from_input_object_type_permissions(
field_path: &mut [String],
type_reference: &QualifiedTypeReference,
ndc_argument_name: &Option<String>,
object_types: &HashMap<Qualified<CustomTypeName>, resolved::ObjectTypeWithRelationships>,
type_mappings: &BTreeMap<Qualified<CustomTypeName>, resolved::TypeMapping>,
object_types: &HashMap<
Qualified<CustomTypeName>,
metadata_resolve::ObjectTypeWithRelationships,
>,
type_mappings: &BTreeMap<Qualified<CustomTypeName>, metadata_resolve::TypeMapping>,
role_presets_map: &mut HashMap<Role, types::ArgumentPresets>,
) -> Result<(), schema::Error> {
if let Some(object_type) = unwrap_custom_type_name(type_reference) {
@ -231,7 +246,7 @@ fn build_annotations_from_input_object_type_permissions(
type_mappings
.get(object_type)
.map(|type_mapping| match type_mapping {
resolved::TypeMapping::Object {
metadata_resolve::TypeMapping::Object {
ndc_object_type_name: _,
field_mappings,
} => field_mappings,
@ -288,14 +303,14 @@ fn build_annotations_from_input_object_type_permissions(
/// Preset map we generate -
/// `Map<("person", ["address", "country"]), ValueExpression(SessionVariable("x-hasura-user-country"))>`
fn build_preset_map_from_input_object_type_permission(
permission: &resolved::TypeInputPermission,
field_mappings: Option<&BTreeMap<FieldName, resolved::FieldMapping>>,
permission: &metadata_resolve::TypeInputPermission,
field_mappings: Option<&BTreeMap<FieldName, metadata_resolve::FieldMapping>>,
type_reference: &QualifiedTypeReference,
field_path: &[String],
ndc_argument_name: &Option<String>,
object_type: &Qualified<CustomTypeName>,
) -> Result<
BTreeMap<ArgumentNameAndPath, (QualifiedTypeReference, resolved::ValueExpression)>,
BTreeMap<ArgumentNameAndPath, (QualifiedTypeReference, metadata_resolve::ValueExpression)>,
schema::Error,
> {
let preset_map = permission
@ -348,10 +363,13 @@ fn build_preset_map_from_input_object_type_permission(
/// We need to check the permissions of the source fields
/// in the relationship mappings.
pub(crate) fn get_command_relationship_namespace_annotations(
command: &resolved::CommandWithPermissions,
source_object_type_representation: &resolved::ObjectTypeWithRelationships,
mappings: &[resolved::RelationshipCommandMapping],
object_types: &HashMap<Qualified<CustomTypeName>, resolved::ObjectTypeWithRelationships>,
command: &metadata_resolve::CommandWithPermissions,
source_object_type_representation: &metadata_resolve::ObjectTypeWithRelationships,
mappings: &[metadata_resolve::RelationshipCommandMapping],
object_types: &HashMap<
Qualified<CustomTypeName>,
metadata_resolve::ObjectTypeWithRelationships,
>,
) -> Result<HashMap<Role, Option<types::NamespaceAnnotation>>, crate::schema::Error> {
let select_permissions = get_command_namespace_annotations(command, object_types)?;
@ -374,7 +392,7 @@ pub(crate) fn get_command_relationship_namespace_annotations(
/// for a role if the role has access (select permissions)
/// to all the Global ID fields.
pub(crate) fn get_node_interface_annotations(
object_type_representation: &resolved::ObjectTypeWithRelationships,
object_type_representation: &metadata_resolve::ObjectTypeWithRelationships,
) -> HashMap<Role, Option<types::NamespaceAnnotation>> {
let mut permissions = HashMap::new();
for (role, type_output_permission) in &object_type_representation.type_output_permissions {
@ -395,7 +413,7 @@ pub(crate) fn get_node_interface_annotations(
/// for a role if the role has access (select permissions)
/// to all the key fields.
pub(crate) fn get_entity_union_permissions(
object_type_representation: &resolved::ObjectTypeWithRelationships,
object_type_representation: &metadata_resolve::ObjectTypeWithRelationships,
) -> HashMap<Role, Option<types::NamespaceAnnotation>> {
let mut permissions = HashMap::new();
for (role, type_output_permission) in &object_type_representation.type_output_permissions {
@ -413,7 +431,7 @@ pub(crate) fn get_entity_union_permissions(
/// Build namespace annotations for each field based on the type permissions
pub(crate) fn get_allowed_roles_for_field<'a>(
object_type_representation: &'a resolved::ObjectTypeWithRelationships,
object_type_representation: &'a metadata_resolve::ObjectTypeWithRelationships,
field_name: &'a FieldName,
) -> impl Iterator<Item = &'a Role> {
object_type_representation
@ -430,9 +448,9 @@ pub(crate) fn get_allowed_roles_for_field<'a>(
/// Builds namespace annotations for the `node` field.
pub(crate) fn get_node_field_namespace_permissions(
object_type_representation: &resolved::ObjectTypeWithRelationships,
model: &resolved::ModelWithPermissions,
) -> HashMap<Role, resolved::FilterPermission> {
object_type_representation: &metadata_resolve::ObjectTypeWithRelationships,
model: &metadata_resolve::ModelWithPermissions,
) -> HashMap<Role, metadata_resolve::FilterPermission> {
let mut permissions = HashMap::new();
match &model.select_permissions {
@ -469,9 +487,9 @@ pub(crate) fn get_node_field_namespace_permissions(
/// Builds namespace annotations for the `_entities` field.
pub(crate) fn get_entities_field_namespace_permissions(
object_type_representation: &resolved::ObjectTypeWithRelationships,
model: &resolved::ModelWithPermissions,
) -> HashMap<Role, resolved::FilterPermission> {
object_type_representation: &metadata_resolve::ObjectTypeWithRelationships,
model: &metadata_resolve::ModelWithPermissions,
) -> HashMap<Role, metadata_resolve::FilterPermission> {
let mut permissions = HashMap::new();
match &model.select_permissions {

6
v3/crates/engine/src/schema/query_root/apollo_federation.rs
View File

@ -5,9 +5,9 @@ use lang_graphql::ast::common as ast;
use lang_graphql::{mk_name, schema as gql_schema};
use open_dds::types::CustomTypeName;
use crate::metadata::resolved;
use crate::metadata::resolved::Qualified;
use crate::schema::permissions::get_entities_field_namespace_permissions;
use metadata_resolve;
use metadata_resolve::Qualified;
use crate::schema::types::output_type::{
apollo_federation_entities_type, apollo_federation_service_type, get_custom_output_type,
@ -36,7 +36,7 @@ pub(crate) fn apollo_federation_field(
) -> Result<ApolloFederationFieldOutput, crate::schema::Error> {
let mut roles_type_permissions: HashMap<
Role,
HashMap<Qualified<CustomTypeName>, resolved::FilterPermission>,
HashMap<Qualified<CustomTypeName>, metadata_resolve::FilterPermission>,
> = HashMap::new();
let mut typename_mappings = HashMap::new();
for model in gds.metadata.models.values() {

6
v3/crates/engine/src/schema/query_root/node_field.rs
View File

@ -4,8 +4,6 @@ use lang_graphql::{ast::common as ast, schema as gql_schema};
use open_dds::types::CustomTypeName;
use std::collections::{BTreeMap, HashMap};
use crate::metadata::resolved;
use crate::metadata::resolved::Qualified;
use crate::schema::permissions::get_node_field_namespace_permissions;
use crate::schema::types::RelayInputAnnotation;
use crate::schema::types::{
@ -19,6 +17,8 @@ use crate::schema::types::{
};
use crate::schema::{Role, GDS};
use crate::utils::HashMapWithJsonKey;
use metadata_resolve;
use metadata_resolve::Qualified;
pub(crate) struct RelayNodeFieldOutput {
pub relay_node_gql_field: gql_schema::Field<GDS>,
@ -53,7 +53,7 @@ pub(crate) fn relay_node_field(
let mut roles_type_permissions: HashMap<
Role,
HashMap<Qualified<CustomTypeName>, resolved::FilterPermission>,
HashMap<Qualified<CustomTypeName>, metadata_resolve::FilterPermission>,
> = HashMap::new();
for model in gds.metadata.models.values() {
if let Some(global_id_source) = &model.model.global_id_source {

10
v3/crates/engine/src/schema/query_root/select_many.rs
View File

@ -7,7 +7,6 @@ use lang_graphql::ast::common::Name;
use lang_graphql::schema as gql_schema;
use std::collections::BTreeMap;
use crate::metadata::resolved;
use crate::schema::mk_deprecation_status;
use crate::schema::{
model_arguments,
@ -17,12 +16,13 @@ use crate::schema::{
types::{self, output_type::get_custom_output_type, Annotation, ModelInputAnnotation},
GDS,
};
use metadata_resolve;
/// Generates the schema for the arguments of a model selection, which includes
/// limit, offset, order_by and where.
pub(crate) fn generate_select_many_arguments(
builder: &mut gql_schema::Builder<GDS>,
model: &resolved::ModelWithPermissions,
model: &metadata_resolve::ModelWithPermissions,
) -> Result<
BTreeMap<Name, gql_schema::Namespaced<GDS, gql_schema::InputField<GDS>>>,
crate::schema::Error,
@ -97,8 +97,8 @@ pub(crate) fn generate_select_many_arguments(
pub(crate) fn select_many_field(
gds: &GDS,
builder: &mut gql_schema::Builder<GDS>,
model: &resolved::ModelWithPermissions,
select_many: &resolved::SelectManyGraphQlDefinition,
model: &metadata_resolve::ModelWithPermissions,
select_many: &metadata_resolve::SelectManyGraphQlDefinition,
parent_type: &ast::TypeName,
) -> Result<
(
@ -168,7 +168,7 @@ pub(crate) fn generate_int_input_argument(
name: &str,
annotation: Annotation,
) -> Result<gql_schema::InputField<GDS>, crate::schema::Error> {
let input_field_name = resolved::mk_name(name)?;
let input_field_name = metadata_resolve::mk_name(name)?;
Ok(gql_schema::InputField::new(
input_field_name,
None,

8
v3/crates/engine/src/schema/query_root/select_one.rs
View File

@ -5,8 +5,6 @@
use lang_graphql::{ast::common as ast, schema as gql_schema};
use std::collections::BTreeMap;
use crate::metadata::resolved;
use crate::metadata::resolved::mk_name;
use crate::schema::types::output_type::get_object_type_representation;
use crate::schema::{mk_deprecation_status, GDS};
use crate::schema::{
@ -16,13 +14,15 @@ use crate::schema::{
ModelInputAnnotation,
},
};
use metadata_resolve;
use metadata_resolve::mk_name;
/// Generates schema for a 'select_one' operation
pub(crate) fn select_one_field(
gds: &GDS,
builder: &mut gql_schema::Builder<GDS>,
model: &resolved::ModelWithPermissions,
select_unique: &resolved::SelectUniqueGraphQlDefinition,
model: &metadata_resolve::ModelWithPermissions,
select_unique: &metadata_resolve::SelectUniqueGraphQlDefinition,
parent_type: &ast::TypeName,
) -> Result<
(

31
v3/crates/engine/src/schema/types.rs
View File

@ -15,14 +15,13 @@ use open_dds::{
types::{self},
};
use crate::{
metadata::resolved::{
self, deserialize_non_string_key_btreemap, deserialize_qualified_btreemap,
serialize_non_string_key_btreemap, serialize_qualified_btreemap, DataConnectorLink,
NdcColumnForComparison, Qualified, QualifiedTypeReference, TypeMapping, ValueExpression,
},
utils::HashMapWithJsonKey,
use metadata_resolve::{
self, deserialize_non_string_key_btreemap, deserialize_qualified_btreemap,
serialize_non_string_key_btreemap, serialize_qualified_btreemap, DataConnectorLink,
NdcColumnForComparison, Qualified, QualifiedTypeReference, TypeMapping, ValueExpression,
};
use crate::utils::HashMapWithJsonKey;
use strum_macros::Display;
use self::output_type::relationship::{
@ -55,7 +54,7 @@ pub struct NodeFieldTypeNameMapping {
pub type_name: Qualified<types::CustomTypeName>,
// `model_source` is are optional because we allow building schema without specifying a data source
// In such a case, `global_id_fields_ndc_mapping` will also be empty
pub model_source: Option<resolved::ModelSource>,
pub model_source: Option<metadata_resolve::ModelSource>,
pub global_id_fields_ndc_mapping: HashMap<types::FieldName, NdcColumnForComparison>,
}
@ -64,7 +63,7 @@ pub struct EntityFieldTypeNameMapping {
pub type_name: Qualified<types::CustomTypeName>,
// `model_source` is are optional because we allow building schema without specifying a data source
// In such a case, `global_id_fields_ndc_mapping` will also be empty
pub model_source: Option<resolved::ModelSource>,
pub model_source: Option<metadata_resolve::ModelSource>,
pub key_fields_ndc_mapping: HashMap<types::FieldName, NdcColumnForComparison>,
}
@ -117,8 +116,8 @@ pub enum RootFieldAnnotation {
},
Model {
data_type: Qualified<types::CustomTypeName>,
source: Option<resolved::ModelSource>,
// select_permissions: HashMap<Role, resolved::SelectPermission>,
source: Option<metadata_resolve::ModelSource>,
// select_permissions: HashMap<Role, metadata_resolve::SelectPermission>,
kind: RootFieldKind,
name: Qualified<models::ModelName>,
},
@ -298,21 +297,21 @@ pub enum NamespaceAnnotation {
Command(ArgumentPresets),
/// any filter and arguments for selecting from a model
Model {
filter: resolved::FilterPermission,
filter: metadata_resolve::FilterPermission,
argument_presets: ArgumentPresets,
},
/// The `NodeFieldTypeMappings` contains a Hashmap of typename to the filter permission.
/// While executing the `node` field, the `id` field is supposed to be decoded and after
/// decoding, a typename will be obtained. We need to use that typename to look up the
/// Hashmap to get the appropriate `resolved::model::FilterPermission`.
/// Hashmap to get the appropriate `metadata_resolve::model::FilterPermission`.
NodeFieldTypeMappings(
HashMapWithJsonKey<Qualified<types::CustomTypeName>, resolved::FilterPermission>,
HashMapWithJsonKey<Qualified<types::CustomTypeName>, metadata_resolve::FilterPermission>,
),
/// `EntityTypeMappings` is similar to the `NodeFieldTypeMappings`. While executing the `_entities` field, the
/// `representations` argument is used, which contains typename. We need to use that typename to look up the hashmap
/// to get the appropriate `resolved::model::FilterPermission`.
/// to get the appropriate `metadata_resolve::model::FilterPermission`.
EntityTypeMappings(
HashMapWithJsonKey<Qualified<types::CustomTypeName>, resolved::FilterPermission>,
HashMapWithJsonKey<Qualified<types::CustomTypeName>, metadata_resolve::FilterPermission>,
),
}

24
v3/crates/engine/src/schema/types/input_type.rs
View File

@ -1,10 +1,9 @@
use crate::{
metadata::resolved::{
self, get_type_representation, mk_name, Qualified, QualifiedBaseType, QualifiedTypeName,
QualifiedTypeReference, TypeRepresentation,
},
schema::{types, Role, GDS},
use metadata_resolve::{
self, get_type_representation, mk_name, Qualified, QualifiedBaseType, QualifiedTypeName,
QualifiedTypeReference, TypeRepresentation,
};
use crate::schema::{types, Role, GDS};
use lang_graphql::ast::common as ast;
use lang_graphql::schema as gql_schema;
use open_dds::types::CustomTypeName;
@ -79,9 +78,9 @@ fn get_custom_input_type(
.map_err(|_| crate::schema::Error::InternalTypeNotFound {
type_name: gds_type_name.clone(),
})? {
TypeRepresentation::Object(resolved::ObjectTypeWithRelationships {
TypeRepresentation::Object(metadata_resolve::ObjectTypeWithRelationships {
object_type:
resolved::ObjectTypeRepresentation {
metadata_resolve::ObjectTypeRepresentation {
graphql_input_type_name,
..
},
@ -105,9 +104,10 @@ fn get_custom_input_type(
})?
.clone(),
}),
TypeRepresentation::BooleanExpression(
crate::metadata::resolved::ObjectBooleanExpressionType { graphql, .. },
) => Ok(super::TypeId::InputObjectBooleanExpressionType {
TypeRepresentation::BooleanExpression(metadata_resolve::ObjectBooleanExpressionType {
graphql,
..
}) => Ok(super::TypeId::InputObjectBooleanExpressionType {
gds_type_name: gds_type_name.clone(),
graphql_type_name: graphql
.as_ref()
@ -124,7 +124,7 @@ fn get_custom_input_type(
fn input_object_type_input_fields(
gds: &GDS,
builder: &mut gql_schema::Builder<GDS>,
object_type_representation: &resolved::ObjectTypeWithRelationships,
object_type_representation: &metadata_resolve::ObjectTypeWithRelationships,
) -> Result<BTreeMap<ast::Name, gql_schema::Namespaced<GDS, gql_schema::InputField<GDS>>>, Error> {
object_type_representation
.object_type

25
v3/crates/engine/src/schema/types/output_type.rs
View File

@ -13,15 +13,13 @@ use self::relationship::{
};
use super::inbuilt_type::base_type_container_for_inbuilt_type;
use super::{Annotation, PossibleApolloFederationTypes, TypeId};
use crate::metadata::resolved::{self, mk_name};
use crate::metadata::resolved::{get_type_representation, TypeRepresentation};
use crate::metadata::resolved::{
Qualified, QualifiedBaseType, QualifiedTypeName, QualifiedTypeReference,
};
use crate::schema::commands::generate_command_argument;
use crate::schema::query_root::select_many::generate_select_many_arguments;
use crate::schema::{mk_deprecation_status, permissions};
use crate::schema::{Role, GDS};
use metadata_resolve::{self, mk_name};
use metadata_resolve::{get_type_representation, TypeRepresentation};
use metadata_resolve::{Qualified, QualifiedBaseType, QualifiedTypeName, QualifiedTypeReference};
type Error = crate::schema::Error;
@ -188,8 +186,11 @@ fn object_type_fields(
gds: &GDS,
builder: &mut gql_schema::Builder<GDS>,
type_name: &Qualified<CustomTypeName>,
object_type_representation: &resolved::ObjectTypeWithRelationships,
object_types: &HashMap<Qualified<CustomTypeName>, resolved::ObjectTypeWithRelationships>,
object_type_representation: &metadata_resolve::ObjectTypeWithRelationships,
object_types: &HashMap<
Qualified<CustomTypeName>,
metadata_resolve::ObjectTypeWithRelationships,
>,
) -> Result<BTreeMap<ast::Name, gql_schema::Namespaced<GDS, gql_schema::Field<GDS>>>, Error> {
let mut graphql_fields = object_type_representation
.object_type
@ -227,7 +228,7 @@ fn object_type_fields(
let deprecation_status = mk_deprecation_status(&relationship.deprecated);
let relationship_field = match &relationship.target {
resolved::RelationshipTarget::Command {
metadata_resolve::RelationshipTarget::Command {
command_name,
target_type,
mappings,
@ -288,7 +289,7 @@ fn object_type_fields(
)?,
)
}
resolved::RelationshipTarget::Model {
metadata_resolve::RelationshipTarget::Model {
model_name,
relationship_type,
target_typename,
@ -339,7 +340,7 @@ fn object_type_fields(
source_type: relationship.source.clone(),
relationship_name: relationship.name.clone(),
model_name: model_name.clone(),
target_source: resolved::ModelTargetSource::new(
target_source: metadata_resolve::ModelTargetSource::new(
model,
relationship,
)?,
@ -377,7 +378,7 @@ fn object_type_fields(
}
fn generate_apollo_federation_directives(
apollo_federation_config: &resolved::ResolvedObjectApolloFederationConfig,
apollo_federation_config: &metadata_resolve::ResolvedObjectApolloFederationConfig,
) -> Vec<Directive> {
let mut directives = Vec::new();
for key in &apollo_federation_config.keys {
@ -515,7 +516,7 @@ pub fn output_type_schema(
pub(crate) fn get_object_type_representation<'s>(
gds: &'s GDS,
gds_type: &Qualified<CustomTypeName>,
) -> Result<&'s resolved::ObjectTypeWithRelationships, crate::schema::Error> {
) -> Result<&'s metadata_resolve::ObjectTypeWithRelationships, crate::schema::Error> {
gds.metadata.object_types.get(gds_type).ok_or_else(|| {
crate::schema::Error::InternalTypeNotFound {
type_name: gds_type.clone(),

45
v3/crates/engine/src/schema/types/output_type/relationship.rs
View File

@ -9,15 +9,14 @@ use open_dds::{
use serde::{Deserialize, Serialize};
use crate::{
metadata::resolved::{
self, deserialize_qualified_btreemap, serialize_qualified_btreemap, Qualified,
QualifiedTypeReference,
},
schema::{
self,
types::{CommandSourceDetail, TypeKind},
},
use metadata_resolve::{
self, deserialize_qualified_btreemap, serialize_qualified_btreemap, Qualified,
QualifiedTypeReference,
};
use crate::schema::{
self,
types::{CommandSourceDetail, TypeKind},
};
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
@ -25,10 +24,10 @@ pub struct ModelRelationshipAnnotation {
pub source_type: Qualified<CustomTypeName>,
pub relationship_name: RelationshipName,
pub model_name: Qualified<ModelName>,
pub target_source: Option<resolved::ModelTargetSource>,
pub target_source: Option<metadata_resolve::ModelTargetSource>,
pub target_type: Qualified<CustomTypeName>,
pub relationship_type: RelationshipType,
pub mappings: Vec<resolved::RelationshipModelMapping>,
pub mappings: Vec<metadata_resolve::RelationshipModelMapping>,
}
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
@ -36,16 +35,16 @@ pub struct FilterRelationshipAnnotation {
pub relationship_name: RelationshipName,
pub relationship_type: RelationshipType,
pub source_type: Qualified<CustomTypeName>,
pub source_data_connector: resolved::DataConnectorLink,
pub source_data_connector: metadata_resolve::DataConnectorLink,
#[serde(
serialize_with = "serialize_qualified_btreemap",
deserialize_with = "deserialize_qualified_btreemap"
)]
pub source_type_mappings: BTreeMap<Qualified<CustomTypeName>, resolved::TypeMapping>,
pub target_source: resolved::ModelTargetSource,
pub source_type_mappings: BTreeMap<Qualified<CustomTypeName>, metadata_resolve::TypeMapping>,
pub target_source: metadata_resolve::ModelTargetSource,
pub target_type: Qualified<CustomTypeName>,
pub target_model_name: Qualified<ModelName>,
pub mappings: Vec<resolved::RelationshipModelMapping>,
pub mappings: Vec<metadata_resolve::RelationshipModelMapping>,
}
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
@ -53,16 +52,16 @@ pub struct OrderByRelationshipAnnotation {
pub relationship_name: RelationshipName,
pub relationship_type: RelationshipType,
pub source_type: Qualified<CustomTypeName>,
pub source_data_connector: resolved::DataConnectorLink,
pub source_data_connector: metadata_resolve::DataConnectorLink,
#[serde(
serialize_with = "serialize_qualified_btreemap",
deserialize_with = "deserialize_qualified_btreemap"
)]
pub source_type_mappings: BTreeMap<Qualified<CustomTypeName>, resolved::TypeMapping>,
pub target_source: resolved::ModelTargetSource,
pub source_type_mappings: BTreeMap<Qualified<CustomTypeName>, metadata_resolve::TypeMapping>,
pub target_source: metadata_resolve::ModelTargetSource,
pub target_type: Qualified<CustomTypeName>,
pub target_model_name: Qualified<ModelName>,
pub mappings: Vec<resolved::RelationshipModelMapping>,
pub mappings: Vec<metadata_resolve::RelationshipModelMapping>,
}
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
@ -73,20 +72,20 @@ pub struct CommandRelationshipAnnotation {
pub target_source: Option<CommandTargetSource>,
pub target_type: QualifiedTypeReference,
pub target_base_type_kind: TypeKind,
pub mappings: Vec<resolved::RelationshipCommandMapping>,
pub mappings: Vec<metadata_resolve::RelationshipCommandMapping>,
}
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
pub struct CommandTargetSource {
pub(crate) details: CommandSourceDetail,
pub(crate) function_name: FunctionName,
pub(crate) capabilities: resolved::RelationshipCapabilities,
pub(crate) capabilities: metadata_resolve::RelationshipCapabilities,
}
impl CommandTargetSource {
pub fn new(
command: &resolved::CommandWithPermissions,
relationship: &resolved::Relationship,
command: &metadata_resolve::CommandWithPermissions,
relationship: &metadata_resolve::Relationship,
) -> Result<Option<Self>, schema::Error> {
command
.command

3
v3/crates/engine/src/schema/types/scalar_type.rs
View File

@ -1,6 +1,7 @@
use crate::{metadata::resolved::Qualified, schema::GDS};
use crate::schema::GDS;
use lang_graphql::ast::common as ast;
use lang_graphql::schema as gql_schema;
use metadata_resolve::Qualified;
use open_dds::types::CustomTypeName;
type Error = crate::schema::Error;

4
v3/crates/engine/tests/validate_metadata.rs
View File

@ -1,10 +1,10 @@
use std::fs;
use std::path::PathBuf;
use engine::metadata::resolved::BooleanExpressionError;
use engine::metadata::resolved::Error as ResolveError;
use engine::schema::Error as SchemaError;
use engine::schema::GDS;
use metadata_resolve::BooleanExpressionError;
use metadata_resolve::Error as ResolveError;
#[test]
fn test_select_many_model_arguments_without_arguments_input_type() -> anyhow::Result<()> {

27
v3/crates/metadata-resolve/Cargo.toml Normal file
View File

@ -0,0 +1,27 @@
[package]
name = "metadata-resolve"
version.workspace = true
edition.workspace = true
license.workspace = true
[lib]
bench = false
[dependencies]
hasura-authn-core = { path = "../auth/hasura-authn-core" }
lang-graphql = { path = "../lang-graphql" }
open-dds = { path = "../open-dds" }
derive_more = "0.99.17"
indexmap = { version = "2", features = ["serde"] }
lazy_static = "1.4.0"
ndc-models = { git = "https://github.com/hasura/ndc-spec.git", tag = "v0.1.2" }
nonempty = "0.10"
reqwest = { version = "0.11", features = ["json", "multipart"] }
serde = "1.0.152"
serde_json = "1.0.92"
thiserror = "1.0"
url = "2.4.1"
[lints]
workspace = true

20
v3/crates/engine/src/metadata/resolved/helpers/argument.rs → v3/crates/metadata-resolve/src/helpers/argument.rs
View File

@ -1,21 +1,17 @@
use crate::metadata::resolved::helpers::model::resolve_ndc_type;
use crate::metadata::resolved::helpers::ndc_validation;
use crate::metadata::resolved::helpers::type_mappings;
use crate::metadata::resolved::helpers::types::{
use crate::helpers::model::resolve_ndc_type;
use crate::helpers::ndc_validation;
use crate::helpers::type_mappings;
use crate::helpers::types::{
get_object_type_for_boolean_expression, get_type_representation, unwrap_custom_type_name,
TypeRepresentation,
};
use crate::metadata::resolved::stages::{
use crate::stages::{
boolean_expressions, data_connector_scalar_types, model_permissions, object_types,
relationships, scalar_types, type_permissions,
};
use crate::metadata::resolved::types::error::{
Error, TypeError, TypeMappingValidationError, TypePredicateError,
};
use crate::metadata::resolved::types::permission::ValueExpression;
use crate::metadata::resolved::types::subgraph::{
ArgumentInfo, Qualified, QualifiedBaseType, QualifiedTypeReference,
};
use crate::types::error::{Error, TypeError, TypeMappingValidationError, TypePredicateError};
use crate::types::permission::ValueExpression;
use crate::types::subgraph::{ArgumentInfo, Qualified, QualifiedBaseType, QualifiedTypeReference};
use indexmap::IndexMap;
use ndc_models;
use open_dds::arguments::ArgumentName;

0
v3/crates/engine/src/metadata/resolved/helpers/mod.rs → v3/crates/metadata-resolve/src/helpers/mod.rs
View File

6
v3/crates/engine/src/metadata/resolved/helpers/model.rs → v3/crates/metadata-resolve/src/helpers/model.rs
View File

@ -1,8 +1,8 @@
use crate::metadata::resolved::stages::data_connector_scalar_types;
use crate::stages::data_connector_scalar_types;
use crate::metadata::resolved::types::error::Error;
use crate::types::error::Error;
use crate::metadata::resolved::types::subgraph::{
use crate::types::subgraph::{
mk_qualified_type_name, Qualified, QualifiedBaseType, QualifiedTypeReference,
};

4
v3/crates/engine/src/metadata/resolved/helpers/ndc_validation.rs → v3/crates/metadata-resolve/src/helpers/ndc_validation.rs
View File

@ -1,4 +1,4 @@
use crate::metadata::resolved::stages::{commands, models, object_types};
use crate::stages::{commands, models, object_types};
use ndc_models;
use open_dds::{
commands::{CommandName, DataConnectorCommand, FunctionName, ProcedureName},
@ -8,7 +8,7 @@ use open_dds::{
};
use thiserror::Error;
use crate::metadata::resolved::types::subgraph::{
use crate::types::subgraph::{
Qualified, QualifiedBaseType, QualifiedTypeName, QualifiedTypeReference,
};

10
v3/crates/engine/src/metadata/resolved/helpers/type_mappings.rs → v3/crates/metadata-resolve/src/helpers/type_mappings.rs
View File

@ -1,10 +1,8 @@
use crate::metadata::resolved::stages::{object_types, scalar_types, type_permissions};
use crate::stages::{object_types, scalar_types, type_permissions};
use crate::metadata::resolved::helpers::ndc_validation::{
get_underlying_named_type, NDCValidationError,
};
use crate::metadata::resolved::helpers::types::{object_type_exists, unwrap_custom_type_name};
use crate::metadata::resolved::types::subgraph::Qualified;
use crate::helpers::ndc_validation::{get_underlying_named_type, NDCValidationError};
use crate::helpers::types::{object_type_exists, unwrap_custom_type_name};
use crate::types::subgraph::Qualified;
use open_dds::data_connector::DataConnectorName;
use open_dds::types::{CustomTypeName, FieldName};

2
v3/crates/engine/src/metadata/resolved/helpers/typecheck.rs → v3/crates/metadata-resolve/src/helpers/typecheck.rs
View File

@ -1,5 +1,5 @@
//! Functions for typechecking JSON literals against expected types
use crate::metadata::resolved::types::subgraph;
use crate::types::subgraph;
use thiserror::Error;
#[derive(Error, Debug, PartialEq)]

6
v3/crates/engine/src/metadata/resolved/helpers/types.rs → v3/crates/metadata-resolve/src/helpers/types.rs
View File

@ -1,7 +1,7 @@
use crate::metadata::resolved::stages::{boolean_expressions, relationships, scalar_types};
use crate::metadata::resolved::types::error::{BooleanExpressionError, Error};
use crate::stages::{boolean_expressions, relationships, scalar_types};
use crate::types::error::{BooleanExpressionError, Error};
use crate::metadata::resolved::types::subgraph::{
use crate::types::subgraph::{
Qualified, QualifiedBaseType, QualifiedTypeName, QualifiedTypeReference,
};
use lang_graphql::ast::common as ast;

0
v3/crates/engine/src/metadata/resolved.rs → v3/crates/metadata-resolve/src/lib.rs
View File

4
v3/crates/engine/src/metadata/resolved/stages/apollo/mod.rs → v3/crates/metadata-resolve/src/stages/apollo/mod.rs
View File

@ -2,9 +2,9 @@ use std::collections::HashMap;
use open_dds::{models::ModelName, types::CustomTypeName};
use crate::metadata::resolved::types::error::Error;
use crate::types::error::Error;
use crate::metadata::resolved::types::subgraph::Qualified;
use crate::types::subgraph::Qualified;
/// This isn't a particularly satisfying resolve step, as it only serves to validate
/// the output of previous steps.

12
v3/crates/engine/src/metadata/resolved/stages/boolean_expressions/mod.rs → v3/crates/metadata-resolve/src/stages/boolean_expressions/mod.rs
View File

@ -1,15 +1,15 @@
pub mod types;
use crate::metadata::resolved::stages::{
use crate::stages::{
data_connector_scalar_types, data_connectors, graphql_config, object_types, scalar_types,
type_permissions,
};
use crate::metadata::resolved::types::error::{BooleanExpressionError, Error, GraphqlConfigError};
use crate::types::error::{BooleanExpressionError, Error, GraphqlConfigError};
use crate::metadata::resolved::helpers::model::resolve_ndc_type;
use crate::metadata::resolved::helpers::types::{mk_name, store_new_graphql_type};
use crate::metadata::resolved::types::subgraph::Qualified;
use crate::helpers::model::resolve_ndc_type;
use crate::helpers::types::{mk_name, store_new_graphql_type};
use crate::types::subgraph::Qualified;
use crate::metadata::resolved::helpers::type_mappings;
use crate::helpers::type_mappings;
use lang_graphql::ast::common as ast;
use open_dds::types::CustomTypeName;
use std::collections::{BTreeMap, HashMap, HashSet};

4
v3/crates/engine/src/metadata/resolved/stages/boolean_expressions/types.rs → v3/crates/metadata-resolve/src/stages/boolean_expressions/types.rs
View File

@ -1,6 +1,6 @@
use crate::metadata::resolved::stages::{data_connectors, object_types};
use crate::stages::{data_connectors, object_types};
use crate::metadata::resolved::types::subgraph::{Qualified, QualifiedTypeReference};
use crate::types::subgraph::{Qualified, QualifiedTypeReference};
use std::collections::{BTreeMap, HashMap};
use lang_graphql::ast::common::{self as ast};

14
v3/crates/engine/src/metadata/resolved/stages/command_permissions/mod.rs → v3/crates/metadata-resolve/src/stages/command_permissions/mod.rs
View File

@ -6,21 +6,19 @@ use indexmap::IndexMap;
use open_dds::{commands::CommandName, types::CustomTypeName};
use crate::metadata::resolved::stages::{
boolean_expressions, commands, data_connector_scalar_types, relationships,
};
use crate::metadata::resolved::types::error::Error;
use crate::metadata::resolved::types::permission::ValueExpression;
use crate::metadata::resolved::types::subgraph::{Qualified, QualifiedTypeReference};
use crate::stages::{boolean_expressions, commands, data_connector_scalar_types, relationships};
use crate::types::error::Error;
use crate::types::permission::ValueExpression;
use crate::types::subgraph::{Qualified, QualifiedTypeReference};
use open_dds::arguments::ArgumentName;
use crate::metadata::resolved::helpers::argument::resolve_value_expression_for_argument;
use crate::helpers::argument::resolve_value_expression_for_argument;
use open_dds::permissions::CommandPermissionsV1;
use std::collections::BTreeMap;
use crate::metadata::resolved::helpers::typecheck;
use crate::helpers::typecheck;
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
pub struct CommandWithPermissions {

16
v3/crates/engine/src/metadata/resolved/stages/commands/mod.rs → v3/crates/metadata-resolve/src/stages/commands/mod.rs
View File

@ -1,18 +1,16 @@
mod types;
use crate::metadata::resolved::helpers::argument::get_argument_mappings;
use crate::metadata::resolved::helpers::ndc_validation;
use crate::metadata::resolved::helpers::types::{
use crate::helpers::argument::get_argument_mappings;
use crate::helpers::ndc_validation;
use crate::helpers::types::{
get_type_representation, mk_name, object_type_exists, unwrap_custom_type_name,
};
use crate::metadata::resolved::stages::{
use crate::stages::{
boolean_expressions, data_connector_scalar_types, data_connectors, scalar_types,
type_permissions,
};
use crate::metadata::resolved::types::error::Error;
use crate::metadata::resolved::types::subgraph::{
mk_qualified_type_reference, ArgumentInfo, Qualified,
};
use crate::types::error::Error;
use crate::types::subgraph::{mk_qualified_type_reference, ArgumentInfo, Qualified};
use indexmap::IndexMap;
use open_dds::commands::{self, CommandName, CommandV1, DataConnectorCommand};
@ -22,7 +20,7 @@ use open_dds::types::{BaseType, CustomTypeName, TypeName, TypeReference};
use std::collections::{BTreeMap, HashMap};
use crate::metadata::resolved::helpers::type_mappings;
use crate::helpers::type_mappings;
/// resolve commands
pub fn resolve(

4
v3/crates/engine/src/metadata/resolved/stages/commands/types.rs → v3/crates/metadata-resolve/src/stages/commands/types.rs
View File

@ -1,5 +1,5 @@
use crate::metadata::resolved::stages::{data_connectors, object_types};
use crate::metadata::resolved::types::subgraph::{
use crate::stages::{data_connectors, object_types};
use crate::types::subgraph::{
deserialize_qualified_btreemap, serialize_qualified_btreemap, ArgumentInfo, Qualified,
QualifiedTypeReference,
};

8
v3/crates/engine/src/metadata/resolved/stages/data_connector_scalar_types/mod.rs → v3/crates/metadata-resolve/src/stages/data_connector_scalar_types/mod.rs
View File

@ -11,11 +11,11 @@ use open_dds::types::{CustomTypeName, TypeName};
use open_dds::data_connector::DataConnectorName;
use crate::metadata::resolved::helpers::types::mk_name;
use crate::metadata::resolved::types::error::Error;
use crate::metadata::resolved::types::subgraph::Qualified;
use crate::helpers::types::mk_name;
use crate::types::error::Error;
use crate::types::subgraph::Qualified;
use crate::metadata::resolved::stages::{data_connectors, scalar_types};
use crate::stages::{data_connectors, scalar_types};
pub struct DataConnectorWithScalarsOutput<'a> {
pub data_connectors: DataConnectorsWithScalars<'a>,

4
v3/crates/engine/src/metadata/resolved/stages/data_connector_scalar_types/types.rs → v3/crates/metadata-resolve/src/stages/data_connector_scalar_types/types.rs
View File

@ -1,6 +1,6 @@
use crate::metadata::resolved::types::subgraph::Qualified;
use crate::types::subgraph::Qualified;
use crate::metadata::resolved::stages::data_connectors;
use crate::stages::data_connectors;
use lang_graphql::ast::common as ast;
use ndc_models;

4
v3/crates/engine/src/metadata/resolved/stages/data_connectors/mod.rs → v3/crates/metadata-resolve/src/stages/data_connectors/mod.rs
View File

@ -1,5 +1,5 @@
use crate::metadata::resolved::types::error::Error;
use crate::metadata::resolved::types::subgraph::Qualified;
use crate::types::error::Error;
use crate::types::subgraph::Qualified;
pub mod types;
use std::collections::HashMap;

6
v3/crates/engine/src/metadata/resolved/stages/data_connectors/types.rs → v3/crates/metadata-resolve/src/stages/data_connectors/types.rs
View File

@ -1,5 +1,5 @@
use crate::metadata::resolved::types::error::Error;
use crate::metadata::resolved::types::subgraph::Qualified;
use crate::types::error::Error;
use crate::types::subgraph::Qualified;
use serde::{Deserialize, Serialize};
use indexmap::IndexMap;
@ -284,7 +284,7 @@ mod tests {
use ndc_models;
use open_dds::data_connector::DataConnectorLinkV1;
use crate::metadata::resolved::stages::data_connectors::types::DataConnectorContext;
use crate::stages::data_connectors::types::DataConnectorContext;
#[test]
fn test_url_serialization_deserialization() {

4
v3/crates/engine/src/metadata/resolved/stages/graphql_config/mod.rs → v3/crates/metadata-resolve/src/stages/graphql_config/mod.rs
View File

@ -1,6 +1,6 @@
use crate::metadata::resolved::helpers::types::mk_name;
use crate::helpers::types::mk_name;
/// this is where we will resolve graphql configuration
use crate::metadata::resolved::types::error::{Error, GraphqlConfigError};
use crate::types::error::{Error, GraphqlConfigError};
use lang_graphql::ast::common as ast;
use open_dds::graphql_config::{self, OrderByDirection};
use serde::{Deserialize, Serialize};

2
v3/crates/engine/src/metadata/resolved/stages/mod.rs → v3/crates/metadata-resolve/src/stages/mod.rs
View File

@ -17,7 +17,7 @@ mod types;
pub use types::Metadata;
use crate::metadata::resolved::types::error::Error;
use crate::types::error::Error;
/// this is where we take the input metadata and attempt to resolve a working `Metadata` object
/// currently the bulk of this lives in the `resolve_metadata` function, we'll be slowly breaking

16
v3/crates/engine/src/metadata/resolved/stages/model_permissions/mod.rs → v3/crates/metadata-resolve/src/stages/model_permissions/mod.rs
View File

@ -1,9 +1,9 @@
mod types;
use crate::metadata::resolved::helpers::typecheck;
use crate::metadata::resolved::stages::{
use crate::helpers::typecheck;
use crate::stages::{
boolean_expressions, data_connector_scalar_types, models, object_types, relationships,
};
use crate::metadata::resolved::types::permission::ValueExpression;
use crate::types::permission::ValueExpression;
use indexmap::IndexMap;
use open_dds::{models::ModelName, types::CustomTypeName};
use std::collections::{BTreeMap, HashMap};
@ -12,11 +12,11 @@ pub use types::{
PredicateRelationshipInfo, SelectPermission,
};
use crate::metadata::resolved::helpers::argument::resolve_value_expression_for_argument;
use crate::metadata::resolved::types::error::{Error, RelationshipError};
use crate::helpers::argument::resolve_value_expression_for_argument;
use crate::types::error::{Error, RelationshipError};
use crate::metadata::resolved::helpers::types::mk_name;
use crate::metadata::resolved::types::subgraph::{
use crate::helpers::types::mk_name;
use crate::types::subgraph::{
mk_qualified_type_name, Qualified, QualifiedBaseType, QualifiedTypeReference,
};
@ -482,7 +482,7 @@ fn get_model_object_type_representation<'s>(
>,
data_type: &Qualified<CustomTypeName>,
model_name: &Qualified<ModelName>,
) -> Result<&'s relationships::ObjectTypeWithRelationships, crate::metadata::resolved::Error> {
) -> Result<&'s relationships::ObjectTypeWithRelationships, crate::Error> {
match object_types.get(data_type) {
Some(object_type_representation) => Ok(object_type_representation),
None => Err(Error::UnknownModelDataType {

16
v3/crates/engine/src/metadata/resolved/stages/model_permissions/types.rs → v3/crates/metadata-resolve/src/stages/model_permissions/types.rs
View File

@ -1,9 +1,7 @@
use crate::metadata::resolved::stages::{data_connectors, models, object_types, relationships};
use crate::metadata::resolved::types::error::{Error, RelationshipError};
use crate::metadata::resolved::types::permission::ValueExpression;
use crate::metadata::resolved::types::subgraph::{
deserialize_qualified_btreemap, serialize_qualified_btreemap,
};
use crate::stages::{data_connectors, models, object_types, relationships};
use crate::types::error::{Error, RelationshipError};
use crate::types::permission::ValueExpression;
use crate::types::subgraph::{deserialize_qualified_btreemap, serialize_qualified_btreemap};
use open_dds::{
models::ModelName,
relationships::{RelationshipName, RelationshipType},
@ -12,7 +10,7 @@ use open_dds::{
use std::collections::{BTreeMap, HashMap};
use crate::metadata::resolved::types::subgraph::{Qualified, QualifiedTypeReference};
use crate::types::subgraph::{Qualified, QualifiedTypeReference};
use ndc_models;
@ -80,8 +78,8 @@ pub struct PredicateRelationshipInfo {
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
pub struct ModelTargetSource {
pub(crate) model: models::ModelSource,
pub(crate) capabilities: relationships::RelationshipCapabilities,
pub model: models::ModelSource,
pub capabilities: relationships::RelationshipCapabilities,
}
impl ModelTargetSource {

20
v3/crates/engine/src/metadata/resolved/stages/models/mod.rs → v3/crates/metadata-resolve/src/stages/models/mod.rs
View File

@ -6,20 +6,18 @@ pub use types::{
};
mod types;
use crate::metadata::resolved::helpers::argument::get_argument_mappings;
use crate::metadata::resolved::helpers::ndc_validation;
use crate::metadata::resolved::types::error::{BooleanExpressionError, Error, GraphqlConfigError};
use crate::helpers::argument::get_argument_mappings;
use crate::helpers::ndc_validation;
use crate::types::error::{BooleanExpressionError, Error, GraphqlConfigError};
use crate::metadata::resolved::helpers::type_mappings;
use crate::metadata::resolved::helpers::types::NdcColumnForComparison;
use crate::metadata::resolved::helpers::types::{mk_name, store_new_graphql_type};
use crate::metadata::resolved::stages::{
use crate::helpers::type_mappings;
use crate::helpers::types::NdcColumnForComparison;
use crate::helpers::types::{mk_name, store_new_graphql_type};
use crate::stages::{
boolean_expressions, data_connector_scalar_types, data_connectors, graphql_config,
object_types, scalar_types, type_permissions,
};
use crate::metadata::resolved::types::subgraph::{
mk_qualified_type_reference, ArgumentInfo, Qualified,
};
use crate::types::subgraph::{mk_qualified_type_reference, ArgumentInfo, Qualified};
use indexmap::IndexMap;
use lang_graphql::ast::common::{self as ast};
@ -736,7 +734,7 @@ fn get_model_object_type_representation<'s>(
>,
data_type: &Qualified<CustomTypeName>,
model_name: &Qualified<ModelName>,
) -> Result<&'s type_permissions::ObjectTypeWithPermissions, crate::metadata::resolved::Error> {
) -> Result<&'s type_permissions::ObjectTypeWithPermissions, crate::Error> {
match object_types.get(data_type) {
Some(object_type_representation) => Ok(object_type_representation),
None => Err(Error::UnknownModelDataType {

6
v3/crates/engine/src/metadata/resolved/stages/models/types.rs → v3/crates/metadata-resolve/src/stages/models/types.rs
View File

@ -1,6 +1,6 @@
use crate::metadata::resolved::helpers::types::NdcColumnForComparison;
use crate::metadata::resolved::stages::{boolean_expressions, data_connectors, object_types};
use crate::metadata::resolved::types::subgraph::{
use crate::helpers::types::NdcColumnForComparison;
use crate::stages::{boolean_expressions, data_connectors, object_types};
use crate::types::subgraph::{
deserialize_qualified_btreemap, serialize_qualified_btreemap, ArgumentInfo, Qualified,
QualifiedTypeReference,
};

8
v3/crates/engine/src/metadata/resolved/stages/object_types/mod.rs → v3/crates/metadata-resolve/src/stages/object_types/mod.rs
View File

@ -7,11 +7,11 @@ pub use types::{
ResolvedApolloFederationObjectKey, ResolvedObjectApolloFederationConfig, TypeMapping,
};
use crate::metadata::resolved::helpers::types::{mk_name, store_new_graphql_type};
use crate::metadata::resolved::stages::data_connectors;
use crate::helpers::types::{mk_name, store_new_graphql_type};
use crate::stages::data_connectors;
use crate::metadata::resolved::types::error::{Error, TypeMappingValidationError};
use crate::metadata::resolved::types::subgraph::{mk_qualified_type_reference, Qualified};
use crate::types::error::{Error, TypeMappingValidationError};
use crate::types::subgraph::{mk_qualified_type_reference, Qualified};
use indexmap::IndexMap;
use lang_graphql::ast::common as ast;

6
v3/crates/engine/src/metadata/resolved/stages/object_types/types.rs → v3/crates/metadata-resolve/src/stages/object_types/types.rs
View File

@ -1,5 +1,5 @@
use crate::metadata::resolved::types::error::Error;
use crate::metadata::resolved::types::subgraph::QualifiedTypeReference;
use crate::types::error::Error;
use crate::types::subgraph::QualifiedTypeReference;
use indexmap::IndexMap;
use open_dds::types::{CustomTypeName, Deprecated, FieldName};
@ -8,7 +8,7 @@ use std::collections::{BTreeMap, HashMap, HashSet};
use open_dds::models::ModelName;
use crate::metadata::resolved::types::subgraph::Qualified;
use crate::types::subgraph::Qualified;
use lang_graphql::ast::common as ast;
use open_dds::data_connector::DataConnectorName;

8
v3/crates/engine/src/metadata/resolved/stages/relationships/mod.rs → v3/crates/metadata-resolve/src/stages/relationships/mod.rs
View File

@ -11,11 +11,11 @@ use indexmap::IndexMap;
use open_dds::{commands::CommandName, models::ModelName, types::CustomTypeName};
use crate::metadata::resolved::types::error::{Error, RelationshipError};
use crate::metadata::resolved::types::subgraph::Qualified;
use crate::types::error::{Error, RelationshipError};
use crate::types::subgraph::Qualified;
use crate::metadata::resolved::helpers::types::mk_name;
use crate::metadata::resolved::stages::{
use crate::helpers::types::mk_name;
use crate::stages::{
commands, data_connector_scalar_types, data_connectors, models, object_types, type_permissions,
};

6
v3/crates/engine/src/metadata/resolved/stages/relationships/types.rs → v3/crates/metadata-resolve/src/stages/relationships/types.rs
View File

@ -1,11 +1,11 @@
use crate::metadata::resolved::stages::{object_types, type_permissions};
use crate::metadata::resolved::types::subgraph::{Qualified, QualifiedTypeReference};
use crate::stages::{object_types, type_permissions};
use crate::types::subgraph::{Qualified, QualifiedTypeReference};
use indexmap::IndexMap;
use open_dds::permissions::Role;
use open_dds::{commands::CommandName, models::ModelName, types::CustomTypeName};
use serde::{Deserialize, Serialize};
use crate::metadata::resolved::helpers::types::NdcColumnForComparison;
use crate::helpers::types::NdcColumnForComparison;
use lang_graphql::ast::common as ast;
use open_dds::arguments::ArgumentName;
use std::collections::HashMap;

4
v3/crates/engine/src/metadata/resolved/stages/roles/mod.rs → v3/crates/metadata-resolve/src/stages/roles/mod.rs
View File

@ -5,9 +5,9 @@ use indexmap::IndexMap;
use open_dds::{commands::CommandName, models::ModelName, types::CustomTypeName};
use crate::metadata::resolved::types::subgraph::Qualified;
use crate::types::subgraph::Qualified;
use crate::metadata::resolved::stages::{command_permissions, model_permissions, relationships};
use crate::stages::{command_permissions, model_permissions, relationships};
/// Gather all roles from various permission objects.
pub fn resolve(

6
v3/crates/engine/src/metadata/resolved/stages/scalar_types/mod.rs → v3/crates/metadata-resolve/src/stages/scalar_types/mod.rs
View File

@ -2,9 +2,9 @@ use std::collections::{HashMap, HashSet};
use lang_graphql::ast::common as ast;
use crate::metadata::resolved::helpers::types::{mk_name, store_new_graphql_type};
use crate::metadata::resolved::types::error::Error;
use crate::metadata::resolved::types::subgraph::Qualified;
use crate::helpers::types::{mk_name, store_new_graphql_type};
use crate::types::error::Error;
use crate::types::subgraph::Qualified;
pub mod types;
pub use types::{ScalarTypeRepresentation, ScalarTypesOutput};

2
v3/crates/engine/src/metadata/resolved/stages/scalar_types/types.rs → v3/crates/metadata-resolve/src/stages/scalar_types/types.rs
View File

@ -1,4 +1,4 @@
use crate::metadata::resolved::types::subgraph::Qualified;
use crate::types::subgraph::Qualified;
use lang_graphql::ast::common as ast;
use serde::{Deserialize, Serialize};
use std::collections::{HashMap, HashSet};

8
v3/crates/engine/src/metadata/resolved/stages/type_permissions/mod.rs → v3/crates/metadata-resolve/src/stages/type_permissions/mod.rs
View File

@ -6,12 +6,12 @@ use open_dds::permissions::{
use open_dds::types::{CustomTypeName, FieldName};
use crate::metadata::resolved::types::error::Error;
use crate::types::error::Error;
use crate::metadata::resolved::types::subgraph::Qualified;
use crate::types::subgraph::Qualified;
use crate::metadata::resolved::helpers::typecheck;
use crate::metadata::resolved::stages::object_types;
use crate::helpers::typecheck;
use crate::stages::object_types;
use serde::{Deserialize, Serialize};
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, derive_more::Display)]

4
v3/crates/engine/src/metadata/resolved/stages/types.rs → v3/crates/metadata-resolve/src/stages/types.rs
View File

@ -6,9 +6,9 @@ use serde::{Deserialize, Serialize};
use open_dds::{commands::CommandName, models::ModelName, types::CustomTypeName};
use crate::metadata::resolved::types::subgraph::Qualified;
use crate::types::subgraph::Qualified;
use crate::metadata::resolved::stages::{
use crate::stages::{
boolean_expressions, command_permissions, graphql_config, model_permissions, relationships,
scalar_types,
};

6
v3/crates/engine/src/metadata/resolved/types/error.rs → v3/crates/metadata-resolve/src/types/error.rs
View File

@ -1,7 +1,7 @@
use thiserror::Error;
use crate::metadata::resolved::helpers::argument::ArgumentMappingError;
use crate::metadata::resolved::types::subgraph::{Qualified, QualifiedTypeReference};
use crate::helpers::argument::ArgumentMappingError;
use crate::types::subgraph::{Qualified, QualifiedTypeReference};
use lang_graphql::ast::common as ast;
use open_dds::{
arguments::ArgumentName,
@ -12,7 +12,7 @@ use open_dds::{
types::{CustomTypeName, FieldName, OperatorName, TypeReference},
};
use crate::metadata::resolved::helpers::{
use crate::helpers::{
ndc_validation::NDCValidationError, type_mappings::TypeMappingCollectionError, typecheck,
};

0
v3/crates/engine/src/metadata/resolved/types/mod.rs → v3/crates/metadata-resolve/src/types/mod.rs
View File

2
v3/crates/engine/src/metadata/resolved/types/permission.rs → v3/crates/metadata-resolve/src/types/permission.rs
View File

@ -1,4 +1,4 @@
use crate::metadata::resolved::stages::model_permissions;
use crate::stages::model_permissions;
use serde::{Deserialize, Serialize};
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]

0
v3/crates/engine/src/metadata/resolved/types/subgraph.rs → v3/crates/metadata-resolve/src/types/subgraph.rs
View File

12
v3/docs/architecture.md
View File

@ -17,12 +17,12 @@ crates
│   │   ├── schema
│   │   ├── introspection
│   │   ├── validation
├── metadata-resolve
├── engine
│   ├── bin
│   │   ├── engine
│   ├── src
│   │   ├── execute
│   │   ├── metadata
│   │   ├── schema
│   │   │   ├── operations
│   │   │   ├── types
@ -72,6 +72,11 @@ Provides schema and type introspection for GraphQL schemas.
Validates GraphQL requests vs a schema, and produces normalized ASTs, which
contain additional relevant data from the schema.
##### `metadata-resolve`
Resolves and validates the input Open DDS metadata and creates intermediate
structures that are used in the `engine` crate for schema generation.
### `engine`
Responsible for the core operation of the engine in the context of a user
@ -90,11 +95,6 @@ primitives provided by the `lang-graphql` crate. It is responsible for
validating Open DDS metadata, creating a GraphQL schema from resolved Open DDS
metadata, and implementing the GraphQL operations.
##### `engine/src/metadata`
Resolves and validates the input Open DDS metadata and creates intermediate
structures that are used in the rest of the crate for schema generation.
##### `engine/src/schema`
Provides functions to resolve the Open DDS metadata, generate the GraphQL scehma