@aws-amplify/graphql-api-construct 1.4.3 → 1.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws-amplify/graphql-api-construct",
-  "version": "1.4.3",
+  "version": "1.5.0",
   "description": "AppSync GraphQL Api Construct using Amplify GraphQL Transformer.",
   "repository": {
     "type": "git",
@@ -75,20 +75,20 @@
   "dependencies": {
     "@aws-amplify/backend-output-schemas": "^0.4.0",
     "@aws-amplify/backend-output-storage": "^0.2.2",
-    "@aws-amplify/graphql-auth-transformer": "3.2.3",
-    "@aws-amplify/graphql-default-value-transformer": "2.1.12",
-    "@aws-amplify/graphql-function-transformer": "2.1.11",
-    "@aws-amplify/graphql-http-transformer": "2.1.11",
-    "@aws-amplify/graphql-index-transformer": "2.2.3",
-    "@aws-amplify/graphql-maps-to-transformer": "3.3.3",
-    "@aws-amplify/graphql-model-transformer": "2.3.3",
-    "@aws-amplify/graphql-predictions-transformer": "2.1.11",
-    "@aws-amplify/graphql-relational-transformer": "2.2.3",
-    "@aws-amplify/graphql-searchable-transformer": "2.3.3",
-    "@aws-amplify/graphql-sql-transformer": "0.1.3",
-    "@aws-amplify/graphql-transformer": "1.3.3",
-    "@aws-amplify/graphql-transformer-core": "2.3.3",
-    "@aws-amplify/graphql-transformer-interfaces": "3.3.1",
+    "@aws-amplify/graphql-auth-transformer": "3.3.0",
+    "@aws-amplify/graphql-default-value-transformer": "2.2.0",
+    "@aws-amplify/graphql-function-transformer": "2.1.12",
+    "@aws-amplify/graphql-http-transformer": "2.1.12",
+    "@aws-amplify/graphql-index-transformer": "2.3.0",
+    "@aws-amplify/graphql-maps-to-transformer": "3.4.0",
+    "@aws-amplify/graphql-model-transformer": "2.4.0",
+    "@aws-amplify/graphql-predictions-transformer": "2.1.12",
+    "@aws-amplify/graphql-relational-transformer": "2.3.0",
+    "@aws-amplify/graphql-searchable-transformer": "2.4.0",
+    "@aws-amplify/graphql-sql-transformer": "0.2.0",
+    "@aws-amplify/graphql-transformer": "1.3.4",
+    "@aws-amplify/graphql-transformer-core": "2.4.0",
+    "@aws-amplify/graphql-transformer-interfaces": "3.3.2",
     "@aws-amplify/platform-core": "^0.2.0",
     "@aws-amplify/plugin-types": "^0.4.1",
     "charenc": "^0.0.2",
@@ -96,8 +96,8 @@
     "fs-extra": "^8.1.0",
     "graceful-fs": "^4.2.11",
     "graphql": "^15.5.0",
-    "graphql-mapping-template": "4.20.12",
-    "graphql-transformer-common": "4.26.2",
+    "graphql-mapping-template": "4.20.13",
+    "graphql-transformer-common": "4.27.0",
     "hjson": "^3.2.2",
     "immer": "^9.0.12",
     "is-buffer": "^2.0.5",
@@ -112,6 +112,7 @@
     "zod": "^3.22.3"
   },
   "devDependencies": {
+    "@aws-amplify/graphql-transformer-test-utils": "0.4.0",
     "@types/fs-extra": "^8.0.1",
     "@types/node": "^12.12.6",
     "aws-cdk-lib": "2.80.0",
@@ -162,7 +163,11 @@
         "functions": 80,
         "lines": 80
       }
-    }
+    },
+    "coverageReporters": [
+      "clover",
+      "text"
+    ]
   },
-  "gitHead": "5256b5955ee204dd56f8074a43406852f8206c54"
+  "gitHead": "6e450d037cf84098b51ce787a99d6023cbc0e39d"
 }

package/src/amplify-graphql-api.ts

@@ -29,7 +29,6 @@ import { IEventBus } from 'aws-cdk-lib/aws-events';
 import { IFunction } from 'aws-cdk-lib/aws-lambda';
 import { IServerlessCluster } from 'aws-cdk-lib/aws-rds';
 import { ISecret } from 'aws-cdk-lib/aws-secretsmanager';
-import { MYSQL_DB_TYPE, POSTGRES_DB_TYPE, RDSConnectionSecrets } from '@aws-amplify/graphql-transformer-core';
 import { parseUserDefinedSlots, validateFunctionSlots, separateSlots } from './internal/user-defined-slots';
 import type {
   AmplifyGraphqlApiResources,
@@ -38,6 +37,7 @@ import type {
   IBackendOutputStorageStrategy,
   AddFunctionProps,
   ConflictResolution,
+  IAmplifyGraphqlDefinition,
 } from './types';
 import {
   convertAuthorizationModesToTransformerAuthConfig,
@@ -49,10 +49,8 @@ import {
   CodegenAssets,
   getAdditionalAuthenticationTypes,
 } from './internal';
-import { mapInterfaceCustomSqlStrategiesToImplementationStrategies, parseDataSourceConfig } from './internal/data-source-config';
 import { getStackForScope, walkAndProcessNodes } from './internal/construct-tree';
-import { SQLLambdaModelDataSourceStrategy } from './model-datasource-strategy';
-import { isSQLLambdaModelDataSourceStrategy } from './sql-model-datasource-strategy';
+import { getDataSourceStrategiesProvider } from './internal/data-source-config';
 
 /**
  * L3 Construct which invokes the Amplify Transformer Pattern over an input Graphql Schema.
@@ -156,7 +154,11 @@ export class AmplifyGraphqlApi extends Construct {
       outputStorageStrategy,
     } = props;
 
-    new AttributionMetadataStorage().storeAttributionMetadata(Stack.of(scope), this.stackType, path.join(__dirname, '..', 'package.json'));
+    const dataSources = getMetadataDataSources(definition);
+
+    new AttributionMetadataStorage().storeAttributionMetadata(Stack.of(scope), this.stackType, path.join(__dirname, '..', 'package.json'), {
+      dataSources,
+    });
 
     const { authConfig, authSynthParameters } = convertAuthorizationModesToTransformerAuthConfig(authorizationModes);
 
@@ -173,7 +175,7 @@ export class AmplifyGraphqlApi extends Construct {
 
     const assetManager = new AssetManager();
 
-    let executeTransformConfig: ExecuteTransformConfig = {
+    const executeTransformConfig: ExecuteTransformConfig = {
       scope: this,
       nestedStackProvider: {
         provide: (nestedStackScope: Construct, name: string) => new NestedStack(nestedStackScope, name),
@@ -204,33 +206,12 @@ export class AmplifyGraphqlApi extends Construct {
         ...defaultTranslationBehavior,
         ...(translationBehavior ?? {}),
       },
-
-      // Adds a modelToDataSourceMap field/value
-      ...parseDataSourceConfig(definition.dataSourceStrategies),
+      // CDK construct uses a custom resource. We'll define this explicitly here to remind ourselves that this value is unused in the CDK
+      // construct flow
+      rdsLayerMapping: undefined,
+      ...getDataSourceStrategiesProvider(definition),
     };
 
-    // TODO: Normalize all of this once we start using strategies internally. Right now the data source configuration (VPC, connection info,
-    // etc) is separate from the DataSourceType, and singular
-    const customSqlDataSourceStrategies = mapInterfaceCustomSqlStrategiesToImplementationStrategies(
-      definition.customSqlDataSourceStrategies,
-    );
-    if (customSqlDataSourceStrategies.length > 0) {
-      executeTransformConfig = {
-        ...executeTransformConfig,
-        customSqlDataSourceStrategies,
-      };
-    }
-
-    // TODO: Update this to support multiple definitions; right now we assume only one SQL data source type
-    const modelStrategies = Object.values(definition.dataSourceStrategies).filter(isSQLLambdaModelDataSourceStrategy);
-    const customSqlStrategies = definition.customSqlDataSourceStrategies?.map((css) => css.strategy) ?? [];
-    for (const strategy of [...modelStrategies, ...customSqlStrategies]) {
-      if (isSQLLambdaModelDataSourceStrategy(strategy)) {
-        executeTransformConfig = this.extendTransformConfig(executeTransformConfig, strategy);
-        break;
-      }
-    }
-
     executeTransform(executeTransformConfig);
 
     this.codegenAssets = new CodegenAssets(this, 'AmplifyCodegenAssets', { modelSchema: definition.schema });
@@ -246,66 +227,6 @@ export class AmplifyGraphqlApi extends Construct {
     this.apiKey = this.resources.cfnResources.cfnApiKey?.attrApiKey;
   }
 
-  /**
-   * Extends executeTransformConfig with fields for provisioning a SQL Lambda
-   * @param executeTransformConfig the executeTransformConfig to extend
-   * @param strategy the SQLLambdaModelDataSourceStrategy containing the SQL connection values to add to the transform config
-   * @returns the extended configuration that includes SQL DB connection information
-   */
-  private extendTransformConfig(
-    executeTransformConfig: ExecuteTransformConfig,
-    strategy: SQLLambdaModelDataSourceStrategy,
-  ): ExecuteTransformConfig {
-    const extendedConfig = { ...executeTransformConfig };
-
-    if (strategy.customSqlStatements) {
-      extendedConfig.customQueries = new Map(Object.entries(strategy.customSqlStatements));
-    }
-
-    const dbSecrets: Map<string, RDSConnectionSecrets> = new Map();
-    let dbSecretDbTypeKey: string;
-    switch (strategy.dbType) {
-      case 'MYSQL':
-        dbSecretDbTypeKey = MYSQL_DB_TYPE;
-        break;
-      case 'POSTGRES':
-        dbSecretDbTypeKey = POSTGRES_DB_TYPE;
-        break;
-      default:
-        throw new Error(`Unsupported binding type ${strategy.dbType}`);
-    }
-    dbSecrets.set(dbSecretDbTypeKey, {
-      username: strategy.dbConnectionConfig.usernameSsmPath,
-      password: strategy.dbConnectionConfig.passwordSsmPath,
-      host: strategy.dbConnectionConfig.hostnameSsmPath,
-      // Cast through `any` to allow the SSM Path string to be used on a type expecting a number. This flow expects the incoming value to be
-      // a string containing the SSM path.
-      port: strategy.dbConnectionConfig.portSsmPath as any,
-      database: strategy.dbConnectionConfig.databaseNameSsmPath,
-    });
-    extendedConfig.datasourceSecretParameterLocations = dbSecrets;
-
-    if (strategy.vpcConfiguration) {
-      const subnetAvailabilityZoneConfig = strategy.vpcConfiguration.subnetAvailabilityZoneConfig.map(
-        (saz): { subnetId: string; availabilityZone: string } => ({
-          subnetId: saz.subnetId,
-          availabilityZone: saz.availabilityZone,
-        }),
-      );
-      extendedConfig.sqlLambdaVpcConfig = {
-        vpcId: strategy.vpcConfiguration.vpcId,
-        securityGroupIds: strategy.vpcConfiguration.securityGroupIds,
-        subnetAvailabilityZoneConfig,
-      };
-    }
-
-    if (strategy.sqlLambdaProvisionedConcurrencyConfig) {
-      extendedConfig.sqlLambdaProvisionedConcurrencyConfig = strategy.sqlLambdaProvisionedConcurrencyConfig;
-    }
-
-    return extendedConfig;
-  }
-
   /**
    * Stores graphql api output to be used for client config generation
    * @param outputStorageStrategy Strategy to store construct outputs. If no strategy is provided a default strategy will be used.
@@ -484,3 +405,10 @@ const validateNoOtherAmplifyGraphqlApiInStack = (scope: Construct): void => {
     throw new Error('Only one AmplifyGraphqlApi is expected in a stack');
   }
 };
+
+const getMetadataDataSources = (definition: IAmplifyGraphqlDefinition): string => {
+  const dataSourceDbTypes = Object.values(definition.dataSourceStrategies).map((strategy) => strategy.dbType.toLocaleLowerCase());
+  const customSqlDbTypes = (definition.customSqlDataSourceStrategies ?? []).map((strategy) => strategy.strategy.dbType.toLocaleLowerCase());
+  const dataSources = [...new Set([...dataSourceDbTypes, ...customSqlDbTypes])].sort();
+  return dataSources.join(',');
+};

package/src/amplify-graphql-definition.ts

@@ -1,9 +1,14 @@
 import * as os from 'os';
 import { SchemaFile } from 'aws-cdk-lib/aws-appsync';
+import { isSqlStrategy } from '@aws-amplify/graphql-transformer-core';
 import { IAmplifyGraphqlDefinition } from './types';
-import { constructDataSourceStrategyMap } from './internal';
-import { ModelDataSourceStrategy } from './model-datasource-strategy';
-import { constructCustomSqlDataSourceStrategies } from './internal/data-source-config';
+import { constructDataSourceStrategies } from './internal';
+import { CustomSqlDataSourceStrategy, ModelDataSourceStrategy } from './model-datasource-strategy-types';
+import {
+  constructCustomSqlDataSourceStrategies,
+  schemaByMergingDefinitions,
+  validateDataSourceStrategy,
+} from './internal/data-source-config';
 
 export const DEFAULT_MODEL_DATA_SOURCE_STRATEGY: ModelDataSourceStrategy = {
   dbType: 'DYNAMODB',
@@ -16,24 +21,21 @@ export const DEFAULT_MODEL_DATA_SOURCE_STRATEGY: ModelDataSourceStrategy = {
 export class AmplifyGraphqlDefinition {
   /**
    * Produce a schema definition from a string input.
-   *
-   * **NOTE** The 'dataSourceStrategy' configuration option is in preview and is not recommended to use with production systems.
-   *
    * @param schema the graphql input as a string
    * @param dataSourceStrategy the provisioning definition for datasources that resolve `@model`s and custom SQL statements in this schema.
    * The DynamoDB from CloudFormation will be used by default.
-   * @experimental dataSourceStrategy
    * @returns a fully formed amplify graphql definition
    */
   static fromString(
     schema: string,
     dataSourceStrategy: ModelDataSourceStrategy = DEFAULT_MODEL_DATA_SOURCE_STRATEGY,
   ): IAmplifyGraphqlDefinition {
+    validateDataSourceStrategy(dataSourceStrategy);
     return {
       schema,
       functionSlots: [],
       referencedLambdaFunctions: {},
-      dataSourceStrategies: constructDataSourceStrategyMap(schema, dataSourceStrategy),
+      dataSourceStrategies: constructDataSourceStrategies(schema, dataSourceStrategy),
       customSqlDataSourceStrategies: constructCustomSqlDataSourceStrategies(schema, dataSourceStrategy),
     };
   }
@@ -53,10 +55,6 @@ export class AmplifyGraphqlDefinition {
 
   /**
    * Convert one or more appsync SchemaFile objects into an Amplify Graphql Schema
-   *
-   * **NOTE** This API is in preview and is not recommended to use with production systems.
-   *
-   * @experimental
    * @param filePaths one or more paths to the graphql files to process
    * @param dataSourceStrategy the provisioning definition for datasources that resolve `@model`s in this schema. The DynamoDB from
    * CloudFormation will be used by default.
@@ -75,10 +73,6 @@ export class AmplifyGraphqlDefinition {
 
   /**
    * Combines multiple IAmplifyGraphqlDefinitions into a single definition.
-   *
-   * **NOTE** This API is in preview and is not recommended to use with production systems.
-   *
-   * @experimental
    * @param definitions the definitions to combine
    */
   static combine(definitions: IAmplifyGraphqlDefinition[]): IAmplifyGraphqlDefinition {
@@ -88,11 +82,41 @@ export class AmplifyGraphqlDefinition {
     if (definitions.length === 1) {
       return definitions[0];
     }
+
+    // A strategy will be present multiple times in a given definition: once per model. We'll create a unique list per definition to ensure
+    // no reuse across definitions.
+    let combinedStrategyNames: string[] = [];
+    for (const definition of definitions) {
+      const definitionStrategyNames = new Set<string>();
+      for (const strategy of Object.values(definition.dataSourceStrategies)) {
+        if (!isSqlStrategy(strategy)) {
+          continue;
+        }
+        const strategyName = strategy.name;
+        if (combinedStrategyNames.includes(strategyName)) {
+          throw new Error(
+            `The SQL-based ModelDataSourceStrategy '${strategyName}' was found in multiple definitions, but a strategy name cannot be ` +
+              "shared between definitions. To specify a SQL-based API with schemas across multiple files, use 'fromFilesAndStrategy'",
+          );
+        }
+        definitionStrategyNames.add(strategyName);
+      }
+      combinedStrategyNames = [...combinedStrategyNames, ...definitionStrategyNames];
+    }
+
+    const customSqlDataSourceStrategies = definitions.reduce(
+      (acc, cur) => [...acc, ...(cur.customSqlDataSourceStrategies ?? [])],
+      [] as CustomSqlDataSourceStrategy[],
+    );
+
+    const mergedSchema = schemaByMergingDefinitions(definitions);
+
     return {
-      schema: definitions.map((def) => def.schema).join(os.EOL),
+      schema: mergedSchema,
       functionSlots: [],
       referencedLambdaFunctions: definitions.reduce((acc, cur) => ({ ...acc, ...cur.referencedLambdaFunctions }), {}),
       dataSourceStrategies: definitions.reduce((acc, cur) => ({ ...acc, ...cur.dataSourceStrategies }), {}),
+      customSqlDataSourceStrategies,
     };
   }
 }

package/src/index.ts

@@ -43,4 +43,4 @@ export {
   StreamSpecification,
 } from './amplify-dynamodb-table-wrapper';
 export { SQLLambdaModelDataSourceStrategyFactory } from './sql-model-datasource-strategy';
-export * from './model-datasource-strategy';
+export * from './model-datasource-strategy-types';

package/src/internal/data-source-config.ts

@@ -1,37 +1,17 @@
-import { parse } from 'graphql';
+import { DefinitionNode, FieldDefinitionNode, InterfaceTypeDefinitionNode, ObjectTypeDefinitionNode, parse, print } from 'graphql';
 import {
-  CustomSqlDataSourceStrategy as ImplementationCustomSqlDataSourceStrategy,
-  DataSourceType,
-  SQLLambdaModelProvisionStrategy,
-} from '@aws-amplify/graphql-transformer-interfaces';
-import {
-  dataSourceStrategyToDataSourceType,
+  isBuiltInGraphqlNode,
   isSqlStrategy,
   isQueryNode,
   isMutationNode,
   fieldsWithSqlDirective,
 } from '@aws-amplify/graphql-transformer-core';
-import { normalizeDbType } from '@aws-amplify/graphql-transformer-core/lib/utils';
-import { CustomSqlDataSourceStrategy as InterfaceCustomSqlDataSourceStrategy, ModelDataSourceStrategy } from '../model-datasource-strategy';
-
-type DataSourceConfig = {
-  modelToDatasourceMap: Map<string, DataSourceType>;
-};
-
-/**
- * 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.
- */
-export const parseDataSourceConfig = (dataSourceDefinitionMap: Record<string, ModelDataSourceStrategy>): DataSourceConfig => {
-  const modelToDatasourceMap = new Map<string, DataSourceType>();
-  for (const [key, value] of Object.entries(dataSourceDefinitionMap)) {
-    const dataSourceType = dataSourceStrategyToDataSourceType(value);
-    modelToDatasourceMap.set(key, dataSourceType);
-  }
-  return {
-    modelToDatasourceMap,
-  };
-};
+import { DataSourceStrategiesProvider } from '@aws-amplify/graphql-transformer-interfaces';
+import {
+  CustomSqlDataSourceStrategy as ConstructCustomSqlDataSourceStrategy,
+  ModelDataSourceStrategy as ConstructModelDataSourceStrategy,
+} from '../model-datasource-strategy-types';
+import { IAmplifyGraphqlDefinition } from '../types';
 
 /**
  * Creates an interface flavor of customSqlDataSourceStrategies from a factory method's schema and data source. Internally, this function
@@ -40,13 +20,11 @@ export const parseDataSourceConfig = (dataSourceDefinitionMap: Record<string, Mo
  *
  * 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.
  */
 export const constructCustomSqlDataSourceStrategies = (
   schema: string,
-  dataSourceStrategy: ModelDataSourceStrategy,
-): InterfaceCustomSqlDataSourceStrategy[] => {
+  dataSourceStrategy: ConstructModelDataSourceStrategy,
+): ConstructCustomSqlDataSourceStrategy[] => {
   if (!isSqlStrategy(dataSourceStrategy)) {
     return [];
   }
@@ -59,7 +37,7 @@ export const constructCustomSqlDataSourceStrategies = (
     return [];
   }
 
-  const customSqlDataSourceStrategies: InterfaceCustomSqlDataSourceStrategy[] = [];
+  const customSqlDataSourceStrategies: ConstructCustomSqlDataSourceStrategy[] = [];
 
   if (queryNode) {
     const fields = fieldsWithSqlDirective(queryNode);
@@ -87,25 +65,141 @@ export const 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.
  */
-export const mapInterfaceCustomSqlStrategiesToImplementationStrategies = (
-  strategies?: InterfaceCustomSqlDataSourceStrategy[],
-): ImplementationCustomSqlDataSourceStrategy[] => {
-  if (!strategies) {
-    return [];
+export const getDataSourceStrategiesProvider = (definition: IAmplifyGraphqlDefinition): DataSourceStrategiesProvider => {
+  const provider: DataSourceStrategiesProvider = {
+    // 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: Record<string, string> = {};
+
+  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;
+};
+
+/**
+ * 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).
+ */
+export const schemaByMergingDefinitions = (definitions: IAmplifyGraphqlDefinition[]): string => {
+  const schema = definitions.map((def) => def.schema).join('\n');
+  const parsedSchema = 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: Record<
+    string,
+    {
+      node: ObjectTypeDefinitionNode | InterfaceTypeDefinitionNode;
+      fields: FieldDefinitionNode[];
+    }
+  > = {};
+
+  // Throws if the field has already been encountered
+  const validateField = (typeName: string, fieldName: string): void => {
+    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(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];
+    }, [] as DefinitionNode[]);
+
+  // Filter out the old Query & Mutation definitions
+  const filteredDefinitions = parsedSchema.definitions.filter((def) => !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 = print(newSchema);
+  return combinedSchemaString;
+};
+
+/*
+ * 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
+ */
+export const validateDataSourceStrategy = (strategy: ConstructModelDataSourceStrategy) => {
+  if (!isSqlStrategy(strategy)) {
+    return;
+  }
+
+  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(', ')}.`,
+    );
   }
-  return strategies.map((interfaceStrategy) => ({
-    fieldName: interfaceStrategy.fieldName,
-    typeName: interfaceStrategy.typeName,
-    dataSourceType: {
-      dbType: normalizeDbType(interfaceStrategy.strategy.dbType),
-      provisionDB: false,
-      provisionStrategy: SQLLambdaModelProvisionStrategy.DEFAULT,
-    },
-  }));
+};
+
+const isValidSSMPath = (path: string): boolean => {
+  return path.startsWith('/');
 };

package/src/internal/model-type-name.ts

@@ -1,8 +1,9 @@
 import { Kind, ObjectTypeDefinitionNode, StringValueNode, parse } from 'graphql';
-import { ModelDataSourceStrategy } from '../model-datasource-strategy';
+import { ModelDataSourceStrategy } from '../model-datasource-strategy-types';
 
 const MODEL_DIRECTIVE_NAME = 'model';
 const MANY_TO_MANY_DIRECTIVE_NAME = 'manyToMany';
+
 /**
  * Get the type names with model directives in the GraphQL schema in SDL
  * @param schema graphql schema in SDL
@@ -30,7 +31,7 @@ export const getModelTypeNames = (schema: string): string[] => {
   return modelKeys.filter((key, idx) => modelKeys.indexOf(key) === idx);
 };
 
-export const constructDataSourceStrategyMap = (
+export const constructDataSourceStrategies = (
   schema: string,
   dataSourceStrategy: ModelDataSourceStrategy,
 ): Record<string, ModelDataSourceStrategy> => {