@aws-amplify/graphql-model-transformer 0.16.7 → 0.17.0-rds-support-preview1.0.0

package/src/resolvers/common.ts

@@ -1,88 +1,29 @@
 import {
-  CompoundExpressionNode,
-  Expression,
-  comment,
   iff,
-  and,
   ref,
   notEquals,
   methodCall,
-  int,
   compoundExpression,
-  set,
   obj,
-  equals,
-  ifElse,
   printBlock,
   toJson,
-  qref,
   str,
   not,
 } from 'graphql-mapping-template';
-import { OPERATION_KEY } from '../definitions';
 
 const API_KEY = 'API Key Authorization';
-
 /**
- * Helper method to generate code that converts DynamoDB condition object to condition
- * expression
- * @param inputConditionObjectName : Variable in stash that holds condition object
- * @param conditionOutputVariableName: Variable to store generated DDB expression
+ * Util function to generate sandbox mode expression
  */
-export const generateConditionSlot = (inputConditionObjectName: string, conditionOutputVariableName: string): CompoundExpressionNode => {
-  const statements: Expression[] = [
-    comment('Start condition block'),
-
-    iff(
-      and([ref(inputConditionObjectName), notEquals(methodCall(ref(`${inputConditionObjectName}.size`)), int(0))]),
-      compoundExpression([
-        set(ref('mergedConditions'), obj({ and: ref(inputConditionObjectName) })),
-        set(
-          ref(conditionOutputVariableName),
-          methodCall(ref('util.parseJson'), methodCall(ref('util.transform.toDynamoDBConditionExpression'), ref('mergedConditions'))),
-        ),
-        iff(
-          and([
-            ref(`${conditionOutputVariableName}.expressionValues`),
-            equals(methodCall(ref(`${conditionOutputVariableName}.expressionValues.size`)), int(0)),
-          ]),
-          set(
-            ref(conditionOutputVariableName),
-            obj({
-              expression: ref(`${conditionOutputVariableName}.expression`),
-              expressionNames: ref(`${conditionOutputVariableName}.expressionNames`),
-            }),
-          ),
-        ),
-        comment('End condition block'),
-      ]),
-    ),
-  ];
-  return compoundExpression(statements);
-};
+export const generateAuthExpressionForSandboxMode = (enabled: boolean): string => {
+  let exp;
 
-/**
- * Generate common response template used by most of the resolvers.
- * Append operation if response is coming from a mutation, this is to protect field resolver for subscriptions
- */
-export const generateDefaultResponseMappingTemplate = (isSyncEnabled: boolean, mutation = false): string => {
-  const statements: Expression[] = [];
-  if (mutation) statements.push(qref(methodCall(ref('ctx.result.put'), str(OPERATION_KEY), str('Mutation'))));
-  if (isSyncEnabled) {
-    statements.push(
-      ifElse(
-        ref('ctx.error'),
-        methodCall(ref('util.error'), ref('ctx.error.message'), ref('ctx.error.type'), ref('ctx.result')),
-        toJson(ref('ctx.result')),
-      ),
-    );
-  } else {
-    statements.push(
-      ifElse(ref('ctx.error'), methodCall(ref('util.error'), ref('ctx.error.message'), ref('ctx.error.type')), toJson(ref('ctx.result'))),
-    );
-  }
+  if (enabled) exp = iff(notEquals(methodCall(ref('util.authType')), str(API_KEY)), methodCall(ref('util.unauthorized')));
+  else exp = methodCall(ref('util.unauthorized'));
 
-  return printBlock('ResponseTemplate')(compoundExpression(statements));
+  return printBlock(`Sandbox Mode ${enabled ? 'Enabled' : 'Disabled'}`)(
+    compoundExpression([iff(not(ref('ctx.stash.get("hasAuth")')), exp), toJson(obj({}))]),
+  );
 };
 
 /**
@@ -93,17 +34,3 @@ export const generateDefaultResponseMappingTemplate = (isSyncEnabled: boolean, m
 export const generateResolverKey = (typeName: string, fieldName: string): string => {
   return `${typeName}.${fieldName}`;
 };
-
-/**
- * Util function to generate sandbox mode expression
- */
-export const generateAuthExpressionForSandboxMode = (enabled: boolean): string => {
-  let exp;
-
-  if (enabled) exp = iff(notEquals(methodCall(ref('util.authType')), str(API_KEY)), methodCall(ref('util.unauthorized')));
-  else exp = methodCall(ref('util.unauthorized'));
-
-  return printBlock(`Sandbox Mode ${enabled ? 'Enabled' : 'Disabled'}`)(
-    compoundExpression([iff(not(ref('ctx.stash.get("hasAuth")')), exp), toJson(obj({}))]),
-  );
-};

package/src/resolvers/dynamodb/common.ts

@@ -0,0 +1,84 @@
+import {
+  CompoundExpressionNode,
+  Expression,
+  comment,
+  iff,
+  and,
+  ref,
+  notEquals,
+  methodCall,
+  int,
+  compoundExpression,
+  set,
+  obj,
+  equals,
+  ifElse,
+  printBlock,
+  toJson,
+  qref,
+  str,
+  not,
+} from 'graphql-mapping-template';
+import { OPERATION_KEY } from '../../definitions';
+
+/**
+ * Helper method to generate code that converts DynamoDB condition object to condition
+ * expression
+ * @param inputConditionObjectName : Variable in stash that holds condition object
+ * @param conditionOutputVariableName: Variable to store generated DDB expression
+ */
+export const generateConditionSlot = (inputConditionObjectName: string, conditionOutputVariableName: string): CompoundExpressionNode => {
+  const statements: Expression[] = [
+    comment('Start condition block'),
+
+    iff(
+      and([ref(inputConditionObjectName), notEquals(methodCall(ref(`${inputConditionObjectName}.size`)), int(0))]),
+      compoundExpression([
+        set(ref('mergedConditions'), obj({ and: ref(inputConditionObjectName) })),
+        set(
+          ref(conditionOutputVariableName),
+          methodCall(ref('util.parseJson'), methodCall(ref('util.transform.toDynamoDBConditionExpression'), ref('mergedConditions'))),
+        ),
+        iff(
+          and([
+            ref(`${conditionOutputVariableName}.expressionValues`),
+            equals(methodCall(ref(`${conditionOutputVariableName}.expressionValues.size`)), int(0)),
+          ]),
+          set(
+            ref(conditionOutputVariableName),
+            obj({
+              expression: ref(`${conditionOutputVariableName}.expression`),
+              expressionNames: ref(`${conditionOutputVariableName}.expressionNames`),
+            }),
+          ),
+        ),
+        comment('End condition block'),
+      ]),
+    ),
+  ];
+  return compoundExpression(statements);
+};
+
+/**
+ * Generate common response template used by most of the resolvers.
+ * Append operation if response is coming from a mutation, this is to protect field resolver for subscriptions
+ */
+export const generateDefaultResponseMappingTemplate = (isSyncEnabled: boolean, mutation = false): string => {
+  const statements: Expression[] = [];
+  if (mutation) statements.push(qref(methodCall(ref('ctx.result.put'), str(OPERATION_KEY), str('Mutation'))));
+  if (isSyncEnabled) {
+    statements.push(
+      ifElse(
+        ref('ctx.error'),
+        methodCall(ref('util.error'), ref('ctx.error.message'), ref('ctx.error.type'), ref('ctx.result')),
+        toJson(ref('ctx.result')),
+      ),
+    );
+  } else {
+    statements.push(
+      ifElse(ref('ctx.error'), methodCall(ref('util.error'), ref('ctx.error.message'), ref('ctx.error.type')), toJson(ref('ctx.result'))),
+    );
+  }
+
+  return printBlock('ResponseTemplate')(compoundExpression(statements));
+};

package/src/resolvers/dynamodb/index.ts

@@ -0,0 +1,4 @@
+export * from './common';
+export * from './mutation';
+export * from './subscriptions';
+export * from './query';

package/src/resolvers/{mutation.ts → dynamodb/mutation.ts}

@@ -19,7 +19,7 @@ import {
   printBlock,
 } from 'graphql-mapping-template';
 import { setArgs } from 'graphql-transformer-common';
-import { ModelDirectiveConfiguration } from '../directive';
+import { ModelDirectiveConfiguration } from '../../directive';
 import { generateConditionSlot } from './common';
 
 /**
@@ -145,7 +145,7 @@ export const generateUpdateRequestTemplate = (modelName: string, isSyncEnabled:
     ),
     toJson(ref('UpdateItem')),
   ];
-  return printBlock(`${modelName} Update resolver`)(compoundExpression(statements));
+  return printBlock(`Mutation Update resolver`)(compoundExpression(statements));
 };
 
 /**
@@ -256,7 +256,7 @@ export const generateCreateInitSlotTemplate = (modelConfig: ModelDirectiveConfig
  * Generates VTL template in delete mutation
  *
  */
-export const generateDeleteRequestTemplate = (isSyncEnabled: boolean): string => {
+export const generateDeleteRequestTemplate = (modelName:string, isSyncEnabled: boolean): string => {
   const statements: Expression[] = [
     setArgs,
     set(

package/src/resolvers/generators/dynamodb-vtl-generator.ts

@@ -0,0 +1,61 @@
+import {
+  ModelCreateInitSlotConfig,
+  ModelCreateRequestConfig,
+  ModelDefaultResponseConfig,
+  ModelRequestConfig,
+  ModelUpdateRequestConfig,
+  ModelVTLGenerator,
+} from './vtl-generator';
+import {
+  generateUpdateRequestTemplate,
+  generateCreateRequestTemplate,
+  generateCreateInitSlotTemplate,
+  generateDeleteRequestTemplate,
+  generateUpdateInitSlotTemplate,
+  generateGetRequestTemplate,
+  generateGetResponseTemplate,
+  generateListRequestTemplate,
+  generateSyncRequestTemplate,
+  generateSubscriptionRequestTemplate,
+  generateSubscriptionResponseTemplate,
+  generateDefaultResponseMappingTemplate,
+} from '../dynamodb';
+
+export class DynamoDBModelVTLGenerator implements ModelVTLGenerator {
+  generateUpdateRequestTemplate(config: ModelUpdateRequestConfig): string {
+    return generateUpdateRequestTemplate(config.modelName, config.isSyncEnabled);
+  }
+  generateCreateRequestTemplate(config: ModelCreateRequestConfig): string {
+    return generateCreateRequestTemplate(config.modelName, config.modelIndexFields);
+  }
+  generateCreateInitSlotTemplate(config: ModelCreateInitSlotConfig): string {
+    return generateCreateInitSlotTemplate(config.modelConfig);
+  }
+  generateDeleteRequestTemplate(config: ModelUpdateRequestConfig): string {
+    return generateDeleteRequestTemplate(config.modelName, config.isSyncEnabled);
+  }
+  generateUpdateInitSlotTemplate(config: ModelCreateInitSlotConfig): string {
+    return generateUpdateInitSlotTemplate(config.modelConfig);
+  }
+  generateGetRequestTemplate(config: ModelRequestConfig): string {
+    return generateGetRequestTemplate();
+  }
+  generateGetResponseTemplate(config: ModelUpdateRequestConfig): string {
+    return generateGetResponseTemplate(config.isSyncEnabled);
+  }
+  generateListRequestTemplate(config: ModelRequestConfig): string {
+    return generateListRequestTemplate();
+  }
+  generateSyncRequestTemplate(config: ModelRequestConfig): string {
+    return generateSyncRequestTemplate();
+  }
+  generateSubscriptionRequestTemplate(): string {
+    return generateSubscriptionRequestTemplate();
+  }
+  generateSubscriptionResponseTemplate(): string {
+    return generateSubscriptionResponseTemplate();
+  }
+  generateDefaultResponseMappingTemplate(config: ModelDefaultResponseConfig): string {
+    return generateDefaultResponseMappingTemplate(config.isSyncEnabled, config.mutation);
+  }
+}

package/src/resolvers/generators/index.ts

@@ -0,0 +1,3 @@
+export * from './vtl-generator';
+export * from './dynamodb-vtl-generator';
+export * from './rds-vtl-generator';

package/src/resolvers/generators/rds-vtl-generator.ts

@@ -0,0 +1,62 @@
+import {
+  generateDefaultLambdaResponseMappingTemplate,
+  generateGetLambdaResponseTemplate,
+  generateLambdaRequestTemplate,
+  generateCreateInitSlotTemplate,
+  generateLambdaCreateRequestTemplate,
+  generateUpdateInitSlotTemplate,
+  generateLambdaUpdateRequestTemplate,
+  generateLambdaDeleteRequestTemplate,
+} from '../rds';
+import {
+  generateSubscriptionRequestTemplate,
+  generateSubscriptionResponseTemplate,
+} from '../dynamodb';
+import {
+  ModelCreateInitSlotConfig,
+  ModelCreateRequestConfig,
+  ModelDefaultResponseConfig,
+  ModelRequestConfig,
+  ModelUpdateRequestConfig,
+  ModelVTLGenerator,
+} from './vtl-generator';
+
+// TODO: This class is created only to show the class structure. This needs a revisit to generate correct resolvers for RDS.
+export class RDSModelVTLGenerator implements ModelVTLGenerator {
+  generateUpdateRequestTemplate(config: ModelUpdateRequestConfig): string {
+    return generateLambdaUpdateRequestTemplate(config.modelName, config.operationName, config.modelIndexFields ?? ['id']);
+  }
+  generateCreateRequestTemplate(config: ModelCreateRequestConfig): string {
+    return generateLambdaCreateRequestTemplate(config.modelName, config.operationName);
+  }
+  generateCreateInitSlotTemplate(config: ModelCreateInitSlotConfig): string {
+    return generateCreateInitSlotTemplate(config.modelConfig);
+  }
+  generateDeleteRequestTemplate(config: ModelUpdateRequestConfig): string {
+    return generateLambdaDeleteRequestTemplate(config.modelName, config.operationName, config.modelIndexFields ?? ['id']);
+  }
+  generateUpdateInitSlotTemplate(config: ModelCreateInitSlotConfig): string {
+    return generateUpdateInitSlotTemplate(config.modelConfig);
+  }
+  generateGetRequestTemplate(config: ModelRequestConfig): string {
+    return generateLambdaRequestTemplate(config.modelName, config.operation, config.operationName);
+  }
+  generateGetResponseTemplate(config: ModelUpdateRequestConfig): string {
+    return generateGetLambdaResponseTemplate(false);
+  }
+  generateListRequestTemplate(config: ModelRequestConfig): string {
+    return generateLambdaRequestTemplate(config.modelName, config.operation, config.operationName);
+  }
+  generateSyncRequestTemplate(config: ModelRequestConfig): string {
+    return generateDefaultLambdaResponseMappingTemplate(false);
+  }
+  generateSubscriptionRequestTemplate(): string {
+    return generateSubscriptionRequestTemplate();
+  }
+  generateSubscriptionResponseTemplate(): string {
+    return generateSubscriptionResponseTemplate();
+  }
+  generateDefaultResponseMappingTemplate(config: ModelDefaultResponseConfig): string {
+    return generateDefaultLambdaResponseMappingTemplate(false);
+  }
+}

package/src/resolvers/generators/vtl-generator.ts

@@ -0,0 +1,46 @@
+import { ModelDirectiveConfiguration } from '../../directive';
+
+export type ModelRequestConfig = {
+  modelName: string;
+  operation: string;
+  operationName: string;
+}
+
+export type ModelUpdateRequestConfig = ModelRequestConfig & {
+  modelIndexFields: string[];
+  isSyncEnabled: boolean;
+}
+
+export type ModelDeleteRequestConfig = ModelUpdateRequestConfig;
+
+export type ModelCreateRequestConfig = ModelRequestConfig & {
+  modelIndexFields: string[];
+}
+
+export type ModelCreateInitSlotConfig = {
+  modelConfig: ModelDirectiveConfiguration;
+}
+
+export type ModelUpdateInitSlotConfig = ModelCreateInitSlotConfig;
+
+export type ModelGetResponseConfig = ModelUpdateRequestConfig;
+
+export type ModelDefaultResponseConfig = ModelRequestConfig & {
+  isSyncEnabled: boolean;
+  mutation: boolean;
+}
+
+export interface ModelVTLGenerator {
+  generateUpdateRequestTemplate(config: ModelUpdateRequestConfig): string;
+  generateCreateRequestTemplate(config: ModelCreateRequestConfig): string;
+  generateCreateInitSlotTemplate(config: ModelCreateInitSlotConfig): string;
+  generateDeleteRequestTemplate(config: ModelDeleteRequestConfig): string;
+  generateUpdateInitSlotTemplate(config: ModelUpdateInitSlotConfig): string;
+  generateGetRequestTemplate(config: ModelRequestConfig): string;
+  generateGetResponseTemplate(config: ModelGetResponseConfig): string;
+  generateListRequestTemplate(config: ModelRequestConfig): string;
+  generateSyncRequestTemplate(config: ModelRequestConfig): string;
+  generateSubscriptionRequestTemplate(): string;
+  generateSubscriptionResponseTemplate(): string;
+  generateDefaultResponseMappingTemplate(config: ModelDefaultResponseConfig): string;
+}

package/src/resolvers/index.ts

@@ -1,3 +1,5 @@
+export * from './generators';
 export * from './common';
-export * from './mutation';
-export * from './subscriptions';
+export {
+  generateApplyDefaultsToInputTemplate
+} from './dynamodb';

package/src/resolvers/rds/index.ts

@@ -0,0 +1,2 @@
+export * from './resolver';
+export * from './mutation';

package/src/resolvers/rds/mutation.ts

@@ -0,0 +1,152 @@
+import {
+  comment,
+  compoundExpression,
+  Expression, list,
+  methodCall,
+  obj,
+  printBlock,
+  qref,
+  ref,
+  set,
+  str,
+  toJson,
+} from 'graphql-mapping-template';
+import { ModelDirectiveConfiguration } from '../../directive';
+
+/**
+ * Generate mapping template that sets default values for create mutation
+ * @param modelConfig directive configuration
+ */
+export const generateCreateInitSlotTemplate = (modelConfig: ModelDirectiveConfiguration): string => {
+  const statements: Expression[] = [
+    // initialize defaultValues
+    qref(
+      methodCall(
+        ref('ctx.stash.put'),
+        str('defaultValues'),
+        methodCall(ref('util.defaultIfNull'), ref('ctx.stash.defaultValues'), obj({})),
+      ),
+    ),
+  ];
+
+  if (modelConfig?.timestamps) {
+    statements.push(set(ref('createdAt'), methodCall(ref('util.time.nowISO8601'))));
+    statements.push(qref(methodCall(ref('ctx.stash.defaultValues.put'), str('id'), methodCall(ref('util.autoId')))));
+    if (modelConfig.timestamps.createdAt) {
+      statements.push(qref(methodCall(ref('ctx.stash.defaultValues.put'), str(modelConfig.timestamps.createdAt), ref('createdAt'))));
+    }
+    if (modelConfig.timestamps.updatedAt) {
+      statements.push(qref(methodCall(ref('ctx.stash.defaultValues.put'), str(modelConfig.timestamps.updatedAt), ref('createdAt'))));
+    }
+  }
+  statements.push(
+    toJson(
+      obj({
+        version: str('2018-05-29'),
+        payload: obj({}),
+      }),
+    ),
+  );
+  return printBlock('Initialization default values')(compoundExpression(statements));
+};
+
+export const generateLambdaCreateRequestTemplate = (tableName: string, operationName: string): string => {
+  return printBlock('Invoke RDS Lambda data source')(
+    compoundExpression([
+      set(ref('lambdaInput'), obj({})),
+      set(ref('lambdaInput.table'), str(tableName)),
+      set(ref('lambdaInput.args'), obj({})),
+      set(ref('lambdaInput.operation'), str('CREATE')),
+      set(ref('lambdaInput.operationName'), str(operationName)),
+      comment('Set the default values to put request'),
+      set(ref('lambdaInput.args.input'), methodCall(ref('util.defaultIfNull'), ref('ctx.stash.defaultValues'), obj({}))),
+      comment('copy the values from input'),
+      qref(methodCall(ref('lambdaInput.args.input.putAll'), methodCall(ref('util.defaultIfNull'), ref('context.arguments.input'), obj({})))),
+      obj({
+        version: str('2018-05-29'),
+        operation: str('Invoke'),
+        payload: methodCall(ref('util.toJson'), ref('lambdaInput')),
+      }),
+    ]),
+  );
+};
+
+/**
+ * Generate VTL template that sets the default values for Update mutation
+ * @param modelConfig model directive configuration
+ */
+export const generateUpdateInitSlotTemplate = (modelConfig: ModelDirectiveConfiguration): string => {
+  const statements: Expression[] = [
+    // initialize defaultValues
+    qref(
+      methodCall(
+        ref('ctx.stash.put'),
+        str('defaultValues'),
+        methodCall(ref('util.defaultIfNull'), ref('ctx.stash.defaultValues'), obj({})),
+      ),
+    ),
+  ];
+  if (modelConfig?.timestamps) {
+    if (modelConfig.timestamps.updatedAt) {
+      statements.push(set(ref('updatedAt'), methodCall(ref('util.time.nowISO8601'))));
+      statements.push(qref(methodCall(ref('ctx.stash.defaultValues.put'), str(modelConfig.timestamps.updatedAt), ref('updatedAt'))));
+    }
+  }
+  statements.push(
+    toJson(
+      obj({
+        version: str('2018-05-29'),
+        payload: obj({}),
+      }),
+    ),
+  );
+  return printBlock('Initialization default values')(compoundExpression(statements));
+};
+
+/**
+ * Generate VTL template that calls the lambda for an Update mutation
+ */
+export const generateLambdaUpdateRequestTemplate = (tableName: string, operationName: string, modelIndexFields: string[]) => {
+  return printBlock('Invoke RDS Lambda data source')(
+    compoundExpression([
+      set(ref('lambdaInput'), obj({})),
+      set(ref('lambdaInput.table'), str(tableName)),
+      set(ref('lambdaInput.args'), obj({})),
+      set(ref('lambdaInput.operation'), str('UPDATE')),
+      set(ref('lambdaInput.operationName'), str(operationName)),
+      set(ref('lambdaInput.args.metadata'), obj({})),
+      set(ref('lambdaInput.args.metadata.keys'), list(modelIndexFields.map((field) => str(field)))),
+      comment('Set the default values to put request'),
+      set(ref('lambdaInput.args.input'), methodCall(ref('util.defaultIfNull'), ref('ctx.stash.defaultValues'), obj({}))),
+      comment('copy the values from input'),
+      qref(methodCall(ref('lambdaInput.args.input.putAll'), methodCall(ref('util.defaultIfNull'), ref('context.arguments.input'), obj({})))),
+      obj({
+        version: str('2018-05-29'),
+        operation: str('Invoke'),
+        payload: methodCall(ref('util.toJson'), ref('lambdaInput')),
+      }),
+    ]),
+  );
+};
+
+/**
+ * Generate VTL template that calls the lambda for a Delete mutation
+ */
+export const generateLambdaDeleteRequestTemplate = (tableName: string, operationName: string, modelIndexFields: string[]) => {
+  return printBlock('Invoke RDS Lambda data source')(
+    compoundExpression([
+      set(ref('lambdaInput'), obj({})),
+      set(ref('lambdaInput.table'), str(tableName)),
+      set(ref('lambdaInput.args'), ref('context.arguments')),
+      set(ref('lambdaInput.operation'), str('DELETE')),
+      set(ref('lambdaInput.operationName'), str(operationName)),
+      set(ref('lambdaInput.args.metadata'), obj({})),
+      set(ref('lambdaInput.args.metadata.keys'), list(modelIndexFields.map((field) => str(field)))),
+      obj({
+        version: str('2018-05-29'),
+        operation: str('Invoke'),
+        payload: methodCall(ref('util.toJson'), ref('lambdaInput')),
+      }),
+    ]),
+  );
+};