fix: handle Enums correctly on Typescript data schema generation

packages/amplify-graphql-schema-generator/src/__tests__/__snapshots__/generate-ts-data-schema.test.ts.snap

@@ -85,12 +85,120 @@ export const schema = a.schema({
  \\"User\\": a.model({
  id: a.string().required(),
  name: a.string(),
- status: a.enum([
- \\"ACTIVE\\",
- \\"INACTIVE\\"
- ])
+ status: a.ref(\\"UserStatus\\")
  }).identifier([
  \\"id\\"
+ ]),
+ UserStatus: a.enum([
+ \\"ACTIVE\\",
+ \\"INACTIVE\\"
+ ])
+});
+"
+`;
+
+exports[`Type name conversions generates enums for models in mysql 1`] = `
+"/* eslint-disable */
+/* THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY. */
+import { a } from \\"@aws-amplify/data-schema\\";
+
+export const schema = a.schema({
+ \\"User\\": a.model({
+ id: a.string().required(),
+ name: a.string(),
+ status: a.ref(\\"UserStatus\\").required()
+ }).identifier([
+ \\"id\\"
+ ]),
+ \\"Test\\": a.model({
+ id: a.string().required(),
+ name: a.string(),
+ age: a.ref(\\"TestAge\\").required()
+ }).identifier([
+ \\"id\\"
+ ]),
+ UserStatus: a.enum([
+ \\"ACTIVE\\",
+ \\"INACTIVE\\"
+ ]),
+ TestAge: a.enum([
+ \\"Above18\\",
+ \\"Below18\\"
+ ])
+});
+"
+`;
+
+exports[`Type name conversions generates required and null enums correctly in the same model 1`] = `
+"/* eslint-disable */
+/* THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY. */
+import { a } from \\"@aws-amplify/data-schema\\";
+
+export const schema = a.schema({
+ \\"User\\": a.model({
+ id: a.string().required(),
+ name: a.string(),
+ statsu1: a.ref(\\"UserStatus1\\"),
+ status: a.ref(\\"UserStatus\\").required()
+ }).identifier([
+ \\"id\\"
+ ]),
+ UserStatus1: a.enum([
+ \\"ACTIVE\\",
+ \\"INACTIVE\\"
+ ]),
+ UserStatus: a.enum([
+ \\"ACTIVE\\",
+ \\"INACTIVE\\"
+ ])
+});
+"
+`;
+
+exports[`Type name conversions generates required enums correctly 1`] = `
+"/* eslint-disable */
+/* THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY. */
+import { a } from \\"@aws-amplify/data-schema\\";
+
+export const schema = a.schema({
+ \\"User\\": a.model({
+ id: a.string().required(),
+ name: a.string(),
+ status: a.ref(\\"UserStatus\\").required()
+ }).identifier([
+ \\"id\\"
+ ]),
+ UserStatus: a.enum([
+ \\"ACTIVE\\",
+ \\"INACTIVE\\"
+ ])
+});
+"
+`;
+
+exports[`Type name conversions generates single enum referenced for two different models 1`] = `
+"/* eslint-disable */
+/* THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY. */
+import { a } from \\"@aws-amplify/data-schema\\";
+
+export const schema = a.schema({
+ \\"User\\": a.model({
+ id: a.string().required(),
+ name: a.string(),
+ status: a.ref(\\"UserStatus\\").required()
+ }).identifier([
+ \\"id\\"
+ ]),
+ \\"Test\\": a.model({
+ id: a.string().required(),
+ name: a.string(),
+ status: a.ref(\\"UserStatus\\").required()
+ }).identifier([
+ \\"id\\"
+ ]),
+ UserStatus: a.enum([
+ \\"ACTIVE\\",
+ \\"INACTIVE\\"
  ])
 });
 "

packages/amplify-graphql-schema-generator/src/__tests__/generate-ts-data-schema.test.ts

@@ -177,6 +177,77 @@ describe('Type name conversions', () => {
  expect(graphqlSchema).toMatchSnapshot();
  });
 
+ it('generates required enums correctly', () => {
+ const dbschema = new Schema(new Engine('Postgres'));
+ const model = new Model('User');
+ model.addField(new Field('id', { kind: 'NonNull', type: { kind: 'Scalar', name: 'String' } }));
+ model.addField(new Field('name', { kind: 'Scalar', name: 'String' }));
+ model.addField(new Field('status', { kind: 'NonNull', type: { kind: 'Enum', name: 'UserStatus', values: ['ACTIVE', 'INACTIVE'] } }));
+ model.setPrimaryKey(['id']);
+ dbschema.addModel(model);
+
+ const graphqlSchema = generateTypescriptDataSchema(dbschema);
+ expect(graphqlSchema).toMatchSnapshot();
+ });
+
+ it('generates required and null enums correctly in the same model', () => {
+ const dbschema = new Schema(new Engine('Postgres'));
+ const model = new Model('User');
+ model.addField(new Field('id', { kind: 'NonNull', type: { kind: 'Scalar', name: 'String' } }));
+ model.addField(new Field('name', { kind: 'Scalar', name: 'String' }));
+ model.addField(new Field('statsu1', { kind: 'Enum', name: 'UserStatus1', values: ['ACTIVE', 'INACTIVE'] }));
+ model.addField(new Field('status', { kind: 'NonNull', type: { kind: 'Enum', name: 'UserStatus', values: ['ACTIVE', 'INACTIVE'] } }));
+ model.setPrimaryKey(['id']);
+ dbschema.addModel(model);
+
+ const graphqlSchema = generateTypescriptDataSchema(dbschema);
+ expect(graphqlSchema).toMatchSnapshot();
+ });
+
+ it('generates single enum referenced for two different models', () => {
+ const dbschema = new Schema(new Engine('Postgres'));
+ const modelUser = new Model('User');
+ const modelTest = new Model('Test');
+ modelUser.addField(new Field('id', { kind: 'NonNull', type: { kind: 'Scalar', name: 'String' } }));
+ modelUser.addField(new Field('name', { kind: 'Scalar', name: 'String' }));
+ modelUser.addField(
+ new Field('status', { kind: 'NonNull', type: { kind: 'Enum', name: 'UserStatus', values: ['ACTIVE', 'INACTIVE'] } }),
+ );
+ modelUser.setPrimaryKey(['id']);
+ dbschema.addModel(modelUser);
+ modelTest.addField(new Field('id', { kind: 'NonNull', type: { kind: 'Scalar', name: 'String' } }));
+ modelTest.addField(new Field('name', { kind: 'Scalar', name: 'String' }));
+ modelTest.addField(
+ new Field('status', { kind: 'NonNull', type: { kind: 'Enum', name: 'UserStatus', values: ['ACTIVE', 'INACTIVE'] } }),
+ );
+ modelTest.setPrimaryKey(['id']);
+ dbschema.addModel(modelTest);
+
+ const graphqlSchema = generateTypescriptDataSchema(dbschema);
+ expect(graphqlSchema).toMatchSnapshot();
+ });
+
+ it('generates enums for models in mysql', () => {
+ const dbschema = new Schema(new Engine('MySQL'));
+ const modelUser = new Model('User');
+ const modelTest = new Model('Test');
+ modelUser.addField(new Field('id', { kind: 'NonNull', type: { kind: 'Scalar', name: 'String' } }));
+ modelUser.addField(new Field('name', { kind: 'Scalar', name: 'String' }));
+ modelUser.addField(
+ new Field('status', { kind: 'NonNull', type: { kind: 'Enum', name: 'userStatus', values: ['ACTIVE', 'INACTIVE'] } }),
+ );
+ modelUser.setPrimaryKey(['id']);
+ dbschema.addModel(modelUser);
+ modelTest.addField(new Field('id', { kind: 'NonNull', type: { kind: 'Scalar', name: 'String' } }));
+ modelTest.addField(new Field('name', { kind: 'Scalar', name: 'String' }));
+ modelTest.addField(new Field('age', { kind: 'NonNull', type: { kind: 'Enum', name: 'TestAge', values: ['Above18', 'Below18'] } }));
+ modelTest.setPrimaryKey(['id']);
+ dbschema.addModel(modelTest);
+
+ const graphqlSchema = generateTypescriptDataSchema(dbschema);
+ expect(graphqlSchema).toMatchSnapshot();
+ });
+
  it('schema with database config secret and vpc should generate typescript data schema with configure', () => {
  const dbschema = new Schema(new Engine('MySQL'));
  let model = new Model('User');

packages/amplify-graphql-schema-generator/src/__tests__/mysql-string-datasource-adapter.test.ts

@@ -69,7 +69,7 @@ describe('testStringDataSourceAdapter', () => {
  });
  expect(adapter.mapDataType('enum', true, 'table', 'field', 'enum("OPEN","CLOSED")')).toEqual({
  kind: 'Enum',
- name: 'table_field',
+ name: 'TableField',
  values: ['OPEN', 'CLOSED'],
  });
  expect(adapter.mapDataType('bool', true, 'table', 'field', 'varchar(50)')).toEqual({

packages/amplify-graphql-schema-generator/src/datasource-adapter/mysql-string-datasource-adapter.ts

@@ -1,3 +1,4 @@
+import { toPascalCase } from 'graphql-transformer-common';
 import { EnumType, Field, FieldDataType, FieldType, Index } from '../schema-representation';
 import { StringDataSourceAdapter, EmptySchemaError, InvalidSchemaError } from './string-datasource-adapter';
 
@@ -279,12 +280,12 @@ export class MySQLStringDataSourceAdapter extends StringDataSourceAdapter {
  return value.match(regex).map((a) => a.slice(1, -1));
  }
 
- private generateEnumName(tableName: string, fieldName: string) {
- const enumNamePrefix = [tableName, fieldName].join('_');
+ private generateEnumName(tableName: string, fieldName: string): string {
+ const enumNamePrefix = toPascalCase([tableName, fieldName]);
  let enumName = enumNamePrefix;
  let counter = 0;
  while (this.enums.has(enumName)) {
- enumName = [enumNamePrefix, counter.toString()].join('_');
+ enumName = toPascalCase([enumNamePrefix, counter.toString()]);
  counter++;
  }
  return enumName;

packages/amplify-graphql-schema-generator/src/datasource-adapter/pg-string-datasource-adapter.ts

@@ -1,5 +1,6 @@
 import { EnumType, Field, FieldDataType, FieldType, Index } from '../schema-representation';
 import { StringDataSourceAdapter, EmptySchemaError, InvalidSchemaError } from './string-datasource-adapter';
+import { toPascalCase } from 'graphql-transformer-common';
 
 export interface PostgresIndex {
  tableName: string;
@@ -156,7 +157,7 @@ export class PostgresStringDataSourceAdapter extends StringDataSourceAdapter {
  const enumValues = row.enum_values.substring(1, row.enum_values.length - 1).split(',');
  const enumType: EnumType = {
  kind: 'Enum',
- name: enumName,
+ name: toPascalCase([enumName]),
  values: enumValues,
  };
 

packages/amplify-graphql-schema-generator/src/ts-schema-generator/helpers.ts

@@ -1,7 +1,8 @@
 import ts from 'typescript';
-import { TYPESCRIPT_DATA_SCHEMA_CONSTANTS } from 'graphql-transformer-common';
+import { TYPESCRIPT_DATA_SCHEMA_CONSTANTS, toPascalCase } from 'graphql-transformer-common';
 import { VpcConfig } from '@aws-amplify/graphql-transformer-interfaces';
-import { DBEngineType, Field, FieldType, Model, Schema } from '../schema-representation';
+import { DBEngineType, EnumType, Field, FieldType, Model, Schema } from '../schema-representation';
+import { CommentNode } from '../../../graphql-mapping-template/lib/ast';
 
 const GQL_TYPESCRIPT_DATA_SCHEMA_TYPE_MAP = {
  string: 'string',
@@ -46,16 +47,12 @@ const createDataType = (type: FieldType): ts.Node => {
  );
  }
 
+ // make it in the form a.ref('name')
  if (type.kind === 'Enum') {
  return ts.factory.createCallExpression(
- ts.factory.createIdentifier(`${TYPESCRIPT_DATA_SCHEMA_CONSTANTS.REFERENCE_A}.${TYPESCRIPT_DATA_SCHEMA_CONSTANTS.ENUM_METHOD}`),
+ ts.factory.createIdentifier(`${TYPESCRIPT_DATA_SCHEMA_CONSTANTS.REFERENCE_A}.${TYPESCRIPT_DATA_SCHEMA_CONSTANTS.REF_METHOD}`),
  undefined,
- [
- ts.factory.createArrayLiteralExpression(
- type.values.map((value) => ts.factory.createStringLiteral(value)),
- true,
- ),
- ],
+ [ts.factory.createStringLiteral(toPascalCase([type.name]))],
  );
  }
 
@@ -91,6 +88,26 @@ const createModelDefinition = (model: Model): ts.Node => {
  return ts.factory.createObjectLiteralExpression(properties as ts.ObjectLiteralElementLike[], true);
 };
 
+/**
+ * Creates a typescript data schema type from internal SQL schema representation
+ * Example typescript data schema type output: `a.enum()`
+ * @param type SQL IR Enum type
+ * @returns Typescript data schema type in TS Node format
+ */
+const createEnums = (type: EnumType): ts.Node => {
+ const typeExpression = ts.factory.createCallExpression(
+ ts.factory.createIdentifier(`${TYPESCRIPT_DATA_SCHEMA_CONSTANTS.REFERENCE_A}.${TYPESCRIPT_DATA_SCHEMA_CONSTANTS.ENUM_METHOD}`),
+ undefined,
+ [
+ ts.factory.createArrayLiteralExpression(
+ type.values.map((value) => ts.factory.createStringLiteral(value)),
+ true,
+ ),
+ ],
+ );
+ return ts.factory.createPropertyAssignment(ts.factory.createIdentifier(toPascalCase([type.name])), typeExpression);
+};
+
 const createModel = (model: Model): ts.Node => {
  const modelExpr = ts.factory.createCallExpression(
  ts.factory.createIdentifier(`${TYPESCRIPT_DATA_SCHEMA_CONSTANTS.REFERENCE_A}.${TYPESCRIPT_DATA_SCHEMA_CONSTANTS.MODEL_METHOD}`),
@@ -147,19 +164,61 @@ export const createSchema = (schema: Schema, config?: DataSourceGenerateConfig):
  throw new Error('No valid tables found. Make sure at least one table has a primary key.');
  }
 
+ const nullableEnumFields = schema.getModels().map((model) =>
+ model
+ .getFields()
+ .filter((field) => field.type.kind === 'Enum')
+ .map((field) => {
+ if (field.type.kind === 'Enum') {
+ return createEnums(field.type);
+ } else {
+ return undefined;
+ }
+ }),
+ );
+
+ const requiredEnumFields = schema.getModels().map((model) =>
+ model
+ .getFields()
+ .filter((field) => field.type.kind === 'NonNull' && field.type.type.kind === 'Enum')
+ .map((field) => {
+ if (field.type.kind === 'NonNull' && field.type.type.kind === 'Enum') {
+ return createEnums(field.type.type);
+ } else {
+ return undefined;
+ }
+ }),
+ );
+
  const models = schema
  .getModels()
  .filter((model) => model.getPrimaryKey())
  .map((model) => {
  return createModel(model);
  });
+
+ const combinedEnums = nullableEnumFields.concat(requiredEnumFields).flat(); // making 1 D array
+
+ // to eliminate duplicate definition of enums in case where same enum is referenced in 2 differed models
+ const seenEnums = new Set<string>();
+ const uniqueEnums = combinedEnums.filter((node) => {
+ if (seenEnums.has(node['name'].escapedText)) {
+ return false;
+ } else {
+ seenEnums.add(node['name'].escapedText);
+ return true;
+ }
+ });
+
+ const modelsWithEnums = models.concat(uniqueEnums);
+
  const tsSchema = ts.factory.createCallExpression(
  ts.factory.createPropertyAccessExpression(
  createConfigureExpression(schema, config),
  ts.factory.createIdentifier(TYPESCRIPT_DATA_SCHEMA_CONSTANTS.SCHEMA_METHOD),
  ),
  undefined,
- [ts.factory.createObjectLiteralExpression(models as ts.ObjectLiteralElementLike[], true)],
+ [ts.factory.createObjectLiteralExpression(modelsWithEnums as ts.ObjectLiteralElementLike[], true)],
  );
  return ts.factory.createVariableStatement(
  [exportModifier],

packages/graphql-transformer-common/API.md

@@ -510,6 +510,7 @@ export const TYPESCRIPT_DATA_SCHEMA_CONSTANTS: {
  ARRAY_METHOD: string;
  REQUIRED_METHOD: string;
  STRING_METHOD: string;
+ REF_METHOD: string;
  ENUM_METHOD: string;
  REFERENCE_A: string;
  EXPORT_VARIABLE_NAME: string;

packages/graphql-transformer-common/src/TypescriptSchemaConstants.ts

@@ -8,6 +8,7 @@ export const TYPESCRIPT_DATA_SCHEMA_CONSTANTS = {
  ARRAY_METHOD: 'array',
  REQUIRED_METHOD: 'required',
  STRING_METHOD: 'string',
+ REF_METHOD: 'ref',
  ENUM_METHOD: 'enum',
  REFERENCE_A: 'a',
  EXPORT_VARIABLE_NAME: 'schema',