@coderich/autograph 0.10.0 → 0.10.1

package/src/graphql/extension/api.js

@@ -1,7 +1,7 @@
 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, makeQueryResolver, makeMutationResolver } = require('../../service/decorator.service');
 
@@ -10,7 +10,6 @@ const interfaceKinds = [Kind.INTERFACE_TYPE_DEFINITION, Kind.INTERFACE_TYPE_EXTE
 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;
@@ -51,9 +50,9 @@ module.exports = (schema) => {
           ${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()}
@@ -133,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);
           },
         });
       }, {});
@@ -164,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
-        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!] #
-        resolve: [AutoGraphTransformEnum!] # Transforms when resolving
-        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)` : ''}
           }
         `;
       }

package/src/query/Query.js

@@ -1,15 +1,21 @@
 const Boom = require('../core/Boom');
-const { unravelObject } = require('../service/app.service');
 
 module.exports = class Query {
   constructor(props = {}) {
     this.props = {};
     this.timers = {};
+    this.isCursorPaging = false;
+    this.isClassicPaging = false;
     this.props.joins = this.props.joins || [];
     this.props.match = this.props.match || {};
     this.props.options = this.props.options || {};
-    this.isClassicPaging = false;
-    this.isCursorPaging = false;
+    this.props.flags = this.props.flags || {
+      debug: false,
+      silent: false,
+      validate: true, // { externals }
+      pipeline: true, // { instruct, construct, destruct, restruct, serialize, deserialize, transform, rekey }
+      required: false,
+    };
     this.merge(props);
   }
 
@@ -22,12 +28,19 @@ module.exports = class Query {
   id(id) {
     this.propCheck('id', 'where', 'native', 'sort', 'skip', 'limit', 'before', 'after', 'first', 'last');
     this.props.id = id;
+    this.props.batch = 'id';
+    this.props.where = { id };
     return this.match({ id });
   }
 
+  batch(batch) {
+    this.props.batch = batch;
+    return this;
+  }
+
   where(where) {
     this.propCheck('where', 'id', 'native');
-    this.props.where = unravelObject(where);
+    this.props.where = where;
     return this.match(where);
   }
 
@@ -44,12 +57,12 @@ module.exports = class Query {
   }
 
   match(match) {
-    this.props.match = unravelObject(match);
+    this.props.match = match;
     return this;
   }
 
   select(select) {
-    this.props.select = unravelObject(select);
+    this.props.select = select;
     return this;
   }
 
@@ -70,7 +83,7 @@ module.exports = class Query {
 
   sort(sort) {
     this.propCheck('sort', 'id');
-    this.props.sort = unravelObject(sort);
+    this.props.sort = sort;
     return this;
   }
 
@@ -142,7 +155,7 @@ module.exports = class Query {
   }
 
   flags(flags) {
-    this.props.flags = flags;
+    Object.assign(this.props.flags, flags);
     return this;
   }
 
@@ -161,6 +174,12 @@ module.exports = class Query {
 
   resolver(resolver) {
     this.props.resolver = resolver;
+    this.props.context = resolver.getContext();
+    return this;
+  }
+
+  context(context) {
+    this.props.context = context;
     return this;
   }
 
@@ -175,7 +194,7 @@ module.exports = class Query {
   }
 
   cmd(cmd) {
-    this.props.cmd = cmd;
+    this.props.cmd = cmd; // Terminal cmd from QueryBuilder
     return this;
   }
 
@@ -185,14 +204,32 @@ module.exports = class Query {
     switch (method) {
       case 'createOne': case 'createMany': {
         this.props.crud = 'create';
+        this.props.key = `create${this.props.model}`;
         break;
       }
       case 'updateOne': case 'updateMany': {
         this.props.crud = 'update';
+        this.props.key = `update${this.props.model}`;
         break;
       }
-      case 'deleteOne': case 'deleteMay': case 'removeOne': case 'removeMany': {
+      case 'deleteOne': case 'deleteMany': case 'removeOne': case 'removeMany': {
         this.props.crud = 'delete';
+        this.props.key = `delete${this.props.model}`;
+        break;
+      }
+      case 'count': {
+        this.props.crud = 'read';
+        this.props.key = `count${this.props.model}`;
+        break;
+      }
+      case 'findOne': {
+        this.props.crud = 'read';
+        this.props.key = `get${this.props.model}`;
+        break;
+      }
+      case 'findMany': {
+        this.props.crud = 'read';
+        this.props.key = `find${this.props.model}`;
         break;
       }
       default: {
@@ -209,6 +246,11 @@ module.exports = class Query {
     return this;
   }
 
+  key(key) {
+    this.props.key = key;
+    return this;
+  }
+
   input(input = {}) { // Allows .save(/* empty */);
     // delete input.id; // We do not want to allow changing id via input
     this.props.input = input;
@@ -241,10 +283,13 @@ module.exports = class Query {
   }
 
   clone() {
-    return new Query({ ...this.props });
+    const clone = new Query();
+    clone.props = { ...this.props };
+    return clone;
   }
 
   toDriver() {
+    const self = this;
     const { model } = this.props;
     const isSorted = Boolean(Object.keys(this.props.$sort || {}).length);
 
@@ -261,9 +306,22 @@ module.exports = class Query {
       skip: this.props.skip,
       limit: this.props.limit,
       first: isSorted ? this.props.first : undefined,
-      after: isSorted && this.props.after ? model.normalize(this, JSON.parse(Buffer.from(this.props.after, 'base64').toString('ascii')), 'serialize') : undefined,
       last: isSorted ? this.props.last : undefined,
-      before: isSorted && this.props.before ? model.normalize(this, JSON.parse(Buffer.from(this.props.before, 'base64').toString('ascii')), 'serialize') : undefined,
+      // before: isSorted && this.props.before ? model.normalize(this, JSON.parse(Buffer.from(this.props.before, 'base64').toString('ascii')), 'serialize') : undefined,
+      get before() {
+        if (!isSorted || !self.props.before) return undefined;
+        const shape = model.getShape('create', 'sort');
+        const before = JSON.parse(Buffer.from(self.props.before, 'base64').toString('ascii'));
+        const $before = model.shapeObject(shape, before, self);
+        return $before;
+      },
+      get after() {
+        if (!isSorted || !self.props.after) return undefined;
+        const shape = model.getShape('create', 'sort');
+        const after = JSON.parse(Buffer.from(self.props.after, 'base64').toString('ascii'));
+        const $after = model.shapeObject(shape, after, self);
+        return $after;
+      },
       options: this.props.options,
       input: this.props.$input,
       flags: this.props.flags,
@@ -278,7 +336,7 @@ module.exports = class Query {
 
   getCacheKey() {
     return {
-      // model: `${this.props.model}`,
+      cmd: this.props.cmd,
       method: this.props.method,
       where: this.props.match,
       search: this.props.search,

package/src/query/QueryBuilder.js

@@ -1,12 +1,12 @@
 const Query = require('./Query');
 const QueryResolver = require('./QueryResolver');
-const { toKeyObj, unravelObject } = require('../service/app.service');
+const { unravelObject } = require('../service/app.service');
 
 /*
 * QueryBuilder
 *
 * Facilitates the creation and execution of a Query. It provides a chainable API to build a query
-* plus a list of terminal commands to resolve the query.
+* plus a list of terminal commands to execute the query.
 */
 module.exports = class QueryBuilder {
   constructor(resolver, model) {
@@ -14,13 +14,13 @@ module.exports = class QueryBuilder {
 
     // Chainable commands
     this.id = (id) => { this.query.id(id); return this; };
-    // this.select = (select) => { this.query.select(select); return this; };
-    this.select = (select) => { this.query.select(Object.entries(toKeyObj(select)).reduce((prev, [key, value]) => Object.assign(prev, { [key.replace(/edges.node./g, '')]: !!value }), {})); return this; };
-    this.where = (where) => { this.query.where(where); return this; };
-    this.match = (match) => { this.query.match(match); return this; };
+    this.select = (select) => { this.query.select(unravelObject(select)); return this; };
+    // this.select = (select) => { this.query.select(Object.entries(toKeyObj(select)).reduce((prev, [key, value]) => Object.assign(prev, { [key.replace(/edges.node./g, '')]: !!value }), {})); return this; };
+    this.where = (where) => { this.query.where(unravelObject(where)); return this; };
+    this.match = (match) => { this.query.match(unravelObject(match)); return this; };
     this.native = (native) => { this.query.native(native); return this; };
-    this.sort = (sort) => { this.query.sort(sort); return this; };
-    this.sortBy = (sortBy) => { this.query.sort(sortBy); return this; };
+    this.sort = (sort) => { this.query.sort(unravelObject(sort)); return this; };
+    this.sortBy = (sortBy) => { this.query.sort(unravelObject(sortBy)); return this; };
     this.limit = (limit) => { this.query.limit(limit); return this; };
     this.skip = (skip) => { this.query.skip(skip); return this; };
     this.before = (cursor) => { this.query.before(cursor); return this; };
@@ -28,64 +28,72 @@ module.exports = class QueryBuilder {
     this.meta = (meta) => { this.query.meta(meta); return this; };
     this.flags = (flags) => { this.query.flags(flags); return this; };
     this.merge = (merge) => { this.query.merge(merge); return this; };
+    this.batch = (batch) => { this.query.batch(batch); return this; };
     this.transaction = (txn) => { this.query.transaction(txn); return this; };
 
     // Terminal commands
-    this.one = (...args) => this.resolve('one', args);
-    this.many = (...args) => this.resolve('many', args);
-    this.save = (...args) => this.resolve('save', args.map(arg => unravelObject(arg)));
-    this.delete = (...args) => this.resolve('delete', args);
-    this.remove = (...args) => this.resolve('remove', args);
+    this.one = (...args) => this.execute('one', args);
+    this.many = (...args) => this.execute('many', args);
+    this.save = (...args) => this.execute('save', args.map(arg => unravelObject(arg)));
+    this.delete = (...args) => this.execute('delete', args);
+    this.remove = (...args) => this.execute('remove', args);
+    this.resolve = (...args) => this.execute('resolve', args);
     //
-    this.count = (...args) => this.resolve('count', args);
-    this.push = (...args) => this.resolve('push', args.map(arg => unravelObject(arg)));
-    this.pull = (...args) => this.resolve('pull', args.map(arg => unravelObject(arg)));
-    this.splice = (...args) => this.resolve('splice', args.map(arg => unravelObject(arg)));
-    this.first = (...args) => { this.query.first(...args); return this.resolve('first', args); };
-    this.last = (...args) => { this.query.last(...args); return this.resolve('last', args); };
+    this.count = (...args) => this.execute('count', args);
+    this.push = (...args) => this.execute('push', args.map(arg => unravelObject(arg)));
+    this.pull = (...args) => this.execute('pull', args.map(arg => unravelObject(arg)));
+    this.splice = (...args) => this.execute('splice', args.map(arg => unravelObject(arg)));
+    this.first = (...args) => { this.query.first(...args); return this.execute('first', args); };
+    this.last = (...args) => { this.query.last(...args); return this.execute('last', args); };
     //
     // this.min = (...args) => this.makeTheCall(query, 'min', args);
     // this.max = (...args) => this.makeTheCall(query, 'max', args);
     // this.avg = (...args) => this.makeTheCall(query, 'avg', args);
+    // this.sum = (...args) => this.makeTheCall(query, 'sum', args); // Would sum be different than count?
     // // Food for thought...
     // this.archive = (...args) => this.makeTheCall(query, 'archive', args); // Soft Delete
     // this.stream = (...args) => this.makeTheCall(query, 'stream', args); // Stream records 1 by 1
-    // this.sum = (...args) => this.makeTheCall(query, 'sum', args); // Would sum be different than count?
     // this.rollup = (...args) => this.makeTheCall(query, 'rollup', args); // Like sum, but for nested attributes (eg. Person.rollupAuthoredChaptersPages)
   }
 
-  resolve(cmd, args) {
-    let method, crud, input = {};
-    let { flags = {} } = this.query.toObject();
+  execute(cmd, args) {
+    let method, crud, input, flags = {};
     const { id, where } = this.query.toObject();
 
     switch (cmd) {
+      case 'resolve': {
+        crud = 'read';
+        method = 'autoResolve';
+        break;
+      }
       case 'one': case 'many': {
         crud = 'read';
-        flags = args[0] || flags;
+        [flags] = args;
         method = cmd === 'one' ? 'findOne' : 'findMany';
         break;
       }
       case 'first': case 'last': {
         crud = 'read';
-        flags = args[1] || flags;
+        [, flags] = args;
         method = cmd;
         break;
       }
       case 'save': {
+        [input, flags] = args;
         crud = id || where ? 'update' : 'create';
-        if (crud === 'update') { method = id ? 'updateOne' : 'updateMany'; [input] = args; }
-        if (crud === 'create') { method = args.length < 2 ? 'createOne' : 'createMany'; input = args.length < 2 ? args[0] || {} : args; }
+        if (crud === 'update') { method = id ? 'updateOne' : 'updateMany'; }
+        if (crud === 'create') { method = Array.isArray(input) ? 'createMany' : 'createOne'; }
         break;
       }
       case 'push': case 'pull': case 'splice': {
+        // [target, input, flags] = args;
         crud = 'update'; // Your logic wants this to be a simple "update". Sub documents systemEvents will emit either "create" or "udpate"
         method = id ? `${cmd}One` : `${cmd}Many`;
         break;
       }
       case 'remove': case 'delete': {
         crud = 'delete';
-        flags = args[0] || flags;
+        [flags] = args;
         if (id) method = 'deleteOne';
         else if (where) method = 'deleteMany';
         else return Promise.reject(new Error('Remove requires an id() or where()'));
@@ -93,7 +101,7 @@ module.exports = class QueryBuilder {
       }
       case 'count': {
         crud = 'read';
-        flags = args[0] || flags;
+        [flags] = args;
         method = 'count';
         break;
       }
@@ -102,6 +110,6 @@ module.exports = class QueryBuilder {
       }
     }
 
-    return new QueryResolver(this.query.cmd(cmd).method(method).crud(crud).input(input).flags(flags).args(args)).resolve();
+    return new QueryResolver(this.query.method(method).cmd(cmd).crud(crud).input(input).flags(flags).args(args)).resolve();
   }
 };

package/src/query/QueryBuilderTransaction.js

@@ -6,7 +6,7 @@ module.exports = class QueryBuilderTransaction extends QueryBuilder {
     this.query.transaction(transaction);
   }
 
-  resolve(cmd, args) {
+  execute(cmd, args) {
     return new Promise((resolve, reject) => {
       this.theCall = { cmd, args, resolve, reject };
     });
@@ -15,10 +15,10 @@ module.exports = class QueryBuilderTransaction extends QueryBuilder {
   exec(options) {
     if (!this.theCall) return undefined;
 
-    this.query.options(options);
     const { cmd, args, resolve } = this.theCall;
+    this.query.options(options);
 
-    return super.resolve(cmd, args).then((result) => {
+    return super.execute(cmd, args).then((result) => {
       resolve(result);
       return result;
     });