@coderich/autograph 0.9.16 → 0.10.2

package/src/graphql/ast/Schema.js

@@ -1,141 +1,138 @@
 const FS = require('fs');
 const Glob = require('glob');
 const Merge = require('deepmerge');
-const { nvl, uvl } = require('../../service/app.service');
-const { validateSchema, makeExecutableSchema, mergeASTSchema, mergeASTArray } = require('../../service/graphql.service');
+const { Kind, print, parse, visit } = require('graphql');
+const { mergeASTArray } = require('../../service/graphql.service');
+const { deleteKeys } = require('../../service/app.service');
+const frameworkExt = require('../extension/framework');
+const typeExt = require('../extension/type');
+const apiExt = require('../extension/api');
+const TypeDefApi = require('./TypeDefApi');
 const Node = require('./Node');
-const Model = require('./Model');
 
-const loadFile = file => FS.readFileSync(file, 'utf8');
-const reqFile = file => require(file); // eslint-disable-line global-require,import/no-dynamic-require
-
-module.exports = class Schema extends Node {
-  constructor(schema) {
-    // Ensure schema
-    schema.resolvers = schema.resolvers || {};
-    schema.schemaDirectives = schema.schemaDirectives || {};
-    schema.context = schema.context || {};
-
-    //
-    super(schema.typeDefs);
-    this.schema = schema;
-    this.initialize();
+/**
+ * Schema
+ *
+ * This class helps facilitate dynamic modification of a schema before it is passed to makeExecutableSchema(). It allows
+ * for "intelligent" merging of schemas and exposes an API wrapper for typeDefs.
+ *
+ * A "schema" is defined by the following object attributes:
+ *
+ *    typeDefs <String|Object> - GQL String or AST Object (also supports a mixed array of both)
+ *    resolvers <Object> - GraphQL resolvers
+ *    schemaDirectives <Object> - GraphQL directives
+ *
+ */
+module.exports = class Schema extends TypeDefApi {
+  constructor(schema, toExecutableSchema) {
+    super();
+    this.toExecutableSchema = toExecutableSchema;
+    this.schema = { typeDefs: [], resolvers: {}, schemaDirectives: {} };
+    if (schema) this.mergeSchema(schema);
   }
 
-  initialize() {
-    const definitions = this.ast.definitions.map(d => new Node(d));
-    this.models = definitions.filter(d => d.isModel()).map(d => new Model(this, d.getAST()));
-    this.modelsByName = this.models.reduce((prev, model) => Object.assign(prev, { [model.getName()]: model }), {});
-    this.modelsByKey = this.models.reduce((prev, model) => Object.assign(prev, { [model.getKey()]: model }), {});
-    this.inputs = definitions.filter(d => d.isInput()).map(d => new Model(this, d.getAST()));
-    this.scalars = definitions.filter(d => d.isScalar());
-    this.enums = definitions.filter(d => d.isEnum());
+  /**
+   * Synchronously merge a schema
+   */
+  mergeSchema(schema, options = {}) {
+    // Ensure this is a schema of sorts otherwise skip it
+    if (typeof schema !== 'string' && ['typeDefs', 'resolvers', 'schemaDirectives'].every(key => !schema[key])) return this;
+
+    // Here we want to normalize the schema into the shape { typeDefs, resolvers, schemaDirectives }
+    // We do NOT want to modify the schema object because that may cause unwanted side-effects.
+    const normalizedSchema = { ...schema };
+    if (typeof schema === 'string') normalizedSchema.typeDefs = [schema];
+    else if (schema.typeDefs && !Array.isArray(schema.typeDefs)) normalizedSchema.typeDefs = [schema.typeDefs];
+
+    // For typeDefs we want the AST so that it can be intelligently merged. Here we convert
+    // GQL strings to AST objects and also filter out anything that does not parse to AST.
+    if (normalizedSchema.typeDefs && normalizedSchema.typeDefs.length) {
+      normalizedSchema.typeDefs = deleteKeys(normalizedSchema.typeDefs.map((td) => {
+        try {
+          const ast = typeof td === 'object' ? td : parse(td);
+          return ast.definitions;
+        } catch (e) {
+          return null;
+        }
+      }), ['loc']).filter(Boolean).flat();
+    }
+
+    // Now we're ready to merge the schema
+    const [left, right] = options.passive ? [normalizedSchema, this.schema] : [this.schema, normalizedSchema];
+    if (normalizedSchema.typeDefs && normalizedSchema.typeDefs.length) this.schema.typeDefs = mergeASTArray(left.typeDefs.concat(right.typeDefs));
+    if (normalizedSchema.resolvers) this.schema.resolvers = Merge(left.resolvers, right.resolvers);
+    if (normalizedSchema.schemaDirectives) this.schema.schemaDirectives = Merge(left.schemaDirectives, right.schemaDirectives);
+
+    // Chaining
+    return this;
   }
 
   /**
-   * This is the final call used to pass in a schema to makeExecutableSchema.
-   * Here I'm making last-minute modifications to the schema that is exposed to the API.
+   * Asynchronously load files from a given glob pattern and merge each schema
    */
-  getSchema() {
-    const definitions = this.ast.definitions.map((definition) => {
-      definition.fields = (definition.fields || []).filter((f) => {
-        const node = new Node(f, 'field');
-        const scope = nvl(uvl(node.getDirectiveArg('field', 'gqlScope'), 'crud'), '');
-        return scope.indexOf('r') > -1;
+  mergeSchemaFromFiles(globPattern, options) {
+    return new Promise((resolve, reject) => {
+      Glob(globPattern, options, (err, files) => {
+        if (err) return reject(err);
+
+        return Promise.all(files.map((file) => {
+          return new Promise((res) => {
+            if (file.endsWith('.js')) res(require(file)); // eslint-disable-line global-require,import/no-dynamic-require
+            else res(FS.readFileSync(file, 'utf8'));
+          }).then(schema => this.mergeSchema(schema, options));
+        })).then(() => resolve(this)).catch(e => reject(e));
       });
-
-      return definition;
     });
-
-    const ast = Object.assign({}, this.ast, { definitions });
-    const schema = Object.assign({}, this.schema, { typeDefs: ast });
-    validateSchema(schema);
-    return schema;
-  }
-
-  getModel(name) {
-    return this.modelsByName[name] || this.modelsByKey[name];
-  }
-
-  getModels() {
-    return this.models;
-  }
-
-  getModelNames() {
-    return this.getModels().map(model => model.getName());
-  }
-
-  getModelMap() {
-    return this.getModels().reduce((prev, model) => Object.assign(prev, { [model.getName()]: model }), {});
-  }
-
-  getInput(name) {
-    return this.getInputs().find(input => input.getName() === name);
-  }
-
-  getInputs() {
-    return this.inputs;
-  }
-
-  getScalar(name) {
-    return this.getScalars().find(scalar => scalar.getName() === name);
-  }
-
-  getScalars() {
-    return this.scalars;
   }
 
-  getEnum(name) {
-    return this.getEnums().find(el => el.getName() === name);
-  }
-
-  getEnums() {
-    return this.enums;
-  }
-
-  getMarkedModels() {
-    return this.getModels().filter(model => model.isMarkedModel());
-  }
-
-  getEntityModels() {
-    return this.getModels().filter(model => model.isEntity());
+  /**
+   * Traverses the current schema's typeDefs in order to keep the TypeDefApi in sync. This operation
+   * only needs to be called when typeDefs have been changed and you want to keep the data model in sync.
+   */
+  initialize() {
+    super.initialize(this.schema.typeDefs);
+    this.getModels().forEach(model => model.initialize());
+    return this;
   }
 
-  getContext() {
-    return this.schema.context;
+  /**
+   * Decorate the schema with Autograph's default api/definitions
+   */
+  decorate() {
+    this.initialize();
+    this.mergeSchema(frameworkExt(this), { passive: true });
+    this.mergeSchema(typeExt(this), { passive: true });
+    this.initialize();
+    this.mergeSchema(apiExt(this), { passive: true });
+    this.finalize();
+    return this;
   }
 
-  loadDir(dir, options) {
-    // Typedefs
-    const typeDefs = Glob.sync(`${dir}/**/*.{gql,graphql}`, options).map(file => loadFile(file)).join('\n\n');
-
-    // Possibly full schema definitions
-    const schema = Glob.sync(`${dir}/**/*.js`, options).map(file => reqFile(file)).reduce((prev, data) => {
-      return Merge(prev, data);
-    }, {
-      typeDefs: typeDefs.length ? typeDefs : undefined,
-      context: {},
-      resolvers: {},
-      schemaDirectives: {},
+  /**
+   * This should be called once before passing to makeExecutableSchema()
+   */
+  finalize() {
+    const definitions = visit(this.schema.typeDefs, {
+      [Kind.FIELD_DEFINITION]: (node) => {
+        const scope = new Node(node, 'field').getDirectiveArg('field', 'gqlScope', 'crud');
+        if (scope === null || scope.indexOf('r') === -1) return null; // Delete node
+        return false; // Stop traversing this node
+      },
     });
 
-    return this.extend(schema);
+    this.schema.typeDefs = { kind: Kind.DOCUMENT, definitions };
+    return this;
   }
 
-  sextend(...schemas) {
-    const definitions = schemas.filter(schema => schema.typeDefs).map(schema => mergeASTSchema(schema.typeDefs).definitions);
-    this.ast.definitions = mergeASTArray(this.ast.definitions.concat(...definitions));
-    this.schema.resolvers = Merge(schemas.reduce((prev, schema) => Merge(prev, schema.resolvers || {}), {}), this.schema.resolvers);
-    return this;
+  makeExecutableSchema() {
+    return this.toExecutableSchema(this.schema);
   }
 
-  extend(...schemas) {
-    this.sextend(...schemas);
-    this.initialize();
-    return this;
+  toObject() {
+    return this.schema;
   }
 
-  makeExecutableSchema() {
-    return makeExecutableSchema(this.getSchema());
+  toString() {
+    return print(this.typeDefs);
   }
 };

package/src/graphql/extension/api.js

@@ -1,16 +1,15 @@
 const { get } = require('lodash');
 const { Kind } = require('graphql');
 const ServerResolver = require('../../core/ServerResolver');
-const { ucFirst, fromGUID } = require('../../service/app.service');
+const { ucFirst, toGUID, fromGUID } = require('../../service/app.service');
 const { findGQLModels } = require('../../service/schema.service');
-const { makeCreateAPI, makeReadAPI, makeUpdateAPI, makeDeleteAPI, makeSubscriptionAPI, makeInputSplice, makeQueryResolver, makeMutationResolver } = require('../../service/decorator.service');
+const { makeCreateAPI, makeReadAPI, makeUpdateAPI, makeDeleteAPI, makeSubscriptionAPI, makeQueryResolver, makeMutationResolver } = require('../../service/decorator.service');
 
 const interfaceKinds = [Kind.INTERFACE_TYPE_DEFINITION, Kind.INTERFACE_TYPE_EXTENSION];
 
 const getGQLWhereFields = (model) => {
   return model.getFields().filter((field) => {
     if (!field.hasGQLScope('r')) return false;
-    if (field.hasBoundValue() && !field.getDirectiveArg('value', 'passive')) return false;
     const modelRef = field.getModelRef();
     if (modelRef && !modelRef.isEmbedded() && !modelRef.isEntity()) return false;
     return true;
@@ -25,8 +24,6 @@ module.exports = (schema) => {
   const createModels = findGQLModels('c', markedModels, allModels);
   const readModels = findGQLModels('r', markedModels, allModels);
   const updateModels = findGQLModels('u', markedModels, allModels);
-  const deleteModels = findGQLModels('d', markedModels, allModels);
-  const spliceModels = [...new Set([...createModels, ...updateModels, ...deleteModels])];
 
   return ({
     typeDefs: [
@@ -40,7 +37,6 @@ module.exports = (schema) => {
         input ${model.getName()}InputUpdate {
           ${model.getFields().filter(field => field.hasGQLScope('u') && !field.isVirtual()).map(field => `${field.getName()}: ${field.getGQLType('InputUpdate')}`)}
         }
-        # ${makeInputSplice(model)}
       `),
 
       ...readModels.map(model => `
@@ -50,19 +46,14 @@ module.exports = (schema) => {
         input ${model.getName()}InputSort {
           ${getGQLWhereFields(model).map(field => `${field.getName()}: ${field.getModelRef() ? `${ucFirst(field.getDataRef())}InputSort` : 'SortOrderEnum'}`)}
         }
-      `),
-
-      ...readModels.map(model => `
         extend ${interfaceKinds.indexOf(model.getKind()) > -1 ? 'interface' : 'type'} ${model.getName()} {
           ${model.getFields().filter(field => field.hasGQLScope('r')).map(field => `${field.getName()}${field.getExtendArgs()}: ${field.getPayloadType()}`)}
         }
-
         type ${model.getName()}Connection {
+          count: Int!
           pageInfo: PageInfo!
           edges: [${model.getName()}Edge]
-          count: Int!
         }
-
         type ${model.getName()}Edge {
           node: ${model.getName()}
           cursor: String!
@@ -90,7 +81,7 @@ module.exports = (schema) => {
         }
 
         type ${model.getName()}SubscriptionPayloadEventData {
-          ${model.getFields().filter(field => field.hasGQLScope('r')).map(field => `${field.getName()}: ${field.getSubscriptionType()}`)}
+          ${getGQLWhereFields(model).map(field => `${field.getName()}: ${field.getSubscriptionType()}`)}
         }
 
         interface ${model.getName()}SubscriptionQuery {
@@ -105,13 +96,6 @@ module.exports = (schema) => {
           ${model.getFields().filter(field => field.hasGQLScope('r')).map(field => `${field.getName()}: ${field.getPayloadType()}`)}
         }
       `),
-
-      ...spliceModels.map(model => `
-        #input ${model.getName()}InputSplice {
-        #  with: ${model}InputWhere
-        #  put: ${model}InputUpdate
-        #}
-      `),
     ].concat([
       `type PageInfo {
         startCursor: String!
@@ -148,21 +132,20 @@ module.exports = (schema) => {
         const isConnection = field.isConnection();
 
         return Object.assign(def, {
-          [fieldName]: (root, args, { autograph }) => {
-            if (fieldName === 'id') return autograph.legacyMode ? root.id : root.$id;
-
-            const $fieldName = `$${fieldName}`;
+          [fieldName]: (doc, args, { autograph }, info) => {
+            if (fieldName === 'id') return autograph.legacyMode ? doc.id : toGUID(modelName, doc.id);
 
+            // If this field is a connection we return thunks in order to delay query
+            // until the "Connection" resolver (below) is run
             if (isConnection) {
               return {
-                args,
-                edges: root[$fieldName], // Thunk to the data/edges
-                pageInfo: root[$fieldName], // You still need the data/edges to get pageInfo!
-                count: root[`${$fieldName}:count`], // Thunk to $$count
+                count: () => field.count(autograph.resolver, doc, args),
+                edges: () => field.resolve(autograph.resolver, doc, args),
+                pageInfo: () => field.resolve(autograph.resolver, doc, args),
               };
             }
 
-            return root.$$isResultSetItem ? root[$fieldName](args) : root[fieldName];
+            return field.resolve(autograph.resolver, doc, args);
           },
         });
       }, {});
@@ -179,24 +162,28 @@ module.exports = (schema) => {
       return Object.assign(prev, {
         [modelName]: fieldResolvers,
         [`${modelName}Connection`]: {
-          edges: ({ edges, args }) => edges(args).then(rs => rs.map(node => ({ cursor: get(node, '$$cursor'), node }))),
-          pageInfo: ({ pageInfo, args }) => pageInfo(args).then(rs => get(rs, '$$pageInfo')),
-          count: ({ count, args }) => count(args),
+          count: ({ count }) => count(),
+          edges: ({ edges }) => edges().then(rs => rs.map(node => ({ cursor: get(node, '$$cursor'), node }))),
+          pageInfo: ({ pageInfo }) => pageInfo().then(rs => get(rs, '$$pageInfo')),
         },
       });
     }, {
       Node: {
-        __resolveType: (root, args, context, info) => root.__typename || fromGUID(root.$id)[0], // eslint-disable-line no-underscore-dangle
+        __resolveType: (doc, args, context, info) => doc.__typename, // eslint-disable-line no-underscore-dangle
       },
 
       Query: entityModels.reduce((prev, model) => {
         return Object.assign(prev, makeQueryResolver(model.getName(), model, resolver));
       }, {
-        node: (root, args, context, info) => {
+        node: (doc, args, context, info) => {
           const { id } = args;
           const [modelName] = fromGUID(id);
           const model = schema.getModel(modelName);
-          return resolver.get(context, model, args, false, info);
+          return resolver.get(context, model, args, false, info).then((result) => {
+            if (result == null) return result;
+            result.__typename = modelName; // eslint-disable-line no-underscore-dangle
+            return result;
+          });
         },
       }),
 

package/src/graphql/extension/framework.js

@@ -1,5 +1,6 @@
-const Rule = require('../../core/Rule');
-const Transformer = require('../../core/Transformer');
+const Pipeline = require('../../data/Pipeline');
+
+Pipeline.createPresets();
 
 module.exports = (schema) => {
   return {
@@ -7,51 +8,49 @@ module.exports = (schema) => {
       scalar AutoGraphMixed
       scalar AutoGraphDriver
       scalar AutoGraphDateTime @field(transform: toDate)
-      enum AutoGraphEnforceEnum { ${Object.keys(Rule.getInstances()).join(' ')} }
-      enum AutoGraphTransformEnum  { ${Object.keys(Transformer.getInstances()).join(' ')} }
+      enum AutoGraphPipelineEnum { ${Object.keys(Pipeline).join(' ')} }
       enum AutoGraphAuthzEnum { private protected public }
-      enum AutoGraphValueScopeEnum { self context }
       enum AutoGraphOnDeleteEnum { cascade nullify restrict defer }
       enum AutoGraphIndexEnum { unique }
 
       directive @model(
-        key: String # Specify it's key during transit
+        id: String # Specify db key (default "id")
+        key: String # Specify db table/collection name
+        createdAt: String # Specify db key (default "createdAt")
+        updatedAt: String # Specify db key (default "updatedAt")
+        meta: AutoGraphMixed # Custom input "meta" field for mutations
+        embed: Boolean # Mark this an embedded model (default false)
+        persist: Boolean # Persist this model (default true)
         gqlScope: AutoGraphMixed # Dictate how GraphQL API behaves
         dalScope: AutoGraphMixed # Dictate how the DAL behaves
         fieldScope: AutoGraphMixed # Dictate how a FIELD may use me
-        meta: AutoGraphMixed # Custom input 'meta' field for mutations
-        embed: Boolean # Mark this an embedded model (default false)
-        persist: Boolean # Persist this model (default true)
         driver: AutoGraphDriver # External data driver
         authz: AutoGraphAuthzEnum # Access level used for authorization (default: private)
         namespace: String # Logical grouping of models that can be globbed (useful for authz)
-
-        # Override auto-gen
-        id: String
-        createdAt: String
-        updatedAt: String
       ) on OBJECT | INTERFACE
 
       directive @field(
-        key: String # Specify it's key during transit
+        id: String # Specify the ModelRef this field FK References
+        key: String # Specify db key
+        persist: Boolean # Persist this field (default true)
+        connection: Boolean # Treat this field as a connection type (default false - rolling this out slowly)
+        default: AutoGraphMixed # Define a default value
         ref: AutoGraphMixed # Specify the modelRef field's name (overrides isEmbedded)
         gqlScope: AutoGraphMixed # Dictate how GraphQL API behaves
         dalScope: AutoGraphMixed # Dictate how the DAL behaves
         fieldScope: AutoGraphMixed # Dictate how a FIELD may use me
-        persist: Boolean # Persist this field (default true)
-        default: AutoGraphMixed # Define a default value
-        embedApi: Boolean # Should we also create an embedded API from this (default false)
-        connection: Boolean # Treat this field as a connection type (default false - rolling this out slowly)
-
-        noRepeat: Boolean
+        onDelete: AutoGraphOnDeleteEnum # onDelete behavior
 
         authz: AutoGraphAuthzEnum # Access level used for authorization (default: private)
-        onDelete: AutoGraphOnDeleteEnum
 
-        enforce: [AutoGraphEnforceEnum!] #
-        transform: [AutoGraphTransformEnum!] # Transforms when serialize + deserialize
-        serialize: [AutoGraphTransformEnum!] # Transforms when serialize
-        deserialize: [AutoGraphTransformEnum!] # Transforms when deserialize
+        # Pipeline Structure
+        instruct: [AutoGraphPipelineEnum!]
+        destruct: [AutoGraphPipelineEnum!]
+        restruct: [AutoGraphPipelineEnum!]
+        construct: [AutoGraphPipelineEnum!]
+        serialize: [AutoGraphPipelineEnum!]
+        deserialize: [AutoGraphPipelineEnum!]
+        transform: [AutoGraphPipelineEnum!]
       ) on FIELD_DEFINITION | INPUT_FIELD_DEFINITION | SCALAR
 
       directive @link(
@@ -60,13 +59,6 @@ module.exports = (schema) => {
         use: AutoGraphMixed # The VALUE to use (default's to @link'd value); useful for many-to-many relationships
       ) on FIELD_DEFINITION
 
-      directive @value(
-        path: String! # The path to the data
-        # merge: Boolean # Deep merge the data? (default false - overwrite) [does not even look supported at the moment]
-        passive: Boolean # If value exists leave it alone (default false)
-        scope: AutoGraphValueScopeEnum # Where to look for the data (default self)
-      ) on OBJECT | FIELD_DEFINITION | INPUT_FIELD_DEFINITION | SCALAR
-
       directive @index(
         name: String
         on: [AutoGraphMixed!]!

package/src/graphql/extension/type.js

@@ -17,8 +17,8 @@ module.exports = (schema) => {
         return `
           extend type ${modelName}${interfacesGQL} {
             ${id ? `id: ID! @field(key: "${id}", gqlScope: r)` : ''}
-            ${createdAt ? `createdAt: AutoGraphDateTime @field(key: "${createdAt}", gqlScope: r)` : ''}
-            ${updatedAt ? `updatedAt: AutoGraphDateTime @field(key: "${updatedAt}", gqlScope: r)` : ''}
+            ${createdAt ? `createdAt: AutoGraphDateTime @field(key: "${createdAt}", serialize: createdAt, gqlScope: r)` : ''}
+            ${updatedAt ? `updatedAt: AutoGraphDateTime @field(key: "${updatedAt}", serialize: timestamp, gqlScope: r)` : ''}
           }
         `;
       }