@aws-amplify/graphql-api-construct 1.4.0-construct-publish-test.0 → 1.4.0-nov-14-cut-1.0

package/src/amplify-graphql-api.ts

@@ -1,6 +1,6 @@
 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';
@@ -29,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,
@@ -37,6 +38,7 @@ import type {
   IBackendOutputStorageStrategy,
   AddFunctionProps,
   ConflictResolution,
+  SQLLambdaModelDataSourceStrategy,
 } from './types';
 import {
   convertAuthorizationModesToTransformerAuthConfig,
@@ -48,6 +50,7 @@ import {
   CodegenAssets,
   getAdditionalAuthenticationTypes,
 } from './internal';
+import { isSQLLambdaModelDataSourceStrategy } from './sql-model-datasource-strategy';
 import { parseDataSourceConfig } from './internal/data-source-config';
 import { getStackForScope, walkAndProcessNodes } from './internal/construct-tree';
 
@@ -170,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),
@@ -189,7 +192,10 @@ export class AmplifyGraphqlApi extends Construct {
       transformersFactoryArgs: {
         customTransformers: transformerPlugins ?? [],
         ...(predictionsBucket ? { storageConfig: { bucketName: predictionsBucket.bucketName } } : {}),
-        functionNameMap,
+        functionNameMap: {
+          ...definition.referencedLambdaFunctions,
+          ...functionNameMap,
+        },
       },
       authConfig,
       stackMapping: stackMappings ?? {},
@@ -198,8 +204,20 @@ export class AmplifyGraphqlApi extends Construct {
         ...defaultTranslationBehavior,
         ...(translationBehavior ?? {}),
       },
-      ...parseDataSourceConfig(definition.dataSourceDefinition),
-    });
+
+      // 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 });
 
@@ -214,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,41 +1,44 @@
 import * as os from 'os';
 import { SchemaFile } from 'aws-cdk-lib/aws-appsync';
-import { IAmplifyGraphqlDefinition, ModelDataSourceDefinition } from './types';
-import { constructDataSourceDefinitionMap } from './internal';
+import { IAmplifyGraphqlDefinition, ModelDataSourceStrategy } from './types';
+import { constructDataSourceStrategyMap } from './internal';
 
-export const DEFAULT_MODEL_DATA_SOURCE_DEFINITION: ModelDataSourceDefinition = {
-  name: 'DefaultDynamoDB',
-  strategy: {
-    dbType: 'DYNAMODB',
-    provisionStrategy: 'DEFAULT',
-  },
+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 modelDataSourceDefinition the provision definition for `@model` datasource. The DynamoDB from CloudFormation will be used by default.
-   * @experimental modelDataSourceDefinition
+   * @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,
-    modelDataSourceDefinition: ModelDataSourceDefinition = DEFAULT_MODEL_DATA_SOURCE_DEFINITION,
+    dataSourceStrategy: ModelDataSourceStrategy = DEFAULT_MODEL_DATA_SOURCE_STRATEGY,
   ): IAmplifyGraphqlDefinition {
     return {
       schema,
       functionSlots: [],
-      dataSourceDefinition: constructDataSourceDefinitionMap(schema, modelDataSourceDefinition),
+      referencedLambdaFunctions: {},
+      dataSourceStrategies: constructDataSourceStrategyMap(schema, dataSourceStrategy),
     };
   }
 
   /**
-   * Convert one or more appsync SchemaFile objects into an Amplify Graphql Schema
+   * 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
+   * @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)) {
@@ -45,20 +48,25 @@ export class AmplifyGraphqlDefinition {
     return {
       schema,
       functionSlots: [],
-      dataSourceDefinition: constructDataSourceDefinitionMap(schema, DEFAULT_MODEL_DATA_SOURCE_DEFINITION),
+      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 modelDataSourceDefinition the provision definition for `@model` datasource. The DynamoDB from CloudFormation will be used by default.
+   * @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 fromFilesAndDefinition(
+  static fromFilesAndStrategy(
     filePaths: string | string[],
-    modelDataSourceDefinition: ModelDataSourceDefinition = DEFAULT_MODEL_DATA_SOURCE_DEFINITION,
+    dataSourceStrategy: ModelDataSourceStrategy = DEFAULT_MODEL_DATA_SOURCE_STRATEGY,
   ): IAmplifyGraphqlDefinition {
     if (!Array.isArray(filePaths)) {
       filePaths = [filePaths];
@@ -67,12 +75,16 @@ export class AmplifyGraphqlDefinition {
     return {
       schema,
       functionSlots: [],
-      dataSourceDefinition: constructDataSourceDefinitionMap(schema, modelDataSourceDefinition),
+      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
    */
@@ -86,7 +98,8 @@ export class AmplifyGraphqlDefinition {
     return {
       schema: definitions.map((def) => def.schema).join(os.EOL),
       functionSlots: [],
-      dataSourceDefinition: definitions.reduce((acc, cur) => ({ ...acc, ...cur.dataSourceDefinition }), {}),
+      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,11 +31,16 @@ export type {
   IBackendOutputStorageStrategy,
   IBackendOutputEntry,
   AddFunctionProps,
-  ModelDataSourceDefinition,
-  ModelDataSourceDefinitionStrategy,
-  DefaultDynamoDbModelDataSourceDefinitionStrategy,
-  AmplifyDynamoDbModelDataSourceDefinitionStrategy,
-  ModelDataSourceDefinitionDbType,
+  ModelDataSourceStrategy,
+  DefaultDynamoDbModelDataSourceStrategy,
+  AmplifyDynamoDbModelDataSourceStrategy,
+  SQLLambdaModelDataSourceStrategy,
+  ModelDataSourceStrategyDbType,
+  VpcConfig,
+  SubnetAvailabilityZone,
+  SQLLambdaLayerMapping,
+  SqlModelDataSourceDbConnectionConfig,
+  ProvisionedConcurrencyConfig,
 } from './types';
 export { AmplifyGraphqlApi } from './amplify-graphql-api';
 export { AmplifyGraphqlDefinition } from './amplify-graphql-definition';

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

@@ -1,13 +1,21 @@
-import { ModelDataSourceDefinition } from '../types';
-import { DataSourceType, DynamoDBProvisionStrategy } from '@aws-amplify/graphql-transformer-interfaces';
+import {
+  DataSourceType,
+  DynamoDBProvisionStrategy,
+  SQLDBType,
+  SQLLambdaModelProvisionStrategy,
+} from '@aws-amplify/graphql-transformer-interfaces';
+import { ModelDataSourceStrategy } from '../types';
 
 type DataSourceConfig = {
   modelToDatasourceMap: Map<string, DataSourceType>;
 };
-const convertToDataSourceType = (modelDataSourceDefinition: ModelDataSourceDefinition): DataSourceType => {
-  const { strategy } = modelDataSourceDefinition;
-  if (strategy.dbType === 'DYNAMODB') {
-    switch (strategy.provisionStrategy) {
+
+// TODO: Do away with this after we normalize database types throughout the internals
+const convertSQLDBType = (definitionDBType: 'MYSQL' | 'POSTGRES'): SQLDBType => (definitionDBType === 'MYSQL' ? 'MySQL' : 'Postgres');
+
+const convertToDataSourceType = (dataSourceStrategy: ModelDataSourceStrategy): DataSourceType => {
+  if (dataSourceStrategy.dbType === 'DYNAMODB') {
+    switch (dataSourceStrategy.provisionStrategy) {
       case 'DEFAULT':
         return {
           dbType: 'DDB',
@@ -21,13 +29,23 @@ const convertToDataSourceType = (modelDataSourceDefinition: ModelDataSourceDefin
           provisionStrategy: DynamoDBProvisionStrategy.AMPLIFY_TABLE,
         };
       default:
-        throw new Error(`Encountered unexpected provision strategy: ${(strategy as any).provisionStrategy}`);
+        throw new Error(`Encountered unexpected provision strategy: ${(dataSourceStrategy as any).provisionStrategy}`);
     }
+  } else if (dataSourceStrategy.dbType === 'MYSQL' || dataSourceStrategy.dbType === 'POSTGRES') {
+    return {
+      dbType: convertSQLDBType(dataSourceStrategy.dbType),
+      provisionDB: false,
+      provisionStrategy: SQLLambdaModelProvisionStrategy.DEFAULT,
+    };
   }
-  throw new Error(`Encountered unexpected database type ${strategy.dbType}`);
+  throw new Error(`Encountered unexpected database type ${dataSourceStrategy.dbType}`);
 };
 
-export const parseDataSourceConfig = (dataSourceDefinitionMap: Record<string, ModelDataSourceDefinition>): DataSourceConfig => {
+/**
+ * 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 = convertToDataSourceType(value);

package/src/internal/default-parameters.ts

@@ -17,4 +17,6 @@ export const defaultTranslationBehavior: TranslationBehavior = {
   respectPrimaryKeyAttributesOnConnectionField: true,
   enableSearchNodeToNodeEncryption: false,
   enableTransformerCfnOutputs: false,
+  allowDestructiveGraphqlSchemaUpdates: false,
+  replaceTableUponGsiUpdate: false,
 };

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

@@ -1,30 +1,39 @@
-import { Kind, ObjectTypeDefinitionNode, parse } from 'graphql';
-import { ModelDataSourceDefinition } from '../types';
+import { ModelDataSourceStrategy } from '../types';
+import { Kind, ObjectTypeDefinitionNode, StringValueNode, parse } from 'graphql';
 
 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
  * @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);
+  const parsedSchema = parse(schema);
+  const nodesWithModelDirective = parsedSchema.definitions.filter(
+    (obj) => obj.kind === Kind.OBJECT_TYPE_DEFINITION && obj.directives?.some((dir) => dir.name.value === MODEL_DIRECTIVE_NAME),
+  );
+  const modelKeys = nodesWithModelDirective.map((type) => (type as ObjectTypeDefinitionNode).name.value);
+  nodesWithModelDirective.forEach((obj) => {
+    const { fields } = obj as ObjectTypeDefinitionNode;
+    fields?.forEach((field) => {
+      field.directives?.forEach((dir) => {
+        if (dir.name.value === MANY_TO_MANY_DIRECTIVE_NAME) {
+          const relationArg = dir.arguments?.find((arg) => arg.name.value === 'relationName');
+          if (relationArg) {
+            modelKeys.push((relationArg.value as StringValueNode).value);
+          }
+        }
+      });
+    });
+  });
+  return modelKeys.filter((key, idx) => modelKeys.indexOf(key) === idx);
 }
 
-export function constructDataSourceDefinitionMap(
+export const constructDataSourceStrategyMap = (
   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 }), {});
-}
+  dataSourceStrategy: ModelDataSourceStrategy,
+): Record<string, ModelDataSourceStrategy> => {
+  const modelKeys = getModelTypeNames(schema);
+  return modelKeys.reduce((acc, cur) => ({ ...acc, [cur]: dataSourceStrategy }), {});
+};

package/src/sql-model-datasource-strategy.ts

@@ -0,0 +1,62 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { SQLLambdaModelDataSourceStrategy, SqlModelDataSourceDbConnectionConfig } from './types';
+
+/**
+ * Type predicate that returns true if the object is a SQLLambdaModelDataSourceStrategy.
+ * @param obj the object to inspect
+ * @returns true if the object is shaped like a SQLLambdaModelDataSourceStrategy
+ */
+export const isSQLLambdaModelDataSourceStrategy = (obj: any): obj is SQLLambdaModelDataSourceStrategy => {
+  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) &&
+    isSqlModelDataSourceDbConnectionConfig(obj.dbConnectionConfig)
+  );
+};
+
+/**
+ * Type predicate that returns true if the object is a SqlModelDataSourceDbConnectionConfig.
+ * @param obj the object to inspect
+ * @returns true if the object is shaped like a SqlModelDataSourceDbConnectionConfig
+ */
+export const isSqlModelDataSourceDbConnectionConfig = (obj: any): obj is SqlModelDataSourceDbConnectionConfig => {
+  return (
+    (typeof obj === 'object' || typeof obj === 'function') &&
+    typeof obj.hostnameSsmPath === 'string' &&
+    typeof obj.portSsmPath === 'string' &&
+    typeof obj.usernameSsmPath === 'string' &&
+    typeof obj.passwordSsmPath === 'string' &&
+    typeof obj.databaseNameSsmPath === 'string'
+  );
+};
+
+/**
+ * Class exposing utilities to produce SQLLambdaModelDataSourceStrategy objects given various inputs.
+ */
+export class SQLLambdaModelDataSourceStrategyFactory {
+  /**
+   * Creates a SQLLambdaModelDataSourceStrategy where the binding's `customSqlStatements` are populated from `sqlFiles`. The key
+   * of the `customSqlStatements` record is the file's base name (that is, the name of the file minus the directory and extension).
+   * @param sqlFiles the list of files to load SQL statements from.
+   * @param options the remaining SQLLambdaModelDataSourceStrategy options.
+   */
+  static fromCustomSqlFiles(
+    sqlFiles: string[],
+    options: Exclude<SQLLambdaModelDataSourceStrategy, 'customSqlStatements'>,
+  ): SQLLambdaModelDataSourceStrategy {
+    const customSqlStatements = sqlFiles.reduce((acc, filePath): Record<string, string> => {
+      const basename = path.parse(filePath).name;
+      acc[basename] = fs.readFileSync(filePath, 'utf8');
+      return acc;
+    }, {} as Record<string, string>);
+
+    return {
+      customSqlStatements,
+      ...options,
+    };
+  }
+}