@aws-amplify/graphql-model-transformer 0.14.5-alpha.26 → 0.14.5-alpha.32

package/src/definitions.ts

@@ -5,6 +5,12 @@ export const FLOAT_CONDITIONS = ['ne', 'eq', 'le', 'lt', 'ge', 'gt', 'between'];
 export const BOOLEAN_CONDITIONS = ['ne', 'eq'];
 export const SIZE_CONDITIONS = ['ne', 'eq', 'le', 'lt', 'ge', 'gt', 'between'];
 
+export const SUBSCRIPTION_STRING_CONDITIONS = ['ne', 'eq', 'le', 'lt', 'ge', 'gt', 'contains', 'notContains', 'between', 'beginsWith', 'in', 'notIn'];
+export const SUBSCRIPTION_ID_CONDITIONS = ['ne', 'eq', 'le', 'lt', 'ge', 'gt', 'contains', 'notContains', 'between', 'beginsWith', 'in', 'notIn'];
+export const SUBSCRIPTION_INT_CONDITIONS = ['ne', 'eq', 'le', 'lt', 'ge', 'gt', 'between', 'in', 'notIn'];
+export const SUBSCRIPTION_FLOAT_CONDITIONS = ['ne', 'eq', 'le', 'lt', 'ge', 'gt', 'between', 'in', 'notIn'];
+export const SUBSCRIPTION_BOOLEAN_CONDITIONS = ['ne', 'eq'];
+
 export const STRING_FUNCTIONS = new Set<string>(['attributeExists', 'attributeType', 'size']);
 export const ID_FUNCTIONS = new Set<string>(['attributeExists', 'attributeType', 'size']);
 export const INT_FUNCTIONS = new Set<string>(['attributeExists', 'attributeType']);

package/src/graphql-model-transformer.ts

@@ -66,6 +66,7 @@ import {
   makeCreateInputField,
   makeDeleteInputField,
   makeListQueryFilterInput,
+  makeSubscriptionQueryFilterInput,
   makeListQueryModel,
   makeModelSortDirectionEnumObject,
   makeMutationConditionInput,
@@ -756,8 +757,8 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
       const maps = subscriptionToMutationsMap[subscriptionFieldName];
 
       const args: InputValueDefinitionNode[] = [];
-      maps.map(it => args.concat(
-        this.getInputs(ctx, def!, {
+      maps.map(it => args.push(
+        ...this.getInputs(ctx, def!, {
           fieldName: it.fieldName,
           typeName: it.typeName,
           type: it.type,
@@ -978,7 +979,19 @@ export class ModelTransformer extends TransformerModelBase implements Transforme
       case SubscriptionFieldType.ON_CREATE:
       case SubscriptionFieldType.ON_DELETE:
       case SubscriptionFieldType.ON_UPDATE:
-        return [];
+        const filterInputName = toPascalCase(['ModelSubscription', type.name.value, 'FilterInput']);
+        const filterInputs = createEnumModelFilters(ctx, type);
+        filterInputs.push(makeSubscriptionQueryFilterInput(ctx, filterInputName, type));
+        filterInputs.forEach(input => {
+          const conditionInputName = input.name.value;
+          if (!ctx.output.getType(conditionInputName)) {
+            ctx.output.addInput(input);
+          }
+        });
+
+        return [
+          makeInputValueDefinition('filter', makeNamedType(filterInputName)),
+        ];
 
       default:
         throw new Error('Unknown operation type');

package/src/graphql-types/common.ts

@@ -21,7 +21,15 @@ import {
   makeNamedType,
   makeValueNode,
   ModelResourceIDs,
+  toPascalCase,
 } from 'graphql-transformer-common';
+import {
+  EnumWrapper,
+  FieldWrapper,
+  InputFieldWrapper,
+  InputObjectDefinitionWrapper,
+  ObjectDefinitionWrapper,
+} from '@aws-amplify/graphql-transformer-core';
 import {
   ATTRIBUTE_TYPES,
   BOOLEAN_CONDITIONS,
@@ -36,14 +44,12 @@ import {
   STRING_CONDITIONS,
   STRING_FUNCTIONS,
   API_KEY_DIRECTIVE,
+  SUBSCRIPTION_STRING_CONDITIONS,
+  SUBSCRIPTION_ID_CONDITIONS,
+  SUBSCRIPTION_INT_CONDITIONS,
+  SUBSCRIPTION_FLOAT_CONDITIONS,
+  SUBSCRIPTION_BOOLEAN_CONDITIONS,
 } from '../definitions';
-import {
-  EnumWrapper,
-  FieldWrapper,
-  InputFieldWrapper,
-  InputObjectDefinitionWrapper,
-  ObjectDefinitionWrapper,
-} from '@aws-amplify/graphql-transformer-core';
 
 /**
  * Creates the condition/filter input for a model
@@ -59,36 +65,96 @@ export const makeConditionFilterInput = (
   const supportsConditions = true;
   const input = InputObjectDefinitionWrapper.create(name);
   const wrappedObject = new ObjectDefinitionWrapper(object);
-  for (let field of wrappedObject.fields) {
+  for (const field of wrappedObject.fields) {
     const fieldType = ctx.output.getType(field.getTypeName());
     const isEnumType = fieldType && fieldType.kind === Kind.ENUM_TYPE_DEFINITION;
     if (field.isScalar() || isEnumType) {
-      const conditionTypeName =
-        isEnumType && field.isList()
-          ? ModelResourceIDs.ModelFilterListInputTypeName(field.getTypeName(), !supportsConditions)
-          : ModelResourceIDs.ModelFilterScalarInputTypeName(field.getTypeName(), !supportsConditions);
+      const conditionTypeName = isEnumType && field.isList()
+        ? ModelResourceIDs.ModelFilterListInputTypeName(field.getTypeName(), !supportsConditions)
+        : ModelResourceIDs.ModelFilterScalarInputTypeName(field.getTypeName(), !supportsConditions);
       const inputField = InputFieldWrapper.create(field.name, conditionTypeName, true);
       input.addField(inputField);
     }
   }
 
   // additional conditions of list type
-  for (let additionalField of ['and', 'or']) {
+  for (const additionalField of ['and', 'or']) {
     const inputField = InputFieldWrapper.create(additionalField, name, true, true);
     input.addField(inputField);
   }
   // additional conditions of non-list type
-  for (let additionalField of ['not']) {
+  for (const additionalField of ['not']) {
     const inputField = InputFieldWrapper.create(additionalField, name, true, false);
     input.addField(inputField);
   }
   return input;
 };
 
+/**
+ * Generates subscription filter input type
+ */
+export const makeSubscriptionFilterInput = (
+  ctx: TransformerTransformSchemaStepContextProvider,
+  name: string,
+  object: ObjectTypeDefinitionNode,
+): InputObjectDefinitionWrapper => {
+  const supportsConditions = true;
+  const input = InputObjectDefinitionWrapper.create(name);
+  const wrappedObject = new ObjectDefinitionWrapper(object);
+  for (const field of wrappedObject.fields) {
+    const fieldType = ctx.output.getType(field.getTypeName());
+    const isEnumType = fieldType && fieldType.kind === Kind.ENUM_TYPE_DEFINITION;
+    if (field.isScalar() || isEnumType) {
+      const conditionTypeName = ModelResourceIDs.ModelFilterScalarInputTypeName(
+        isEnumType ? 'String' : field.getTypeName(),
+        !supportsConditions,
+        true,
+      );
+      const inputField = InputFieldWrapper.create(field.name, conditionTypeName, true);
+      input.addField(inputField);
+    }
+  }
+
+  // additional conditions of list type
+  for (const additionalField of ['and', 'or']) {
+    const inputField = InputFieldWrapper.create(additionalField, name, true, true);
+    input.addField(inputField);
+  }
+
+  return input;
+};
+
+/**
+ * Generates the Subscription filter input type name
+ */
+export const getSubscriptionFilterInputName = (name: string): string => toPascalCase(['ModelSubscription', name, 'FilterInput']);
+
+/**
+ * Removes the given attribute from the subscription filter input type
+ */
+export const removeSubscriptionFilterInputAttribute = (
+  ctx: TransformerTransformSchemaStepContextProvider,
+  typeName: string,
+  fieldName: string,
+): void => {
+  const filterTypeName = getSubscriptionFilterInputName(typeName);
+  const filterType = ctx.output.getType(filterTypeName) as InputObjectTypeDefinitionNode;
+  if (!filterType) {
+    return;
+  }
+  const newFilterType: InputObjectTypeDefinitionNode = {
+    ...filterType,
+    fields: filterType.fields?.filter(field => field.name.value !== fieldName),
+  };
+  ctx.output.putType(newFilterType);
+};
+
+/**
+ * Generates model condition input type
+ */
 export const addModelConditionInputs = (ctx: TransformerTransformSchemaStepContextProvider): void => {
-  const conditionsInput: TypeDefinitionNode[] = ['String', 'Int', 'Float', 'Boolean', 'ID'].map(scalarName =>
-    makeModelScalarFilterInputObject(scalarName, true),
-  );
+  const conditionsInput: TypeDefinitionNode[] = ['String', 'Int', 'Float', 'Boolean', 'ID'].map(scalarName => makeModelScalarFilterInputObject(scalarName, true));
+  ['String', 'Int', 'Float', 'Boolean', 'ID'].map(scalarName => conditionsInput.push(makeModelScalarFilterInputObject(scalarName, true, true)));
   conditionsInput.push(makeAttributeTypeEnum());
   conditionsInput.push(makeSizeInputType());
   conditionsInput.forEach(input => {
@@ -104,14 +170,17 @@ export const addModelConditionInputs = (ctx: TransformerTransformSchemaStepConte
  * @param typeName Name of the scalar type
  * @param includeFilter add filter suffix to input
  */
-export function generateModelScalarFilterInputName(typeName: string, includeFilter: boolean): string {
+export function generateModelScalarFilterInputName(typeName: string, includeFilter: boolean, isSubscriptionFilter = false): string {
   const nameOverride = DEFAULT_SCALARS[typeName];
   if (nameOverride) {
-    return `Model${nameOverride}${includeFilter ? 'Filter' : ''}Input`;
+    return `Model${isSubscriptionFilter ? 'Subscription' : ''}${nameOverride}${includeFilter ? 'Filter' : ''}Input`;
   }
-  return `Model${typeName}${includeFilter ? 'Filter' : ''}Input`;
+  return `Model${isSubscriptionFilter ? 'Subscription' : ''}${typeName}${includeFilter ? 'Filter' : ''}Input`;
 }
 
+/**
+ * Creates Enum Model Filters
+ */
 export const createEnumModelFilters = (
   ctx: TransformerTransformSchemaStepContextProvider,
   type: ObjectTypeDefinitionNode,
@@ -132,11 +201,15 @@ export const createEnumModelFilters = (
  * @param type scalar type name
  * @param supportsConditions add filter suffix to input
  */
-export function makeModelScalarFilterInputObject(type: string, supportsConditions: boolean): InputObjectTypeDefinitionNode {
-  const name = generateModelScalarFilterInputName(type, !supportsConditions);
-  const conditions = getScalarConditions(type);
+export function makeModelScalarFilterInputObject(
+  type: string,
+  supportsConditions: boolean,
+  isSubscriptionFilter = false,
+): InputObjectTypeDefinitionNode {
+  const name = generateModelScalarFilterInputName(type, !supportsConditions, isSubscriptionFilter);
+  const conditions = isSubscriptionFilter ? getSubscriptionScalarConditions(type) : getScalarConditions(type);
   const scalarConditionInput = InputObjectDefinitionWrapper.create(name);
-  for (let condition of conditions) {
+  for (const condition of conditions) {
     let typeName;
     switch (condition) {
       case 'and':
@@ -147,12 +220,16 @@ export function makeModelScalarFilterInputObject(type: string, supportsCondition
         typeName = type;
     }
     const field = InputFieldWrapper.create(condition, typeName, true);
-    if (condition === 'between') {
+    if (condition === 'between' || condition === 'in' || condition === 'notIn') {
       field.wrapListType();
     }
     scalarConditionInput.addField(field);
   }
-  makeFunctionInputFields(type).map(f => scalarConditionInput.addField(f));
+
+  if (!isSubscriptionFilter) {
+    makeFunctionInputFields(type).map(f => scalarConditionInput.addField(f));
+  }
+
   return scalarConditionInput.serialize();
 }
 
@@ -173,6 +250,23 @@ function getScalarConditions(type: string): string[] {
   }
 }
 
+function getSubscriptionScalarConditions(type: string): string[] {
+  switch (type) {
+    case 'String':
+      return SUBSCRIPTION_STRING_CONDITIONS;
+    case 'ID':
+      return SUBSCRIPTION_ID_CONDITIONS;
+    case 'Int':
+      return SUBSCRIPTION_INT_CONDITIONS;
+    case 'Float':
+      return SUBSCRIPTION_FLOAT_CONDITIONS;
+    case 'Boolean':
+      return SUBSCRIPTION_BOOLEAN_CONDITIONS;
+    default:
+      throw new Error('Valid types are String, ID, Int, Float, Boolean');
+  }
+}
+
 function getFunctionListForType(typeName: string): Set<string> {
   switch (typeName) {
     case 'String':
@@ -209,21 +303,30 @@ function makeFunctionInputFields(typeName: string): InputFieldWrapper[] {
   return fields;
 }
 
+/**
+ * Makes Attribute Type Enum
+ */
 export function makeAttributeTypeEnum(): EnumTypeDefinitionNode {
   return EnumWrapper.create('ModelAttributeTypes', ATTRIBUTE_TYPES).serialize();
 }
 
+/**
+ * Makes subscription field
+ */
 export function makeSubscriptionField(fieldName: string, returnTypeName: string, mutations: string[]): FieldDefinitionNode {
   return makeField(fieldName, [], makeNamedType(returnTypeName), [
     makeDirective('aws_subscribe', [makeArgument('mutations', makeValueNode(mutations))]),
   ]);
 }
 
+/**
+ * Makes Input Type size
+ */
 export function makeSizeInputType(): InputObjectTypeDefinitionNode {
   const name = 'ModelSizeInput';
   const input = InputObjectDefinitionWrapper.create(name);
 
-  for (let condition of SIZE_CONDITIONS) {
+  for (const condition of SIZE_CONDITIONS) {
     const field = InputFieldWrapper.create(condition, 'Int', true);
     if (condition === 'between') field.wrapListType();
     input.addField(field);
@@ -231,6 +334,9 @@ export function makeSizeInputType(): InputObjectTypeDefinitionNode {
   return input.serialize();
 }
 
+/**
+ * Makes enum filter input
+ */
 export function makeEnumFilterInput(fieldWrapper: FieldWrapper): InputObjectTypeDefinitionNode {
   const supportsConditions = true;
   const conditionTypeName = fieldWrapper.isList()
@@ -252,12 +358,15 @@ export function makeEnumFilterInput(fieldWrapper: FieldWrapper): InputObjectType
   return input.serialize();
 }
 
+/**
+ * Adds the directive to the field
+ */
 export const addDirectivesToField = (
   ctx: TransformerTransformSchemaStepContextProvider,
   typeName: string,
   fieldName: string,
   directives: Array<DirectiveNode>,
-) => {
+): void => {
   const type = ctx.output.getType(typeName) as ObjectTypeDefinitionNode;
   if (type) {
     const field = type.fields?.find(f => f.name.value === fieldName);
@@ -274,12 +383,15 @@ export const addDirectivesToField = (
   }
 };
 
+/**
+ * Adds directives to operation
+ */
 export const addDirectivesToOperation = (
   ctx: TransformerTransformSchemaStepContextProvider,
   typeName: string,
   operationName: string,
   directives: Array<DirectiveNode>,
-) => {
+): void => {
   // add directives to the given operation
   addDirectivesToField(ctx, typeName, operationName, directives);
 
@@ -300,6 +412,9 @@ export const addDirectivesToOperation = (
   }
 };
 
+/**
+ * Extends type with directives
+ */
 export const extendTypeWithDirectives = (
   ctx: TransformerTransformSchemaStepContextProvider,
   typeName: string,
@@ -310,17 +425,23 @@ export const extendTypeWithDirectives = (
   ctx.output.addObjectExtension(objectTypeExtension);
 };
 
-export function makeModelSortDirectionEnumObject(): EnumTypeDefinitionNode {
+/**
+ * Makes model sort direction enum object
+ */
+export const makeModelSortDirectionEnumObject = (): EnumTypeDefinitionNode => {
   const name = 'ModelSortDirection';
   return EnumWrapper.create(name, ['ASC', 'DESC']).serialize();
-}
+};
 // the smaller version of it's @auth equivalent since we only support
 // apikey as the only global auth rule
+/**
+ * Propagates api key to nested types
+ */
 export const propagateApiKeyToNestedTypes = (
   ctx: TransformerContextProvider,
   def: ObjectTypeDefinitionNode,
   seenNonModelTypes: Set<string>,
-) => {
+): void => {
   const nonModelTypePredicate = (fieldType: TypeDefinitionNode): TypeDefinitionNode | undefined => {
     if (fieldType) {
       if (fieldType.kind !== 'ObjectTypeDefinition') {

package/src/graphql-types/query.ts

@@ -1,7 +1,7 @@
 import { TransformerTransformSchemaStepContextProvider } from '@aws-amplify/graphql-transformer-interfaces';
 import { InputObjectTypeDefinitionNode, ObjectTypeDefinitionNode } from 'graphql';
 import { FieldWrapper, ObjectDefinitionWrapper } from '@aws-amplify/graphql-transformer-core';
-import { makeConditionFilterInput } from './common';
+import { makeConditionFilterInput, makeSubscriptionFilterInput } from './common';
 export const makeListQueryFilterInput = (
   ctx: TransformerTransformSchemaStepContextProvider,
   name: string,
@@ -10,6 +10,14 @@ export const makeListQueryFilterInput = (
   return makeConditionFilterInput(ctx, name, object).serialize();
 };
 
+export const makeSubscriptionQueryFilterInput = (
+  ctx: TransformerTransformSchemaStepContextProvider,
+  name: string,
+  object: ObjectTypeDefinitionNode,
+): InputObjectTypeDefinitionNode => {
+  return makeSubscriptionFilterInput(ctx, name, object).serialize();
+};
+
 export const makeListQueryModel = (type: ObjectTypeDefinitionNode, modelName: string, isSyncEnabled: boolean): ObjectTypeDefinitionNode => {
   const outputType = ObjectDefinitionWrapper.create(modelName);
 

package/src/resolvers/subscriptions.ts

@@ -1,11 +1,25 @@
-import { compoundExpression, Expression, obj, printBlock, str, toJson, nul } from 'graphql-mapping-template';
+import {
+  compoundExpression, Expression, obj, printBlock, str, toJson, nul, iff, not, isNullOrEmpty, ref,
+} from 'graphql-mapping-template';
 
+/**
+ * Generates subscription request template
+ */
 export const generateSubscriptionRequestTemplate = (): string => {
   const statements: Expression[] = [toJson(obj({ version: str('2018-05-29'), payload: obj({}) }))];
   return printBlock('Subscription Request template')(compoundExpression(statements));
 };
 
+/**
+ * Generates subscription response template
+ */
 export const generateSubscriptionResponseTemplate = (): string => {
-  const statements: Expression[] = [toJson(nul())];
+  const statements: Expression[] = [
+    iff(
+      not(isNullOrEmpty(ref('ctx.args.filter'))),
+      ref('extensions.setSubscriptionFilter($util.transform.toSubscriptionFilter($ctx.args.filter))'),
+    ),
+    toJson(nul()),
+  ];
   return printBlock('Subscription Response template')(compoundExpression(statements));
 };