@aws-amplify/graphql-api-construct 1.3.0 → 1.4.0-nov-14-cut.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws-amplify/graphql-api-construct",
-  "version": "1.3.0",
+  "version": "1.4.0-nov-14-cut.0",
   "description": "AppSync GraphQL Api Construct using Amplify GraphQL Transformer.",
   "repository": {
     "type": "git",
@@ -11,16 +11,12 @@
   "license": "Apache-2.0",
   "main": "lib/index.js",
   "scripts": {
-    "jsii": "jsii",
-    "build": "yarn config set script-shell bash && yarn transform-deps && yarn config delete script-shell && jsii",
+    "build": "jsii",
     "watch": "jsii -w",
     "package": "jsii-pacmak",
     "clean": "rimraf lib dist tsconfig.json tsconfig.tsbuildinfo node_modules",
     "test": "jest",
     "test-watch": "jest --watch",
-    "transform-deps": "dir=node_modules/@aws-amplify/backend-output-schemas yarn transform-in-place && dir=node_modules/@aws-amplify/backend-output-storage yarn transform-in-place",
-    "transform-in-place": "npx babel $dir --extensions .js --out-dir transpiled --copy-files && cp -r transpiled/* $dir && rimraf transpiled && yarn force-cjs-module $dir",
-    "force-cjs-module": "ts-node --project extract-api.tsconfig.json ./remove-module-type-from-package-json.ts",
     "extract-api": "ts-node --project extract-api.tsconfig.json ../../scripts/extract-api.ts",
     "update-readme": "cp README_HEAD.md README.md && jsii && jsii-docgen --readme --output README.md",
     "prepublishOnly": "jsii && git add .jsii && git commit -m \"chore: update .jsii assembly\" --no-verify"
@@ -40,10 +36,6 @@
   "bundledDependencies": [
     "@aws-amplify/backend-output-schemas",
     "@aws-amplify/backend-output-storage",
-    "@aws-amplify/graphql-transformer",
-    "@aws-amplify/graphql-transformer-core",
-    "@aws-amplify/graphql-transformer-interfaces",
-    "zod",
     "@aws-amplify/graphql-auth-transformer",
     "@aws-amplify/graphql-default-value-transformer",
     "@aws-amplify/graphql-function-transformer",
@@ -54,48 +46,58 @@
     "@aws-amplify/graphql-predictions-transformer",
     "@aws-amplify/graphql-relational-transformer",
     "@aws-amplify/graphql-searchable-transformer",
-    "fs-extra",
-    "graphql",
-    "graphql-transformer-common",
-    "hjson",
-    "lodash",
-    "md5",
-    "object-hash",
-    "ts-dedent",
+    "@aws-amplify/graphql-sql-transformer",
+    "@aws-amplify/graphql-transformer",
+    "@aws-amplify/graphql-transformer-core",
+    "@aws-amplify/graphql-transformer-interfaces",
+    "@aws-amplify/platform-core",
+    "@aws-amplify/plugin-types",
     "charenc",
     "crypt",
+    "fs-extra",
     "graceful-fs",
+    "graphql",
     "graphql-mapping-template",
+    "graphql-transformer-common",
+    "hjson",
     "immer",
     "is-buffer",
     "jsonfile",
     "libphonenumber-js",
+    "lodash",
+    "md5",
+    "object-hash",
     "pluralize",
-    "universalify"
+    "ts-dedent",
+    "universalify",
+    "zod"
   ],
   "dependencies": {
-    "@aws-amplify/backend-output-schemas": "^0.2.0-alpha.6",
-    "@aws-amplify/backend-output-storage": "^0.1.1-alpha.2",
-    "@aws-amplify/graphql-auth-transformer": "3.1.10",
-    "@aws-amplify/graphql-default-value-transformer": "2.1.8",
-    "@aws-amplify/graphql-function-transformer": "2.1.7",
-    "@aws-amplify/graphql-http-transformer": "2.1.7",
-    "@aws-amplify/graphql-index-transformer": "2.1.8",
-    "@aws-amplify/graphql-maps-to-transformer": "3.2.5",
-    "@aws-amplify/graphql-model-transformer": "2.2.4",
-    "@aws-amplify/graphql-predictions-transformer": "2.1.7",
-    "@aws-amplify/graphql-relational-transformer": "2.1.8",
-    "@aws-amplify/graphql-searchable-transformer": "2.2.4",
-    "@aws-amplify/graphql-transformer": "1.2.6",
-    "@aws-amplify/graphql-transformer-core": "2.2.4",
-    "@aws-amplify/graphql-transformer-interfaces": "3.2.2",
+    "@aws-amplify/backend-output-schemas": "^0.2.1",
+    "@aws-amplify/backend-output-storage": "^0.2.0",
+    "@aws-amplify/graphql-auth-transformer": "3.2.0-nov-14-cut.0",
+    "@aws-amplify/graphql-default-value-transformer": "2.1.9-nov-14-cut.0",
+    "@aws-amplify/graphql-function-transformer": "2.1.8-nov-14-cut.0",
+    "@aws-amplify/graphql-http-transformer": "2.1.8-nov-14-cut.0",
+    "@aws-amplify/graphql-index-transformer": "2.2.0-nov-14-cut.0",
+    "@aws-amplify/graphql-maps-to-transformer": "3.3.0-nov-14-cut.0",
+    "@aws-amplify/graphql-model-transformer": "2.3.0-nov-14-cut.0",
+    "@aws-amplify/graphql-predictions-transformer": "2.1.8-nov-14-cut.0",
+    "@aws-amplify/graphql-relational-transformer": "2.2.0-nov-14-cut.0",
+    "@aws-amplify/graphql-searchable-transformer": "2.3.0-nov-14-cut.0",
+    "@aws-amplify/graphql-sql-transformer": "0.1.0-nov-14-cut.0",
+    "@aws-amplify/graphql-transformer": "1.3.0-nov-14-cut.0",
+    "@aws-amplify/graphql-transformer-core": "2.3.0-nov-14-cut.0",
+    "@aws-amplify/graphql-transformer-interfaces": "3.3.0-nov-14-cut.0",
+    "@aws-amplify/platform-core": "^0.1.3",
+    "@aws-amplify/plugin-types": "^0.3.0",
     "charenc": "^0.0.2",
     "crypt": "^0.0.2",
     "fs-extra": "^8.1.0",
     "graceful-fs": "^4.2.11",
     "graphql": "^15.5.0",
     "graphql-mapping-template": "4.20.12",
-    "graphql-transformer-common": "4.25.1",
+    "graphql-transformer-common": "4.26.0-nov-14-cut.0",
     "hjson": "^3.2.2",
     "immer": "^9.0.12",
     "is-buffer": "^2.0.5",
@@ -156,11 +158,11 @@
     "collectCoverage": true,
     "coverageThreshold": {
       "global": {
-        "branches": 78,
+        "branches": 80,
         "functions": 80,
         "lines": 80
       }
     }
   },
-  "gitHead": "0c58cc8cff88e98ae2e7797b9ad0e900c3af8499"
+  "gitHead": "fc9a8439add9d01a28f308ebf3b07b73b8d23923"
 }

package/src/amplify-dynamodb-table-wrapper.ts

@@ -0,0 +1,177 @@
+import { CfnResource } from 'aws-cdk-lib';
+import { BillingMode, StreamViewType } from 'aws-cdk-lib/aws-dynamodb';
+
+const AMPLIFY_DYNAMODB_TABLE_RESOURCE_TYPE = 'Custom::AmplifyDynamoDBTable';
+
+/**
+ * Shape for TTL config.
+ */
+export interface TimeToLiveSpecification {
+  /**
+   * Boolean determining if the ttl is enabled or not.
+   */
+  readonly enabled: boolean;
+
+  /**
+   * Attribute name to apply to the ttl spec.
+   */
+  readonly attributeName?: string;
+}
+
+/**
+ * Wrapper for provisioned throughput config in DDB.
+ */
+export interface ProvisionedThroughput {
+  /**
+   * The read capacity units on the table or index.
+   */
+  readonly readCapacityUnits: number;
+
+  /**
+   * The write capacity units on the table or index.
+   */
+  readonly writeCapacityUnits: number;
+}
+
+/**
+ * Server Side Encryption Type Values
+ * - `KMS` - Server-side encryption that uses AWS KMS. The key is stored in your account and is managed by KMS (AWS KMS charges apply).
+ */
+export enum SSEType {
+  KMS = 'KMS',
+}
+
+/**
+ * Represents the settings used to enable server-side encryption.
+ */
+export interface SSESpecification {
+  /**
+   * Indicates whether server-side encryption is done using an AWS managed key or an AWS owned key.
+   * If enabled (true), server-side encryption type is set to `KMS` and an AWS managed key is used ( AWS KMS charges apply).
+   * If disabled (false) or not specified, server-side encryption is set to AWS owned key.
+   */
+  readonly sseEnabled: boolean;
+
+  /**
+   * The AWS KMS key that should be used for the AWS KMS encryption.
+   * To specify a key, use its key ID, Amazon Resource Name (ARN), alias name, or alias ARN. Note that you should only provide
+   * this parameter if the key is different from the default DynamoDB key `alias/aws/dynamodb` .
+   */
+  readonly kmsMasterKeyId?: string;
+
+  /**
+   * Server-side encryption type. The only supported value is:
+   * `KMS` Server-side encryption that uses AWS Key Management Service.
+   *   The key is stored in your account and is managed by AWS KMS ( AWS KMS charges apply).
+   */
+  readonly sseType?: SSEType;
+}
+
+/**
+ * Represents the DynamoDB Streams configuration for a table in DynamoDB.
+ */
+export interface StreamSpecification {
+  /**
+   * When an item in the table is modified, `StreamViewType` determines what information is written to the stream for this table.
+   * Valid values for `StreamViewType` are:
+   * - `KEYS_ONLY` - Only the key attributes of the modified item are written to the stream.
+   * - `NEW_IMAGE` - The entire item, as it appears after it was modified, is written to the stream.
+   * - `OLD_IMAGE` - The entire item, as it appeared before it was modified, is written to the stream.
+   * - `NEW_AND_OLD_IMAGES` - Both the new and the old item images of the item are written to the stream.
+   */
+  readonly streamViewType: StreamViewType;
+}
+
+/**
+ * Wrapper class around Custom::AmplifyDynamoDBTable custom resource, to simplify
+ * the override experience a bit. This is NOT a construct, just an easier way to access
+ * the generated construct.
+ * This is a wrapper intended to mimic the `aws_cdk_lib.aws_dynamodb.Table` functionality more-or-less.
+ * Notable differences is the addition of TKTK properties, to account for the fact that they're constructor props
+ * in the CDK construct, as well as the removal of all from*, grant*, and metric* methods implemented by Table.
+ */
+export class AmplifyDynamoDbTableWrapper {
+  /**
+   * Return true and perform type narrowing if a given input appears to be capable of
+   * @param x the object to check.
+   * @returns whether or not the resource is an underlying amplify dynamodb table resource.
+   */
+  static isAmplifyDynamoDbTableResource(x: any): x is CfnResource {
+    return x instanceof CfnResource && x.cfnResourceType === AMPLIFY_DYNAMODB_TABLE_RESOURCE_TYPE;
+  }
+
+  /**
+   * Create the wrapper given an underlying CfnResource that is an instance of Custom::AmplifyDynamoDBTable.
+   * @param resource the Cfn resource.
+   */
+  constructor(private readonly resource: CfnResource) {
+    if (resource.cfnResourceType !== AMPLIFY_DYNAMODB_TABLE_RESOURCE_TYPE) {
+      throw new Error(`Only CfnResource with type ${AMPLIFY_DYNAMODB_TABLE_RESOURCE_TYPE} can be used in AmplifyDynamoDbTable`);
+    }
+  }
+
+  /**
+   * Specify how you are charged for read and write throughput and how you manage capacity.
+   */
+  set billingMode(billingMode: BillingMode) {
+    this.resource.addPropertyOverride('billingMode', billingMode);
+  }
+
+  /**
+   * The name of TTL attribute.
+   */
+  set timeToLiveAttribute(timeToLiveSpecification: TimeToLiveSpecification) {
+    this.resource.addPropertyOverride('timeToLiveSpecification', timeToLiveSpecification);
+  }
+
+  /**
+   * Whether point-in-time recovery is enabled.
+   */
+  set pointInTimeRecoveryEnabled(pointInTimeRecoveryEnabled: boolean) {
+    this.resource.addPropertyOverride('pointInTimeRecoverySpecification', { pointInTimeRecoveryEnabled });
+  }
+
+  /**
+   * Update the provisioned throughput for the base table.
+   */
+  set provisionedThroughput(provisionedThroughput: ProvisionedThroughput) {
+    this.resource.addPropertyOverride('provisionedThroughput', provisionedThroughput);
+  }
+
+  /**
+   * Set the provisionedThroughtput for a specified GSI by name.
+   * @param indexName the index to specify a provisionedThroughput config for
+   * @param provisionedThroughput the config to set
+   */
+  setGlobalSecondaryIndexProvisionedThroughput(indexName: string, provisionedThroughput: ProvisionedThroughput): void {
+    const gsis: Array<[string, { indexName: string }]> = Object.entries(
+      (this.resource as any).rawOverrides?.Properties?.globalSecondaryIndexes ?? {},
+    );
+    const foundGsis = gsis.filter(([_, gsiConfig]) => indexName === gsiConfig.indexName).map(([gsiIndex]) => gsiIndex);
+    if (foundGsis.length !== 1) {
+      throw new Error(`Index with name ${indexName} not found in table definition`);
+    }
+    this.resource.addPropertyOverride(`globalSecondaryIndexes.${foundGsis[0]}.provisionedThroughput`, provisionedThroughput);
+  }
+
+  /**
+   * Set the ddb stream specification on the table.
+   */
+  set streamSpecification(streamSpecification: StreamSpecification) {
+    this.resource.addPropertyOverride('streamSpecification', streamSpecification);
+  }
+
+  /**
+   * Set the ddb server-side encryption specification on the table.
+   */
+  set sseSpecification(sseSpecification: SSESpecification) {
+    this.resource.addPropertyOverride('sseSpecification', sseSpecification);
+  }
+
+  /**
+   * Set table deletion protection.
+   */
+  set deletionProtectionEnabled(deletionProtectionEnabled: boolean) {
+    this.resource.addPropertyOverride('deletionProtectionEnabled', deletionProtectionEnabled);
+  }
+}

package/src/amplify-graphql-api.ts

@@ -1,9 +1,10 @@
+import * as path from 'path';
 import { Construct } from 'constructs';
-import { executeTransform } from '@aws-amplify/graphql-transformer';
+import { ExecuteTransformConfig, executeTransform } from '@aws-amplify/graphql-transformer';
 import { NestedStack, Stack } from 'aws-cdk-lib';
 import { Asset } from 'aws-cdk-lib/aws-s3-assets';
 import { AssetProps } from '@aws-amplify/graphql-transformer-interfaces';
-import { StackMetadataBackendOutputStorageStrategy } from '@aws-amplify/backend-output-storage';
+import { AttributionMetadataStorage, StackMetadataBackendOutputStorageStrategy } from '@aws-amplify/backend-output-storage';
 import { graphqlOutputKey } from '@aws-amplify/backend-output-schemas';
 import type { GraphqlOutput, AwsAppsyncAuthenticationType } from '@aws-amplify/backend-output-schemas';
 import {
@@ -28,6 +29,7 @@ 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,
@@ -36,6 +38,7 @@ import type {
   IBackendOutputStorageStrategy,
   AddFunctionProps,
   ConflictResolution,
+  SQLLambdaModelDataSourceStrategy,
 } from './types';
 import {
   convertAuthorizationModesToTransformerAuthConfig,
@@ -45,9 +48,10 @@ import {
   getGeneratedResources,
   getGeneratedFunctionSlots,
   CodegenAssets,
-  addAmplifyMetadataToStackDescription,
   getAdditionalAuthenticationTypes,
 } from './internal';
+import { isSQLLambdaModelDataSourceStrategy } from './sql-model-datasource-strategy';
+import { parseDataSourceConfig } from './internal/data-source-config';
 import { getStackForScope, walkAndProcessNodes } from './internal/construct-tree';
 
 /**
@@ -122,6 +126,11 @@ export class AmplifyGraphqlApi extends Construct {
    */
   private readonly conflictResolution: ConflictResolution | undefined;
 
+  /**
+   * Be very careful editing this value. This is the string that is used to identify graphql stacks in BI metrics
+   */
+  private readonly stackType = 'api-AppSync';
+
   /**
    * New AmplifyGraphqlApi construct, this will create an appsync api with authorization, a schema, and all necessary resolvers, functions,
    * and datasources.
@@ -147,7 +156,7 @@ export class AmplifyGraphqlApi extends Construct {
       outputStorageStrategy,
     } = props;
 
-    addAmplifyMetadataToStackDescription(scope);
+    new AttributionMetadataStorage().storeAttributionMetadata(Stack.of(scope), this.stackType, path.join(__dirname, '..', 'package.json'));
 
     const { authConfig, authSynthParameters } = convertAuthorizationModesToTransformerAuthConfig(authorizationModes);
 
@@ -164,7 +173,7 @@ export class AmplifyGraphqlApi extends Construct {
 
     const assetManager = new AssetManager();
 
-    executeTransform({
+    let executeTransformConfig: ExecuteTransformConfig = {
       scope: this,
       nestedStackProvider: {
         provide: (nestedStackScope: Construct, name: string) => new NestedStack(nestedStackScope, name),
@@ -183,7 +192,10 @@ export class AmplifyGraphqlApi extends Construct {
       transformersFactoryArgs: {
         customTransformers: transformerPlugins ?? [],
         ...(predictionsBucket ? { storageConfig: { bucketName: predictionsBucket.bucketName } } : {}),
-        functionNameMap,
+        functionNameMap: {
+          ...definition.referencedLambdaFunctions,
+          ...functionNameMap,
+        },
       },
       authConfig,
       stackMapping: stackMappings ?? {},
@@ -192,7 +204,20 @@ export class AmplifyGraphqlApi extends Construct {
         ...defaultTranslationBehavior,
         ...(translationBehavior ?? {}),
       },
-    });
+
+      // Adds a modelToDataSourceMap field/value
+      ...parseDataSourceConfig(definition.dataSourceStrategies),
+    };
+
+    // TODO: Update this to support multiple definitions; right now we assume only one SQL data source type
+    for (const strategy of Object.values(definition.dataSourceStrategies)) {
+      if (isSQLLambdaModelDataSourceStrategy(strategy)) {
+        executeTransformConfig = this.extendTransformConfig(executeTransformConfig, strategy);
+        break;
+      }
+    }
+
+    executeTransform(executeTransformConfig);
 
     this.codegenAssets = new CodegenAssets(this, 'AmplifyCodegenAssets', { modelSchema: definition.schema });
 
@@ -207,6 +232,65 @@ 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 dataSourceDefinition 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.

package/src/amplify-graphql-definition.ts

@@ -1,32 +1,105 @@
 import * as os from 'os';
 import { SchemaFile } from 'aws-cdk-lib/aws-appsync';
-import { IAmplifyGraphqlDefinition } from './types';
+import { IAmplifyGraphqlDefinition, ModelDataSourceStrategy } from './types';
+import { constructDataSourceStrategyMap } from './internal';
+
+export const DEFAULT_MODEL_DATA_SOURCE_STRATEGY: ModelDataSourceStrategy = {
+  dbType: 'DYNAMODB',
+  provisionStrategy: 'DEFAULT',
+};
 
 /**
  * Class exposing utilities to produce IAmplifyGraphqlDefinition objects given various inputs.
  */
 export class AmplifyGraphqlDefinition {
   /**
-   * Produce a schema definition from a string input
+   * 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 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): IAmplifyGraphqlDefinition {
+  static fromString(
+    schema: string,
+    dataSourceStrategy: ModelDataSourceStrategy = DEFAULT_MODEL_DATA_SOURCE_STRATEGY,
+  ): IAmplifyGraphqlDefinition {
+    return {
+      schema,
+      functionSlots: [],
+      referencedLambdaFunctions: {},
+      dataSourceStrategies: constructDataSourceStrategyMap(schema, dataSourceStrategy),
+    };
+  }
+
+  /**
+   * Convert one or more appsync SchemaFile objects into an Amplify Graphql Schema, binding them to a DynamoDB data source.
+   * @param filePaths one or more paths to the graphql files to process
+   * @returns a fully formed amplify graphql definition, whose models will be resolved by DynamoDB tables created during deployment.
+   */
+  static fromFiles(...filePaths: string[]): IAmplifyGraphqlDefinition {
+    if (!Array.isArray(filePaths)) {
+      filePaths = [filePaths];
+    }
+    const schema = filePaths.map((filePath) => new SchemaFile({ filePath }).definition).join(os.EOL);
     return {
       schema,
       functionSlots: [],
+      referencedLambdaFunctions: {},
+      dataSourceStrategies: constructDataSourceStrategyMap(schema, DEFAULT_MODEL_DATA_SOURCE_STRATEGY),
     };
   }
 
   /**
    * 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.
    * @returns a fully formed amplify graphql definition
    */
-  static fromFiles(...filePaths: string[]): IAmplifyGraphqlDefinition {
+  static fromFilesAndStrategy(
+    filePaths: string | string[],
+    dataSourceStrategy: ModelDataSourceStrategy = DEFAULT_MODEL_DATA_SOURCE_STRATEGY,
+  ): IAmplifyGraphqlDefinition {
+    if (!Array.isArray(filePaths)) {
+      filePaths = [filePaths];
+    }
+    const schema = filePaths.map((filePath) => new SchemaFile({ filePath }).definition).join(os.EOL);
+    return {
+      schema,
+      functionSlots: [],
+      referencedLambdaFunctions: {},
+      dataSourceStrategies: constructDataSourceStrategyMap(schema, dataSourceStrategy),
+    };
+  }
+
+  /**
+   * 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 {
+    if (definitions.length === 0) {
+      throw new Error('The definitions of amplify GraphQL cannot be empty.');
+    }
+    if (definitions.length === 1) {
+      return definitions[0];
+    }
     return {
-      schema: filePaths.map((filePath) => new SchemaFile({ filePath }).definition).join(os.EOL),
+      schema: definitions.map((def) => def.schema).join(os.EOL),
       functionSlots: [],
+      referencedLambdaFunctions: definitions.reduce((acc, cur) => ({ ...acc, ...cur.referencedLambdaFunctions }), {}),
+      dataSourceStrategies: definitions.reduce((acc, cur) => ({ ...acc, ...cur.dataSourceStrategies }), {}),
     };
   }
 }

package/src/index.ts

@@ -1,3 +1,7 @@
+/* ATTENTION
+ *
+ * If you modify this file your must also modify packages/amplify-data-construct/src/index.ts to have the same exports
+ */
 export type {
   IAMAuthorizationConfig,
   UserPoolAuthorizationConfig,
@@ -27,6 +31,24 @@ export type {
   IBackendOutputStorageStrategy,
   IBackendOutputEntry,
   AddFunctionProps,
+  ModelDataSourceStrategy,
+  DefaultDynamoDbModelDataSourceStrategy,
+  AmplifyDynamoDbModelDataSourceStrategy,
+  SQLLambdaModelDataSourceStrategy,
+  ModelDataSourceStrategyDbType,
+  VpcConfig,
+  SubnetAvailabilityZone,
+  SQLLambdaLayerMapping,
+  SqlModelDataSourceDbConnectionConfig,
+  ProvisionedConcurrencyConfig,
 } from './types';
 export { AmplifyGraphqlApi } from './amplify-graphql-api';
 export { AmplifyGraphqlDefinition } from './amplify-graphql-definition';
+export {
+  AmplifyDynamoDbTableWrapper,
+  TimeToLiveSpecification,
+  ProvisionedThroughput,
+  SSESpecification,
+  SSEType,
+  StreamSpecification,
+} from './amplify-dynamodb-table-wrapper';

package/src/internal/construct-exports.ts

@@ -14,6 +14,7 @@ import { CfnResource, NestedStack } from 'aws-cdk-lib';
 import { getResourceName } from '@aws-amplify/graphql-transformer-core';
 import { CfnFunction, Function as LambdaFunction } from 'aws-cdk-lib/aws-lambda';
 import { AmplifyGraphqlApiResources, FunctionSlot } from '../types';
+import { AmplifyDynamoDbTableWrapper } from '../amplify-dynamodb-table-wrapper';
 import { walkAndProcessNodes } from './construct-tree';
 
 /**
@@ -34,6 +35,7 @@ export const getGeneratedResources = (scope: Construct): AmplifyGraphqlApiResour
   const cfnDataSources: Record<string, CfnDataSource> = {};
   const tables: Record<string, Table> = {};
   const cfnTables: Record<string, CfnTable> = {};
+  const amplifyDynamoDbTables: Record<string, AmplifyDynamoDbTableWrapper> = {};
   const roles: Record<string, Role> = {};
   const cfnRoles: Record<string, CfnRole> = {};
   const functions: Record<string, LambdaFunction> = {};
@@ -78,6 +80,10 @@ export const getGeneratedResources = (scope: Construct): AmplifyGraphqlApiResour
       cfnTables[resourceName] = currentScope;
       return;
     }
+    if (AmplifyDynamoDbTableWrapper.isAmplifyDynamoDbTableResource(currentScope)) {
+      amplifyDynamoDbTables[resourceName] = new AmplifyDynamoDbTableWrapper(currentScope);
+      return;
+    }
     if (currentScope instanceof Role) {
       roles[resourceName] = currentScope;
       return;
@@ -117,6 +123,7 @@ export const getGeneratedResources = (scope: Construct): AmplifyGraphqlApiResour
   return {
     graphqlApi: GraphqlApi.fromGraphqlApiAttributes(scope, 'L2GraphqlApi', { graphqlApiId: cfnGraphqlApi.attrApiId }),
     tables,
+    amplifyDynamoDbTables,
     roles,
     functions,
     nestedStacks,