@coderich/autograph 0.9.15 → 0.10.1

package/src/data/DataService.js

@@ -1,11 +1,19 @@
-const { remove } = require('lodash');
-const Boom = require('../core/Boom');
-const { isPlainObject, objectContaining, mergeDeep, map } = require('../service/app.service');
+const { get, remove } = require('lodash');
+const { map, isPlainObject, objectContaining, mergeDeep, ensureArray, keyPaths } = require('../service/app.service');
 
-exports.paginateResultSet = (rs, first, after, last, before) => {
+exports.paginateResultSet = (rs, query) => {
+  const { first, after, last, before, sort } = query.toObject();
+  const sortPaths = keyPaths(sort);
+  const limiter = first || last;
   let hasNextPage = false;
   let hasPreviousPage = false;
-  const limiter = first || last;
+
+  // Add $$cursor data
+  map(rs, (doc) => {
+    const sortValues = sortPaths.reduce((prv, path) => Object.assign(prv, { [path]: get(doc, path) }), {});
+    const sortJSON = JSON.stringify(sortValues);
+    doc.$$cursor = Buffer.from(sortJSON).toString('base64');
+  });
 
   // First try to take off the "bookends" ($gte | $lte)
   if (rs.length && rs[0].$$cursor === after) {
@@ -34,64 +42,57 @@ exports.paginateResultSet = (rs, first, after, last, before) => {
     }
   }
 
-  return { hasNextPage, hasPreviousPage };
+  // Add $$pageInfo data (hidden)
+  return Object.defineProperties(rs, {
+    $$pageInfo: {
+      get() {
+        return {
+          startCursor: get(rs, '0.$$cursor', ''),
+          endCursor: get(rs, `${rs.length - 1}.$$cursor`, ''),
+          hasPreviousPage,
+          hasNextPage,
+        };
+      },
+      enumerable: false,
+    },
+  });
 };
 
-/**
- * @param from <Array>
- * @param to <Array>
- */
-exports.spliceEmbeddedArray = (query, doc, key, from, to) => {
-  const { model } = query.toObject();
-  const field = model.getField(key);
-  const modelRef = field.getModelRef();
+exports.spliceEmbeddedArray = (array, from, to) => {
   const op = from && to ? 'edit' : (from ? 'pull' : 'push'); // eslint-disable-line no-nested-ternary
-  const promises = [];
-
-  // Can only splice arrays
-  if (!field || !field.isArray()) return Promise.reject(Boom.badRequest(`Cannot splice field '${key}'`));
-
-  // We have to deserialize because this normalizes the data (casting etc)
-  let $to = model.deserialize(query, { [key]: to })[key] || to;
-  const $from = model.deserialize(query, { [key]: from })[key] || from;
-
-  // If it's embedded we need to append default/create fields for insertion
-  if ($to && field.isEmbedded()) $to = $to.map(el => modelRef.appendDefaultFields(query, modelRef.appendCreateFields(el, true)));
 
   // Convenience so the user does not have to explicity type out the same value over and over to replace
-  if ($from && $from.length > 1 && $to && $to.length === 1) $to = Array.from($from).fill($to[0]);
-
-  // Traverse the document till we find the segment to modify (in place)
-  return key.split('.').reduce((prev, segment, i, arr) => {
-    if (prev == null) return prev;
+  if (from && from.length > 1 && to && to.length === 1) to = Array.from(from).fill(to[0]);
 
-    return map(prev, (data) => {
-      if (i < (arr.length - 1)) return data[segment]; // We have not found the target segment yet
-      data[segment] = data[segment] || []; // Ensuring target segment is an array
-
-      switch (op) {
-        case 'edit': {
-          data[segment].forEach((el, j) => {
-            $from.forEach((val, k) => {
-              if (objectContaining(el, val)) data[segment][j] = isPlainObject(el) ? mergeDeep(el, $to[k]) : $to[k];
-            });
-          });
-          break;
-        }
-        case 'push': {
-          data[segment].push(...$to);
-          break;
-        }
-        case 'pull': {
-          remove(data[segment], el => $from.find(val => objectContaining(el, val)));
-          break;
-        }
-        default: {
-          break;
-        }
-      }
+  switch (op) {
+    case 'edit': {
+      array.forEach((el, j) => {
+        ensureArray(from).forEach((val, k) => {
+          if (objectContaining(el, val)) array[j] = isPlainObject(el) ? mergeDeep(el, ensureArray(to)[k]) : ensureArray(to)[k];
+        });
+      });
+      break;
+    }
+    // case 'edit': {
+    //   ensureArray(from).forEach((f, i) => {
+    //     const t = ensureArray(to)[i];
+    //     const indexes = array.map((el, j) => (el === f ? j : -1)).filter(index => index !== -1);
+    //     indexes.forEach(index => (array[index] = t));
+    //   });
+    //   break;
+    // }
+    case 'push': {
+      array.push(...to);
+      break;
+    }
+    case 'pull': {
+      remove(array, el => from.find(val => objectContaining(el, val)));
+      break;
+    }
+    default: {
+      break;
+    }
+  }
 
-      return Promise.all(promises);
-    });
-  }, doc);
+  return array;
 };

package/src/data/Field.js

@@ -1,8 +1,9 @@
+const { isEmpty } = require('lodash');
 const Type = require('./Type');
 const Field = require('../graphql/ast/Field');
-const Rule = require('../core/Rule');
-const Transformer = require('../core/Transformer');
-const { map, uvl, isPlainObject, ensureArray } = require('../service/app.service');
+const Boom = require('../core/Boom');
+const Pipeline = require('./Pipeline');
+const { isPlainObject, ensureArray } = require('../service/app.service');
 
 module.exports = class extends Field {
   constructor(model, field) {
@@ -11,115 +12,89 @@ module.exports = class extends Field {
     this.model = model;
   }
 
-  cast(value) {
-    if (value == null) return value;
-    const casted = Transformer.cast(this.getType())(this, value);
-    return this.isArray() ? ensureArray(casted) : casted;
-  }
-
-  getRules() {
-    const rules = [];
-
-    Object.entries(this.getDirectiveArgs('field', {})).forEach(([key, value]) => {
-      if (!Array.isArray(value)) value = [value];
-      if (key === 'enforce') rules.push(...value.map(r => Rule.getInstances()[r]));
-    });
-
-    if (this.isRequired() && this.isPersistable() && !this.isVirtual()) rules.push(Rule.required());
+  getStructures() {
+    // Grab structures from the underlying type
+    const structures = this.type.getStructures();
+    const { isRequired, isPersistable, isVirtual, isPrimaryKeyId, isIdField } = this.props;
 
-    return rules.concat(this.type.getRules());
-  }
-
-  getTransformers() {
-    const transformers = [];
-
-    Object.entries(this.getDirectiveArgs('field', {})).forEach(([key, value]) => {
+    // Structures defined on the field
+    const $structures = Object.entries(this.getDirectiveArgs('field', {})).reduce((prev, [key, value]) => {
       if (!Array.isArray(value)) value = [value];
-      if (key === 'transform') transformers.push(...value.map(t => Transformer.getInstances()[t]));
-    });
-
-    return transformers.concat(this.type.getTransformers());
+      if (key === 'instruct') prev.instructs.unshift(...value.map(t => Pipeline[t]));
+      if (key === 'restruct') prev.restructs.unshift(...value.map(t => Pipeline[t]));
+      if (key === 'destruct') prev.destructs.unshift(...value.map(t => Pipeline[t]));
+      if (key === 'construct') prev.constructs.unshift(...value.map(t => Pipeline[t]));
+      if (key === 'serialize') prev.serializers.unshift(...value.map(t => Pipeline[t]));
+      if (key === 'deserialize') prev.deserializers.unshift(...value.map(t => Pipeline[t]));
+      if (key === 'transform') prev.transformers.unshift(...value.map(t => Pipeline[t]));
+      return prev;
+    }, structures);
+
+    // IDs (first - shift)
+    if (isPrimaryKeyId) $structures.serializers.unshift(Pipeline.idKey);
+    if (isIdField) $structures.$serializers.unshift(Pipeline.idField);
+
+    // Required (last - push)
+    if (isRequired && isPersistable && !isVirtual) $structures.serializers.push(Pipeline.required);
+
+    return $structures;
   }
 
-  getSerializers() {
-    const transformers = [];
-
-    Object.entries(this.getDirectiveArgs('field', {})).forEach(([key, value]) => {
-      if (!Array.isArray(value)) value = [value];
-      if (key === 'serialize') transformers.push(...value.map(t => Transformer.getInstances()[t]));
-    });
-
-    return transformers.concat(this.type.getSerializers());
-  }
-
-  getDeserializers() {
-    const transformers = [];
-
-    Object.entries(this.getDirectiveArgs('field', {})).forEach(([key, value]) => {
-      if (!Array.isArray(value)) value = [value];
-      if (key === 'deserialize') transformers.push(...value.map(t => Transformer.getInstances()[t]));
-    });
-
-    return transformers.concat(this.type.getDeserializers());
-  }
+  async validate(query, value) {
+    if (value == null) return value;
+    const { resolver } = query.toObject();
+    const { type, modelRef, isEmbedded } = this.props;
 
-  validate(query, value) {
-    const modelRef = this.getModelRef();
-    const rules = [...this.getRules()];
+    if (modelRef && !isEmbedded) {
+      const ids = Array.from(new Set(ensureArray(value).map(v => `${v}`)));
+      await resolver.match(type).where({ id: ids }).count().then((count) => {
+        // if (type === 'Category') console.log(ids, count);
+        if (count !== ids.length) throw Boom.notFound(`${type} Not Found`);
+      });
+    }
 
-    if (modelRef && !this.isEmbedded()) rules.push(Rule.ensureId());
+    if (modelRef && isPlainObject(ensureArray(value)[0])) return modelRef.validate(query, value); // Model delegation
 
-    return Promise.all(rules.map((rule) => {
-      return rule(this, value, query);
-    })).then((res) => {
-      if (modelRef && isPlainObject(ensureArray(value)[0])) return modelRef.validate(query, value); // Model delegation
-      return res;
-    });
+    return value;
   }
 
-  /**
-   * Ensures the value of the field via bound @value + transformations
-   */
-  transform(query, value, serdes = (() => { throw new Error('No Sir Sir SerDes!'); })()) {
-    // Determine value
-    const $value = serdes === 'serialize' ? this.resolveBoundValue(query, value) : uvl(value, this.getDefaultValue());
+  resolve(resolver, doc, args = {}) {
+    const { name, isArray, isScalar, isVirtual, isRequired, isEmbedded, modelRef, virtualField } = this.props;
+    const value = doc[name];
 
-    // Determine transformers
-    const transformers = [...(serdes === 'serialize' ? this.getSerializers() : this.getDeserializers()), ...this.getTransformers()];
+    // Default resolver return immediately!
+    if (isScalar || isEmbedded) return value;
 
-    // Transform
-    return transformers.reduce((prev, transformer) => {
-      return transformer(this, prev, query);
-    }, this.cast($value));
-  }
+    // Ensure where clause for DB lookup
+    args.where = args.where || {};
 
-  /**
-   * Ensures the value of the field is appropriate for the driver
-   */
-  serialize(query, value, minimal = false) {
-    const modelRef = uvl(this.getModelRef(), this.getType() === 'ID' ? this.model : undefined);
-    const isEmbedded = this.isEmbedded();
+    if (isArray) {
+      if (isVirtual) {
+        if (isEmpty(args.where)) args.batch = `${virtualField}`;
+        args.where[virtualField] = doc.id;
+        return resolver.match(modelRef).merge(args).many();
+      }
 
-    // If embedded, simply delgate
-    if (isEmbedded) return modelRef.serialize(query, value, minimal);
+      // Not a "required" query + strip out nulls
+      if (isEmpty(args.where)) args.batch = 'id';
+      args.where.id = value;
+      return resolver.match(modelRef).merge(args).many();
+    }
 
-    // Now, normalize and resolve
-    const $value = this.transform(query, value, 'serialize');
-    if (modelRef && !isEmbedded) return map($value, v => modelRef.idValue(v.id || v));
-    return $value;
-  }
+    if (isVirtual) {
+      if (isEmpty(args.where)) args.batch = `${virtualField}`;
+      args.where[virtualField] = doc.id;
+      return resolver.match(modelRef).merge(args).one();
+    }
 
-  deserialize(query, value) {
-    return this.transform(query, value, 'deserialize');
+    return resolver.match(modelRef).id(value).one({ required: isRequired });
   }
 
-  tform(query, value) {
-    // Determine transformers
-    const transformers = this.getTransformers();
-
-    // Transform
-    return transformers.reduce((prev, transformer) => {
-      return transformer(this, prev, query);
-    }, this.cast(value));
+  count(resolver, doc, args = {}) {
+    const { name, isVirtual, modelRef, virtualField } = this.props;
+    args.where = args.where || {};
+    if (isVirtual) args.where[virtualField] = doc.id;
+    else args.where.id = doc[name];
+    return resolver.match(modelRef).merge(args).count();
   }
 };

package/src/data/Model.js

@@ -1,6 +1,10 @@
+const Stream = require('stream');
 const Field = require('./Field');
+const Pipeline = require('./Pipeline');
 const Model = require('../graphql/ast/Model');
-const { map, ucFirst, ensureArray } = require('../service/app.service');
+const { paginateResultSet } = require('./DataService');
+const { eventEmitter } = require('../service/event.service');
+const { map, seek, deseek, ensureArray } = require('../service/app.service');
 
 module.exports = class extends Model {
   constructor(schema, model, driver) {
@@ -8,6 +12,7 @@ module.exports = class extends Model {
     this.driver = driver;
     this.fields = super.getFields().map(field => new Field(this, field));
     this.namedQueries = {};
+    this.shapesCache = new Map();
   }
 
   raw() {
@@ -43,140 +48,117 @@ module.exports = class extends Model {
     return this.referentials;
   }
 
+  validate(query, data) {
+    const { flags = {} } = query.toObject();
+    const { validate = true } = flags;
+
+    if (!validate) return Promise.resolve();
+
+    return Promise.all(this.getFields().map((field) => {
+      return Promise.all(ensureArray(map(data, (obj) => {
+        if (obj == null) return Promise.resolve();
+        return field.validate(query, obj[field.getKey()]);
+      })));
+    })).then(() => {
+      return eventEmitter.emit('validate', query);
+    });
+  }
+
   /**
-   * Called when creating a new document. Will add attributes such as id, createdAt, updatedAt
-   * while ensuring that all defaulted values are set appropriately
+   * Convenience method to deserialize data from a data source (such as a database)
    */
-  appendCreateFields(input, embed = false) {
-    // id, createdAt, updatedAt
-    const timestamp = new Date();
-    if (embed && !input.id && this.idKey()) input.id = this.idValue();
-    if (!input.createdAt) input.createdAt = timestamp;
-    input.updatedAt = timestamp;
-
-    // Generate embedded default values
-    this.getEmbeddedFields().filter(field => field.isPersistable()).forEach((field) => {
-      if (input[field]) map(input[field], v => field.getModelRef().appendCreateFields(v, true));
+  deserialize(mixed, query) {
+    const { flags = {} } = query.toObject();
+    const { pipeline = true } = flags;
+    const shape = this.getShape();
+
+    return new Promise((resolve, reject) => {
+      if (!(mixed instanceof Stream)) {
+        resolve(pipeline ? this.shapeObject(shape, mixed, query) : mixed);
+      } else {
+        const results = [];
+        mixed.on('data', (data) => { results.push(pipeline ? this.shapeObject(shape, data, query) : data); });
+        mixed.on('end', () => { resolve(results); });
+        mixed.on('error', reject);
+      }
+    }).then((results) => {
+      return results.length && pipeline ? paginateResultSet(results, query) : results;
     });
-
-    return input;
   }
 
-  appendUpdateFields(input, embed = false) {
-    // id, updatedAt
-    if (embed && !input.id && this.idKey()) input.id = this.idValue();
-    input.updatedAt = new Date();
+  getShape(crud = 'read', target = 'doc', paths = []) {
+    const cacheKey = `${crud}:${target}`;
+    if (this.shapesCache.has(cacheKey)) return this.shapesCache.get(cacheKey);
 
-    // Generate embedded default values
-    this.getEmbeddedFields().filter(field => field.isPersistable()).forEach((field) => {
-      if (input[field]) map(input[field], v => field.getModelRef().appendUpdateFields(v, field.isArray())); // Only embedded when it's an array (because then we'll ensure ids)
-    });
+    const serdes = crud === 'read' ? 'deserialize' : 'serialize';
+    const fields = serdes === 'deserialize' ? this.getSelectFields() : this.getPersistableFields();
+    const crudMap = { create: ['constructs'], update: ['restructs'], delete: ['destructs'], remove: ['destructs'] };
+    const crudKeys = crudMap[crud] || [];
 
-    return input;
-  }
+    const targetMap = {
+      doc: ['defaultValue', 'ensureArrayValue', 'castValue', ...crudKeys, `$${serdes}rs`, 'instructs', 'transformers', `${serdes}rs`],
+      where: ['castValue', `$${serdes}rs`, 'instructs'],
+    };
 
-  appendDefaultFields(query, input) {
-    this.getDefaultedFields().filter(field => field.isPersistable()).forEach((field) => {
-      input[field] = field.resolveBoundValue(query, input[field]);
-    });
+    const structureKeys = targetMap[target] || ['castValue'];
 
-    // Generate embedded default values
-    this.getEmbeddedFields().filter(field => field.isPersistable()).forEach((field) => {
-      map(input[field], v => field.getModelRef().appendDefaultFields(query, v));
-    });
+    // Create shape, recursive
+    const shape = fields.map((field) => {
+      const structures = field.getStructures();
+      const [key, name, type, isArray] = [field.getKey(), field.getName(), field.getType(), field.isArray(), field.isIdField()];
+      const [from, to] = serdes === 'serialize' ? [name, key] : [key, name];
+      const path = paths.concat(to);
+      const subShape = field.isEmbedded() ? field.getModelRef().getShape(crud, target, path) : null;
 
-    return input;
-  }
+      structures.castValue = Pipeline.castValue;
+      structures.defaultValue = Pipeline.defaultValue;
 
-  /**
-   * Serialize data from Domain Model to Data Model (where clause has special handling)
-   */
-  serialize(query, data, minimal = false) {
-    return this.transform(query, data, 'serialize', minimal);
-  }
+      structures.ensureArrayValue = ({ value }) => (value != null && isArray && !Array.isArray(value) ? [value] : value);
+      const transformers = structureKeys.reduce((prev, struct) => prev.concat(structures[struct]), []).filter(Boolean);
+      return { field, path, from, to, type, isArray, transformers, shape: subShape };
+    });
 
-  /**
-   * Deserialize data from Data Model to Domain Model
-   */
-  deserialize(query, data) {
-    return this.transform(query, data, 'deserialize');
-  }
+    // Adding useful shape info
+    shape.crud = crud;
+    shape.model = this;
+    shape.serdes = serdes;
 
-  /**
-   * Serializer/Deserializer
-   */
-  transform(query, data, serdes = (() => { throw new Error('No Sir Sir SerDes!'); })(), minimal = false) {
-    // Serialize always gets the bound values
-    const appendFields = (serdes === 'serialize' ? [...this.getBoundValueFields()] : []);
-
-    // Certain cases do not want custom serdes or defaults
-    if (!minimal) appendFields.push(...this[`get${ucFirst(serdes)}Fields`](), ...this.getDefaultFields());
-
-    // Transform all the data
-    return map(data, (doc) => {
-      // We want the appendFields + those in the data, deduped
-      const fields = [...new Set(appendFields.concat(Object.keys(doc).map(k => this.getField(k))))].filter(Boolean);
-
-      // Loop through the fields and delegate (renaming keys appropriately)
-      return fields.reduce((prev, field) => {
-        const [key, name] = serdes === 'serialize' ? [field.getKey(), field.getName()] : [field.getName(), field.getKey()];
-        prev[key] = field[serdes](query, doc[name], minimal);
-        return prev;
-      }, {});
-    });
+    // Cache and return
+    this.shapesCache.set(cacheKey, shape);
+    return shape;
   }
 
-  normalize(query, data, serdes = (() => { throw new Error('No Sir Sir SerDes!'); }), keysOnly = false) {
-    // Transform all the data
-    return map(data, (doc) => {
-      const fields = Object.keys(doc).map(k => this.getField(k)).filter(Boolean);
+  shapeObject(shape, obj, query, root) {
+    const { serdes, model } = shape;
+    const { context, doc = {} } = query.toObject();
 
-      // Loop through the fields and delegate (renaming keys appropriately)
-      return fields.reduce((prev, field) => {
-        const [key, name] = serdes === 'serialize' ? [field.getKey(), field.getName()] : [field.getName(), field.getKey()];
-        prev[key] = keysOnly ? doc[name] : field[serdes](query, doc[name], true);
-        return prev;
-      }, {});
-    });
-  }
+    return map(obj, (parent) => {
+      // "root" is the base of the object
+      root = root || parent;
 
-  validate(query, data) {
-    const normalized = this.deserialize(query, data);
+      // Lookup helper functions
+      const docPath = (p, hint) => seek(doc, p, hint); // doc is already serialized; so always a seek
+      const rootPath = (p, hint) => (serdes === 'serialize' ? seek(root, p, hint) : deseek(shape, root, p, hint));
+      const parentPath = (p, hint) => (serdes === 'serialize' ? seek(parent, p, hint) : deseek(shape, parent, p, hint));
 
-    return Promise.all(this.getFields().map((field) => {
-      return Promise.all(ensureArray(map(normalized, (obj) => {
-        if (obj == null) return Promise.resolve();
-        return field.validate(query, obj[field.getName()]);
-      })));
-    }));
-  }
+      return shape.reduce((prev, { field, from, to, path, type, isArray, defaultValue, transformers = [], shape: subShape }) => {
+        const startValue = parent[from];
 
-  tform(query, data) {
-    return map(data, (doc) => {
-      return Object.keys(doc).map(k => this.getField(k)).filter(Boolean).reduce((prev, curr) => {
-        const key = curr.getName();
-        const value = doc[key];
-        return Object.assign(prev, { [key]: curr.tform(query, value) });
-      }, {});
-    });
-  }
+        // Transform value
+        const transformedValue = transformers.reduce((value, t) => {
+          const v = t({ model, field, path, docPath, rootPath, parentPath, startValue, value, context });
+          return v === undefined ? value : v;
+        }, startValue);
 
-  getShape(serdes = 'deserialize', recursive = true) {
-    return this.getSelectFields().map((field) => {
-      const [from, to] = serdes === 'serialize' ? [field.getName(), field.getKey()] : [field.getKey(), field.getName()];
-      const shape = recursive && field.isEmbedded() ? field.getModelRef().getShape(serdes, recursive) : null;
-      return { from, to, type: field.getDataType(), isArray: field.isArray(), shape };
-    });
-  }
+        // if (`${field}` === 'searchability') console.log(startValue, transformedValue, transformers);
 
-  shape(data, serdes = (() => { throw new Error('No Sir Sir SerDes!'); }), shape) {
-    shape = shape || this.getShape(serdes);
+        // Determine if key should stay or be removed
+        if (transformedValue === undefined && !Object.prototype.hasOwnProperty.call(parent, from)) return prev;
 
-    return map(data, (doc) => {
-      return shape.reduce((prev, { from, to, shape: subShape }) => {
-        const value = doc[from];
-        if (value === undefined) return prev;
-        return Object.assign(prev, { [to]: subShape ? this.shape(value, serdes, subShape) : value });
+        // Rename key & assign value
+        prev[to] = (!subShape || transformedValue == null) ? transformedValue : this.shapeObject(subShape, transformedValue, query, root);
+
+        return prev;
       }, {});
     });
   }