@aws-amplify/graphql-api-construct 1.3.0-rds-5.0 → 1.4.0-construct-publish-test.0

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 { ExecuteTransformConfig, executeTransform } from '@aws-amplify/graphql-transformer';
+import { 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,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, constructDataSourceMap } from '@aws-amplify/graphql-transformer-core';
 import { parseUserDefinedSlots, validateFunctionSlots, separateSlots } from './internal/user-defined-slots';
 import type {
   AmplifyGraphqlApiResources,
@@ -37,7 +37,6 @@ import type {
   IBackendOutputStorageStrategy,
   AddFunctionProps,
   ConflictResolution,
-  SqlModelDataSourceBinding,
 } from './types';
 import {
   convertAuthorizationModesToTransformerAuthConfig,
@@ -47,10 +46,9 @@ import {
   getGeneratedResources,
   getGeneratedFunctionSlots,
   CodegenAssets,
-  addAmplifyMetadataToStackDescription,
   getAdditionalAuthenticationTypes,
 } from './internal';
-import { isSqlModelDataSourceBinding } from './sql-model-datasource-binding';
+import { parseDataSourceConfig } from './internal/data-source-config';
 import { getStackForScope, walkAndProcessNodes } from './internal/construct-tree';
 
 /**
@@ -125,6 +123,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.
@@ -149,7 +152,8 @@ export class AmplifyGraphqlApi extends Construct {
       functionNameMap,
       outputStorageStrategy,
     } = props;
-    addAmplifyMetadataToStackDescription(scope);
+
+    new AttributionMetadataStorage().storeAttributionMetadata(Stack.of(scope), this.stackType, path.join(__dirname, '..', 'package.json'));
 
     const { authConfig, authSynthParameters } = convertAuthorizationModesToTransformerAuthConfig(authorizationModes);
 
@@ -166,7 +170,7 @@ export class AmplifyGraphqlApi extends Construct {
 
     const assetManager = new AssetManager();
 
-    let executeTransformConfig: ExecuteTransformConfig = {
+    executeTransform({
       scope: this,
       nestedStackProvider: {
         provide: (nestedStackScope: Construct, name: string) => new NestedStack(nestedStackScope, name),
@@ -194,13 +198,8 @@ export class AmplifyGraphqlApi extends Construct {
         ...defaultTranslationBehavior,
         ...(translationBehavior ?? {}),
       },
-    };
-
-    if (isSqlModelDataSourceBinding(definition.modelDataSourceBinding)) {
-      executeTransformConfig = this.extendTransformConfig(executeTransformConfig, definition.modelDataSourceBinding);
-    }
-
-    executeTransform(executeTransformConfig);
+      ...parseDataSourceConfig(definition.dataSourceDefinition),
+    });
 
     this.codegenAssets = new CodegenAssets(this, 'AmplifyCodegenAssets', { modelSchema: definition.schema });
 
@@ -215,67 +214,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 modelDataSourceBinding the modelDataSourceBinding containing the values to add to the transform config
-   */
-  private extendTransformConfig(
-    executeTransformConfig: ExecuteTransformConfig,
-    modelDataSourceBinding: SqlModelDataSourceBinding,
-  ): ExecuteTransformConfig {
-    const extendedConfig = { ...executeTransformConfig };
-    if (modelDataSourceBinding.customSqlStatements) {
-      extendedConfig.customQueries = new Map(Object.entries(modelDataSourceBinding.customSqlStatements));
-    }
-
-    const dbSecrets: Map<string, RDSConnectionSecrets> = new Map();
-    let dbSecretDbTypeKey: string;
-    switch (modelDataSourceBinding.bindingType) {
-      case MYSQL_DB_TYPE:
-        dbSecretDbTypeKey = MYSQL_DB_TYPE;
-        break;
-      case POSTGRES_DB_TYPE:
-        dbSecretDbTypeKey = POSTGRES_DB_TYPE;
-        break;
-      default:
-        throw new Error(`Unsupported binding type ${modelDataSourceBinding.bindingType}`);
-    }
-    dbSecrets.set(dbSecretDbTypeKey, {
-      username: modelDataSourceBinding.dbConnectionConfig.usernameSsmPath,
-      password: modelDataSourceBinding.dbConnectionConfig.passwordSsmPath,
-      host: modelDataSourceBinding.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: modelDataSourceBinding.dbConnectionConfig.portSsmPath as any,
-      database: modelDataSourceBinding.dbConnectionConfig.databaseNameSsmPath,
-    });
-    extendedConfig.datasourceSecretParameterLocations = dbSecrets;
-
-    const subnetAvailabilityZoneConfig = modelDataSourceBinding.vpcConfiguration.subnetAvailabilityZones.map(
-      (saz): { SubnetId: string; AvailabilityZone: string } => ({
-        SubnetId: saz.subnetId,
-        AvailabilityZone: saz.availabilityZone,
-      }),
-    );
-
-    if (!extendedConfig.modelToDatasourceMap || extendedConfig.modelToDatasourceMap.size === 0) {
-      const defaultDatasourceType = {
-        dbType: modelDataSourceBinding.bindingType,
-        provisionDB: false,
-      };
-      extendedConfig.modelToDatasourceMap = constructDataSourceMap(extendedConfig.schema, defaultDatasourceType);
-    }
-
-    extendedConfig.sqlLambdaVpcConfig = {
-      vpcId: modelDataSourceBinding.vpcConfiguration.vpcId,
-      securityGroupIds: modelDataSourceBinding.vpcConfiguration.securityGroupIds,
-      subnetAvailabilityZoneConfig,
-    };
-
-    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,52 +1,92 @@
 import * as os from 'os';
 import { SchemaFile } from 'aws-cdk-lib/aws-appsync';
-import { ModelDataSourceBinding, IAmplifyGraphqlDefinition } from './types';
+import { IAmplifyGraphqlDefinition, ModelDataSourceDefinition } from './types';
+import { constructDataSourceDefinitionMap } from './internal';
 
-const DEFAULT_DATA_SOURCE_BINDING: ModelDataSourceBinding = {
-  bindingType: 'DynamoDB',
+export const DEFAULT_MODEL_DATA_SOURCE_DEFINITION: ModelDataSourceDefinition = {
+  name: 'DefaultDynamoDB',
+  strategy: {
+    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
    * @param schema the graphql input as a string
-   * @param modelDataSourceBinding the ModelDataSourceBinding to use for the schema. This parameter is @experimental
-   * @returns a fully formed amplify graphql definition, whose models will be resolved by the data source specifed in the
-   *   modelDataSourceBinding
+   * @param modelDataSourceDefinition the provision definition for `@model` datasource. The DynamoDB from CloudFormation will be used by default.
+   * @experimental modelDataSourceDefinition
+   * @returns a fully formed amplify graphql definition
    */
   static fromString(
     schema: string,
-    modelDataSourceBinding: ModelDataSourceBinding = DEFAULT_DATA_SOURCE_BINDING,
+    modelDataSourceDefinition: ModelDataSourceDefinition = DEFAULT_MODEL_DATA_SOURCE_DEFINITION,
   ): IAmplifyGraphqlDefinition {
     return {
       schema,
       functionSlots: [],
-      modelDataSourceBinding,
+      dataSourceDefinition: constructDataSourceDefinitionMap(schema, modelDataSourceDefinition),
     };
   }
 
   /**
-   * Convert one or more appsync SchemaFile objects into an Amplify Graphql Schema, binding them to a DynamoDB data source.
+   * Convert one or more appsync SchemaFile objects into an Amplify Graphql Schema
    * @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.
+   * @returns a fully formed amplify graphql definition
    */
   static fromFiles(...filePaths: string[]): IAmplifyGraphqlDefinition {
-    return AmplifyGraphqlDefinition.fromFilesAndBinding(filePaths, DEFAULT_DATA_SOURCE_BINDING);
+    if (!Array.isArray(filePaths)) {
+      filePaths = [filePaths];
+    }
+    const schema = filePaths.map((filePath) => new SchemaFile({ filePath }).definition).join(os.EOL);
+    return {
+      schema,
+      functionSlots: [],
+      dataSourceDefinition: constructDataSourceDefinitionMap(schema, DEFAULT_MODEL_DATA_SOURCE_DEFINITION),
+    };
   }
 
   /**
-   * Convert one or more appsync SchemaFile objects into an Amplify Graphql Schema, binding them with the specified ModelDataSourceBinding.
-   * @param filePaths one or more paths to the graphql files to process
-   * @param modelDataSourceBinding the ModelDataSourceBinding to use for the schema.
-   * @returns a fully formed amplify graphql definition, whose models will be resolved by the data source specifed in the
-   *   modelDataSourceBinding
+   * Convert one or more appsync SchemaFile objects into an Amplify Graphql Schema
    * @experimental
+   * @param filePaths one or more paths to the graphql files to process
+   * @param modelDataSourceDefinition the provision definition for `@model` datasource. The DynamoDB from CloudFormation will be used by default.
+   * @returns a fully formed amplify graphql definition
    */
-  static fromFilesAndBinding(filePaths: string[], modelDataSourceBinding: ModelDataSourceBinding): IAmplifyGraphqlDefinition {
+  static fromFilesAndDefinition(
+    filePaths: string | string[],
+    modelDataSourceDefinition: ModelDataSourceDefinition = DEFAULT_MODEL_DATA_SOURCE_DEFINITION,
+  ): IAmplifyGraphqlDefinition {
+    if (!Array.isArray(filePaths)) {
+      filePaths = [filePaths];
+    }
     const schema = filePaths.map((filePath) => new SchemaFile({ filePath }).definition).join(os.EOL);
-    return AmplifyGraphqlDefinition.fromString(schema, modelDataSourceBinding);
+    return {
+      schema,
+      functionSlots: [],
+      dataSourceDefinition: constructDataSourceDefinitionMap(schema, modelDataSourceDefinition),
+    };
+  }
+
+  /**
+   * Combines multiple IAmplifyGraphqlDefinitions into a single definition.
+   * @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: definitions.map((def) => def.schema).join(os.EOL),
+      functionSlots: [],
+      dataSourceDefinition: definitions.reduce((acc, cur) => ({ ...acc, ...cur.dataSourceDefinition }), {}),
+    };
   }
 }

package/src/index.ts

@@ -27,12 +27,19 @@ export type {
   IBackendOutputStorageStrategy,
   IBackendOutputEntry,
   AddFunctionProps,
-  ModelDataSourceBinding,
-  DynamoModelDataSourceBinding,
-  SqlModelDataSourceBinding,
-  SqlModelDataSourceBindingVpcConfig,
-  SubnetAvailabilityZone,
-  SqlModelDataSourceBindingDbConnectionConfig,
+  ModelDataSourceDefinition,
+  ModelDataSourceDefinitionStrategy,
+  DefaultDynamoDbModelDataSourceDefinitionStrategy,
+  AmplifyDynamoDbModelDataSourceDefinitionStrategy,
+  ModelDataSourceDefinitionDbType,
 } 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/authorization-modes.ts

@@ -1,6 +1,7 @@
 import { AppSyncAuthConfiguration, AppSyncAuthConfigurationEntry, SynthParameters } from '@aws-amplify/graphql-transformer-interfaces';
 import { CfnGraphQLApi } from 'aws-cdk-lib/aws-appsync';
 import { isArray } from 'lodash';
+import { IRole, ServicePrincipal } from 'aws-cdk-lib/aws-iam';
 import {
   AuthorizationModes,
   ApiKeyAuthorizationConfig,
@@ -56,6 +57,7 @@ const convertAuthModeToAuthProvider = (authMode: AuthorizationConfigMode): AppSy
       return {
         authenticationType,
         lambdaAuthorizerConfig: {
+          lambdaArn: authMode.function.functionArn,
           lambdaFunction: authMode.function.functionName,
           ttlSeconds: authMode.ttl.toSeconds(),
         },
@@ -89,6 +91,12 @@ const convertAuthConfigToAppSyncAuth = (authModes: AuthorizationModes): AppSyncA
     throw new Error('A defaultAuthorizationMode is required if multiple authorization modes are configured.');
   }
 
+  // Enable appsync to invoke a provided lambda authorizer function
+  authModes.lambdaConfig?.function.addPermission('appsync-auth-invoke', {
+    principal: new ServicePrincipal('appsync.amazonaws.com'),
+    action: 'lambda:InvokeFunction',
+  });
+
   // In the case of a single mode, defaultAuthorizationMode is not required, just use the provided value.
   if (authProviders.length === 1) {
     return {
@@ -149,13 +157,26 @@ export const convertAuthorizationModesToTransformerAuthConfig = (authModes: Auth
   authSynthParameters: getSynthParameters(authModes),
 });
 
+/**
+ * Merge iamConfig allowListedRoles with deprecated adminRoles property, converting to strings.
+ * @param authModes the auth modes provided to the construct.
+ * @returns the list of admin roles as strings to pass into the transformer
+ */
+const getAllowListedRoles = (authModes: AuthorizationModes): string[] =>
+  [...(authModes?.iamConfig?.allowListedRoles ?? []), ...(authModes.adminRoles ?? [])].map((roleOrRoleName: IRole | string) => {
+    if (typeof roleOrRoleName === 'string' || roleOrRoleName instanceof String) {
+      return roleOrRoleName as string;
+    }
+    return roleOrRoleName.roleName;
+  });
+
 /**
  * Transform the authorization config into the transformer synth parameters pertaining to auth.
  * @param authModes the auth modes provided to the construct.
  * @returns a record of params to be consumed by the transformer.
  */
 const getSynthParameters = (authModes: AuthorizationModes): AuthSynthParameters => ({
-  adminRoles: authModes.adminRoles?.map((role) => role.roleName) ?? [],
+  adminRoles: getAllowListedRoles(authModes),
   identityPoolId: authModes.iamConfig?.identityPoolId,
   ...(authModes.userPoolConfig ? { userPoolId: authModes.userPoolConfig.userPool.userPoolId } : {}),
   ...(authModes?.iamConfig

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,

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

@@ -0,0 +1,39 @@
+import { ModelDataSourceDefinition } from '../types';
+import { DataSourceType, DynamoDBProvisionStrategy } from '@aws-amplify/graphql-transformer-interfaces';
+
+type DataSourceConfig = {
+  modelToDatasourceMap: Map<string, DataSourceType>;
+};
+const convertToDataSourceType = (modelDataSourceDefinition: ModelDataSourceDefinition): DataSourceType => {
+  const { strategy } = modelDataSourceDefinition;
+  if (strategy.dbType === 'DYNAMODB') {
+    switch (strategy.provisionStrategy) {
+      case 'DEFAULT':
+        return {
+          dbType: 'DDB',
+          provisionDB: true,
+          provisionStrategy: DynamoDBProvisionStrategy.DEFAULT,
+        };
+      case 'AMPLIFY_TABLE':
+        return {
+          dbType: 'DDB',
+          provisionDB: true,
+          provisionStrategy: DynamoDBProvisionStrategy.AMPLIFY_TABLE,
+        };
+      default:
+        throw new Error(`Encountered unexpected provision strategy: ${(strategy as any).provisionStrategy}`);
+    }
+  }
+  throw new Error(`Encountered unexpected database type ${strategy.dbType}`);
+};
+
+export const parseDataSourceConfig = (dataSourceDefinitionMap: Record<string, ModelDataSourceDefinition>): DataSourceConfig => {
+  const modelToDatasourceMap = new Map<string, DataSourceType>();
+  for (const [key, value] of Object.entries(dataSourceDefinitionMap)) {
+    const dataSourceType = convertToDataSourceType(value);
+    modelToDatasourceMap.set(key, dataSourceType);
+  }
+  return {
+    modelToDatasourceMap,
+  };
+};

package/src/internal/index.ts

@@ -4,4 +4,4 @@ export * from './default-parameters';
 export * from './conflict-resolution';
 export * from './asset-manager';
 export * from './codegen-assets';
-export * from './amplify-metadata';
+export * from './model-type-name';

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

@@ -0,0 +1,30 @@
+import { Kind, ObjectTypeDefinitionNode, parse } from 'graphql';
+import { ModelDataSourceDefinition } from '../types';
+
+const MODEL_DIRECTIVE_NAME = 'model';
+/**
+ * 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 function getModelTypeNames(schema: string): string[] {
+  const parsedDocument = parse(schema);
+  const nodesWithModelDirective = parsedDocument.definitions.filter(
+    (def) =>
+      def.kind === Kind.OBJECT_TYPE_DEFINITION &&
+      def.directives &&
+      def.directives.find((dir) => dir.name.value === MODEL_DIRECTIVE_NAME) != undefined,
+  ) as ObjectTypeDefinitionNode[];
+  return nodesWithModelDirective.map((node) => node.name.value);
+}
+
+export function constructDataSourceDefinitionMap(
+  schema: string,
+  dataSourceDefinition: ModelDataSourceDefinition,
+): Record<string, ModelDataSourceDefinition> {
+  const parsedSchema = parse(schema);
+  return parsedSchema.definitions
+    .filter((obj) => obj.kind === Kind.OBJECT_TYPE_DEFINITION && obj.directives?.some((dir) => dir.name.value === MODEL_DIRECTIVE_NAME))
+    .map((type) => (type as ObjectTypeDefinitionNode).name.value)
+    .reduce((acc, cur) => ({ ...acc, [cur]: dataSourceDefinition }), {});
+}