@coderich/autograph 0.10.0 → 0.10.1

package/src/core/SchemaDecorator.js

@@ -1,46 +0,0 @@
-const Model = require('../data/Model');
-const SchemaDecorator = require('../graphql/ast/SchemaDecorator');
-const { identifyOnDeletes } = require('../service/schema.service');
-const { createSystemEvent } = require('../service/event.service');
-
-// Export class
-module.exports = class extends SchemaDecorator {
-  constructor(schema, stores) {
-    super(schema);
-
-    // Create drivers
-    this.drivers = Object.entries(stores).reduce((prev, [key, value]) => {
-      const { Driver } = value;
-
-      return Object.assign(prev, {
-        [key]: {
-          dao: new Driver(value, this),
-          idKey: Driver.idKey,
-          idValue: Driver.idValue,
-        },
-      });
-    }, {});
-  }
-
-  setup() {
-    return createSystemEvent('Setup', this, () => {
-      const entities = this.models.filter(m => m.isEntity());
-
-      // Create model indexes
-      return Promise.all(entities.map(async (model) => {
-        const key = model.getKey();
-        const indexes = model.getIndexes();
-        const driver = model.getDriver();
-        if (driver.createCollection) await driver.createCollection(key);
-        return driver.createIndexes(key, indexes);
-      }));
-    });
-  }
-
-  initialize() {
-    super.initialize();
-    this.models = super.getModels().map(model => new Model(this, model, this.drivers[model.getDriverName()]));
-    this.models.forEach(model => model.referentialIntegrity(identifyOnDeletes(this.models, model)));
-    return this;
-  }
-};

package/src/core/Transformer.js

@@ -1,68 +0,0 @@
-const { get, set, uniqWith } = require('lodash');
-const { map, serialize, castCmp, hashObject } = require('../service/app.service');
-
-const instances = {};
-let allInstances;
-
-const jsStringMethods = [
-  'charAt', 'charCodeAt', 'codePointAt', 'concat', 'indexOf', 'lastIndexOf', 'localeCompare',
-  'normalize', 'padEnd', 'padStart', 'repeat', 'replace', 'search', 'slice', 'split', 'substr', 'substring',
-  'toLocaleLowerCase', 'toLocaleUpperCase', 'toLowerCase', 'toString', 'toUpperCase', 'trim', 'trimEnd', 'trimStart', 'raw',
-];
-
-class Transformer {
-  constructor(thunk, options = {}) {
-    const { ignoreNull = true, itemize = true } = (options || {});
-
-    return Object.defineProperty((field, val, query) => {
-      if (ignoreNull && val == null) return val;
-      if (ignoreNull && itemize) return map(val, v => thunk(field, v, query));
-      return thunk(field, val, query);
-    }, 'type', { value: 'transformer' });
-  }
-
-  static factory(name, thunk, options = {}) {
-    return Object.defineProperty(Transformer, name, {
-      value: (...args) => Object.defineProperty(new Transformer(thunk(...args), options), 'method', { value: name }),
-      writable: options.writable,
-      enumerable: options.enumerable,
-    })[name];
-  }
-
-  static extend(name, instance) {
-    const invalidArg = () => { throw new Error('Invalid argument; expected Transformer factory instance'); };
-    const { method = invalidArg(), type = invalidArg() } = instance;
-    if (type !== 'transformer' || !Transformer[method]) invalidArg();
-    return (instances[name] = instance);
-  }
-
-  static getInstances() {
-    if (allInstances) return allInstances;
-    const defaultTransformers = Object.entries(Transformer).map(([name, method]) => ({ name, instance: method() }));
-    const customTransformers = Object.entries(instances).map(([name, instance]) => ({ name, instance }));
-    const transformers = defaultTransformers.concat(customTransformers);
-    allInstances = transformers.reduce((prev, { name, instance }) => Object.assign(prev, { [name]: instance }), {});
-    return allInstances;
-  }
-}
-
-// Factory methods
-const enumerables = ['toLowerCase', 'toUpperCase', 'trim', 'trimEnd', 'trimStart', 'toString'];
-jsStringMethods.forEach(name => Transformer.factory(name, (...args) => (f, v) => String(v)[name](...args), { enumerable: enumerables.indexOf(name) > -1 }));
-Transformer.factory('toTitleCase', () => (f, v) => v.replace(/\w\S*/g, w => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()), { enumerable: true });
-Transformer.factory('toLocaleTitleCase', (...args) => (f, v) => v.replace(/\w\S*/g, w => w.charAt(0).toLocaleUpperCase(...args) + w.slice(1).toLocaleLowerCase()));
-Transformer.factory('toSentenceCase', () => (f, v) => v.charAt(0).toUpperCase() + v.slice(1), { enumerable: true });
-Transformer.factory('toLocaleSentenceCase', (...args) => (f, v) => v.charAt(0).toLocaleUpperCase(...args) + v.slice(1));
-Transformer.factory('toId', () => (f, v) => f.getModel().idValue(v), { enumerable: true });
-Transformer.factory('toArray', () => (f, v) => (Array.isArray(v) ? v : [v]), { itemize: false, enumerable: true });
-Transformer.factory('toDate', () => (f, v) => new Date(v), { enumerable: true, writable: true });
-Transformer.factory('dedupe', () => (f, a) => uniqWith(a, (b, c) => hashObject(b) === hashObject(c)), { ignoreNull: false, enumerable: true });
-Transformer.factory('dedupeBy', key => (f, a) => uniqWith(a, (b, c) => hashObject(b[key]) === hashObject(c[key])), { ignoreNull: false, enumerable: true });
-Transformer.factory('timestamp', () => (f, v) => Date.now(), { enumerable: true });
-Transformer.factory('first', () => (f, v) => (Array.isArray(v) ? v[0] : v), { enumerable: true });
-Transformer.factory('get', path => (f, v) => get(v, path), { enumerable: true });
-Transformer.factory('set', path => (f, v) => set({}, path, v), { enumerable: true });
-Transformer.factory('cast', type => (f, v) => castCmp(type, v));
-Transformer.factory('serialize', () => (f, v) => serialize(f, v));
-
-module.exports = Transformer;

package/src/data/Memoizer.js

@@ -1,39 +0,0 @@
-/**
- * Memoizer.
- *
- * Keeps a memoized cache of function call results; executing them once and reusing the result.
- *
- * @param {Object} src - the object|function to memoize
- * @param {Array} whitelist - whitelist of src methods to memoize (defaults to enumerable functions)
- */
-module.exports = class Memoizer {
-  constructor(src, whitelist = Object.keys(src).filter(k => typeof src[k] === 'function')) {
-    const cache = {};
-
-    return new Proxy(src, {
-      // This gets called when accessing properties of an object
-      get(target, prop, rec) {
-        const value = Reflect.get(target, prop, rec);
-
-        if (typeof value === 'function') {
-          if (whitelist.indexOf(prop) === -1) return value.bind(target);
-
-          return (...args) => {
-            const key = `${prop}:${JSON.stringify(args)}`;
-            cache[key] = Object.prototype.hasOwnProperty.call(cache, key) ? cache[key] : value.bind(target)(...args);
-            return cache[key];
-          };
-        }
-
-        return value;
-      },
-
-      // This gets called when src is a function
-      apply(target, thisArg, args) {
-        const key = JSON.stringify(args);
-        cache[key] = Object.prototype.hasOwnProperty.call(cache, key) ? cache[key] : target.call(thisArg, ...args);
-        return cache[key];
-      },
-    });
-  }
-};

package/src/data/ResultSet.js

@@ -1,205 +0,0 @@
-const { get } = require('lodash');
-const DataService = require('./DataService');
-const { map, ensureArray, keyPaths, mapPromise, toGUID, hashObject } = require('../service/app.service');
-
-module.exports = class ResultSet {
-  constructor(query, data, adjustForPagination = true) {
-    if (data == null) return data;
-    const { resolver, model, sort, first, after, last, before } = query.toObject();
-    const fields = model.getFields().filter(f => f.getName() !== 'id');
-
-    const rs = map(data, (doc) => {
-      if (doc == null || typeof doc !== 'object') return doc;
-
-      //
-      const cache = new Map();
-
-      const definition = fields.reduce((prev, field) => {
-        const key = field.getKey();
-        const name = field.getName();
-        const $name = `$${name}`;
-        const value = doc[key];
-
-        // Field attributes
-        prev[name] = {
-          get() {
-            if (cache.has(name)) return cache.get(name);
-            let $value = field.deserialize(query, value);
-            $value = $value != null && field.isEmbedded() ? new ResultSet(query.model(field.getModelRef()), $value, false) : $value;
-            cache.set(name, $value);
-            return $value;
-          },
-          set($value) {
-            cache.set(name, $value);
-          },
-          enumerable: true,
-          configurable: true, // Allows things like delete
-        };
-
-        // Hydrated field attributes
-        prev[`$${name}`] = {
-          get() {
-            return (args = {}) => {
-              // Ensure where clause
-              args.where = args.where || {};
-
-              // Cache
-              const cacheKey = `${$name}-${hashObject(args)}`;
-              if (cache.has(cacheKey)) return cache.get(cacheKey);
-
-              const promise = new Promise((resolve, reject) => {
-                (() => {
-                  const $value = this[name];
-
-                  if (field.isScalar() || field.isEmbedded()) return Promise.resolve($value);
-
-                  const modelRef = field.getModelRef();
-
-                  if (field.isArray()) {
-                    if (field.isVirtual()) {
-                      args.where[[field.getVirtualField()]] = this.id; // Is where[[field.getVirtualField()]] correct?
-                      return resolver.match(modelRef).merge(args).many();
-                    }
-
-                    // Not a "required" query + strip out nulls
-                    args.where.id = $value;
-                    return resolver.match(modelRef).merge(args).many();
-                  }
-
-                  if (field.isVirtual()) {
-                    args.where[[field.getVirtualField()]] = this.id;
-                    return resolver.match(modelRef).merge(args).one();
-                  }
-
-                  return resolver.match(modelRef).id($value).one({ required: field.isRequired() });
-                })().then((results) => {
-                  if (results == null) return field.resolve(query, results); // Allow field to determine
-                  return mapPromise(results, result => field.resolve(query, result)).then(() => results); // Resolve the inside fields but still return "results"!!!!
-                }).then((resolved) => {
-                  resolve(resolved);
-                }).catch((e) => {
-                  reject(e);
-                });
-              });
-
-              cache.set(cacheKey, promise);
-              return promise;
-            };
-          },
-          enumerable: false,
-        };
-
-        // Field count (let's assume it's a Connection Type - meaning dont try with anything else)
-        prev[`$${name}:count`] = {
-          get() {
-            return (q = {}) => {
-              q.where = q.where || {};
-              if (field.isVirtual()) q.where[field.getVirtualField()] = this.id;
-              else q.where.id = this[name];
-              return resolver.match(field.getModelRef()).merge(q).count();
-            };
-          },
-          enumerable: false,
-        };
-
-        return prev;
-      }, {
-        id: {
-          get() { return doc.id || doc[model.idKey()]; },
-          set(id) { doc.id = id; }, // Embedded array of documents need to set id
-          enumerable: true,
-        },
-
-        $id: {
-          get() { return toGUID(model.getName(), this.id); },
-          enumerable: false,
-        },
-
-        $$cursor: {
-          get() {
-            const sortPaths = keyPaths(sort);
-            const sortValues = sortPaths.reduce((prv, path) => Object.assign(prv, { [path]: get(this, path) }), {});
-            const sortJSON = JSON.stringify(sortValues);
-            return Buffer.from(sortJSON).toString('base64');
-          },
-          enumerable: false,
-        },
-
-        $$model: {
-          value: model,
-          enumerable: false,
-        },
-
-        $$isResultSetItem: {
-          value: true,
-          enumerable: false,
-        },
-
-        $$save: {
-          get() { return input => resolver.match(model).id(this.id).save({ ...this, ...input }); },
-          enumerable: false,
-        },
-
-        $$remove: {
-          get() { return () => resolver.match(model).id(this.id).remove(); },
-          enumerable: false,
-        },
-
-        $$delete: {
-          get() { return () => resolver.match(model).id(this.id).delete(); },
-          enumerable: false,
-        },
-
-        toObject: {
-          get() {
-            return () => map(this, obj => Object.entries(obj).reduce((prev, [key, value]) => {
-              if (value === undefined) return prev;
-              prev[key] = get(value, '$$isResultSet') ? value.toObject() : value;
-              return prev;
-            }, {}));
-          },
-          enumerable: false,
-          configurable: true,
-        },
-      });
-
-      // Create and return ResultSetItem
-      return Object.defineProperties({}, definition);
-    });
-
-    let hasNextPage = false;
-    let hasPreviousPage = false;
-    if (adjustForPagination && rs.length) (({ hasPreviousPage, hasNextPage } = DataService.paginateResultSet(rs, first, after, last, before)));
-
-    return Object.defineProperties(rs, {
-      $$pageInfo: {
-        get() {
-          const edges = ensureArray(rs);
-
-          return {
-            startCursor: get(edges, '0.$$cursor', ''),
-            endCursor: get(edges, `${edges.length - 1}.$$cursor`, ''),
-            hasPreviousPage,
-            hasNextPage,
-          };
-        },
-        enumerable: false,
-      },
-      $$isResultSet: {
-        value: true,
-        enumerable: false,
-      },
-      toObject: {
-        get() {
-          return () => map(this, doc => Object.entries(doc).reduce((prev, [key, value]) => {
-            if (value === undefined) return prev;
-            prev[key] = get(value, '$$isResultSet') ? value.toObject() : value;
-            return prev;
-          }, {}));
-        },
-        enumerable: false,
-        configurable: true,
-      },
-    });
-  }
-};

package/src/data/stream/DataHydrator.js

@@ -1,58 +0,0 @@
-const { get } = require('lodash');
-const Stream = require('stream');
-const ResultSet = require('./ResultSet');
-const ResultSetItem = require('./ResultSetItemProxy');
-const { promiseChain, mapPromise, toKeyObj } = require('../../service/app.service');
-
-module.exports = class DataHydrator {
-  constructor(query, data) {
-    let { select = {} } = query.toObject();
-    select = toKeyObj(select);
-    return data instanceof Stream ? DataHydrator.stream(query, data, select) : DataHydrator.process(query, data, select);
-  }
-
-  static stream(query, stream, select) {
-    const promises = [];
-
-    return new Promise((resolve, reject) => {
-      stream.on('data', (data) => {
-        promises.push(DataHydrator.hydrate(query, data, select));
-      });
-
-      stream.on('error', reject);
-
-      stream.on('end', () => {
-        Promise.all(promises).then(results => resolve(new ResultSet(query, results)));
-      });
-    });
-  }
-
-  static process(query, data, select) {
-    return mapPromise(data, d => DataHydrator.hydrate(query, d, select)).then(results => new ResultSet(query, results));
-  }
-
-  static hydrate(query, data, select) {
-    const loopArray = Array.from(new Array(Math.max(0, ...Object.keys(select).map(key => key.split('.').length))));
-
-    return new Promise((resolve, reject) => {
-      const item = new ResultSetItem(query, data);
-
-      return Promise.all(Object.keys(select).map((path) => {
-        const arrPath = path.split('.');
-
-        return Promise.all(loopArray.map((el, depth) => {
-          const arr = arrPath.slice(0, depth);
-          const $arr = arr.map(ele => `$${ele}`);
-          const key = arr[depth];
-
-          // id has special handling
-          if (!key || key === 'id') return Promise.resolve();
-
-          // Resolve all other attributes
-          get(item, arr.join('.'));
-          return promiseChain($arr.map($prop => chain => (chain.pop() || item)[$prop]()));
-        }));
-      })).then(() => resolve(item)).catch(e => reject(e));
-    });
-  }
-};

package/src/data/stream/ResultSet.js

@@ -1,34 +0,0 @@
-const { get } = require('lodash');
-const DataService = require('../DataService');
-const { ensureArray } = require('../../service/app.service');
-
-module.exports = class ResultSet {
-  constructor(query, data, adjustForPagination = true) {
-    if (data == null) return data;
-    const { first, after, last, before } = query.toObject();
-
-    let hasNextPage = false;
-    let hasPreviousPage = false;
-    if (adjustForPagination && data.length) (({ hasPreviousPage, hasNextPage } = DataService.paginateResultSet(data, first, after, last, before)));
-
-    return Object.defineProperties(data, {
-      $$pageInfo: {
-        get() {
-          const edges = ensureArray(data);
-
-          return {
-            startCursor: get(edges, '0.$$cursor', ''),
-            endCursor: get(edges, `${edges.length - 1}.$$cursor`, ''),
-            hasPreviousPage,
-            hasNextPage,
-          };
-        },
-        enumerable: false,
-      },
-      $$isResultSet: {
-        value: true,
-        enumerable: false,
-      },
-    });
-  }
-};

package/src/data/stream/ResultSetItem.js

@@ -1,158 +0,0 @@
-const { get } = require('lodash');
-const ResultSet = require('./ResultSet');
-const { map, keyPaths, mapPromise, toGUID, hashObject } = require('../../service/app.service');
-
-module.exports = class ResultSetItem {
-  constructor(query, doc) {
-    if (doc == null) return doc;
-
-    const cache = new Map();
-    const { resolver, model, sort } = query.toObject();
-    const fields = model.getFields().filter(f => f.getName() !== 'id');
-
-    const definition = fields.reduce((prev, field) => {
-      const name = field.getName();
-      const $name = `$${name}`;
-      const value = doc[name];
-
-      // Field attributes
-      prev[name] = {
-        get() {
-          if (cache.has(name)) return cache.get(name);
-          let $value = field.deserialize(query, value);
-
-          if ($value != null && field.isEmbedded()) {
-            const newModel = field.getModelRef();
-            const newQuery = query.model(newModel);
-            const newFields = newModel.getFields().filter(f => f.getName() !== 'id');
-            $value = new ResultSet(newQuery, map($value, v => new ResultSetItem(newQuery, v, newFields)), false);
-          }
-          cache.set(name, $value);
-          return $value;
-        },
-        set($value) {
-          cache.set(name, $value);
-        },
-        enumerable: true,
-        configurable: true, // Allows things like delete
-      };
-
-      // Hydrated field attributes
-      prev[`$${name}`] = {
-        get() {
-          return (args = {}) => {
-            // Ensure where clause
-            args.where = args.where || {};
-
-            // Cache
-            const cacheKey = `${$name}-${hashObject(args)}`;
-            if (cache.has(cacheKey)) return cache.get(cacheKey);
-
-            const promise = new Promise((resolve, reject) => {
-              (() => {
-                const $value = this[name];
-
-                if (field.isScalar() || field.isEmbedded()) return Promise.resolve($value);
-
-                const modelRef = field.getModelRef();
-
-                if (field.isArray()) {
-                  if (field.isVirtual()) {
-                    args.where[[field.getVirtualField()]] = this.id; // Is where[[field.getVirtualField()]] correct?
-                    return resolver.match(modelRef).merge(args).many();
-                  }
-
-                  // Not a "required" query + strip out nulls
-                  args.where.id = $value;
-                  return resolver.match(modelRef).merge(args).many();
-                }
-
-                if (field.isVirtual()) {
-                  args.where[[field.getVirtualField()]] = this.id;
-                  return resolver.match(modelRef).merge(args).one();
-                }
-
-                return resolver.match(modelRef).id($value).one({ required: field.isRequired() });
-              })().then((results) => {
-                if (results == null) return field.resolve(query, results); // Allow field to determine
-                return mapPromise(results, result => field.resolve(query, result)).then(() => results); // Resolve the inside fields but still return "results"!!!!
-              }).then((resolved) => {
-                resolve(resolved);
-              }).catch((e) => {
-                reject(e);
-              });
-            });
-
-            cache.set(cacheKey, promise);
-            return promise;
-          };
-        },
-        enumerable: false,
-      };
-
-      // Field count (let's assume it's a Connection Type - meaning dont try with anything else)
-      prev[`$${name}:count`] = {
-        get() {
-          return (q = {}) => {
-            q.where = q.where || {};
-            if (field.isVirtual()) q.where[field.getVirtualField()] = this.id;
-            else q.where.id = this[name];
-            return resolver.match(field.getModelRef()).merge(q).count();
-          };
-        },
-        enumerable: false,
-      };
-
-      return prev;
-    }, {
-      id: {
-        get() { return doc.id || doc[model.idKey()]; },
-        set(id) { doc.id = id; }, // Embedded array of documents need to set id
-        enumerable: true,
-      },
-
-      $id: {
-        get() { return toGUID(model.getName(), this.id); },
-        enumerable: false,
-      },
-
-      $$cursor: {
-        get() {
-          const sortPaths = keyPaths(sort);
-          const sortValues = sortPaths.reduce((prv, path) => Object.assign(prv, { [path]: get(this, path) }), {});
-          const sortJSON = JSON.stringify(sortValues);
-          return Buffer.from(sortJSON).toString('base64');
-        },
-        enumerable: false,
-      },
-
-      $$model: {
-        value: model,
-        enumerable: false,
-      },
-
-      $$isResultSetItem: {
-        value: true,
-        enumerable: false,
-      },
-
-      $$save: {
-        get() { return input => resolver.match(model).id(this.id).save({ ...this, ...input }); },
-        enumerable: false,
-      },
-
-      $$remove: {
-        get() { return () => resolver.match(model).id(this.id).remove(); },
-        enumerable: false,
-      },
-
-      $$delete: {
-        get() { return () => resolver.match(model).id(this.id).delete(); },
-        enumerable: false,
-      },
-    });
-
-    // Create and return ResultSetItem
-    return Object.defineProperties(this, definition);
-  }
-};