Subscription

src/engine/action/Action.ts

@@ -23,8 +23,24 @@ export type ActionSetup = {
   resolve?: Function;
   type?: string;
   permissions?: Function | Permission | Permission[];
-  preProcessor?: Function;
-  postProcessor?: Function;
+  // preProcessor?: Function;
+  // postProcessor?: Function;
+  preProcessor?: (
+    action?: Action,
+    source?: any,
+    payload?: any,
+    context?: any,
+    info?: any,
+  ) => Promise<void> | void;
+  postProcessor?: (
+    error?: any,
+    result?: any,
+    action?: Action,
+    source?: any,
+    payload?: any,
+    context?: any,
+    info?: any,
+  ) => Promise<void> | void;
 };
 
 export class Action {

src/engine/entity/Entity.ts

@@ -74,8 +74,22 @@ export type EntitySetup = {
   permissions?: any;
   subscriptions?: any;
   states?: any;
-  preProcessor?: Function;
-  postProcessor?: Function;
+  // preProcessor?: Function;
+  // postProcessor?: Function;
+  preProcessor?: (
+    entity?: Entity,
+    args?: any,
+    context?: any,
+    info?: any,
+  ) => Promise<any> | any;
+  postProcessor?: (
+    translatedRow?: any,
+    entity?: Entity,
+    source?: any,
+    args?: any,
+    context?: any,
+    info?: any,
+  ) => Promise<any> | any;
   preFilters?: PreFilterType;
   preFiltersGenerator?: PreFilterGeneratorType;
   meta?: any;

src/engine/mutation/Mutation.ts

@@ -40,8 +40,30 @@ export type MutationSetup = {
   type?: string;
   description?: string;
   attributes?: string[];
-  preProcessor?: Function;
-  postProcessor?: Function;
+  // preProcessor?: Function;
+  // postProcessor?: Function;
+  preProcessor?: (
+    entity?: Entity,
+    id?: string | number,
+    source?: any,
+    input?: any,
+    typeName?: string,
+    entityMutation?: Mutation,
+    context?: any,
+    info?: any,
+  ) => Promise<any> | any;
+  postProcessor?: (
+    error?: any,
+    result?: any,
+    entity?: Entity,
+    id?: string | number,
+    source?: any,
+    input?: any,
+    typeName?: string,
+    entityMutation?: Mutation,
+    context?: any,
+    info?: any,
+  ) => Promise<void> | void;
   fromState?: string | string[];
   toState?: string | string[];
 };

src/engine/subscription/Subscription.ts

@@ -242,6 +242,7 @@ export const processEntitySubscriptions = (
       });
 
       if (subscription.type === SUBSCRIPTION_TYPE_CREATE) {
+        // todo : remove this check ?
         const missingAttributeNames = requiredAttributeNames.filter(
           requiredAttributeName => {
             return !subscription.attributes.includes(requiredAttributeName);

src/graphqlProtocol/ProtocolGraphQLConfiguration.ts

@@ -7,6 +7,7 @@ import {
 } from './util';
 import { MAX_PAGE_SIZE } from './protocolGraphqlConstants';
 import { ProtocolConfiguration } from '../engine/protocol/ProtocolConfiguration';
+import { Mutation, Subscription, Entity } from '..';
 
 export class ProtocolGraphQLConfiguration extends ProtocolConfiguration {
   constructor() {
@@ -20,6 +21,9 @@ export class ProtocolGraphQLConfiguration extends ProtocolConfiguration {
         'mutationNested',
         'mutationById',
         'mutationByUniqueness',
+        'subscription',
+        'subscriptionNested',
+        'subscriptionById',
       ],
       true,
     );
@@ -85,26 +89,6 @@ export class ProtocolGraphQLConfiguration extends ProtocolConfiguration {
     return generateTypeNamePascalCase(`${typeName}-${fieldName}-i18n`);
   }
 
-  generateMutationI18nAttributeInputTypeName(entity, mutation, attribute) {
-    const typeName = this.generateEntityTypeName(entity);
-    const fieldName = this.generateFieldName(attribute);
-    return generateTypeNamePascalCase(
-      `${mutation.name}-${typeName}-${fieldName}-i18n-input`,
-    );
-  }
-
-  generateSubscriptionI18nAttributeInputTypeName(
-    entity,
-    subscription,
-    attribute,
-  ) {
-    const typeName = this.generateEntityTypeName(entity);
-    const fieldName = this.generateFieldName(attribute);
-    return generateTypeNamePascalCase(
-      `${subscription.name}-${typeName}-${fieldName}-i18n-input`,
-    );
-  }
-
   generateListQueryTypeName(entity) {
     const typeNamePlural = this.generateEntityTypeNamePlural(entity);
     return generateTypeName(`all-${typeNamePlural}`);
@@ -120,26 +104,6 @@ export class ProtocolGraphQLConfiguration extends ProtocolConfiguration {
     return generateTypeName(`${typeName}-by-${fieldName}`);
   }
 
-  generateMutationInstanceInputTypeName(entity, mutation) {
-    const typeName = this.generateEntityTypeName(entity);
-    return generateTypeNamePascalCase(
-      `${mutation.name}-${typeName}-instance-input`,
-    );
-  }
-
-  generateMutationInputTypeName(entity, mutation) {
-    const typeName = this.generateEntityTypeName(entity);
-    return generateTypeNamePascalCase(`${mutation.name}-${typeName}-input`);
-  }
-
-  generateMutationByPrimaryAttributeInputTypeName(entity, mutation, attribute) {
-    const typeName = this.generateEntityTypeName(entity);
-    const fieldName = this.generateFieldName(attribute);
-    return generateTypeNamePascalCase(
-      `${mutation.name}-${typeName}-by-${fieldName}-input`,
-    );
-  }
-
   generateUniquenessAttributesName(_entity, attributes) {
     return generateTypeName(attributes.join('-and-'));
   }
@@ -162,41 +126,6 @@ export class ProtocolGraphQLConfiguration extends ProtocolConfiguration {
     );
   }
 
-  generateMutationInstanceNestedInputTypeName(entity, mutation) {
-    const typeName = this.generateEntityTypeName(entity);
-    return generateTypeNamePascalCase(
-      `${mutation.name}-${typeName}-instance-nested-input`,
-    );
-  }
-
-  generateMutationNestedInputTypeName(entity, mutation) {
-    const typeName = this.generateEntityTypeName(entity);
-    return generateTypeNamePascalCase(
-      `${mutation.name}-${typeName}-nested-input`,
-    );
-  }
-
-  generateMutationOutputTypeName(entity, mutation) {
-    const typeName = this.generateEntityTypeName(entity);
-    return generateTypeNamePascalCase(`${mutation.name}-${typeName}-output`);
-  }
-
-  generateMutationTypeName(entity, mutation) {
-    const typeName = this.generateEntityTypeName(entity);
-    return generateTypeName(`${mutation.name}-${typeName}`);
-  }
-
-  generateMutationNestedTypeName(entity, mutation) {
-    const typeName = this.generateEntityTypeName(entity);
-    return generateTypeName(`${mutation.name}-${typeName}-nested`);
-  }
-
-  generateMutationByPrimaryAttributeTypeName(entity, mutation, attribute) {
-    const typeName = this.generateEntityTypeName(entity);
-    const fieldName = this.generateFieldName(attribute);
-    return generateTypeName(`${mutation.name}-${typeName}-by-${fieldName}`);
-  }
-
   generateActionTypeName(action) {
     return generateTypeName(action.name);
   }
@@ -275,69 +204,100 @@ export class ProtocolGraphQLConfiguration extends ProtocolConfiguration {
     return generateTypeNamePascalCase(`${typeName}-connection`);
   }
 
-  generateSubscriptionInstanceInputTypeName(entity, subscription) {
+  generateOperationI18nAttributeInputTypeName(
+    entity: Entity | any,
+    operation: Mutation | Subscription | any,
+    attribute,
+  ) {
     const typeName = this.generateEntityTypeName(entity);
+    const fieldName = this.generateFieldName(attribute);
     return generateTypeNamePascalCase(
-      `${subscription.name}-${typeName}-instance-input`,
+      `${operation.name}-${typeName}-${fieldName}-i18n-input`,
     );
   }
 
-  generateSubscriptionInputTypeName(entity, subscription) {
+  generateOperationInstanceInputTypeName(
+    entity: Entity,
+    operation: Mutation | Subscription,
+  ) {
     const typeName = this.generateEntityTypeName(entity);
-    return generateTypeNamePascalCase(`${subscription.name}-${typeName}-input`);
+    return generateTypeNamePascalCase(
+      `${operation.name}-${typeName}-instance-input`,
+    );
   }
 
-  generateSubscriptionByPrimaryAttributeInputTypeName(
-    entity,
-    subscription,
+  generateOperationInputTypeName(
+    entity: Entity,
+    operation: Mutation | Subscription,
+  ) {
+    const typeName = this.generateEntityTypeName(entity);
+    return generateTypeNamePascalCase(`${operation.name}-${typeName}-input`);
+  }
+
+  generateOperationByPrimaryAttributeInputTypeName(
+    entity: Entity,
+    operation: Mutation | Subscription,
     attribute,
   ) {
     const typeName = this.generateEntityTypeName(entity);
     const fieldName = this.generateFieldName(attribute);
     return generateTypeNamePascalCase(
-      `${subscription.name}-${typeName}-by-${fieldName}-input`,
+      `${operation.name}-${typeName}-by-${fieldName}-input`,
     );
   }
 
-  generateSubscriptionInstanceNestedInputTypeName(entity, subscription) {
+  generateOperationInstanceNestedInputTypeName(
+    entity: Entity,
+    operation: Mutation | Subscription,
+  ) {
     const typeName = this.generateEntityTypeName(entity);
     return generateTypeNamePascalCase(
-      `${subscription.name}-${typeName}-instance-nested-input`,
+      `${operation.name}-${typeName}-instance-nested-input`,
     );
   }
 
-  generateSubscriptionNestedInputTypeName(entity, subscription) {
+  generateOperationNestedInputTypeName(
+    entity: Entity,
+    operation: Mutation | Subscription,
+  ) {
     const typeName = this.generateEntityTypeName(entity);
     return generateTypeNamePascalCase(
-      `${subscription.name}-${typeName}-nested-input`,
+      `${operation.name}-${typeName}-nested-input`,
     );
   }
 
-  generateSubscriptionOutputTypeName(entity, subscription) {
+  generateOperationOutputTypeName(
+    entity: Entity,
+    operation: Mutation | Subscription,
+  ) {
     const typeName = this.generateEntityTypeName(entity);
-    return generateTypeNamePascalCase(
-      `${subscription.name}-${typeName}-output`,
-    );
+    return generateTypeNamePascalCase(`${operation.name}-${typeName}-output`);
   }
 
-  generateSubscriptionTypeName(entity, subscription) {
+  generateOperationTypeName(
+    entity: Entity,
+    operation: Mutation | Subscription,
+  ) {
     const typeName = this.generateEntityTypeName(entity);
-    return generateTypeName(`${subscription.name}-${typeName}`);
+    return generateTypeName(`${operation.name}-${typeName}`);
   }
 
-  generateSubscriptionNestedTypeName(entity, subscription) {
+  generateOperationNestedTypeName(
+    entity: Entity,
+    operation: Mutation | Subscription,
+  ) {
     const typeName = this.generateEntityTypeName(entity);
-    return generateTypeName(`${subscription.name}-${typeName}-nested`);
+    return generateTypeName(`${operation.name}-${typeName}-nested`);
   }
 
-  generateSubscriptionByPrimaryAttributeTypeName(
-    entity,
-    subscription,
+  generateOperationByPrimaryAttributeTypeName(
+    entity: Entity,
+    operation: Mutation | Subscription,
     attribute,
   ) {
     const typeName = this.generateEntityTypeName(entity);
     const fieldName = this.generateFieldName(attribute);
-    return generateTypeName(`${subscription.name}-${typeName}-by-${fieldName}`);
+    return generateTypeName(`${operation.name}-${typeName}-by-${fieldName}`);
   }
 }
 

src/graphqlProtocol/generator.ts

@@ -35,6 +35,7 @@ import {
 } from '../engine/action/Action';
 import { isViewEntity } from '../engine/entity/ViewEntity';
 import { isShadowEntity } from '../engine/entity/ShadowEntity';
+import { generateInstanceUniquenessInputs } from './operation';
 
 export const getTypeForEntityFromGraphRegistry = entity => {
   const typeName = entity.graphql.typeName;
@@ -342,6 +343,8 @@ export const generateGraphQLSchema = configuration => {
     }
   });
 
+  generateInstanceUniquenessInputs(graphRegistry);
+
   // build the query type
   const queryType = new GraphQLObjectType({
     name: 'Query',
@@ -388,12 +391,6 @@ export const generateGraphQLSchema = configuration => {
 
     fields: () => {
       const subscriptions = generateSubscriptions(graphRegistry);
-      // Object.keys(subscriptions).forEach(sub => {
-      //   console.log('generate subscriptions', {
-      //     name: sub,
-      //     args: subscriptions[sub].args,
-      //   });
-      // });
 
       return subscriptions;
     },

src/graphqlProtocol/io.ts

@@ -73,7 +73,7 @@ const generateDataInputField = (
 
     param.gqlFieldNameI18n = protocolConfiguration.generateI18nFieldName(param);
 
-    const i18nFieldTypeName = protocolConfiguration.generateMutationI18nAttributeInputTypeName(
+    const i18nFieldTypeName = protocolConfiguration.generateOperationI18nAttributeInputTypeName(
       {
         name: baseName,
       },