@coderich/autograph 0.10.0 → 0.10.3

package/src/graphql/ast/Schema.js

@@ -1,141 +1,134 @@
 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 {
+/**
+ * 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) {
-    // Ensure schema
-    schema.resolvers = schema.resolvers || {};
-    schema.schemaDirectives = schema.schemaDirectives || {};
-    schema.context = schema.context || {};
-
-    //
-    super(schema.typeDefs);
-    this.schema = schema;
-    this.initialize();
+    super();
+    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);
-  }
-
-  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);
+    this.schema.typeDefs = { kind: Kind.DOCUMENT, definitions };
+    // validateSchema(this.schema);
     return this;
   }
 
-  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,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,51 @@ 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
         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
-        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
+        validate: [AutoGraphPipelineEnum!]
+        instruct: [AutoGraphPipelineEnum!]
+        restruct: [AutoGraphPipelineEnum!]
+        destruct: [AutoGraphPipelineEnum!]
+        construct: [AutoGraphPipelineEnum!]
+        transform: [AutoGraphPipelineEnum!]
+        normalize: [AutoGraphPipelineEnum!]
+        serialize: [AutoGraphPipelineEnum!]
+        deserialize: [AutoGraphPipelineEnum!]
       ) on FIELD_DEFINITION | INPUT_FIELD_DEFINITION | SCALAR
 
       directive @link(
@@ -60,13 +61,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}", construct: 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;
@@ -230,6 +272,16 @@ module.exports = class Query {
     return this;
   }
 
+  payload(payload) {
+    this.props.payload = payload;
+    return this;
+  }
+
+  result(result) {
+    this.props.result = result;
+    return this;
+  }
+
   $doc($doc) {
     this.props.$doc = $doc;
     return this;
@@ -241,10 +293,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 +316,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 +346,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,