@aws-amplify/graphql-api-construct 1.4.3 → 1.5.1-alpha.1

package/lib/internal/data-source-config.js

@@ -1,24 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mapInterfaceCustomSqlStrategiesToImplementationStrategies = exports.constructCustomSqlDataSourceStrategies = exports.parseDataSourceConfig = void 0;
+exports.validateDataSourceStrategy = exports.schemaByMergingDefinitions = exports.getDataSourceStrategiesProvider = exports.constructCustomSqlDataSourceStrategies = void 0;
 const graphql_1 = require("graphql");
 const graphql_transformer_core_1 = require("@aws-amplify/graphql-transformer-core");
-const utils_1 = require("@aws-amplify/graphql-transformer-core/lib/utils");
-/**
- * An internal helper to convert from a map of model-to-ModelDataSourceStrategies to the map of model-to-DataSourceTypes that internal
- * transform processing requires. TODO: We can remove this once we refactor the internals to use ModelDataSourceStrategies natively.
- */
-const parseDataSourceConfig = (dataSourceDefinitionMap) => {
-    const modelToDatasourceMap = new Map();
-    for (const [key, value] of Object.entries(dataSourceDefinitionMap)) {
-        const dataSourceType = (0, graphql_transformer_core_1.dataSourceStrategyToDataSourceType)(value);
-        modelToDatasourceMap.set(key, dataSourceType);
-    }
-    return {
-        modelToDatasourceMap,
-    };
-};
-exports.parseDataSourceConfig = parseDataSourceConfig;
 /**
  * Creates an interface flavor of customSqlDataSourceStrategies from a factory method's schema and data source. Internally, this function
  * scans the fields of `Query` and `Mutation` looking for fields annotated with the `@sql` directive and designates the specified
@@ -26,8 +10,6 @@ exports.parseDataSourceConfig = parseDataSourceConfig;
  *
  * Note that we do not scan for `Subscription` fields: `@sql` directives are not allowed on those, and it wouldn't make sense to do so
  * anyway, since subscriptions are processed from an incoming Mutation, not as the result of a direct datasource access.
- *
- * TODO: Reword this when we refactor to use Strategies throughout the implementation rather than DataSources.
  */
 const constructCustomSqlDataSourceStrategies = (schema, dataSourceStrategy) => {
     if (!(0, graphql_transformer_core_1.isSqlStrategy)(dataSourceStrategy)) {
@@ -64,25 +46,115 @@ const constructCustomSqlDataSourceStrategies = (schema, dataSourceStrategy) => {
 };
 exports.constructCustomSqlDataSourceStrategies = constructCustomSqlDataSourceStrategies;
 /**
- * We currently use a different type structure to model strategies in the interface than we do in the implementation. This maps the
- * interface CustomSqlDataSourceStrategy (which uses SQLLambdaModelDataSourceStrategy) to the implementation flavor (which uses
- * DataSourceType).
- *
- * TODO: Remove this once we refactor the internals to use strategies rather than DataSourceTypes
+ * Extracts the data source provider from the definition. This jumps through some hoops to avoid changing the public interface. If we decide
+ * to change the public interface to simplify the structure, then this process gets a lot simpler.
  */
-const mapInterfaceCustomSqlStrategiesToImplementationStrategies = (strategies) => {
-    if (!strategies) {
-        return [];
+const getDataSourceStrategiesProvider = (definition) => {
+    const provider = {
+        // We can directly use the interface strategies, even though the SQL strategies have the customSqlStatements field that is unused by the
+        // transformer flavor of this type
+        dataSourceStrategies: definition.dataSourceStrategies,
+        sqlDirectiveDataSourceStrategies: [],
+    };
+    // We'll collect all the custom SQL statements from the definition into a single map, and use that to make our
+    // SqlDirectiveDataSourceStrategies
+    const customSqlStatements = {};
+    const constructSqlStrategies = definition.customSqlDataSourceStrategies ?? [];
+    // Note that we're relying on the `customSqlStatements` object reference to stay the same throughout this loop. Don't reassign it, or the
+    // collected sqlDirectiveStrategies will break
+    constructSqlStrategies.forEach((sqlStrategy) => {
+        if (sqlStrategy.strategy.customSqlStatements) {
+            Object.assign(customSqlStatements, sqlStrategy.strategy.customSqlStatements);
+        }
+        provider.sqlDirectiveDataSourceStrategies.push({
+            typeName: sqlStrategy.typeName,
+            fieldName: sqlStrategy.fieldName,
+            strategy: sqlStrategy.strategy,
+            customSqlStatements,
+        });
+    });
+    return provider;
+};
+exports.getDataSourceStrategiesProvider = getDataSourceStrategiesProvider;
+/**
+ * Creates a new schema by merging the individual schemas contained in the definitions, combining fields of the Query and Mutation types in
+ * individual definitions into a single combined definition. Adding directives to `Query` and `Mutation` types participating in a
+ * combination is not supported (the behavior is undefined whether those directives are migrated).
+ */
+const schemaByMergingDefinitions = (definitions) => {
+    const schema = definitions.map((def) => def.schema).join('\n');
+    const parsedSchema = (0, graphql_1.parse)(schema);
+    // We store the Query & Mutation definitions separately. Since the interfaces are readonly, we'll have to re-compose the types after we've
+    // collected all the fields
+    const queryAndMutationDefinitions = {};
+    // Throws if the field has already been encountered
+    const validateField = (typeName, fieldName) => {
+        const fields = queryAndMutationDefinitions[typeName]?.fields;
+        if (!fields) {
+            return;
+        }
+        if (fields.find((field) => field.name.value === fieldName)) {
+            throw new Error(`The custom ${typeName} field '${fieldName}' was found in multiple definitions, but a field name cannot be shared between definitions.`);
+        }
+    };
+    // Transform the schema by reducing Mutation & Query types:
+    // - Collect Mutation and Query definitions
+    // - Alter the parsed schema by filtering out Mutation & Query types
+    // - Add the combined Mutation & Query definitions to the filtered schema
+    parsedSchema.definitions.filter(graphql_transformer_core_1.isBuiltInGraphqlNode).forEach((def) => {
+        const typeName = def.name.value;
+        if (!queryAndMutationDefinitions[typeName]) {
+            queryAndMutationDefinitions[typeName] = {
+                node: def,
+                // `ObjectTypeDefinitionNode.fields` is a ReadonlyArray; so we have to create a new mutable array to collect all the fields
+                fields: [...(def.fields ?? [])],
+            };
+            return;
+        }
+        (def.fields ?? []).forEach((field) => {
+            validateField(typeName, field.name.value);
+        });
+        queryAndMutationDefinitions[typeName].fields = [...queryAndMutationDefinitions[typeName].fields, ...(def.fields ?? [])];
+    });
+    // Gather the collected Query & Mutation fields into <=2 new definitions
+    const combinedDefinitions = Object.values(queryAndMutationDefinitions)
+        .sort((a, b) => a.node.name.value.localeCompare(b.node.name.value))
+        .reduce((acc, cur) => {
+        const definitionNode = {
+            ...cur.node,
+            fields: cur.fields,
+        };
+        return [...acc, definitionNode];
+    }, []);
+    // Filter out the old Query & Mutation definitions
+    const filteredDefinitions = parsedSchema.definitions.filter((def) => !(0, graphql_transformer_core_1.isBuiltInGraphqlNode)(def));
+    // Compose the new schema by appending the collected definitions to the filtered definitions. This means that every query will be
+    // rewritten such that the Mutation and Query types appear at the end of the schema.
+    const newSchema = {
+        ...parsedSchema,
+        definitions: [...filteredDefinitions, ...combinedDefinitions],
+    };
+    const combinedSchemaString = (0, graphql_1.print)(newSchema);
+    return combinedSchemaString;
+};
+exports.schemaByMergingDefinitions = schemaByMergingDefinitions;
+/*
+ * Validates the user input for the dataSourceStrategy. This is a no-op for DynamoDB strategies for now.
+ * @param strategy user provided model data source strategy
+ * @returns validates and throws an error if the strategy is invalid
+ */
+const validateDataSourceStrategy = (strategy) => {
+    if (!(0, graphql_transformer_core_1.isSqlStrategy)(strategy)) {
+        return;
     }
-    return strategies.map((interfaceStrategy) => ({
-        fieldName: interfaceStrategy.fieldName,
-        typeName: interfaceStrategy.typeName,
-        dataSourceType: {
-            dbType: (0, utils_1.normalizeDbType)(interfaceStrategy.strategy.dbType),
-            provisionDB: false,
-            provisionStrategy: "DEFAULT" /* SQLLambdaModelProvisionStrategy.DEFAULT */,
-        },
-    }));
+    const dbConnectionConfig = strategy.dbConnectionConfig;
+    const invalidSSMPaths = Object.values(dbConnectionConfig).filter((value) => typeof value === 'string' && !isValidSSMPath(value));
+    if (invalidSSMPaths.length > 0) {
+        throw new Error(`Invalid data source strategy "${strategy.name}". Following SSM paths must start with '/' in dbConnectionConfig: ${invalidSSMPaths.join(', ')}.`);
+    }
+};
+exports.validateDataSourceStrategy = validateDataSourceStrategy;
+const isValidSSMPath = (path) => {
+    return path.startsWith('/');
 };
-exports.mapInterfaceCustomSqlStrategiesToImplementationStrategies = mapInterfaceCustomSqlStrategiesToImplementationStrategies;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"data-source-config.js","sourceRoot":"","sources":["../../src/internal/data-source-config.ts"],"names":[],"mappings":";;;AAAA,qCAAgC;AAMhC,oFAM+C;AAC/C,2EAAkF;AAOlF;;;GAGG;AACI,MAAM,qBAAqB,GAAG,CAAC,uBAAgE,EAAoB,EAAE;IAC1H,MAAM,oBAAoB,GAAG,IAAI,GAAG,EAA0B,CAAC;IAC/D,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,uBAAuB,CAAC,EAAE;QAClE,MAAM,cAAc,GAAG,IAAA,6DAAkC,EAAC,KAAK,CAAC,CAAC;QACjE,oBAAoB,CAAC,GAAG,CAAC,GAAG,EAAE,cAAc,CAAC,CAAC;KAC/C;IACD,OAAO;QACL,oBAAoB;KACrB,CAAC;AACJ,CAAC,CAAC;AATW,QAAA,qBAAqB,yBAShC;AAEF;;;;;;;;;GASG;AACI,MAAM,sCAAsC,GAAG,CACpD,MAAc,EACd,kBAA2C,EACH,EAAE;IAC1C,IAAI,CAAC,IAAA,wCAAa,EAAC,kBAAkB,CAAC,EAAE;QACtC,OAAO,EAAE,CAAC;KACX;IAED,MAAM,YAAY,GAAG,IAAA,eAAK,EAAC,MAAM,CAAC,CAAC;IAEnC,MAAM,SAAS,GAAG,YAAY,CAAC,WAAW,CAAC,IAAI,CAAC,sCAAW,CAAC,CAAC;IAC7D,MAAM,YAAY,GAAG,YAAY,CAAC,WAAW,CAAC,IAAI,CAAC,yCAAc,CAAC,CAAC;IACnE,IAAI,CAAC,SAAS,IAAI,CAAC,YAAY,EAAE;QAC/B,OAAO,EAAE,CAAC;KACX;IAED,MAAM,6BAA6B,GAA2C,EAAE,CAAC;IAEjF,IAAI,SAAS,EAAE;QACb,MAAM,MAAM,GAAG,IAAA,iDAAsB,EAAC,SAAS,CAAC,CAAC;QACjD,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE;YAC1B,6BAA6B,CAAC,IAAI,CAAC;gBACjC,QAAQ,EAAE,OAAO;gBACjB,SAAS,EAAE,KAAK,CAAC,IAAI,CAAC,KAAK;gBAC3B,QAAQ,EAAE,kBAAkB;aAC7B,CAAC,CAAC;SACJ;KACF;IAED,IAAI,YAAY,EAAE;QAChB,MAAM,MAAM,GAAG,IAAA,iDAAsB,EAAC,YAAY,CAAC,CAAC;QACpD,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE;YAC1B,6BAA6B,CAAC,IAAI,CAAC;gBACjC,QAAQ,EAAE,UAAU;gBACpB,SAAS,EAAE,KAAK,CAAC,IAAI,CAAC,KAAK;gBAC3B,QAAQ,EAAE,kBAAkB;aAC7B,CAAC,CAAC;SACJ;KACF;IAED,OAAO,6BAA6B,CAAC;AACvC,CAAC,CAAC;AAzCW,QAAA,sCAAsC,0CAyCjD;AAEF;;;;;;GAMG;AACI,MAAM,yDAAyD,GAAG,CACvE,UAAmD,EACN,EAAE;IAC/C,IAAI,CAAC,UAAU,EAAE;QACf,OAAO,EAAE,CAAC;KACX;IACD,OAAO,UAAU,CAAC,GAAG,CAAC,CAAC,iBAAiB,EAAE,EAAE,CAAC,CAAC;QAC5C,SAAS,EAAE,iBAAiB,CAAC,SAAS;QACtC,QAAQ,EAAE,iBAAiB,CAAC,QAAQ;QACpC,cAAc,EAAE;YACd,MAAM,EAAE,IAAA,uBAAe,EAAC,iBAAiB,CAAC,QAAQ,CAAC,MAAM,CAAC;YAC1D,WAAW,EAAE,KAAK;YAClB,iBAAiB,yDAAyC;SAC3D;KACF,CAAC,CAAC,CAAC;AACN,CAAC,CAAC;AAfW,QAAA,yDAAyD,6DAepE","sourcesContent":["import { parse } from 'graphql';\nimport {\n  CustomSqlDataSourceStrategy as ImplementationCustomSqlDataSourceStrategy,\n  DataSourceType,\n  SQLLambdaModelProvisionStrategy,\n} from '@aws-amplify/graphql-transformer-interfaces';\nimport {\n  dataSourceStrategyToDataSourceType,\n  isSqlStrategy,\n  isQueryNode,\n  isMutationNode,\n  fieldsWithSqlDirective,\n} from '@aws-amplify/graphql-transformer-core';\nimport { normalizeDbType } from '@aws-amplify/graphql-transformer-core/lib/utils';\nimport { CustomSqlDataSourceStrategy as InterfaceCustomSqlDataSourceStrategy, ModelDataSourceStrategy } from '../model-datasource-strategy';\n\ntype DataSourceConfig = {\n  modelToDatasourceMap: Map<string, DataSourceType>;\n};\n\n/**\n * An internal helper to convert from a map of model-to-ModelDataSourceStrategies to the map of model-to-DataSourceTypes that internal\n * transform processing requires. TODO: We can remove this once we refactor the internals to use ModelDataSourceStrategies natively.\n */\nexport const parseDataSourceConfig = (dataSourceDefinitionMap: Record<string, ModelDataSourceStrategy>): DataSourceConfig => {\n  const modelToDatasourceMap = new Map<string, DataSourceType>();\n  for (const [key, value] of Object.entries(dataSourceDefinitionMap)) {\n    const dataSourceType = dataSourceStrategyToDataSourceType(value);\n    modelToDatasourceMap.set(key, dataSourceType);\n  }\n  return {\n    modelToDatasourceMap,\n  };\n};\n\n/**\n * Creates an interface flavor of customSqlDataSourceStrategies from a factory method's schema and data source. Internally, this function\n * scans the fields of `Query` and `Mutation` looking for fields annotated with the `@sql` directive and designates the specified\n * dataSourceStrategy to fulfill those custom queries.\n *\n * Note that we do not scan for `Subscription` fields: `@sql` directives are not allowed on those, and it wouldn't make sense to do so\n * anyway, since subscriptions are processed from an incoming Mutation, not as the result of a direct datasource access.\n *\n * TODO: Reword this when we refactor to use Strategies throughout the implementation rather than DataSources.\n */\nexport const constructCustomSqlDataSourceStrategies = (\n  schema: string,\n  dataSourceStrategy: ModelDataSourceStrategy,\n): InterfaceCustomSqlDataSourceStrategy[] => {\n  if (!isSqlStrategy(dataSourceStrategy)) {\n    return [];\n  }\n\n  const parsedSchema = parse(schema);\n\n  const queryNode = parsedSchema.definitions.find(isQueryNode);\n  const mutationNode = parsedSchema.definitions.find(isMutationNode);\n  if (!queryNode && !mutationNode) {\n    return [];\n  }\n\n  const customSqlDataSourceStrategies: InterfaceCustomSqlDataSourceStrategy[] = [];\n\n  if (queryNode) {\n    const fields = fieldsWithSqlDirective(queryNode);\n    for (const field of fields) {\n      customSqlDataSourceStrategies.push({\n        typeName: 'Query',\n        fieldName: field.name.value,\n        strategy: dataSourceStrategy,\n      });\n    }\n  }\n\n  if (mutationNode) {\n    const fields = fieldsWithSqlDirective(mutationNode);\n    for (const field of fields) {\n      customSqlDataSourceStrategies.push({\n        typeName: 'Mutation',\n        fieldName: field.name.value,\n        strategy: dataSourceStrategy,\n      });\n    }\n  }\n\n  return customSqlDataSourceStrategies;\n};\n\n/**\n * We currently use a different type structure to model strategies in the interface than we do in the implementation. This maps the\n * interface CustomSqlDataSourceStrategy (which uses SQLLambdaModelDataSourceStrategy) to the implementation flavor (which uses\n * DataSourceType).\n *\n * TODO: Remove this once we refactor the internals to use strategies rather than DataSourceTypes\n */\nexport const mapInterfaceCustomSqlStrategiesToImplementationStrategies = (\n  strategies?: InterfaceCustomSqlDataSourceStrategy[],\n): ImplementationCustomSqlDataSourceStrategy[] => {\n  if (!strategies) {\n    return [];\n  }\n  return strategies.map((interfaceStrategy) => ({\n    fieldName: interfaceStrategy.fieldName,\n    typeName: interfaceStrategy.typeName,\n    dataSourceType: {\n      dbType: normalizeDbType(interfaceStrategy.strategy.dbType),\n      provisionDB: false,\n      provisionStrategy: SQLLambdaModelProvisionStrategy.DEFAULT,\n    },\n  }));\n};\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"data-source-config.js","sourceRoot":"","sources":["../../src/internal/data-source-config.ts"],"names":[],"mappings":"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","sourcesContent":["import { DefinitionNode, FieldDefinitionNode, InterfaceTypeDefinitionNode, ObjectTypeDefinitionNode, parse, print } from 'graphql';\nimport {\n  isBuiltInGraphqlNode,\n  isSqlStrategy,\n  isQueryNode,\n  isMutationNode,\n  fieldsWithSqlDirective,\n} from '@aws-amplify/graphql-transformer-core';\nimport { DataSourceStrategiesProvider } from '@aws-amplify/graphql-transformer-interfaces';\nimport {\n  CustomSqlDataSourceStrategy as ConstructCustomSqlDataSourceStrategy,\n  ModelDataSourceStrategy as ConstructModelDataSourceStrategy,\n} from '../model-datasource-strategy-types';\nimport { IAmplifyGraphqlDefinition } from '../types';\n\n/**\n * Creates an interface flavor of customSqlDataSourceStrategies from a factory method's schema and data source. Internally, this function\n * scans the fields of `Query` and `Mutation` looking for fields annotated with the `@sql` directive and designates the specified\n * dataSourceStrategy to fulfill those custom queries.\n *\n * Note that we do not scan for `Subscription` fields: `@sql` directives are not allowed on those, and it wouldn't make sense to do so\n * anyway, since subscriptions are processed from an incoming Mutation, not as the result of a direct datasource access.\n */\nexport const constructCustomSqlDataSourceStrategies = (\n  schema: string,\n  dataSourceStrategy: ConstructModelDataSourceStrategy,\n): ConstructCustomSqlDataSourceStrategy[] => {\n  if (!isSqlStrategy(dataSourceStrategy)) {\n    return [];\n  }\n\n  const parsedSchema = parse(schema);\n\n  const queryNode = parsedSchema.definitions.find(isQueryNode);\n  const mutationNode = parsedSchema.definitions.find(isMutationNode);\n  if (!queryNode && !mutationNode) {\n    return [];\n  }\n\n  const customSqlDataSourceStrategies: ConstructCustomSqlDataSourceStrategy[] = [];\n\n  if (queryNode) {\n    const fields = fieldsWithSqlDirective(queryNode);\n    for (const field of fields) {\n      customSqlDataSourceStrategies.push({\n        typeName: 'Query',\n        fieldName: field.name.value,\n        strategy: dataSourceStrategy,\n      });\n    }\n  }\n\n  if (mutationNode) {\n    const fields = fieldsWithSqlDirective(mutationNode);\n    for (const field of fields) {\n      customSqlDataSourceStrategies.push({\n        typeName: 'Mutation',\n        fieldName: field.name.value,\n        strategy: dataSourceStrategy,\n      });\n    }\n  }\n\n  return customSqlDataSourceStrategies;\n};\n\n/**\n * Extracts the data source provider from the definition. This jumps through some hoops to avoid changing the public interface. If we decide\n * to change the public interface to simplify the structure, then this process gets a lot simpler.\n */\nexport const getDataSourceStrategiesProvider = (definition: IAmplifyGraphqlDefinition): DataSourceStrategiesProvider => {\n  const provider: DataSourceStrategiesProvider = {\n    // We can directly use the interface strategies, even though the SQL strategies have the customSqlStatements field that is unused by the\n    // transformer flavor of this type\n    dataSourceStrategies: definition.dataSourceStrategies,\n    sqlDirectiveDataSourceStrategies: [],\n  };\n\n  // We'll collect all the custom SQL statements from the definition into a single map, and use that to make our\n  // SqlDirectiveDataSourceStrategies\n  const customSqlStatements: Record<string, string> = {};\n\n  const constructSqlStrategies = definition.customSqlDataSourceStrategies ?? [];\n\n  // Note that we're relying on the `customSqlStatements` object reference to stay the same throughout this loop. Don't reassign it, or the\n  // collected sqlDirectiveStrategies will break\n  constructSqlStrategies.forEach((sqlStrategy) => {\n    if (sqlStrategy.strategy.customSqlStatements) {\n      Object.assign(customSqlStatements, sqlStrategy.strategy.customSqlStatements);\n    }\n\n    provider.sqlDirectiveDataSourceStrategies!.push({\n      typeName: sqlStrategy.typeName,\n      fieldName: sqlStrategy.fieldName,\n      strategy: sqlStrategy.strategy,\n      customSqlStatements,\n    });\n  });\n\n  return provider;\n};\n\n/**\n * Creates a new schema by merging the individual schemas contained in the definitions, combining fields of the Query and Mutation types in\n * individual definitions into a single combined definition. Adding directives to `Query` and `Mutation` types participating in a\n * combination is not supported (the behavior is undefined whether those directives are migrated).\n */\nexport const schemaByMergingDefinitions = (definitions: IAmplifyGraphqlDefinition[]): string => {\n  const schema = definitions.map((def) => def.schema).join('\\n');\n  const parsedSchema = parse(schema);\n\n  // We store the Query & Mutation definitions separately. Since the interfaces are readonly, we'll have to re-compose the types after we've\n  // collected all the fields\n  const queryAndMutationDefinitions: Record<\n    string,\n    {\n      node: ObjectTypeDefinitionNode | InterfaceTypeDefinitionNode;\n      fields: FieldDefinitionNode[];\n    }\n  > = {};\n\n  // Throws if the field has already been encountered\n  const validateField = (typeName: string, fieldName: string): void => {\n    const fields = queryAndMutationDefinitions[typeName]?.fields;\n    if (!fields) {\n      return;\n    }\n    if (fields.find((field) => field.name.value === fieldName)) {\n      throw new Error(\n        `The custom ${typeName} field '${fieldName}' was found in multiple definitions, but a field name cannot be shared between definitions.`,\n      );\n    }\n  };\n\n  // Transform the schema by reducing Mutation & Query types:\n  // - Collect Mutation and Query definitions\n  // - Alter the parsed schema by filtering out Mutation & Query types\n  // - Add the combined Mutation & Query definitions to the filtered schema\n  parsedSchema.definitions.filter(isBuiltInGraphqlNode).forEach((def) => {\n    const typeName = def.name.value;\n    if (!queryAndMutationDefinitions[typeName]) {\n      queryAndMutationDefinitions[typeName] = {\n        node: def,\n        // `ObjectTypeDefinitionNode.fields` is a ReadonlyArray; so we have to create a new mutable array to collect all the fields\n        fields: [...(def.fields ?? [])],\n      };\n      return;\n    }\n\n    (def.fields ?? []).forEach((field) => {\n      validateField(typeName, field.name.value);\n    });\n\n    queryAndMutationDefinitions[typeName].fields = [...queryAndMutationDefinitions[typeName].fields, ...(def.fields ?? [])];\n  });\n\n  // Gather the collected Query & Mutation fields into <=2 new definitions\n  const combinedDefinitions = Object.values(queryAndMutationDefinitions)\n    .sort((a, b) => a.node.name.value.localeCompare(b.node.name.value))\n    .reduce((acc, cur) => {\n      const definitionNode = {\n        ...cur.node,\n        fields: cur.fields,\n      };\n      return [...acc, definitionNode];\n    }, [] as DefinitionNode[]);\n\n  // Filter out the old Query & Mutation definitions\n  const filteredDefinitions = parsedSchema.definitions.filter((def) => !isBuiltInGraphqlNode(def));\n\n  // Compose the new schema by appending the collected definitions to the filtered definitions. This means that every query will be\n  // rewritten such that the Mutation and Query types appear at the end of the schema.\n  const newSchema = {\n    ...parsedSchema,\n    definitions: [...filteredDefinitions, ...combinedDefinitions],\n  };\n\n  const combinedSchemaString = print(newSchema);\n  return combinedSchemaString;\n};\n\n/*\n * Validates the user input for the dataSourceStrategy. This is a no-op for DynamoDB strategies for now.\n * @param strategy user provided model data source strategy\n * @returns validates and throws an error if the strategy is invalid\n */\nexport const validateDataSourceStrategy = (strategy: ConstructModelDataSourceStrategy) => {\n  if (!isSqlStrategy(strategy)) {\n    return;\n  }\n\n  const dbConnectionConfig = strategy.dbConnectionConfig;\n  const invalidSSMPaths = Object.values(dbConnectionConfig).filter((value) => typeof value === 'string' && !isValidSSMPath(value));\n  if (invalidSSMPaths.length > 0) {\n    throw new Error(\n      `Invalid data source strategy \"${\n        strategy.name\n      }\". Following SSM paths must start with '/' in dbConnectionConfig: ${invalidSSMPaths.join(', ')}.`,\n    );\n  }\n};\n\nconst isValidSSMPath = (path: string): boolean => {\n  return path.startsWith('/');\n};\n"]}

package/lib/internal/model-type-name.d.ts

@@ -1,8 +1,8 @@
-import { ModelDataSourceStrategy } from '../model-datasource-strategy';
+import { ModelDataSourceStrategy } from '../model-datasource-strategy-types';
 /**
  * Get the type names with model directives in the GraphQL schema in SDL
  * @param schema graphql schema in SDL
  * @returns type names which model diretives are attached
  */
 export declare const getModelTypeNames: (schema: string) => string[];
-export declare const constructDataSourceStrategyMap: (schema: string, dataSourceStrategy: ModelDataSourceStrategy) => Record<string, ModelDataSourceStrategy>;
+export declare const constructDataSourceStrategies: (schema: string, dataSourceStrategy: ModelDataSourceStrategy) => Record<string, ModelDataSourceStrategy>;

package/lib/internal/model-type-name.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.constructDataSourceStrategyMap = exports.getModelTypeNames = void 0;
+exports.constructDataSourceStrategies = exports.getModelTypeNames = void 0;
 const graphql_1 = require("graphql");
 const MODEL_DIRECTIVE_NAME = 'model';
 const MANY_TO_MANY_DIRECTIVE_NAME = 'manyToMany';
@@ -29,9 +29,9 @@ const getModelTypeNames = (schema) => {
     return modelKeys.filter((key, idx) => modelKeys.indexOf(key) === idx);
 };
 exports.getModelTypeNames = getModelTypeNames;
-const constructDataSourceStrategyMap = (schema, dataSourceStrategy) => {
+const constructDataSourceStrategies = (schema, dataSourceStrategy) => {
     const modelKeys = (0, exports.getModelTypeNames)(schema);
     return modelKeys.reduce((acc, cur) => ({ ...acc, [cur]: dataSourceStrategy }), {});
 };
-exports.constructDataSourceStrategyMap = constructDataSourceStrategyMap;
-//# sourceMappingURL=data:application/json;base64,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
+exports.constructDataSourceStrategies = constructDataSourceStrategies;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/{model-datasource-strategy.d.ts → model-datasource-strategy-types.d.ts}

@@ -1,12 +1,17 @@
 /**
  * All known ModelDataSourceStrategies. Concrete strategies vary widely in their requirements and implementations.
- * @experimental
  */
 export type ModelDataSourceStrategy = DefaultDynamoDbModelDataSourceStrategy | AmplifyDynamoDbModelDataSourceStrategy | SQLLambdaModelDataSourceStrategy;
-export type ModelDataSourceStrategyDbType = 'DYNAMODB';
+/**
+ * All supported database types that can be used to resolve models.
+ */
+export type ModelDataSourceStrategyDbType = 'DYNAMODB' | ModelDataSourceStrategySqlDbType;
+/**
+ * All supported SQL database types that can be used to resolve models.
+ */
+export type ModelDataSourceStrategySqlDbType = 'MYSQL' | 'POSTGRES';
 /**
  * Use default CloudFormation type 'AWS::DynamoDB::Table' to provision table.
- * @experimental
  */
 export interface DefaultDynamoDbModelDataSourceStrategy {
     readonly dbType: 'DYNAMODB';
@@ -14,7 +19,6 @@ export interface DefaultDynamoDbModelDataSourceStrategy {
 }
 /**
  * Use custom resource type 'Custom::AmplifyDynamoDBTable' to provision table.
- * @experimental
  */
 export interface AmplifyDynamoDbModelDataSourceStrategy {
     readonly dbType: 'DYNAMODB';
@@ -22,8 +26,6 @@ export interface AmplifyDynamoDbModelDataSourceStrategy {
 }
 /**
  * A strategy that creates a Lambda to connect to a pre-existing SQL table to resolve model data.
- *
- * @experimental
  */
 export interface SQLLambdaModelDataSourceStrategy {
     /**
@@ -34,7 +36,7 @@ export interface SQLLambdaModelDataSourceStrategy {
     /**
      * The type of the SQL database used to process model operations for this definition.
      */
-    readonly dbType: 'MYSQL' | 'POSTGRES';
+    readonly dbType: ModelDataSourceStrategySqlDbType;
     /**
      * The parameters the Lambda data source will use to connect to the database.
      */
@@ -59,7 +61,6 @@ export interface SQLLambdaModelDataSourceStrategy {
  * have at least one subnet. The construct will also create VPC service endpoints in the specified subnets, as well as inbound security
  * rules, to allow traffic on port 443 within each security group. This allows the Lambda to read database connection information from
  * Secure Systems Manager.
- * @experimental
  */
 export interface VpcConfig {
     /** The VPC to install the Lambda data source in. */
@@ -71,7 +72,6 @@ export interface VpcConfig {
 }
 /**
  * The configuration for the provisioned concurrency of the Lambda.
- * @experimental
  */
 export interface ProvisionedConcurrencyConfig {
     /** The amount of provisioned concurrency to allocate. **/
@@ -81,7 +81,6 @@ export interface ProvisionedConcurrencyConfig {
  * Subnet configuration for VPC endpoints used by a Lambda resolver for a SQL-based data source. Although it is possible to create multiple
  * subnets in a single availability zone, VPC service endpoints may only be deployed to a single subnet in a given availability zone. This
  * structure ensures that the Lambda function and VPC service endpoints are mutually consistent.
- * @experimental
  */
 export interface SubnetAvailabilityZone {
     /** The subnet ID to install the Lambda data source in. */
@@ -93,7 +92,6 @@ export interface SubnetAvailabilityZone {
  * The Secure Systems Manager parameter paths the Lambda data source will use to connect to the database.
  *
  * These parameters are retrieved from Secure Systems Manager in the same region as the Lambda.
- * @experimental
  */
 export interface SqlModelDataSourceDbConnectionConfig {
     /** The Secure Systems Manager parameter containing the hostname of the database. For RDS-based SQL data sources, this can be the hostname
@@ -109,8 +107,16 @@ export interface SqlModelDataSourceDbConnectionConfig {
     /** The Secure Systems Manager parameter containing the database name. */
     readonly databaseNameSsmPath: string;
 }
+/**
+ * The input type for defining a ModelDataSourceStrategy used to resolve a field annotated with a `@sql` directive. Although this is a
+ * public type, you should rarely need to use this. The AmplifyGraphqlDefinition factory methods (e.g., `fromString`,
+ * `fromFilesAndStrategy`) will automatically construct this structure for you.
+ */
 export interface CustomSqlDataSourceStrategy {
+    /** The built-in type (either "Query" or "Mutation") with which the custom SQL is associated */
     readonly typeName: 'Query' | 'Mutation';
+    /** The field name with which the custom SQL is associated */
     readonly fieldName: string;
+    /** The strategy used to create the datasource that will resolve the custom SQL statement. */
     readonly strategy: SQLLambdaModelDataSourceStrategy;
 }

package/lib/model-datasource-strategy-types.js

@@ -0,0 +1,10 @@
+"use strict";
+// #########################################################################################################################################
+// These are the public-facing types used by customers to define their L3 CDK construct. Many of these have corresponding definitions in the
+// transformer-interfaces package to define internal behavior.
+//
+// If you change types in this file (the customer-facing interface), be sure to make corresponding changes to
+// amplify-graphql-transformer-interfaces/src/model-datasource (the internal implementation)
+// #########################################################################################################################################
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"model-datasource-strategy-types.js","sourceRoot":"","sources":["../src/model-datasource-strategy-types.ts"],"names":[],"mappings":";AAAA,4IAA4I;AAC5I,4IAA4I;AAC5I,8DAA8D;AAC9D,EAAE;AACF,6GAA6G;AAC7G,4FAA4F;AAC5F,4IAA4I","sourcesContent":["// #########################################################################################################################################\n// These are the public-facing types used by customers to define their L3 CDK construct. Many of these have corresponding definitions in the\n// transformer-interfaces package to define internal behavior.\n//\n// If you change types in this file (the customer-facing interface), be sure to make corresponding changes to\n// amplify-graphql-transformer-interfaces/src/model-datasource (the internal implementation)\n// #########################################################################################################################################\n\n/**\n * All known ModelDataSourceStrategies. Concrete strategies vary widely in their requirements and implementations.\n */\nexport type ModelDataSourceStrategy =\n  | DefaultDynamoDbModelDataSourceStrategy\n  | AmplifyDynamoDbModelDataSourceStrategy\n  | SQLLambdaModelDataSourceStrategy;\n\n/**\n * All supported database types that can be used to resolve models.\n */\nexport type ModelDataSourceStrategyDbType = 'DYNAMODB' | ModelDataSourceStrategySqlDbType;\n\n/**\n * All supported SQL database types that can be used to resolve models.\n */\nexport type ModelDataSourceStrategySqlDbType = 'MYSQL' | 'POSTGRES';\n\n/**\n * Use default CloudFormation type 'AWS::DynamoDB::Table' to provision table.\n */\nexport interface DefaultDynamoDbModelDataSourceStrategy {\n  readonly dbType: 'DYNAMODB';\n  readonly provisionStrategy: 'DEFAULT';\n}\n\n/**\n * Use custom resource type 'Custom::AmplifyDynamoDBTable' to provision table.\n */\nexport interface AmplifyDynamoDbModelDataSourceStrategy {\n  readonly dbType: 'DYNAMODB';\n  readonly provisionStrategy: 'AMPLIFY_TABLE';\n}\n\n/**\n * A strategy that creates a Lambda to connect to a pre-existing SQL table to resolve model data.\n */\nexport interface SQLLambdaModelDataSourceStrategy {\n  /**\n   * The name of the strategy. This will be used to name the AppSync DataSource itself, plus any associated resources like resolver Lambdas.\n   * This name must be unique across all schema definitions in a GraphQL API.\n   */\n  readonly name: string;\n\n  /**\n   * The type of the SQL database used to process model operations for this definition.\n   */\n  readonly dbType: ModelDataSourceStrategySqlDbType;\n\n  /**\n   * The parameters the Lambda data source will use to connect to the database.\n   */\n  readonly dbConnectionConfig: SqlModelDataSourceDbConnectionConfig;\n\n  /**\n   * The configuration of the VPC into which to install the Lambda.\n   */\n  readonly vpcConfiguration?: VpcConfig;\n\n  /**\n   * Custom SQL statements. The key is the value of the `references` attribute of the `@sql` directive in the `schema`; the value is the SQL\n   * to be executed.\n   */\n  readonly customSqlStatements?: Record<string, string>;\n\n  /**\n   * The configuration for the provisioned concurrency of the Lambda.\n   */\n  readonly sqlLambdaProvisionedConcurrencyConfig?: ProvisionedConcurrencyConfig;\n}\n\n/**\n * Configuration of the VPC in which to install a Lambda to resolve queries against a SQL-based data source. The SQL Lambda will be deployed\n * into the specified VPC, subnets, and security groups. The specified subnets and security groups must be in the same VPC. The VPC must\n * have at least one subnet. The construct will also create VPC service endpoints in the specified subnets, as well as inbound security\n * rules, to allow traffic on port 443 within each security group. This allows the Lambda to read database connection information from\n * Secure Systems Manager.\n */\nexport interface VpcConfig {\n  /** The VPC to install the Lambda data source in. */\n  readonly vpcId: string;\n\n  /** The security groups to install the Lambda data source in. */\n  readonly securityGroupIds: string[];\n\n  /** The subnets to install the Lambda data source in, one per availability zone. */\n  readonly subnetAvailabilityZoneConfig: SubnetAvailabilityZone[];\n}\n\n/**\n * The configuration for the provisioned concurrency of the Lambda.\n */\nexport interface ProvisionedConcurrencyConfig {\n  /** The amount of provisioned concurrency to allocate. **/\n  readonly provisionedConcurrentExecutions: number;\n}\n\n/**\n * Subnet configuration for VPC endpoints used by a Lambda resolver for a SQL-based data source. Although it is possible to create multiple\n * subnets in a single availability zone, VPC service endpoints may only be deployed to a single subnet in a given availability zone. This\n * structure ensures that the Lambda function and VPC service endpoints are mutually consistent.\n */\nexport interface SubnetAvailabilityZone {\n  /** The subnet ID to install the Lambda data source in. */\n  readonly subnetId: string;\n\n  /** The availability zone of the subnet. */\n  readonly availabilityZone: string;\n}\n\n/**\n * The Secure Systems Manager parameter paths the Lambda data source will use to connect to the database.\n *\n * These parameters are retrieved from Secure Systems Manager in the same region as the Lambda.\n */\nexport interface SqlModelDataSourceDbConnectionConfig {\n  /** The Secure Systems Manager parameter containing the hostname of the database. For RDS-based SQL data sources, this can be the hostname\n   * of a database proxy, cluster, or instance.\n   */\n  readonly hostnameSsmPath: string;\n\n  /** The Secure Systems Manager parameter containing the port number of the database proxy, cluster, or instance. */\n  readonly portSsmPath: string;\n\n  /** The Secure Systems Manager parameter containing the username to use when connecting to the database. */\n  readonly usernameSsmPath: string;\n\n  /** The Secure Systems Manager parameter containing the password to use when connecting to the database. */\n  readonly passwordSsmPath: string;\n\n  /** The Secure Systems Manager parameter containing the database name. */\n  readonly databaseNameSsmPath: string;\n}\n\n/**\n * The input type for defining a ModelDataSourceStrategy used to resolve a field annotated with a `@sql` directive. Although this is a\n * public type, you should rarely need to use this. The AmplifyGraphqlDefinition factory methods (e.g., `fromString`,\n * `fromFilesAndStrategy`) will automatically construct this structure for you.\n */\nexport interface CustomSqlDataSourceStrategy {\n  /** The built-in type (either \"Query\" or \"Mutation\") with which the custom SQL is associated */\n  readonly typeName: 'Query' | 'Mutation';\n\n  /** The field name with which the custom SQL is associated */\n  readonly fieldName: string;\n\n  /** The strategy used to create the datasource that will resolve the custom SQL statement. */\n  readonly strategy: SQLLambdaModelDataSourceStrategy;\n}\n"]}

package/lib/sql-model-datasource-strategy.d.ts

@@ -1,4 +1,4 @@
-import { SQLLambdaModelDataSourceStrategy, SqlModelDataSourceDbConnectionConfig } from './model-datasource-strategy';
+import { SQLLambdaModelDataSourceStrategy, SqlModelDataSourceDbConnectionConfig } from './model-datasource-strategy-types';
 /**
  * Type predicate that returns true if the object is a SQLLambdaModelDataSourceStrategy.
  * @param obj the object to inspect

package/lib/sql-model-datasource-strategy.js

@@ -5,6 +5,7 @@ exports.SQLLambdaModelDataSourceStrategyFactory = exports.isSqlModelDataSourceDb
 const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
 const fs = require("fs");
 const path = require("path");
+const graphql_transformer_core_1 = require("@aws-amplify/graphql-transformer-core");
 /**
  * Type predicate that returns true if the object is a SQLLambdaModelDataSourceStrategy.
  * @param obj the object to inspect
@@ -14,8 +15,7 @@ const isSQLLambdaModelDataSourceStrategy = (obj) => {
     return ((typeof obj === 'object' || typeof obj === 'function') &&
         typeof obj.name === 'string' &&
         typeof obj.dbType === 'string' &&
-        // TODO: Use canonical SQL DB type strings
-        ['MYSQL', 'POSTGRES'].includes(obj.dbType) &&
+        (0, graphql_transformer_core_1.isSqlDbType)(obj.dbType) &&
         (0, exports.isSqlModelDataSourceDbConnectionConfig)(obj.dbConnectionConfig));
 };
 exports.isSQLLambdaModelDataSourceStrategy = isSQLLambdaModelDataSourceStrategy;
@@ -57,5 +57,5 @@ class SQLLambdaModelDataSourceStrategyFactory {
 }
 exports.SQLLambdaModelDataSourceStrategyFactory = SQLLambdaModelDataSourceStrategyFactory;
 _a = JSII_RTTI_SYMBOL_1;
-SQLLambdaModelDataSourceStrategyFactory[_a] = { fqn: "@aws-amplify/graphql-api-construct.SQLLambdaModelDataSourceStrategyFactory", version: "1.4.3" };
-//# sourceMappingURL=data:application/json;base64,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
+SQLLambdaModelDataSourceStrategyFactory[_a] = { fqn: "@aws-amplify/graphql-api-construct.SQLLambdaModelDataSourceStrategyFactory", version: "1.5.1-alpha.1+edba38d57" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/types.d.ts

@@ -6,7 +6,7 @@ import { IUserPool } from 'aws-cdk-lib/aws-cognito';
 import { IFunction, CfnFunction } from 'aws-cdk-lib/aws-lambda';
 import { IBucket } from 'aws-cdk-lib/aws-s3';
 import { AmplifyDynamoDbTableWrapper } from './amplify-dynamodb-table-wrapper';
-import { CustomSqlDataSourceStrategy, ModelDataSourceStrategy } from './model-datasource-strategy';
+import { CustomSqlDataSourceStrategy, ModelDataSourceStrategy } from './model-datasource-strategy-types';
 /**
  * Configuration for IAM Authorization on the Graphql Api.
  * @struct - required since this interface begins with an 'I'
@@ -476,19 +476,11 @@ export interface IAmplifyGraphqlDefinition {
     readonly referencedLambdaFunctions?: Record<string, IFunction>;
     /**
      * Retrieve the datasource strategy mapping. The default strategy is to use DynamoDB from CloudFormation.
-     *
-     * **NOTE** Explicitly specifying the 'dataSourceStrategies' configuration option is in preview and is not recommended to use with
-     * production systems. For production, use the static factory methods `fromString` or `fromFiles`.
-     * @experimental
      * @returns datasource strategy mapping
      */
     readonly dataSourceStrategies: Record<string, ModelDataSourceStrategy>;
     /**
      * An array of custom Query or Mutation SQL commands to the data sources that resolves them.
-     *
-     * **NOTE** Explicitly specifying the 'customSqlDataSourceStrategies' configuration option is in preview and is not recommended to use
-     * with production systems. For production, use the static factory methods `fromString` or `fromFiles`.
-     * @experimental
      * @returns a list of mappings from custom SQL commands to data sources
      */
     readonly customSqlDataSourceStrategies?: CustomSqlDataSourceStrategy[];