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

package/src/amplify-graphql-definition.ts

@@ -1,7 +1,14 @@
 import * as os from 'os';
 import { SchemaFile } from 'aws-cdk-lib/aws-appsync';
-import { IAmplifyGraphqlDefinition, ModelDataSourceStrategy } from './types';
-import { constructDataSourceStrategyMap } from './internal';
+import { isSqlStrategy } from '@aws-amplify/graphql-transformer-core';
+import { IAmplifyGraphqlDefinition } from './types';
+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',
@@ -14,24 +21,22 @@ 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 in this schema. The DynamoDB from
-   * CloudFormation will be used by default.
-   * @experimental dataSourceStrategy
+   * @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.
    * @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),
     };
   }
 
@@ -45,20 +50,11 @@ export class AmplifyGraphqlDefinition {
       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),
-    };
+    return AmplifyGraphqlDefinition.fromString(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.
@@ -72,20 +68,11 @@ export class AmplifyGraphqlDefinition {
       filePaths = [filePaths];
     }
     const schema = filePaths.map((filePath) => new SchemaFile({ filePath }).definition).join(os.EOL);
-    return {
-      schema,
-      functionSlots: [],
-      referencedLambdaFunctions: {},
-      dataSourceStrategies: constructDataSourceStrategyMap(schema, dataSourceStrategy),
-    };
+    return AmplifyGraphqlDefinition.fromString(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 {
@@ -95,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

@@ -1,6 +1,6 @@
 /* ATTENTION
  *
- * If you modify this file your must also modify packages/amplify-data-construct/src/index.ts to have the same exports
+ * If you modify this file you must also modify packages/amplify-data-construct/src/index.ts to have the same exports
  */
 export type {
   IAMAuthorizationConfig,
@@ -31,15 +31,6 @@ export type {
   IBackendOutputStorageStrategy,
   IBackendOutputEntry,
   AddFunctionProps,
-  ModelDataSourceStrategy,
-  DefaultDynamoDbModelDataSourceStrategy,
-  AmplifyDynamoDbModelDataSourceStrategy,
-  SQLLambdaModelDataSourceStrategy,
-  ModelDataSourceStrategyDbType,
-  VpcConfig,
-  SubnetAvailabilityZone,
-  SqlModelDataSourceDbConnectionConfig,
-  ProvisionedConcurrencyConfig,
 } from './types';
 export { AmplifyGraphqlApi } from './amplify-graphql-api';
 export { AmplifyGraphqlDefinition } from './amplify-graphql-definition';
@@ -52,3 +43,4 @@ export {
   StreamSpecification,
 } from './amplify-dynamodb-table-wrapper';
 export { SQLLambdaModelDataSourceStrategyFactory } from './sql-model-datasource-strategy';
+export * from './model-datasource-strategy-types';

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

@@ -1,57 +1,205 @@
+import { DefinitionNode, FieldDefinitionNode, InterfaceTypeDefinitionNode, ObjectTypeDefinitionNode, parse, print } from 'graphql';
 import {
-  DataSourceType,
-  DynamoDBProvisionStrategy,
-  SQLDBType,
-  SQLLambdaModelProvisionStrategy,
-} from '@aws-amplify/graphql-transformer-interfaces';
-import { ModelDataSourceStrategy } from '../types';
-
-type DataSourceConfig = {
-  modelToDatasourceMap: Map<string, DataSourceType>;
-};
+  isBuiltInGraphqlNode,
+  isSqlStrategy,
+  isQueryNode,
+  isMutationNode,
+  fieldsWithSqlDirective,
+} from '@aws-amplify/graphql-transformer-core';
+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
+ * scans the fields of `Query` and `Mutation` looking for fields annotated with the `@sql` directive and designates the specified
+ * dataSourceStrategy to fulfill those custom queries.
+ *
+ * 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.
+ */
+export const constructCustomSqlDataSourceStrategies = (
+  schema: string,
+  dataSourceStrategy: ConstructModelDataSourceStrategy,
+): ConstructCustomSqlDataSourceStrategy[] => {
+  if (!isSqlStrategy(dataSourceStrategy)) {
+    return [];
+  }
+
+  const parsedSchema = parse(schema);
+
+  const queryNode = parsedSchema.definitions.find(isQueryNode);
+  const mutationNode = parsedSchema.definitions.find(isMutationNode);
+  if (!queryNode && !mutationNode) {
+    return [];
+  }
+
+  const customSqlDataSourceStrategies: ConstructCustomSqlDataSourceStrategy[] = [];
+
+  if (queryNode) {
+    const fields = fieldsWithSqlDirective(queryNode);
+    for (const field of fields) {
+      customSqlDataSourceStrategies.push({
+        typeName: 'Query',
+        fieldName: field.name.value,
+        strategy: dataSourceStrategy,
+      });
+    }
+  }
 
-// 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',
-          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: ${(dataSourceStrategy as any).provisionStrategy}`);
+  if (mutationNode) {
+    const fields = fieldsWithSqlDirective(mutationNode);
+    for (const field of fields) {
+      customSqlDataSourceStrategies.push({
+        typeName: 'Mutation',
+        fieldName: field.name.value,
+        strategy: dataSourceStrategy,
+      });
     }
-  } 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 ${dataSourceStrategy.dbType}`);
+
+  return customSqlDataSourceStrategies;
 };
 
 /**
- * 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.
+ * 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 parseDataSourceConfig = (dataSourceDefinitionMap: Record<string, ModelDataSourceStrategy>): 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,
+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(', ')}.`,
+    );
+  }
+};
+
+const isValidSSMPath = (path: string): boolean => {
+  return path.startsWith('/');
 };

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

@@ -1,14 +1,15 @@
-import { ModelDataSourceStrategy } from '../types';
 import { Kind, ObjectTypeDefinitionNode, StringValueNode, parse } from 'graphql';
+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
  * @returns type names which model diretives are attached
  */
-export function getModelTypeNames(schema: string): string[] {
+export const getModelTypeNames = (schema: string): string[] => {
   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),
@@ -28,9 +29,9 @@ export function 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> => {

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

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

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

@@ -1,6 +1,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
-import { SQLLambdaModelDataSourceStrategy, SqlModelDataSourceDbConnectionConfig } from './types';
+import { isSqlDbType } from '@aws-amplify/graphql-transformer-core';
+import { SQLLambdaModelDataSourceStrategy, SqlModelDataSourceDbConnectionConfig } from './model-datasource-strategy-types';
 
 /**
  * Type predicate that returns true if the object is a SQLLambdaModelDataSourceStrategy.
@@ -12,8 +13,7 @@ export const isSQLLambdaModelDataSourceStrategy = (obj: any): obj is SQLLambdaMo
     (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) &&
+    isSqlDbType(obj.dbType) &&
     isSqlModelDataSourceDbConnectionConfig(obj.dbConnectionConfig)
   );
 };