@aws-amplify/graphql-model-transformer 0.6.3-headless-s3-not-for-production.0 → 0.6.5-amplify-export2.0

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

@@ -13,6 +13,7 @@ import {
   verifyInputCount,
   verifyMatchingTypes,
 } from './test-utils/helpers';
+import { expect as cdkExpect, haveResource } from '@aws-cdk/assert';
 
 const featureFlags = {
   getBoolean: jest.fn(),
@@ -880,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!
@@ -949,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!
@@ -982,4 +983,77 @@ describe('ModelTransformer: ', () => {
 
     validateModelSchema(parse(definition));
   });
+
+  it('should generate iam role names under 64 chars and subscriptions under 50', () => {
+    const validSchema = `
+      type ThisIsAVeryLongNameModelThatShouldNotGenerateIAMRoleNamesOver64Characters @model {
+          id: ID!
+          title: String!
+      }
+    `;
+
+    const config: SyncConfig = {
+      ConflictDetection: 'VERSION',
+      ConflictHandler: ConflictHandlerType.AUTOMERGE,
+    };
+
+    const transformer = new GraphQLTransform({
+      transformers: [new ModelTransformer()],
+      featureFlags,
+      transformConfig: {
+        ResolverConfig: {
+          project: config,
+        },
+      },
+    });
+    const out = transformer.transform(validSchema);
+    expect(out).toBeDefined();
+
+    const definition = out.schema;
+    expect(definition).toBeDefined();
+
+    const parsed = parse(definition);
+    const subscriptionType = getObjectType(parsed, 'Subscription');
+    expect(subscriptionType).toBeDefined();
+
+    subscriptionType!.fields!.forEach(it => {
+      expect(it.name.value.length <= 50).toBeTruthy();
+    });
+
+    const iamStackResource = out.stacks.ThisIsAVeryLongNameModelThatShouldNotGenerateIAMRoleNamesOver64Characters;
+    expect(iamStackResource).toBeDefined();
+    cdkExpect(iamStackResource).to(
+      haveResource('AWS::IAM::Role', {
+        AssumeRolePolicyDocument: {
+          Statement: [
+            {
+              Action: 'sts:AssumeRole',
+              Effect: 'Allow',
+              Principal: {
+                Service: 'appsync.amazonaws.com',
+              },
+            },
+          ],
+          Version: '2012-10-17',
+        },
+        RoleName: {
+          'Fn::Join': [
+            '',
+            [
+              'ThisIsAVeryLongNameM2d9fca-',
+              {
+                Ref: 'referencetotransformerrootstackGraphQLAPI20497F53ApiId',
+              },
+              '-',
+              {
+                Ref: 'referencetotransformerrootstackenv10C5A902Ref',
+              },
+            ],
+          ],
+        },
+      }),
+    );
+
+    validateModelSchema(parsed);
+  });
 });

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,
@@ -72,6 +78,7 @@ import {
   ObjectDefinitionWrapper,
 } from './wrappers/object-definition-wrapper';
 import { CfnRole } from '@aws-cdk/aws-iam';
+import md5 from 'md5';
 
 export type Nullable<T> = T | null;
 export type OptionalAndNullable<T> = Partial<T>;
@@ -87,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>;
@@ -168,10 +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;
-    SyncUtils.validateResolverConfigForType(ctx, typeName);
+
+    if (ctx.isProjectUsingDataStore()) {
+      SyncUtils.validateResolverConfigForType(ctx, typeName);
+    }
+
     const directiveWrapped: DirectiveWrapper = new DirectiveWrapper(directive);
     const options = directiveWrapped.getArguments({
       queries: {
@@ -185,10 +195,10 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
         delete: toCamelCase(['delete', typeName]),
       },
       subscriptions: {
-        level: SubscriptionLevel.public,
-        onCreate: [toCamelCase(['onCreate', typeName])],
-        onDelete: [toCamelCase(['onDelete', typeName])],
-        onUpdate: [toCamelCase(['onUpdate', typeName])],
+        level: SubscriptionLevel.on,
+        onCreate: [this.ensureValidSubscriptionName(toCamelCase(['onCreate', typeName]))],
+        onDelete: [this.ensureValidSubscriptionName(toCamelCase(['onDelete', typeName]))],
+        onUpdate: [this.ensureValidSubscriptionName(toCamelCase(['onUpdate', typeName]))],
       },
       timestamps: {
         createdAt: 'createdAt',
@@ -238,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);
@@ -262,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);
       }
@@ -281,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);
+        }
+      }
     }
   };
 
@@ -304,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];
@@ -356,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`,
         ),
       );
@@ -388,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`,
         ),
       );
@@ -698,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`,
         ),
       );
@@ -1106,7 +1156,7 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
   }
 
   private createIAMRole(context: TransformerContextProvider, def: ObjectTypeDefinitionNode, stack: cdk.Stack, tableName: string) {
-    const roleName = context.resourceHelper.generateResourceName(ModelResourceIDs.ModelTableIAMRoleID(def!.name.value));
+    const roleName = context.resourceHelper.generateIAMRoleName(ModelResourceIDs.ModelTableIAMRoleID(def!.name.value));
     const role = new iam.Role(stack, ModelResourceIDs.ModelTableIAMRoleID(def!.name.value), {
       roleName: roleName,
       assumedBy: new iam.ServicePrincipal('appsync.amazonaws.com'),
@@ -1161,7 +1211,6 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
         SyncUtils.createSyncLambdaIAMPolicy(stack, syncConfig.LambdaConflictHandler.name, syncConfig.LambdaConflictHandler.region),
       );
     }
-
     return role;
   }
 
@@ -1179,4 +1228,10 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
       ...options,
     };
   };
+
+  private ensureValidSubscriptionName = (name: string): string => {
+    if (name.length <= 50) return name;
+
+    return name.slice(0, 45) + md5(name).slice(0, 5);
+  };
 }

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))'),