add utils for subscription fields and generation ; generate Subscript…

…ion schema
chriskalmar · May 11, 2020 · 7df04c6 · 7df04c6
1 parent 5199996
commit 7df04c6
Show file tree

Hide file tree

Showing 5 changed files with 1,046 additions and 1 deletion.
diff --git a/src/graphqlProtocol/ProtocolGraphQLConfiguration.ts b/src/graphqlProtocol/ProtocolGraphQLConfiguration.ts
@@ -93,6 +93,18 @@ export class ProtocolGraphQLConfiguration extends ProtocolConfiguration {
     );
   }
 
+  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}`);
@@ -262,6 +274,71 @@ export class ProtocolGraphQLConfiguration extends ProtocolConfiguration {
     const typeName = this.generateEntityTypeName(entity);
     return generateTypeNamePascalCase(`${typeName}-connection`);
   }
+
+  generateSubscriptionInstanceInputTypeName(entity, subscription) {
+    const typeName = this.generateEntityTypeName(entity);
+    return generateTypeNamePascalCase(
+      `${subscription.name}-${typeName}-instance-input`,
+    );
+  }
+
+  generateSubscriptionInputTypeName(entity, subscription) {
+    const typeName = this.generateEntityTypeName(entity);
+    return generateTypeNamePascalCase(`${subscription.name}-${typeName}-input`);
+  }
+
+  generateSubscriptionByPrimaryAttributeInputTypeName(
+    entity,
+    subscription,
+    attribute,
+  ) {
+    const typeName = this.generateEntityTypeName(entity);
+    const fieldName = this.generateFieldName(attribute);
+    return generateTypeNamePascalCase(
+      `${subscription.name}-${typeName}-by-${fieldName}-input`,
+    );
+  }
+
+  generateSubscriptionInstanceNestedInputTypeName(entity, subscription) {
+    const typeName = this.generateEntityTypeName(entity);
+    return generateTypeNamePascalCase(
+      `${subscription.name}-${typeName}-instance-nested-input`,
+    );
+  }
+
+  generateSubscriptionNestedInputTypeName(entity, subscription) {
+    const typeName = this.generateEntityTypeName(entity);
+    return generateTypeNamePascalCase(
+      `${subscription.name}-${typeName}-nested-input`,
+    );
+  }
+
+  generateSubscriptionOutputTypeName(entity, subscription) {
+    const typeName = this.generateEntityTypeName(entity);
+    return generateTypeNamePascalCase(
+      `${subscription.name}-${typeName}-output`,
+    );
+  }
+
+  generateSubscriptionTypeName(entity, subscription) {
+    const typeName = this.generateEntityTypeName(entity);
+    return generateTypeName(`${subscription.name}-${typeName}`);
+  }
+
+  generateSubscriptionNestedTypeName(entity, subscription) {
+    const typeName = this.generateEntityTypeName(entity);
+    return generateTypeName(`${subscription.name}-${typeName}-nested`);
+  }
+
+  generateSubscriptionByPrimaryAttributeTypeName(
+    entity,
+    subscription,
+    attribute,
+  ) {
+    const typeName = this.generateEntityTypeName(entity);
+    const fieldName = this.generateFieldName(attribute);
+    return generateTypeName(`${subscription.name}-${typeName}-by-${fieldName}`);
+  }
 }
 
 export const isProtocolGraphQLConfiguration = (obj: any): boolean => {

diff --git a/src/graphqlProtocol/__snapshots__/generator.spec.ts.snap b/src/graphqlProtocol/__snapshots__/generator.spec.ts.snap
@@ -17,7 +17,7 @@ GraphQLSchema {
   "_mutationType": "Mutation",
   "_possibleTypeMap": Object {},
   "_queryType": "Query",
-  "_subscriptionType": undefined,
+  "_subscriptionType": "Subscription",
   "_typeMap": Object {
     "Boolean": "Boolean",
     "CreateTestEntityNameInput": "CreateTestEntityNameInput",
@@ -33,9 +33,24 @@ GraphQLSchema {
     "Int": "Int",
     "Mutation": "Mutation",
     "Node": "Node",
+    "OnCreateTestEntityNameInput": "OnCreateTestEntityNameInput",
+    "OnCreateTestEntityNameInstanceInput": "OnCreateTestEntityNameInstanceInput",
+    "OnCreateTestEntityNameInstanceNestedInput": "OnCreateTestEntityNameInstanceNestedInput",
+    "OnCreateTestEntityNameNestedInput": "OnCreateTestEntityNameNestedInput",
+    "OnCreateTestEntityNameOutput": "OnCreateTestEntityNameOutput",
+    "OnDeleteTestEntityNameByIdInput": "OnDeleteTestEntityNameByIdInput",
+    "OnDeleteTestEntityNameInput": "OnDeleteTestEntityNameInput",
+    "OnDeleteTestEntityNameOutput": "OnDeleteTestEntityNameOutput",
+    "OnUpdateTestEntityNameByIdInput": "OnUpdateTestEntityNameByIdInput",
+    "OnUpdateTestEntityNameInput": "OnUpdateTestEntityNameInput",
+    "OnUpdateTestEntityNameInstanceInput": "OnUpdateTestEntityNameInstanceInput",
+    "OnUpdateTestEntityNameInstanceNestedInput": "OnUpdateTestEntityNameInstanceNestedInput",
+    "OnUpdateTestEntityNameNestedInput": "OnUpdateTestEntityNameNestedInput",
+    "OnUpdateTestEntityNameOutput": "OnUpdateTestEntityNameOutput",
     "PageInfo": "PageInfo",
     "Query": "Query",
     "String": "String",
+    "Subscription": "Subscription",
     "TestEntityName": "TestEntityName",
     "TestEntityNameConnection": "TestEntityNameConnection",
     "TestEntityNameEdge": "TestEntityNameEdge",

diff --git a/src/graphqlProtocol/generator.ts b/src/graphqlProtocol/generator.ts
@@ -23,6 +23,8 @@ import { generateMutations } from './mutation';
 
 import { generateActions } from './action';
 
+import { generateSubscriptions } from './subscription';
+
 import { resolveByFindOne } from './resolver';
 import { isConfiguration } from '../engine/configuration/Configuration';
 import { isEntity } from '../engine/entity/Entity';
@@ -372,6 +374,7 @@ export const generateGraphQLSchema = configuration => {
     fields: () => {
       const mutations = generateMutations(graphRegistry);
       const actions = generateActions(graphRegistry, ACTION_TYPE_MUTATION);
+      // console.log('generate mutations', { mutations });
 
       return {
         ...mutations,
@@ -380,9 +383,22 @@ export const generateGraphQLSchema = configuration => {
     },
   });
 
+  const subscriptionType = new GraphQLObjectType({
+    name: 'Subscription',
+    // root: 'The root subscription type',
+
+    fields: () => {
+      const subscriptions = generateSubscriptions(graphRegistry);
+      console.log('generate subscriptions', { subscriptions });
+
+      return subscriptions;
+    },
+  });
+
   // put it all together into a graphQL schema
   return new GraphQLSchema({
     query: queryType,
     mutation: mutationType,
+    subscription: subscriptionType,
   });
 };
diff --git a/src/graphqlProtocol/resolver.ts b/src/graphqlProtocol/resolver.ts
@@ -30,6 +30,11 @@ import {
   MUTATION_TYPE_UPDATE,
   MUTATION_TYPE_DELETE,
 } from '../engine/mutation/Mutation';
+import {
+  SUBSCRIPTION_TYPE_CREATE,
+  SUBSCRIPTION_TYPE_UPDATE,
+  // SUBSCRIPTION_TYPE_DELETE,
+} from '../engine/subscription/Subscription';
 import { CustomError } from '../engine/CustomError';
 import {
   fillSystemAttributesDefaultValues,
@@ -453,3 +458,143 @@ export const getMutationResolver = (
     }
   };
 };
+
+export const getSubscriptionPayloadResolver = (
+  entity,
+  entitySubscription,
+  typeName,
+  // nested,
+  // idResolver,
+) => {
+  const protocolConfiguration = ProtocolGraphQL.getProtocolConfiguration() as ProtocolGraphQLConfiguration;
+
+  return async (source, args, context) => {
+    // checkRequiredI18nInputs(
+    //   entity,
+    //   entitySubscription,
+    //   args.input[typeName],
+    //   // context,
+    // );
+
+    // if (nested) {
+    //   args.input[typeName] = await nestedPayloadResolver(
+    //     source,
+    //     args.input[typeName],
+    //     context,
+    //     info,
+    //   );
+    // }
+
+    // const id = idResolver({ args });
+    let result;
+    if (entitySubscription.type !== MUTATION_TYPE_DELETE) {
+      result = entity.graphql.dataShaper(
+        addRelayTypePromoterToInstance(
+          protocolConfiguration.generateEntityTypeName(entity),
+          source,
+        ),
+      );
+
+      result = translateInstance(entity, result, context);
+    }
+
+    let ret = {
+      clientSubscriptionId: args.input.clientSubscriptionId,
+    };
+
+    if (entitySubscription.type === MUTATION_TYPE_DELETE) {
+      ret = {
+        ...ret,
+        ...source,
+      };
+    } else {
+      ret[typeName] = result;
+    }
+
+    return ret;
+  };
+};
+
+export const getSubscriptionResolver = (
+  entity,
+  entitySubscription,
+  typeName,
+  nested,
+  // idResolver,
+) => {
+  const storageType = entity.storageType;
+  // const protocolConfiguration = ProtocolGraphQL.getProtocolConfiguration() as ProtocolGraphQLConfiguration;
+
+  const nestedPayloadResolver = getNestedPayloadResolver(
+    entity,
+    entitySubscription.attributes,
+    storageType,
+  );
+
+  return async (source, args, context, info) => {
+    checkRequiredI18nInputs(
+      entity,
+      entitySubscription,
+      args.input[typeName],
+      // context,
+    );
+
+    if (nested) {
+      args.input[typeName] = await nestedPayloadResolver(
+        source,
+        args.input[typeName],
+        context,
+        info,
+      );
+    }
+
+    // const id = idResolver({ args });
+
+    if (entitySubscription.type === SUBSCRIPTION_TYPE_CREATE) {
+      args.input[typeName] = await fillDefaultValues(
+        entity,
+        entitySubscription,
+        args.input[typeName],
+        context,
+      );
+    }
+
+    if (
+      entitySubscription.type === SUBSCRIPTION_TYPE_CREATE ||
+      entitySubscription.type === SUBSCRIPTION_TYPE_UPDATE
+    ) {
+      args.input[typeName] = fillSystemAttributesDefaultValues(
+        entity,
+        entitySubscription,
+        args.input[typeName],
+        context,
+      );
+    }
+
+    // await validateSubscriptionPayload(
+    //   entity,
+    //   entitySubscription,
+    //   args.input[typeName],
+    //   context,
+    // );
+
+    // if (entitySubscription.type !== SUBSCRIPTION_TYPE_DELETE) {
+    //   //
+    //   // this function might be wrong when we look serializeValues args
+    //   // unless we add typeName ?
+    //   args.input[typeName] = serializeValues(
+    //     entity,
+    //     entitySubscription,
+    //     args.input[typeName],
+    //     typeName,
+    //     context,
+    //   );
+    // }
+
+    // use entity.name and args.input to compose topic
+    const topic = '';
+
+    return context.pubsub ? context.pubsub.asyncIterator(topic) : null;
+    // : pubsub.asyncIterator(topic);
+  };
+};