@aws-amplify/graphql-model-transformer 0.6.4 → 0.6.5-amplify-export2.0

package/src/__tests__/model-transformer.test.ts

@@ -881,7 +881,7 @@ describe('ModelTransformer: ', () => {
     validateModelSchema(parse(out.schema));
   });
 
-  it('should generate sync resolver with ConflictHandlerType.AUTOMERGE', () => {
+  it('should generate sync resolver with ConflictHandlerType.Automerge', () => {
     const validSchema = `
       type Post @model {
           id: ID!
@@ -950,7 +950,7 @@ describe('ModelTransformer: ', () => {
     validateModelSchema(parse(definition));
   });
 
-  it('should generate sync resolver with ConflictHandlerType.OPTIMISTIC', () => {
+  it('should generate sync resolver with ConflictHandlerType.Optimistic', () => {
     const validSchema = `
       type Post @model {
           id: ID!

package/src/definitions.ts

@@ -13,4 +13,4 @@ export const BOOLEAN_FUNCTIONS = new Set<string>(['attributeExists', 'attributeT
 
 export const ATTRIBUTE_TYPES = ['binary', 'binarySet', 'bool', 'list', 'map', 'number', 'numberSet', 'string', 'stringSet', '_null'];
 
-
+export const OPERATION_KEY = '__operation';

package/src/graphql-model-transformer.ts

@@ -54,6 +54,7 @@ import {
   makeUpdateInputField,
 } from './graphql-types';
 import {
+  generateAuthExpressionForSandboxMode,
   generateCreateInitSlotTemplate,
   generateCreateRequestTemplate,
   generateDefaultResponseMappingTemplate,
@@ -64,7 +65,12 @@ import {
   generateUpdateInitSlotTemplate,
   generateUpdateRequestTemplate,
 } from './resolvers';
-import { generateGetRequestTemplate, generateListRequestTemplate, generateSyncRequestTemplate } from './resolvers/query';
+import {
+  generateGetRequestTemplate,
+  generateGetResponseTemplate,
+  generateListRequestTemplate,
+  generateSyncRequestTemplate,
+} from './resolvers/query';
 import {
   DirectiveWrapper,
   FieldWrapper,
@@ -88,17 +94,17 @@ export type ModelDirectiveConfiguration = {
     list: OptionalAndNullable<string>;
     sync: OptionalAndNullable<string>;
   }>;
-  mutations: {
+  mutations: OptionalAndNullable<{
     create: OptionalAndNullable<string>;
     update: OptionalAndNullable<string>;
     delete: OptionalAndNullable<string>;
-  } | null;
-  subscriptions: {
+  }>;
+  subscriptions: OptionalAndNullable<{
     onCreate: OptionalAndNullable<string>[];
     onUpdate: OptionalAndNullable<string>[];
     onDelete: OptionalAndNullable<string>[];
-    level: Partial<SubscriptionLevel>;
-  } | null;
+    level: SubscriptionLevel;
+  }>;
   timestamps: OptionalAndNullable<{
     createdAt: OptionalAndNullable<string>;
     updatedAt: OptionalAndNullable<string>;
@@ -169,12 +175,13 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
         `'${definition.name.value}' is a reserved type name and currently in use within the default schema element.`,
       );
     }
-
     // todo: get model configuration with default values and store it in the map
     const typeName = definition.name.value;
+
     if (ctx.isProjectUsingDataStore()) {
       SyncUtils.validateResolverConfigForType(ctx, typeName);
     }
+
     const directiveWrapped: DirectiveWrapper = new DirectiveWrapper(directive);
     const options = directiveWrapped.getArguments({
       queries: {
@@ -188,7 +195,7 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
         delete: toCamelCase(['delete', typeName]),
       },
       subscriptions: {
-        level: SubscriptionLevel.public,
+        level: SubscriptionLevel.on,
         onCreate: [this.ensureValidSubscriptionName(toCamelCase(['onCreate', typeName]))],
         onDelete: [this.ensureValidSubscriptionName(toCamelCase(['onDelete', typeName]))],
         onUpdate: [this.ensureValidSubscriptionName(toCamelCase(['onUpdate', typeName]))],
@@ -241,8 +248,7 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
 
   generateResolvers = (context: TransformerContextProvider): void => {
     for (let type of this.typesWithModelDirective) {
-      const def = context.output.getObject(type);
-
+      const def = context.output.getObject(type)!;
       // This name is used by the mock functionality. Changing this can break mock.
       const tableLogicalName = `${def!.name.value}Table`;
       const stack = context.stackManager.getStackFor(tableLogicalName, def!.name.value);
@@ -265,7 +271,13 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
           default:
             throw new Error('Unknown query field type');
         }
-
+        resolver.addToSlot(
+          'postAuth',
+          MappingTemplate.s3MappingTemplateFromString(
+            generateAuthExpressionForSandboxMode(context),
+            `${query.typeName}.${query.fieldName}.{slotName}.{slotIndex}.req.vtl`,
+          ),
+        );
         resolver.mapToStack(stack);
         context.resolvers.addResolver(query.typeName, query.fieldName, resolver);
       }
@@ -284,11 +296,49 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
             resolver = this.generateUpdateResolver(context, def!, mutation.typeName, mutation.fieldName);
             break;
           default:
-            throw new Error('Unknown query field type');
+            throw new Error('Unknown mutation field type');
         }
+        resolver.addToSlot(
+          'postAuth',
+          MappingTemplate.s3MappingTemplateFromString(
+            generateAuthExpressionForSandboxMode(context),
+            `${mutation.typeName}.${mutation.fieldName}.{slotName}.{slotIndex}.req.vtl`,
+          ),
+        );
         resolver.mapToStack(stack);
         context.resolvers.addResolver(mutation.typeName, mutation.fieldName, resolver);
       }
+
+      const subscriptionLevel = this.modelDirectiveConfig.get(def.name.value)?.subscriptions?.level;
+      // in order to create subscription resolvers the level needs to be on
+      if (subscriptionLevel === SubscriptionLevel.on) {
+        const subscriptionFields = this.getSubscriptionFieldNames(context, def!);
+        for (let subscription of subscriptionFields.values()) {
+          let resolver;
+          switch (subscription.type) {
+            case SubscriptionFieldType.ON_CREATE:
+              resolver = this.generateOnCreateResolver(context, def, subscription.typeName, subscription.fieldName);
+              break;
+            case SubscriptionFieldType.ON_UPDATE:
+              resolver = this.generateOnUpdateResolver(context, def, subscription.typeName, subscription.fieldName);
+              break;
+            case SubscriptionFieldType.ON_DELETE:
+              resolver = this.generateOnDeleteResolver(context, def, subscription.typeName, subscription.fieldName);
+              break;
+            default:
+              throw new Error('Unknown subscription field type');
+          }
+          resolver.addToSlot(
+            'postAuth',
+            MappingTemplate.s3MappingTemplateFromString(
+              generateAuthExpressionForSandboxMode(context),
+              `${subscription.typeName}.${subscription.fieldName}.{slotName}.{slotIndex}.req.vtl`,
+            ),
+          );
+          resolver.mapToStack(stack);
+          context.resolvers.addResolver(subscription.typeName, subscription.fieldName, resolver);
+        }
+      }
     }
   };
 
@@ -307,10 +357,7 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
         fieldName,
         dataSource,
         MappingTemplate.s3MappingTemplateFromString(generateGetRequestTemplate(), `${typeName}.${fieldName}.req.vtl`),
-        MappingTemplate.s3MappingTemplateFromString(
-          generateDefaultResponseMappingTemplate(isSyncEnabled),
-          `${typeName}.${fieldName}.res.vtl`,
-        ),
+        MappingTemplate.s3MappingTemplateFromString(generateGetResponseTemplate(isSyncEnabled), `${typeName}.${fieldName}.res.vtl`),
       );
     }
     return this.resolverMap[resolverKey];
@@ -359,7 +406,7 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
           `${typeName}.${fieldName}.req.vtl`,
         ),
         MappingTemplate.s3MappingTemplateFromString(
-          generateDefaultResponseMappingTemplate(isSyncEnabled),
+          generateDefaultResponseMappingTemplate(isSyncEnabled, true),
           `${typeName}.${fieldName}.res.vtl`,
         ),
       );
@@ -391,7 +438,7 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
         dataSource,
         MappingTemplate.s3MappingTemplateFromString(generateDeleteRequestTemplate(isSyncEnabled), `${typeName}.${fieldName}.req.vtl`),
         MappingTemplate.s3MappingTemplateFromString(
-          generateDefaultResponseMappingTemplate(isSyncEnabled),
+          generateDefaultResponseMappingTemplate(isSyncEnabled, true),
           `${typeName}.${fieldName}.res.vtl`,
         ),
       );
@@ -701,7 +748,7 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
         dataSource,
         MappingTemplate.s3MappingTemplateFromString(generateCreateRequestTemplate(type.name.value), `${typeName}.${fieldName}.req.vtl`),
         MappingTemplate.s3MappingTemplateFromString(
-          generateDefaultResponseMappingTemplate(isSyncEnabled),
+          generateDefaultResponseMappingTemplate(isSyncEnabled, true),
           `${typeName}.${fieldName}.res.vtl`,
         ),
       );
@@ -1164,7 +1211,6 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
         SyncUtils.createSyncLambdaIAMPolicy(stack, syncConfig.LambdaConflictHandler.name, syncConfig.LambdaConflictHandler.region),
       );
     }
-
     return role;
   }
 

package/src/index.ts

@@ -1,3 +1,4 @@
-export { ModelTransformer } from './graphql-model-transformer';
+export { ModelTransformer, ModelDirectiveConfiguration, SubscriptionLevel } from './graphql-model-transformer';
+export { OPERATION_KEY } from './definitions';
 export * from './graphql-types';
 export * from './resolvers';

package/src/resolvers/common.ts

@@ -15,7 +15,13 @@ import {
   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
@@ -57,9 +63,11 @@ export const generateConditionSlot = (inputConditionObjectName: string, conditio
 
 /**
  * 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): string => {
+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(
@@ -74,14 +82,30 @@ export const generateDefaultResponseMappingTemplate = (isSyncEnabled: boolean):
     );
   }
 
-  return printBlock('Get ResponseTemplate')(compoundExpression(statements));
+  return printBlock('ResponseTemplate')(compoundExpression(statements));
 };
 
 /**
- * Util function to gernate resolver key used to keep track of all the resolvers in memory
+ * Util function to generate resolver key used to keep track of all the resolvers in memory
  * @param typeName Name of the type
  * @param fieldName Name of the field
  */
 export const generateResolverKey = (typeName: string, fieldName: string): string => {
   return `${typeName}.${fieldName}`;
 };
+
+/**
+ * Util function to generate sandbox mode expression
+ * @param ctx context to get sandbox mode
+ */
+export const generateAuthExpressionForSandboxMode = (ctx: any): string => {
+  const enabled = ctx.resourceHelper.api.sandboxModeEnabled;
+  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/mutation.ts

@@ -152,8 +152,6 @@ export const generateUpdateRequestTemplate = (modelName: string, isSyncEnabled:
  */
 export const generateCreateRequestTemplate = (modelName: string): string => {
   const statements: Expression[] = [
-    // set key the condition
-    ...generateKeyConditionTemplate(false),
     // Generate conditions
     comment('Set the default values to put request'),
     set(ref('mergedValues'), methodCall(ref('util.defaultIfNull'), ref('ctx.stash.defaultValues'), obj({}))),
@@ -174,7 +172,6 @@ export const generateCreateRequestTemplate = (modelName: string): string => {
     ),
 
     // add conditions
-
     iff(ref('context.args.condition'), qref(methodCall(ref('ctx.stash.conditions.add'), ref('context.args.condition')))),
     // key conditions
     ...generateKeyConditionTemplate(false),

package/src/resolvers/query.ts

@@ -16,27 +16,86 @@ import {
   equals,
   bool,
   and,
+  isNullOrEmpty,
+  list,
+  forEach,
   nul,
 } from 'graphql-mapping-template';
 import { ResourceConstants } from 'graphql-transformer-common';
+const authFilter = ref('ctx.stash.authFilter');
+
 /**
  * Generate get query resolver template
  */
 export const generateGetRequestTemplate = (): string => {
   const statements: Expression[] = [
-    set(ref('GetRequest'), obj({ version: str('2018-05-29'), operation: str('GetItem') })),
+    set(ref('GetRequest'), obj({ version: str('2018-05-29'), operation: str('Query') })),
     ifElse(
       ref('ctx.stash.metadata.modelObjectKey'),
-      set(ref('key'), ref('ctx.stash.metadata.modelObjectKey')),
-      compoundExpression([set(ref('key'), obj({ id: methodCall(ref('util.dynamodb.toDynamoDB'), ref('ctx.args.id')) }))]),
+      compoundExpression([
+        set(ref('expression'), str('')),
+        set(ref('expressionNames'), obj({})),
+        set(ref('expressionValues'), obj({})),
+        forEach(ref('item'), ref('ctx.stash.metadata.modelObjectKey.entrySet()'), [
+          set(ref('expression'), str('$expression#keyCount$velocityCount = :valueCount$velocityCount AND ')),
+          qref(methodCall(ref('expressionNames.put'), str('#keyCount$velocityCount'), ref('item.key'))),
+          qref(methodCall(ref('expressionValues.put'), str(':valueCount$velocityCount'), ref('item.value'))),
+        ]),
+        set(ref('expression'), methodCall(ref('expression.replaceAll'), str('AND $'), str(''))),
+        set(
+          ref('query'),
+          obj({ expression: ref('expression'), expressionNames: ref('expressionNames'), expressionValues: ref('expressionValues') }),
+        ),
+      ]),
+      set(
+        ref('query'),
+        obj({
+          expression: str('id = :id'),
+          expressionValues: obj({
+            ':id': methodCall(ref('util.parseJson'), methodCall(ref('util.dynamodb.toDynamoDBJson'), ref('ctx.args.id'))),
+          }),
+        }),
+      ),
+    ),
+    qref(methodCall(ref('GetRequest.put'), str('query'), ref('query'))),
+    iff(
+      not(isNullOrEmpty(authFilter)),
+      qref(
+        methodCall(
+          ref('GetRequest.put'),
+          str('filter'),
+          methodCall(ref('util.parseJson'), methodCall(ref('util.transform.toDynamoDBFilterExpression'), authFilter)),
+        ),
+      ),
     ),
-    qref(methodCall(ref('GetRequest.put'), str('key'), ref('key'))),
     toJson(ref('GetRequest')),
   ];
 
   return printBlock('Get Request template')(compoundExpression(statements));
 };
 
+export const generateGetResponseTemplate = (isSyncEnabled: boolean): string => {
+  const statements = new Array<Expression>();
+  if (isSyncEnabled) {
+    statements.push(
+      iff(ref('ctx.error'), methodCall(ref('util.error'), ref('ctx.error.message'), ref('ctx.error.type'), ref('ctx.result'))),
+    );
+  } else {
+    statements.push(iff(ref('ctx.error'), methodCall(ref('util.error'), ref('ctx.error.message'), ref('ctx.error.type'))));
+  }
+  statements.push(
+    ifElse(
+      and([not(ref('ctx.result.items.isEmpty()')), equals(ref('ctx.result.scannedCount'), int(1))]),
+      toJson(ref('ctx.result.items[0]')),
+      compoundExpression([
+        iff(and([ref('ctx.result.items.isEmpty()'), equals(ref('ctx.result.scannedCount'), int(1))]), ref('util.unauthorized()')),
+        toJson(nul()),
+      ]),
+    ),
+  );
+  return printBlock('Get Response template')(compoundExpression(statements));
+};
+
 export const generateListRequestTemplate = (): string => {
   const requestVariable = 'ListRequest';
   const modelQueryObj = 'ctx.stash.modelQueryExpression';
@@ -51,12 +110,20 @@ export const generateListRequestTemplate = (): string => {
       }),
     ),
     iff(ref('context.args.nextToken'), set(ref(`${requestVariable}.nextToken`), ref('context.args.nextToken'))),
+    ifElse(
+      not(isNullOrEmpty(authFilter)),
+      compoundExpression([
+        set(ref('filter'), authFilter),
+        iff(not(isNullOrEmpty(ref('ctx.args.filter'))), set(ref('filter'), obj({ and: list([ref('filter'), ref('ctx.args.filter')]) }))),
+      ]),
+      iff(not(isNullOrEmpty(ref('ctx.args.filter'))), set(ref('filter'), ref('ctx.args.filter'))),
+    ),
     iff(
-      ref('context.args.filter'),
+      not(isNullOrEmpty(ref('filter'))),
       compoundExpression([
         set(
           ref(`filterExpression`),
-          methodCall(ref('util.parseJson'), methodCall(ref('util.transform.toDynamoDBFilterExpression'), ref('ctx.args.filter'))),
+          methodCall(ref('util.parseJson'), methodCall(ref('util.transform.toDynamoDBFilterExpression'), ref('filter'))),
         ),
         iff(
           not(methodCall(ref('util.isNullOrBlank'), ref('filterExpression.expression'))),
@@ -95,10 +162,37 @@ export const generateListRequestTemplate = (): string => {
 export const generateSyncRequestTemplate = (): string => {
   return printBlock('Sync Request template')(
     compoundExpression([
+      ifElse(
+        not(isNullOrEmpty(authFilter)),
+        compoundExpression([
+          set(ref('filter'), authFilter),
+          iff(not(isNullOrEmpty(ref('ctx.args.filter'))), set(ref('filter'), obj({ and: list([ref('filter'), ref('ctx.args.filter')]) }))),
+        ]),
+        iff(not(isNullOrEmpty(ref('ctx.args.filter'))), set(ref('filter'), ref('ctx.args.filter'))),
+      ),
+      iff(
+        not(isNullOrEmpty(ref('filter'))),
+        compoundExpression([
+          set(
+            ref(`filterExpression`),
+            methodCall(ref('util.parseJson'), methodCall(ref('util.transform.toDynamoDBFilterExpression'), ref('filter'))),
+          ),
+          iff(
+            not(methodCall(ref('util.isNullOrBlank'), ref('filterExpression.expression'))),
+            compoundExpression([
+              iff(
+                equals(methodCall(ref('filterEpression.expressionValues.size')), int(0)),
+                qref(methodCall(ref('filterEpression.remove'), str('expressionValues'))),
+              ),
+              set(ref('filter'), ref('filterExpression')),
+            ]),
+          ),
+        ]),
+      ),
       obj({
         version: str('2018-05-29'),
         operation: str('Sync'),
-        filter: ifElse(ref('context.args.filter'), ref('util.transform.toDynamoDBFilterExpression($ctx.args.filter)'), nul()),
+        filter: ifElse(ref('filter'), ref('util.toJson($filter)'), nul()),
         limit: ref(`util.defaultIfNull($ctx.args.limit, ${ResourceConstants.DEFAULT_SYNC_QUERY_PAGE_LIMIT})`),
         lastSync: ref('util.toJson($util.defaultIfNull($ctx.args.lastSync, null))'),
         nextToken: ref('util.toJson($util.defaultIfNull($ctx.args.nextToken, null))'),