@coderich/autograph 0.11.1 → 0.13.0

package/src/graphql/ast/Schema.js

@@ -1,133 +0,0 @@
-const FS = require('fs');
-const Glob = require('glob');
-const Merge = require('deepmerge');
-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');
-
-/**
- * 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) {
-    super();
-    this.schema = { typeDefs: [], resolvers: {}, schemaDirectives: {} };
-    if (schema) this.mergeSchema(schema);
-  }
-
-  /**
-   * 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;
-  }
-
-  /**
-   * Asynchronously load files from a given glob pattern and merge each schema
-   */
-  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));
-      });
-    });
-  }
-
-  /**
-   * 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);
-    return this;
-  }
-
-  /**
-   * 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;
-  }
-
-  /**
-   * 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
-      },
-    });
-
-    this.getModels().forEach(model => model.finalize());
-    this.schema.typeDefs = { kind: Kind.DOCUMENT, definitions };
-    return this;
-  }
-
-  toObject() {
-    return this.schema;
-  }
-
-  toString() {
-    return print(this.schema.typeDefs);
-  }
-};

package/src/graphql/ast/Type.js

@@ -1,26 +0,0 @@
-const Node = require('./Node');
-const { getTypeInfo } = require('../../service/graphql.service');
-
-const scalars = ['ID', 'String', 'Float', 'Int', 'Boolean'];
-
-module.exports = class Type extends Node {
-  getName() {
-    return getTypeInfo(this.ast).name;
-  }
-
-  isArray() {
-    return Boolean(getTypeInfo(this.ast).isArray);
-  }
-
-  isRequired(debug) {
-    return Boolean(getTypeInfo(this.ast, {}, false).isRequired);
-  }
-
-  isArrayElementRequired() {
-    return this.isArray() && Boolean(getTypeInfo(this.ast.type).isRequired);
-  }
-
-  isScalar() {
-    return scalars.indexOf(this.getName()) > -1;
-  }
-};

package/src/graphql/ast/TypeDefApi.js

@@ -1,93 +0,0 @@
-const { Kind, visit } = require('graphql');
-const Model = require('./Model');
-const Node = require('./Node');
-
-const operations = ['Query', 'Mutation', 'Subscription'];
-const modelKinds = [Kind.OBJECT_TYPE_DEFINITION, Kind.OBJECT_TYPE_EXTENSION, Kind.INTERFACE_TYPE_DEFINITION, Kind.INTERFACE_TYPE_EXTENSION];
-const inputKinds = [Kind.INPUT_OBJECT_TYPE_DEFINITION, Kind.INPUT_OBJECT_TYPE_EXTENSION];
-const scalarKinds = [Kind.SCALAR_TYPE_DEFINITION, Kind.SCALAR_TYPE_EXTENSION];
-const enumKinds = [Kind.ENUM_TYPE_DEFINITION, Kind.ENUM_TYPE_EXTENSION];
-
-module.exports = class TypeDefApi {
-  constructor() {
-    this.models = [];
-    this.scalars = [];
-    this.inputs = [];
-    this.enums = [];
-  }
-
-  initialize(typeDefs) {
-    this.models.length = 0;
-    this.scalars.length = 0;
-    this.inputs.length = 0;
-    this.enums.length = 0;
-
-    visit(typeDefs, {
-      enter: (node) => {
-        if (modelKinds.indexOf(node.kind) > -1 && operations.indexOf(node.name.value) === -1) {
-          this.models.push(new Model(this, node));
-        } else if (scalarKinds.indexOf(node.kind) > -1) {
-          this.scalars.push(new Node(node));
-        } else if (inputKinds.indexOf(node.kind) > -1) {
-          this.inputs.push(new Node(node));
-        } else if (enumKinds.indexOf(node.kind) > -1) {
-          this.enums.push(new Node(node));
-        }
-
-        return false; // Stop traversing this node
-      },
-    });
-
-    return this;
-  }
-
-  // Models
-  getModel(name) {
-    return this.models.find(m => m.getName() === 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 }), {});
-  }
-
-  getMarkedModels() {
-    return Object.values(this.models).filter(model => model.isMarkedModel());
-  }
-
-  getEntityModels() {
-    return Object.values(this.models).filter(model => model.isEntity());
-  }
-
-  // Definitions
-  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;
-  }
-};

package/src/graphql/extension/api.js

@@ -1,193 +0,0 @@
-const { get } = require('lodash');
-const { Kind } = require('graphql');
-const ServerResolver = require('../../core/ServerResolver');
-const { ucFirst, toGUID, fromGUID } = require('../../service/app.service');
-const { findGQLModels } = require('../../service/schema.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;
-    const modelRef = field.getModelRef();
-    if (modelRef && !modelRef.isEmbedded() && !modelRef.isEntity()) return false;
-    return true;
-  });
-};
-
-module.exports = (schema) => {
-  const resolver = new ServerResolver();
-  const allModels = schema.getModels();
-  const entityModels = schema.getEntityModels();
-  const markedModels = schema.getMarkedModels();
-  const createModels = findGQLModels('c', markedModels, allModels);
-  const readModels = findGQLModels('r', markedModels, allModels);
-  const updateModels = findGQLModels('u', markedModels, allModels);
-
-  return ({
-    typeDefs: [
-      ...createModels.map(model => `
-        input ${model.getName()}InputCreate {
-          ${model.getFields().filter(field => field.hasGQLScope('c') && !field.isVirtual()).map(field => `${field.getName()}: ${field.getGQLType('InputCreate')}`)}
-        }
-      `),
-
-      ...updateModels.map(model => `
-        input ${model.getName()}InputUpdate {
-          ${model.getFields().filter(field => field.hasGQLScope('u') && !field.isVirtual()).map(field => `${field.getName()}: ${field.getGQLType('InputUpdate')}`)}
-        }
-      `),
-
-      ...readModels.map(model => `
-        input ${model.getName()}InputWhere {
-          ${getGQLWhereFields(model).map(field => `${field.getName()}: ${field.getModelRef() ? `${ucFirst(field.getDataRef())}InputWhere` : 'AutoGraphMixed'}`)}
-        }
-        input ${model.getName()}InputSort {
-          ${getGQLWhereFields(model).map(field => `${field.getName()}: ${field.getModelRef() ? `${ucFirst(field.getDataRef())}InputSort` : 'SortOrderEnum'}`)}
-        }
-        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]
-        }
-        type ${model.getName()}Edge {
-          node: ${model.getName()}
-          cursor: String!
-        }
-      `),
-
-      ...entityModels.filter(model => model.hasGQLScope('s')).map(model => `
-        input ${model.getName()}SubscriptionInputFilter {
-          when: [SubscriptionWhenEnum!]! = [preEvent, postEvent]
-          where: ${model.getName()}SubscriptionInputWhere! = {}
-        }
-
-        input ${model.getName()}SubscriptionInputWhere {
-          ${getGQLWhereFields(model).map(field => `${field.getName()}: ${field.getModelRef() && !field.isFKReference() ? `${ucFirst(field.getDataRef())}InputWhere` : 'AutoGraphMixed'}`)}
-        }
-
-        type ${model.getName()}SubscriptionPayload {
-          event: ${model.getName()}SubscriptionPayloadEvent
-          query: ${model.getName()}SubscriptionQuery
-        }
-
-        type ${model.getName()}SubscriptionPayloadEvent {
-          crud: SubscriptionCrudEnum!
-          data: ${model.getName()}SubscriptionPayloadEventData!
-        }
-
-        type ${model.getName()}SubscriptionPayloadEventData {
-          ${getGQLWhereFields(model).map(field => `${field.getName()}: ${field.getSubscriptionType()}`)}
-        }
-
-        interface ${model.getName()}SubscriptionQuery {
-          ${model.getFields().filter(field => field.hasGQLScope('r')).map(field => `${field.getName()}: ${field.getPayloadType()}`)}
-        }
-
-        type ${model.getName()}Create implements ${model.getName()}SubscriptionQuery {
-          ${model.getFields().filter(field => field.hasGQLScope('r')).map(field => `${field.getName()}: ${field.getPayloadType()}`)}
-        }
-
-        type ${model.getName()}Update implements ${model.getName()}SubscriptionQuery {
-          ${model.getFields().filter(field => field.hasGQLScope('r')).map(field => `${field.getName()}: ${field.getPayloadType()}`)}
-        }
-      `),
-    ].concat([
-      `type PageInfo {
-        startCursor: String!
-        endCursor: String!
-        hasPreviousPage: Boolean!
-        hasNextPage: Boolean!
-      }`,
-
-      `type Query {
-        node(id: ID!): Node
-        ${entityModels.map(model => makeReadAPI(model.getName(), model))}
-      }`,
-
-      `type Mutation {
-        _noop: String
-        ${entityModels.map(model => makeCreateAPI(model.getName(), model))}
-        ${entityModels.map(model => makeUpdateAPI(model.getName(), model))}
-        ${entityModels.map(model => makeDeleteAPI(model.getName(), model))}
-      }`,
-
-      `type Subscription {
-        _noop: String
-        ${entityModels.map(model => makeSubscriptionAPI(model.getName(), model))}
-      }`,
-    ]),
-    resolvers: readModels.reduce((prev, model) => {
-      const modelName = model.getName();
-
-      // Default field resolvers
-      const fieldResolvers = model.getFields().filter(field => field.hasGQLScope('r')).reduce((def, field) => {
-        const fieldName = field.getName();
-        const isConnection = field.isConnection();
-
-        return Object.assign(def, {
-          [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 {
-                count: () => field.count(autograph.resolver, doc, args),
-                edges: () => field.resolve(autograph.resolver, doc, args),
-                pageInfo: () => field.resolve(autograph.resolver, doc, args),
-              };
-            }
-
-            return field.resolve(autograph.resolver, doc, args);
-          },
-        });
-      }, {});
-
-      if (model.isEntity() && model.hasGQLScope('s')) {
-        prev[`${model.getName()}SubscriptionQuery`] = {
-          __resolveType: root => root.__typename, // eslint-disable-line no-underscore-dangle
-          ...fieldResolvers,
-        };
-        prev[`${model.getName()}Create`] = fieldResolvers;
-        prev[`${model.getName()}Update`] = fieldResolvers;
-      }
-
-      return Object.assign(prev, {
-        [modelName]: fieldResolvers,
-        [`${modelName}Connection`]: {
-          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: (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: (doc, args, context, info) => {
-          const { id } = args;
-          const [modelName] = fromGUID(id);
-          const model = schema.getModel(modelName);
-          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;
-          });
-        },
-      }),
-
-      Mutation: entityModels.reduce((prev, model) => {
-        return Object.assign(prev, makeMutationResolver(model.getName(), model, resolver));
-      }, {}),
-    }),
-  });
-};

package/src/graphql/extension/framework.js

@@ -1,71 +0,0 @@
-const Pipeline = require('../../data/Pipeline');
-
-Pipeline.createPresets();
-
-module.exports = (schema) => {
-  return {
-    typeDefs: `
-      scalar AutoGraphMixed
-      scalar AutoGraphDriver
-      scalar AutoGraphDateTime @field(transform: toDate)
-      enum AutoGraphPipelineEnum { ${Object.keys(Pipeline).join(' ')} }
-      enum AutoGraphAuthzEnum { private protected public }
-      enum AutoGraphOnDeleteEnum { cascade nullify restrict defer }
-      enum AutoGraphIndexEnum { unique }
-
-      directive @model(
-        id: String # Specify db key (default "id")
-        key: String # Specify db table/collection name
-        driver: AutoGraphDriver # External data driver
-        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
-        authz: AutoGraphAuthzEnum # Access level used for authorization (default: private)
-        namespace: String # Logical grouping of models that can be globbed (useful for authz)
-      ) on OBJECT | INTERFACE
-
-      directive @field(
-        id: String # Specify the ModelRef this field FK References
-        ref: AutoGraphMixed # Specify the modelRef field's name (overrides isEmbedded)
-        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
-        gqlScope: AutoGraphMixed # Dictate how GraphQL API behaves
-        dalScope: AutoGraphMixed # Dictate how the DAL behaves
-        fieldScope: AutoGraphMixed # Dictate how a FIELD may use me
-        onDelete: AutoGraphOnDeleteEnum # onDelete behavior
-
-        authz: AutoGraphAuthzEnum # Access level used for authorization (default: private)
-
-        # Pipeline Structure
-        validate: [AutoGraphPipelineEnum!]
-        construct: [AutoGraphPipelineEnum!]
-        restruct: [AutoGraphPipelineEnum!]
-        destruct: [AutoGraphPipelineEnum!]
-        instruct: [AutoGraphPipelineEnum!]
-        normalize: [AutoGraphPipelineEnum!]
-        transform: [AutoGraphPipelineEnum!]
-        serialize: [AutoGraphPipelineEnum!]
-        deserialize: [AutoGraphPipelineEnum!]
-      ) on FIELD_DEFINITION | INPUT_FIELD_DEFINITION | SCALAR
-
-      directive @link(
-        to: AutoGraphMixed  # The MODEL to link to (default's to modelRef)
-        by: AutoGraphMixed! # The FIELD to match yourself by
-        use: AutoGraphMixed # The VALUE to use (default's to @link'd value); useful for many-to-many relationships
-      ) on FIELD_DEFINITION
-
-      directive @index(
-        name: String
-        on: [AutoGraphMixed!]!
-        type: AutoGraphIndexEnum!
-      ) repeatable on OBJECT
-    `,
-  };
-};

package/src/graphql/extension/type.js

@@ -1,34 +0,0 @@
-/**
- * Decorate Entity Models
- */
-module.exports = (schema) => {
-  return ({
-    typeDefs: schema.getMarkedModels().map((model) => {
-      const id = model.idKey();
-      const modelName = model.getName();
-      const createdAt = model.getDirectiveArg('model', 'createdAt', 'createdAt');
-      const updatedAt = model.getDirectiveArg('model', 'updatedAt', 'updatedAt');
-
-      if (model.getKind() === 'ObjectTypeDefinition' && (id || createdAt || updatedAt)) {
-        const interfaces = [];
-        if (id) interfaces.push('Node');
-        const interfacesGQL = interfaces.length ? ' implements'.concat(' ', interfaces.join(' & ')) : '';
-
-        return `
-          extend type ${modelName}${interfacesGQL} {
-            ${id ? `id: ID! @field(key: "${id}", gqlScope: r)` : ''}
-            ${createdAt ? `createdAt: AutoGraphDateTime @field(key: "${createdAt}", construct: createdAt, gqlScope: r)` : ''}
-            ${updatedAt ? `updatedAt: AutoGraphDateTime @field(key: "${updatedAt}", serialize: timestamp, gqlScope: r)` : ''}
-          }
-        `;
-      }
-
-      return '';
-    }).concat(`
-      interface Node { id: ID! }
-      enum SortOrderEnum { asc desc }
-      enum SubscriptionCrudEnum { create update delete } # Not going to support "read"
-      enum SubscriptionWhenEnum { preEvent postEvent }
-    `),
-  });
-};

package/src/query/QueryBuilderTransaction.js

@@ -1,26 +0,0 @@
-const QueryBuilder = require('./QueryBuilder');
-
-module.exports = class QueryBuilderTransaction extends QueryBuilder {
-  constructor(resolver, model, transaction) {
-    super(resolver, model);
-    this.query.transaction(transaction);
-  }
-
-  execute(cmd, args) {
-    return new Promise((resolve, reject) => {
-      this.theCall = { cmd, args, resolve, reject };
-    });
-  }
-
-  exec(options) {
-    if (!this.theCall) return undefined;
-
-    const { cmd, args, resolve } = this.theCall;
-    this.query.options(options);
-
-    return super.execute(cmd, args).then((result) => {
-      resolve(result);
-      return result;
-    });
-  }
-};