@coderich/autograph 0.12.0 → 0.13.1

package/src/data/Field.js

@@ -1,83 +0,0 @@
-const { isEmpty } = require('lodash');
-const Type = require('./Type');
-const Field = require('../graphql/ast/Field');
-const Pipeline = require('./Pipeline');
-
-module.exports = class extends Field {
-  constructor(model, field) {
-    super(model, JSON.parse(JSON.stringify((field.getAST()))));
-    this.type = new Type(field);
-    this.model = model;
-  }
-
-  getStructures() {
-    // Grab structures from the underlying type
-    const structures = this.type.getStructures();
-    const { type, isPrimaryKeyId, isIdField, isRequired, isPersistable, isVirtual, isEmbedded, modelRef } = this.props;
-
-    // Structures defined on the field
-    const $structures = Object.entries(this.getDirectiveArgs('field', {})).reduce((prev, [key, value]) => {
-      if (!Array.isArray(value)) value = [value];
-      if (key === 'validate') prev.validators.push(...value.map(t => Pipeline[t]));
-      if (key === 'instruct') prev.instructs.push(...value.map(t => Pipeline[t]));
-      if (key === 'restruct') prev.restructs.push(...value.map(t => Pipeline[t]));
-      if (key === 'destruct') prev.destructs.push(...value.map(t => Pipeline[t]));
-      if (key === 'construct') prev.constructs.push(...value.map(t => Pipeline[t]));
-      if (key === 'transform') prev.transforms.push(...value.map(t => Pipeline[t]));
-      if (key === 'normalize') prev.normalizers.push(...value.map(t => Pipeline[t]));
-      if (key === 'serialize') prev.serializers.push(...value.map(t => Pipeline[t]));
-      if (key === 'deserialize') prev.deserializers.push(...value.map(t => Pipeline[t]));
-      return prev;
-    }, structures);
-
-    // IDs (first - shift)
-    if (isPrimaryKeyId && type === 'ID') $structures.serializers.unshift(Pipeline.idKey);
-    if (isIdField) $structures.$serializers.unshift(Pipeline.idField);
-
-    // Required (last - push)
-    if (isRequired && isPersistable && !isVirtual) $structures.validators.push(Pipeline.required);
-    if (modelRef && !isEmbedded) $structures.validators.push(Pipeline.ensureId);
-
-    return $structures;
-  }
-
-  resolve(resolver, doc, args = {}) {
-    const { name, isArray, isScalar, isVirtual, isRequired, isEmbedded, modelRef, virtualField } = this.props;
-    const value = doc[name];
-
-    // Default resolver return immediately!
-    if (isScalar || isEmbedded) return value;
-
-    // Ensure where clause for DB lookup
-    args.where = args.where || {};
-
-    if (isArray) {
-      if (isVirtual) {
-        if (isEmpty(args.where)) args.batch = `${virtualField}`;
-        args.where[virtualField] = doc.id;
-        return resolver.match(modelRef).merge(args).many();
-      }
-
-      // 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();
-    }
-
-    if (isVirtual) {
-      if (isEmpty(args.where)) args.batch = `${virtualField}`;
-      args.where[virtualField] = doc.id;
-      return resolver.match(modelRef).merge(args).one();
-    }
-
-    return resolver.match(modelRef).id(value).one({ required: isRequired });
-  }
-
-  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,214 +0,0 @@
-const Stream = require('stream');
-const Field = require('./Field');
-const Model = require('../graphql/ast/Model');
-const { eventEmitter } = require('../service/event.service');
-const { finalizeResults } = require('./DataService');
-const { map, mapPromise, seek, deseek } = require('../service/app.service');
-
-module.exports = class extends Model {
-  constructor(schema, model, driver) {
-    super(schema, JSON.parse(JSON.stringify((model.getAST()))));
-    this.driver = driver;
-    this.fields = super.getFields().map(field => new Field(this, field));
-    this.namedQueries = {};
-    this.shapesCache = new Map();
-  }
-
-  raw() {
-    return this.driver.dao.raw(this.getKey());
-  }
-
-  drop() {
-    return this.driver.dao.dropModel(this.getKey());
-  }
-
-  idValue(id) {
-    return this.driver.idValue(id);
-  }
-
-  idKey() {
-    return this.getDirectiveArg('model', 'id', this.driver.idKey());
-  }
-
-  getDriver() {
-    return this.driver.dao;
-  }
-
-  createNamedQuery(name, fn) {
-    this.namedQueries[name] = fn;
-  }
-
-  getNamedQueries(name) {
-    return this.namedQueries;
-  }
-
-  referentialIntegrity(refs) {
-    if (refs) this.referentials = refs;
-    return this.referentials;
-  }
-
-  /**
-   * Convenience method to deserialize data from a data source (such as a database)
-   */
-  deserialize(mixed, query) {
-    const shape = this.getShape();
-
-    return new Promise((resolve, reject) => {
-      if (!(mixed instanceof Stream)) {
-        resolve(this.shapeObject(shape, mixed, query));
-      } else {
-        const results = [];
-        mixed.on('data', (data) => { results.push(this.shapeObject(shape, data, query)); });
-        mixed.on('end', () => { resolve(results); });
-        mixed.on('error', reject);
-      }
-    }).then(rs => finalizeResults(rs, query));
-  }
-
-  getShape(crud = 'read', target = 'doc', paths = [], depth = 0) {
-    if (depth++ > 10) return {}; // Prevent infinite circular references
-
-    // Cache check
-    const cacheKey = `${crud}:${target}`;
-    if (this.shapesCache.has(cacheKey)) return this.shapesCache.get(cacheKey);
-
-    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 sortKeys = ['isIdField', 'isBasicType', 'isEmbedded'];
-    const crudKeys = crudMap[crud] || [];
-
-    // Define target mapping
-    const targetMap = {
-      doc: ['defaultValue', 'castValue', 'ensureArrayValue', 'normalizers', 'instructs', ...crudKeys, `$${serdes}rs`, `${serdes}rs`, 'transforms'],
-      input: ['defaultValue', 'castValue', 'ensureArrayValue', 'normalizers', 'instructs', ...crudKeys, `$${serdes}rs`, `${serdes}rs`, 'transforms'],
-      // input: ['defaultValue', 'castValue', 'ensureArrayValue'],
-      where: ['castValue', 'instructs', `$${serdes}rs`],
-    };
-
-    const structureKeys = targetMap[target] || ['castValue'];
-
-    // Create sorted shape, recursive
-    const shape = fields.sort((a, b) => {
-      const aObject = a.toObject();
-      const bObject = b.toObject();
-
-      // PK first
-      if (aObject.isPrimaryKeyId) return -1;
-      if (bObject.isPrimaryKeyId) return 1;
-
-      // Arrays last
-      if (aObject.isArray && !bObject.isArray) return 1;
-      if (bObject.isArray && !aObject.isArray) return -1;
-
-      // Now, follow sort keys
-      const aNum = sortKeys.findIndex(key => aObject[key]);
-      const bNum = sortKeys.findIndex(key => bObject[key]);
-      if (aNum < bNum) return -1;
-      if (aNum > bNum) return 1;
-      return 0;
-    }).map((field) => {
-      let instructed = false;
-      const structures = field.getStructures();
-      const { key, name, type, isArray, isEmbedded, modelRef } = field.toObject();
-      const [from, to] = serdes === 'serialize' ? [name, key] : [key, name];
-      const actualTo = target === 'input' || target === 'splice' ? from : to;
-      const path = paths.concat(actualTo);
-      const subCrud = crud === 'update' && isArray ? 'create' : crud; // Due to limitation to update embedded array
-      const subShape = isEmbedded ? modelRef.getShape(subCrud, target, path, depth) : null;
-      const transformers = structureKeys.reduce((prev, struct) => {
-        const structs = structures[struct];
-        if (struct === 'instructs' && structs.length) instructed = true;
-        return prev.concat(structs);
-      }, []).filter(Boolean);
-      return { instructed, field, path, from, to: actualTo, type, isArray, transformers, validators: structures.validators, shape: subShape };
-    });
-
-    // Adding useful shape info
-    shape.crud = crud;
-    shape.model = this;
-    shape.serdes = serdes;
-    shape.target = target;
-
-    // Cache and return
-    this.shapesCache.set(cacheKey, shape);
-    return shape;
-  }
-
-  shapeObject(shape, obj, query, root, base) {
-    const { serdes, model } = shape;
-    const { context, resolver, doc = {}, flags = {} } = query.toObject();
-    const { pipeline } = flags;
-
-    if (!pipeline) return obj;
-    // const filters = pipeline === true ? [] : Object.entries(pipeline).map(([k, v]) => (v === false ? k : null)).filter(Boolean);
-
-    // base is the base model
-    base = base || model;
-
-    return map(obj, (parent) => {
-      // root is the base data object
-      root = root || parent;
-
-      // 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 shape.reduce((prev, { instructed, field, from, to, path, type, isArray, defaultValue, transformers = [], shape: subShape }) => {
-        const startValue = parent[from];
-        // transformers = filters.length ? transformers.filter() : transformers;
-
-        // Transform value
-        const transformedValue = transformers.reduce((value, t) => {
-          const v = t({ base, model, field, path, docPath, rootPath, parentPath, startValue, value, resolver, context });
-          return v === undefined ? value : v;
-        }, startValue);
-
-        // Determine if key should stay or be removed
-        if (!instructed && transformedValue === undefined && !Object.prototype.hasOwnProperty.call(parent, from)) return prev;
-        if (!instructed && subShape && typeof transformedValue !== 'object') return prev;
-
-        // Rename key & assign value
-        prev[to] = (!subShape || transformedValue == null) ? transformedValue : this.shapeObject(subShape, transformedValue, query, root, base);
-
-        return prev;
-      }, {});
-    });
-  }
-
-  validateObject(shape, obj, query, root, base, silent = false) {
-    const { model } = shape;
-    const { context, resolver, doc = {}, flags = {} } = query.toObject();
-    const { validate = true } = flags;
-
-    if (!validate) return Promise.resolve();
-
-    // base is the base model
-    base = base || model;
-
-    return mapPromise(obj, (parent) => {
-      // root is the base data object
-      root = root || parent;
-
-      // Lookup helper functions
-      const docPath = (p, hint) => seek(doc, p, hint);
-      const rootPath = (p, hint) => seek(root, p, hint);
-      const parentPath = (p, hint) => seek(parent, p, hint);
-
-      return Promise.all(shape.map(({ field, from, path, validators, shape: subShape }) => {
-        const value = parent[from]; // It hasn't been shaped yet
-
-        return Promise.all(validators.map((v) => {
-          return new Promise((resolve, reject) => {
-            return Promise.resolve(v({ base, model, field, path, docPath, rootPath, parentPath, startValue: value, value, resolver, context })).then(resolve).catch(reject);
-          });
-        })).then(() => {
-          return subShape ? this.validateObject(subShape, value, query, root, base, true) : Promise.resolve();
-        });
-      }));
-    }).then(() => {
-      return silent ? Promise.resolve() : eventEmitter.emit('validate', query.toObject());
-    });
-  }
-};

package/src/data/TreeMap.js

@@ -1,78 +0,0 @@
-/**
- * TreeMap.
- *
- * A utility class to help build and access elements in a tree-like structure. Used
- * primarly when handling nested transactions.
- */
-module.exports = class TreeMap {
-  constructor() {
-    this.map = new Map();
-    this.throw = (e = 'Parent not found') => { throw new Error(e); };
-  }
-
-  add(parent, child) {
-    if (parent && child) {
-      const [, map] = this.get(parent) || this.throw();
-      map.set(child, new Map());
-    } else {
-      this.map.set(parent || child, new Map());
-    }
-  }
-
-  get(parent, map = this.map) {
-    if (map.has(parent)) return [map, map.get(parent)];
-
-    return Array.from(map.values()).reduce((value, child) => {
-      if (value) return value;
-      return this.get(parent, child);
-    }, undefined);
-  }
-
-  remove(parent) {
-    const [map] = this.get(parent) || this.throw();
-    const el = map.get(parent);
-    map.delete(parent);
-    return el;
-  }
-
-  elements(map = this.map) {
-    return Array.from(map.entries()).reduce((prev, [key, value]) => {
-      return prev.concat(key).concat(this.elements(value));
-    }, []);
-  }
-
-  root(parent) {
-    const [root = parent] = this.ascendants(parent);
-    return root;
-  }
-
-  ascendants(parent) {
-    if (!this.get(parent)) this.throw();
-
-    const traverse = (e) => {
-      return Array.from(e.entries()).reduce((prev, [key, value]) => {
-        const descendants = this.descendants(key);
-        if (descendants.indexOf(parent) > -1) prev.push(key);
-        return prev.concat(traverse(value));
-      }, []);
-    };
-
-    return traverse(this.map);
-  }
-
-  descendants(parent) {
-    const [, map] = this.get(parent) || this.throw();
-    return this.elements(map);
-  }
-
-  siblings(parent) {
-    const [map] = this.get(parent) || this.throw();
-    if (map === this.map) return [];
-    return Array.from(map.keys()).filter(node => node !== parent);
-  }
-
-  lineage(parent) {
-    const root = this.root(parent);
-    return [root].concat(this.descendants(root));
-  }
-};

package/src/data/Type.js

@@ -1,50 +0,0 @@
-const Type = require('../graphql/ast/Type');
-const Pipeline = require('./Pipeline');
-
-module.exports = class extends Type {
-  constructor(field) {
-    super(field.getAST());
-    this.field = field;
-  }
-
-  getStructures() {
-    const type = this.field.getType();
-    const enumType = this.field.getEnumRef();
-    const scalarType = this.field.getScalarRef();
-    const structures = {
-      validators: [],
-      instructs: [],
-      restructs: [],
-      destructs: [],
-      constructs: [],
-      normalizers: [],
-      $serializers: [],
-      $deserializers: [],
-      serializers: [],
-      deserializers: [],
-      transforms: [],
-    };
-
-    // Built-in pipelines
-    structures.castValue = Pipeline.castValue;
-    structures.defaultValue = Pipeline.defaultValue;
-    structures.ensureArrayValue = Pipeline.ensureArrayValue;
-
-    if (enumType) structures.validators.push(Pipeline.define(`allow:${type}`, Pipeline.Allow(...enumType.getValue()), { configurable: true }));
-    if (!scalarType) return structures;
-
-    return Object.entries(scalarType.getDirectiveArgs('field', {})).reduce((prev, [key, value]) => {
-      if (!Array.isArray(value)) value = [value];
-      if (key === 'validate') prev.validators.push(...value.map(t => Pipeline[t]));
-      if (key === 'instruct') prev.instructs.push(...value.map(t => Pipeline[t]));
-      if (key === 'restruct') prev.restructs.push(...value.map(t => Pipeline[t]));
-      if (key === 'destruct') prev.destructs.push(...value.map(t => Pipeline[t]));
-      if (key === 'construct') prev.constructs.push(...value.map(t => Pipeline[t]));
-      if (key === 'transform') prev.transforms.push(...value.map(t => Pipeline[t]));
-      if (key === 'normalize') prev.normalizers.push(...value.map(t => Pipeline[t]));
-      if (key === 'serialize') prev.serializers.push(...value.map(t => Pipeline[t]));
-      if (key === 'deserialize') prev.deserializers.push(...value.map(t => Pipeline[t]));
-      return prev;
-    }, structures);
-  }
-};

package/src/driver/MongoDriver.js

@@ -1,227 +0,0 @@
-const Util = require('util');
-const Flat = require('flat');
-const { get } = require('lodash');
-const { MongoClient, ObjectId } = require('mongodb');
-const { map, ensureArray, proxyDeep, toKeyObj, globToRegex, proxyPromise, isScalarDataType, promiseRetry } = require('../service/app.service');
-
-module.exports = class MongoDriver {
-  constructor(config) {
-    this.config = config;
-    this.connection = this.connect();
-    this.getDirectives = () => get(config, 'directives', {});
-  }
-
-  connect() {
-    const { uri, options = {} } = this.config;
-    options.ignoreUndefined = false;
-    return MongoClient.connect(uri, options);
-  }
-
-  disconnect() {
-    return this.connection.then(client => client.close());
-  }
-
-  raw(collection) {
-    return proxyPromise(this.connection.then(client => client.db().collection(collection)));
-  }
-
-  query(collection, method, ...args) {
-    if (get(args[args.length - 1], 'debug') === true) console.log(collection, method, Util.inspect(args, { depth: null, showHidden: false, colors: true }));
-    if (method === 'aggregate') args.splice(2);
-    return this.raw(collection)[method](...args);
-  }
-
-  resolve(query) {
-    const { isNative } = query;
-    if (!isNative) query.where = MongoDriver.normalizeWhere(query.where);
-    return this[query.method](query);
-  }
-
-  findOne(query) {
-    return this.findMany(Object.assign(query, { first: 1 })).then((stream) => {
-      return new Promise((resolve, reject) => {
-        stream.on('data', resolve);
-        stream.on('error', reject);
-        stream.on('end', resolve);
-      });
-    });
-  }
-
-  findMany(query) {
-    const { model, options = {}, flags } = query;
-    Object.assign(options, this.config.query || {});
-    return this.query(model, 'aggregate', MongoDriver.aggregateQuery(query), options, flags).then(cursor => cursor.stream());
-  }
-
-  count(query) {
-    const { model, options = {}, flags } = query;
-    Object.assign(options, this.config.query || {});
-
-    return this.query(model, 'aggregate', MongoDriver.aggregateQuery(query, true), options, flags).then((cursor) => {
-      return cursor.next().then((doc) => {
-        return doc ? doc.count : 0;
-      });
-    });
-  }
-
-  createOne({ model, input, options, flags }) {
-    return this.query(model, 'insertOne', input, options, flags).then(result => Object.assign(input, { id: result.insertedId }));
-  }
-
-  updateOne({ model, where, $doc, options, flags }) {
-    const $update = { $set: Flat.flatten($doc, { safe: true }) };
-    return this.query(model, 'updateOne', where, $update, options, flags).then(() => $doc);
-  }
-
-  deleteOne({ model, where, options, flags }) {
-    return this.query(model, 'deleteOne', where, options, flags).then(() => true);
-  }
-
-  dropModel(model) {
-    return this.query(model, 'deleteMany');
-  }
-
-  createCollection(model) {
-    return this.connection.then(client => client.db().createCollection(model)).catch(e => null);
-  }
-
-  createIndexes(model, indexes) {
-    return Promise.all(indexes.map(({ name, type, on }) => {
-      const $fields = on.reduce((prev, field) => Object.assign(prev, { [field]: 1 }), {});
-
-      switch (type) {
-        case 'unique': return this.query(model, 'createIndex', $fields, { name, unique: true });
-        default: return null;
-      }
-    }));
-  }
-
-  transaction(ops) {
-    const promise = async () => {
-      // Create session and start transaction
-      const session = await this.connection.then(client => client.startSession({ readPreference: { mode: 'primary' } }));
-      session.startTransaction({ readConcern: { level: 'snapshot' }, writeConcern: { w: 'majority' } });
-      const close = () => { session.endSession(); };
-
-      // Execute each operation with session
-      return Promise.all(ops.map(op => op.exec({ session }))).then((results) => {
-        results.$commit = () => session.commitTransaction().then(close);
-        results.$rollback = () => session.abortTransaction().then(close);
-        return results;
-      }).catch((e) => {
-        close();
-        throw e;
-      });
-    };
-
-    // Retry promise conditionally
-    return promiseRetry(promise, 200, 5, e => e.errorLabels && e.errorLabels.indexOf('TransientTransactionError') > -1);
-  }
-
-  static idKey() {
-    return '_id';
-  }
-
-  static idValue(value) {
-    if (value instanceof ObjectId) return value;
-
-    try {
-      const id = ObjectId(value);
-      return id;
-    } catch (e) {
-      return value;
-    }
-  }
-
-  static normalizeWhere(where) {
-    return proxyDeep(toKeyObj(where), {
-      get(target, prop, rec) {
-        const value = Reflect.get(target, prop, rec);
-        if (typeof value === 'function') return value.bind(target);
-        const $value = map(value, v => (typeof v === 'string' ? globToRegex(v, { nocase: true, regex: true }) : v));
-        if (Array.isArray($value)) {
-          // console.log(Util.inspect({ value, $value }, { depth: null, showHidden: false, colors: true }));
-          return { $in: $value };
-        }
-        return $value;
-      },
-    }).toObject();
-  }
-
-  static getAddFields(query) {
-    const { shape, where } = query;
-
-    return shape.reduce((prev, { from, type, isArray }) => {
-      // Basic checks to see if worth converting for regex
-      let value = where[from];
-      if (value === undefined) return prev;
-      if (!isScalarDataType(type)) return prev;
-
-      // Do regex conversion
-      if (isArray) value = value.$in || value; // Where clause does not always use $in
-      if (!ensureArray(value).some(el => el instanceof RegExp)) return prev;
-      const conversion = isArray ? { $map: { input: `$${from}`, as: 'el', in: { $toString: '$$el' } } } : { $toString: `$${from}` };
-      return Object.assign(prev, { [from]: conversion });
-    }, {});
-  }
-
-  static getProjectFields(parentShape, currentShape = { _id: 0, id: '$_id' }, isEmbedded, isEmbeddedArray, path = []) {
-    return parentShape.reduce((project, value) => {
-      const { from, to, shape: subShape, isArray } = value;
-      const $key = isEmbedded && isEmbeddedArray ? `$$embedded.${from}` : `$${path.concat(from).join('.')}`;
-
-      if (subShape) {
-        const $project = MongoDriver.getProjectFields(subShape, {}, true, isArray, path.concat(from));
-        Object.assign(project, { [to]: isArray ? { $map: { input: $key, as: 'embedded', in: $project } } : $project });
-      } else if (isEmbedded) {
-        Object.assign(project, { [to]: $key });
-      } else {
-        Object.assign(project, { [to]: from === to ? 1 : $key });
-      }
-
-      return project;
-    }, currentShape);
-  }
-
-  static aggregateQuery(query, count = false) {
-    const { where: $match, sort = {}, skip, limit, joins, after, before, first } = query;
-    const $aggregate = [{ $match }];
-
-    // Used for $regex matching
-    const $addFields = MongoDriver.getAddFields(query);
-    if (Object.keys($addFields).length) $aggregate.unshift({ $addFields });
-
-    if (count) {
-      $aggregate.push({ $count: 'count' });
-    } else {
-      // This is needed to return FK references as an array in the correct order
-      // http://www.kamsky.org/stupid-tricks-with-mongodb/using-34-aggregation-to-return-documents-in-same-order-as-in-expression
-      // https://jira.mongodb.org/browse/SERVER-7528
-      const idKey = MongoDriver.idKey();
-      const idMatch = $match[idKey];
-      if (typeof idMatch === 'object' && idMatch.$in) {
-        $aggregate.push({ $addFields: { __order: { $indexOfArray: [idMatch.$in, `$${idKey}`] } } });
-        $aggregate.push({ $sort: { __order: 1 } });
-      }
-
-      // Joins
-      if (joins) $aggregate.push(...joins.map(({ to: from, by: foreignField, from: localField, as }) => ({ $lookup: { from, foreignField, localField, as } })));
-
-      // Sort, Skip, Limit documents
-      if (sort && Object.keys(sort).length) $aggregate.push({ $sort: toKeyObj(sort) });
-      if (skip) $aggregate.push({ $skip: skip });
-      if (limit) $aggregate.push({ $limit: limit });
-
-      // Pagination
-      if (after) $aggregate.push({ $match: { $or: Object.entries(after).reduce((prev, [key, value]) => prev.concat({ [key]: { [sort[key] === 1 ? '$gte' : '$lte']: value } }), []) } });
-      if (before) $aggregate.push({ $match: { $or: Object.entries(before).reduce((prev, [key, value]) => prev.concat({ [key]: { [sort[key] === 1 ? '$lte' : '$gte']: value } }), []) } });
-      if (first) $aggregate.push({ $limit: first });
-
-      // // Projection
-      // const $project = MongoDriver.getProjectFields(shape);
-      // $aggregate.push({ $project });
-    }
-
-    return $aggregate;
-  }
-};

package/src/driver/index.js

@@ -1,11 +0,0 @@
-/* eslint-disable global-require */
-module.exports = class Driver {
-  constructor(name) {
-    switch (name) {
-      case 'Mongo': return require('./MongoDriver');
-      // case 'Neo4jDriver': return require('./Neo4jDriver').Neo4jDriver;
-      // case 'Neo4jRestDriver': return require('./Neo4jDriver').Neo4jRestDriver;
-      default: throw new Error(`Unknown driver ${name}`);
-    }
-  }
-};