@coderich/autograph 0.11.1 → 0.13.0

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2020 coderich
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/README.md

@@ -1,76 +0,0 @@
-# AutoGraph
-### Instantly Build [Relay-Compliant](https://relay.dev/docs/en/graphql-server-specification.html) GraphQL APIs
-
-**AutoGraph** is a powerful **framework** to *instantly* build **Relay-Compliant GraphQL APIs** that adhere to *standards and best practice*. It provides a robust set of **directives** that encapsulates *data access*, *validation*, *transformations*, and so much more!
-
-
-#### Features
-- Instantly Connected Relay-Compliant GraphQL APIs
-- Extensible Validation & Transformation Logic
-- Unified Data Access / Abstraction Layer
-- Memoized Caching (via [DataLoader](https://www.npmjs.com/package/dataloader))
-- Transactions, Pagination, and more!
-
-#### Installation
-
-```sh
-npm i @coderich/autograph --save
-```
-
-## Schema API
-#### Custom Types
-```gql
-scalar AutoGraphMixed
-enum AutoGraphScopeEnum { private protected public restricted }
-enum AutoGraphOnDeleteEnum { cascade nullify restrict }
-enum AutoGraphIndexEnum { unique }
-```
-#### Custom Directives
-##### @model
-| arg | type | description |
-| :--- | :--- | :--- |
-| `id` | `String` | Specify database id field name (default: `id`)
-| `meta` | `String` | Define a model
-| `alias` | `String` | Specify database table name (default models's name)
-| `scope` | `AutoGraphScopeEnum` | Access scope for this model (default `protected`)
-| `driver` | `String` | Specify database driver (default `default`)
-| `namespace` | `String` | Define a custom namespace
-| `createdAt` | `String` | TBD
-| `updatedAt` | `String` | TBD
-
-##### @field
-| arg | type | description |
-| :--- | :--- | :--- |
-| `alias` | `String` | Specify database field name (default field's name)
-| `scope` | `AutoGraphScopeEnum` | Access scope for this field (default `protected`)
-| `enforce` | `[AutoGraphEnforceEnum!]` | List of `Rules` to enforce
-| `noRepeat` | `Boolean` | TBD
-| `onDelete` | `AutoGraphOnDeleteEnum` | Specify *onDelete* behavior
-| `transform` | `[AutoGraphTransformEnum!]` | List of `Transformers` to apply
-| `materializeBy` | `String` | Define a virtual field
-
-##### @index
-| arg | type | description |
-| :--- | :--- | :--- |
-| `on` | `[String!]!` | The field names to use for this index
-| `type` | `AutoGraphIndexEnum!` | The type of index to create
-| `name` | `String` | The name of the index
-
-## Data API
-#### Data Access
-#### Data Validation
-#### Data Transformation
-
-
-Each `Resolver` treats your schema definition as a *graph of connected nodes*. To begin a *query* or *mutation*, you must first identify a node in the graph as your starting point.
-
-##### .match
-Identify a node, returns a `QueryBuilder`.
-```
-const queryBuilder = resolver.match('Person');
-```
-##### .transaction
-Identify a node, returns a `Transaction`.
-```
-const txn = resolver.transaction('Person');
-```

package/src/core/Boom.js

@@ -1,9 +0,0 @@
-const Boom = require('@hapi/boom');
-
-/**
- * Boom.
- *
- * Standardizing how known/expected errors are thrown (such as Rule validation errors). This allows
- * upstream applications to more easily decide what to show to end-users and what to hide.
- */
-module.exports = Boom;

package/src/core/EventEmitter.js

@@ -1,95 +0,0 @@
-const EventEmitter = require('events');
-const { ensureArray } = require('../service/app.service');
-
-/**
- * EventEmitter.
- *
- * The difference is that I'm looking at each raw listeners to determine how many arguments it's expecting.
- * If it expects more than 1 we block and wait for it to finish.
- */
-module.exports = class extends EventEmitter {
-  emit(event, data) {
-    return Promise.all(this.rawListeners(event).map((wrapper) => {
-      return new Promise((resolve, reject) => {
-        const next = result => resolve(result); // If a result is passed this will bypass middleware thunk()
-        const numArgs = (wrapper.listener || wrapper).length;
-        Promise.resolve(wrapper(data, next)).catch(e => reject(e));
-        if (numArgs < 2) next();
-      });
-    })).then((results) => {
-      return results.find(r => r !== undefined); // There can be only one (result)
-    });
-  }
-
-  /**
-   * Syntactic sugar to listen on keys
-   */
-  onKeys(on, keys, fn) {
-    const numArgs = fn.length;
-
-    return super.on(on, async (event, next) => {
-      const { key } = event;
-
-      if (ensureArray(keys).indexOf(key) > -1) {
-        if (numArgs < 2) next();
-        await fn(event, next);
-      } else {
-        next();
-      }
-    });
-  }
-
-  /**
-   * Syntactic sugar to listen once keys
-   */
-  onceKeys(once, keys, fn) {
-    const numArgs = fn.length;
-
-    return super.once(once, async (event, next) => {
-      const { key } = event;
-
-      if (ensureArray(keys).indexOf(key) > -1) {
-        if (numArgs < 2) next();
-        await fn(event, next);
-      } else {
-        next();
-      }
-    });
-  }
-
-  /**
-   * Syntactic sugar to listen on models
-   */
-  onModels(on, models, fn) {
-    const numArgs = fn.length;
-
-    return super.on(on, async (event, next) => {
-      const { model } = event;
-
-      if (ensureArray(models).indexOf(`${model}`) > -1) {
-        if (numArgs < 2) next();
-        await fn(event, next);
-      } else {
-        next();
-      }
-    });
-  }
-
-  /**
-   * Syntactic sugar to listen once models
-   */
-  onceModels(once, models, fn) {
-    const numArgs = fn.length;
-
-    return super.once(once, async (event, next) => {
-      const { model } = event;
-
-      if (ensureArray(models).indexOf(`${model}`) > -1) {
-        if (numArgs < 2) next();
-        await fn(event, next);
-      } else {
-        next();
-      }
-    });
-  }
-};

package/src/core/Resolver.js

@@ -1,124 +0,0 @@
-const Model = require('../data/Model');
-const DataLoader = require('../data/DataLoader');
-const DataTransaction = require('../data/DataTransaction');
-const Query = require('../query/Query');
-const QueryBuilder = require('../query/QueryBuilder');
-const { finalizeResults } = require('../data/DataService');
-const { createSystemEvent } = require('../service/event.service');
-
-module.exports = class Resolver {
-  constructor(schema, context = {}) {
-    this.schema = schema;
-    this.context = context;
-    this.models = schema.getModels();
-    this.loaders = this.models.reduce((prev, model) => prev.set(`${model}`, new DataLoader(this, model)), new Map());
-  }
-
-  getSchema() {
-    return this.schema;
-  }
-
-  getContext() {
-    return this.context;
-  }
-
-  /**
-   * Creates and returns a QueryBuilder for a given model
-   */
-  match(model) {
-    return new QueryBuilder(this, this.toModelEntity(model));
-  }
-
-  /**
-   * Returns a user-defined Map (repository) of custom named queries.
-   */
-  named(model) {
-    return this.toModel(model).getNamedQueries();
-  }
-
-  /**
-   * Returns the raw client driver associated with the model.
-   */
-  raw(model) {
-    return this.toModelEntity(model).raw();
-  }
-
-  /**
-   * Creates and returns a Transaction to run multiple queries
-   */
-  transaction(parentTxn) {
-    return new DataTransaction(this, parentTxn);
-  }
-
-  disconnect(model) {
-    return this.toModelEntity(model).getDriver().disconnect();
-  }
-
-  resolve(query) {
-    const { model, crud, method } = query.toObject();
-
-    switch (crud) {
-      case 'create': case 'update': case 'delete': {
-        return model.getDriver().resolve(query.toDriver()).then((data) => {
-          this.clear(model);
-          const rs = model.shapeObject(model.getShape(), data, query);
-          return finalizeResults(rs, query);
-        });
-      }
-      default: {
-        const key = model.idKey();
-        const { where } = query.toDriver();
-        const lookupValue = where[key];
-
-        // This is a shortcut to prevent making unnecessary query
-        if (Object.prototype.hasOwnProperty.call(where, key) && (lookupValue == null || (Array.isArray(lookupValue) && lookupValue.length === 0))) {
-          switch (method) {
-            case 'count': return Promise.resolve(0);
-            case 'findMany': return Promise.resolve([]);
-            default: return Promise.resolve(null);
-          }
-        }
-
-        // Go through DataLoader to cache results
-        return this.loaders.get(`${model}`).load(query);
-      }
-    }
-  }
-
-  toModel(model) {
-    return model instanceof Model ? model : this.schema.getModel(model);
-  }
-
-  toModelMarked(model) {
-    const marked = this.toModel(model);
-    if (!marked) throw new Error(`${model} is not defined in schema`);
-    if (!marked.isMarkedModel()) throw new Error(`${model} is not a marked model`);
-    return marked;
-  }
-
-  toModelEntity(model) {
-    const entity = this.toModel(model);
-    if (!entity) throw new Error(`${model} is not defined in schema`);
-    if (!entity.isEntity()) throw new Error(`${model} is not an entity`);
-    return entity;
-  }
-
-  toResultSet(model, data, method) {
-    model = this.toModel(model);
-    const query = new Query({ model, resolver: this, context: this.context, method });
-    const result = model.deserialize(data, query);
-    const event = { result, query, ...query.doc(result).merged(result).toObject() };
-    return createSystemEvent('Response', event, () => result);
-  }
-
-  // DataLoader Proxy Methods
-  clear(model) {
-    this.loaders.get(`${model}`).clearAll();
-    return this;
-  }
-
-  clearAll() {
-    this.models.forEach(model => this.clear(model));
-    return this;
-  }
-};

package/src/core/Schema.js

@@ -1,55 +0,0 @@
-const Model = require('../data/Model');
-const Schema = require('../graphql/ast/Schema');
-const { identifyOnDeletes } = require('../service/schema.service');
-const { eventEmitter } = require('../service/event.service');
-
-// Export class
-module.exports = class extends Schema {
-  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 eventEmitter.emit('setup', this).then(() => {
-      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);
-      }));
-    });
-  }
-
-  disconnect() {
-    return Promise.all(Object.values(this.drivers).map(({ dao }) => dao.disconnect()));
-  }
-
-  initialize() {
-    super.initialize();
-    this.models = super.getModels().map(model => new Model(this, model, this.drivers[model.getDriverName()]));
-    return this;
-  }
-
-  finalize() {
-    super.finalize();
-    this.models.forEach(model => model.referentialIntegrity(identifyOnDeletes(this.models, model)));
-    return this;
-  }
-};

package/src/core/ServerResolver.js

@@ -1,15 +0,0 @@
-const { unrollGuid, guidToId } = require('../service/app.service');
-
-module.exports = class ServerResolver {
-  constructor() {
-    // Queries
-    this.get = ({ autograph }, model, { id: guid }, required = false, query) => autograph.resolver.match(model).id(guidToId(autograph, guid)).select(query.fields).one({ required });
-    this.query = ({ autograph }, model, args, query) => autograph.resolver.match(model).select(query.fields).merge(args).many();
-    this.count = ({ autograph }, model, args, query) => autograph.resolver.match(model).merge(args).count();
-
-    // Mutations
-    this.create = ({ autograph }, model, { input, meta }, query) => autograph.resolver.match(model).select(query.fields).meta(meta).save(unrollGuid(autograph, model, input));
-    this.delete = ({ autograph }, model, { id: guid, meta }, query) => autograph.resolver.match(model).id(guidToId(autograph, guid)).select(query.fields).meta(meta).remove();
-    this.update = ({ autograph }, model, { id: guid, meta, input }, query) => autograph.resolver.match(model).id(guidToId(autograph, guid)).select(query.fields).meta(meta).save(unrollGuid(autograph, model, input));
-  }
-};

package/src/data/DataService.js

@@ -1,120 +0,0 @@
-const { get, remove } = require('lodash');
-const { map, isPlainObject, objectContaining, mergeDeep, ensureArray, keyPaths } = require('../service/app.service');
-
-exports.finalizeResults = (rs, query) => {
-  const { model, resolver } = query.toObject();
-
-  return map(exports.paginateResults(rs, query), (doc) => {
-    return Object.defineProperties(doc, {
-      $model: { value: model },
-      $save: { value: input => resolver.match(model).id(doc.id).save({ ...doc, ...input }) },
-      $remove: { value: (...args) => resolver.match(model).id(doc.id).remove(...args) },
-      $delete: { value: (...args) => resolver.match(model).id(doc.id).delete(...args) },
-      $lookup: { value: (fieldName, args) => model.getFieldByName(fieldName).resolve(resolver, doc, args) },
-      // $resolve: { value: (fieldName, args) => model.getFieldByName(fieldName).resolve(resolver, doc, args) },
-    });
-  });
-};
-
-/**
- * This is cursor-style pagination only
- * You add 2 extra records to the result in order to determine previous/next
- */
-exports.paginateResults = (rs, query) => {
-  const { first, after, last, before, sort } = query.toObject();
-  const isPaginating = Boolean(first || last || after || before);
-
-  // Return right away if not paginating
-  if (!isPaginating) return rs;
-
-  let hasNextPage = false;
-  let hasPreviousPage = false;
-  const limiter = first || last;
-  const sortPaths = keyPaths(sort);
-
-  // Add $cursor data
-  map(rs, (doc) => {
-    const sortValues = sortPaths.reduce((prv, path) => Object.assign(prv, { [path]: get(doc, path) }), {});
-    Object.defineProperty(doc, '$cursor', { get() { return Buffer.from(JSON.stringify(sortValues)).toString('base64'); } });
-  });
-
-  // First try to take off the "bookends" ($gte | $lte)
-  if (rs.length && rs[0].$cursor === after) {
-    rs.shift();
-    hasPreviousPage = true;
-  }
-
-  if (rs.length && rs[rs.length - 1].$cursor === before) {
-    rs.pop();
-    hasNextPage = true;
-  }
-
-  // Next, remove any overage
-  const overage = rs.length - (limiter - 2);
-
-  if (overage > 0) {
-    if (first) {
-      rs.splice(-overage);
-      hasNextPage = true;
-    } else if (last) {
-      rs.splice(0, overage);
-      hasPreviousPage = true;
-    } else {
-      rs.splice(-overage);
-      hasNextPage = true;
-    }
-  }
-
-  // Add $pageInfo
-  return Object.defineProperties(rs, {
-    $pageInfo: {
-      get() {
-        return {
-          startCursor: get(rs, '0.$cursor', ''),
-          endCursor: get(rs, `${rs.length - 1}.$cursor`, ''),
-          hasPreviousPage,
-          hasNextPage,
-        };
-      },
-    },
-  });
-};
-
-exports.spliceEmbeddedArray = (array, from, to) => {
-  const op = from && to ? 'edit' : (from ? 'pull' : 'push'); // eslint-disable-line no-nested-ternary
-
-  // 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]);
-
-  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 array;
-};

package/src/data/DataTransaction.js

@@ -1,96 +0,0 @@
-const { get } = require('lodash');
-const TreeMap = require('./TreeMap');
-const QueryBuilderTransaction = require('../query/QueryBuilderTransaction');
-
-const makeMap = (resolver) => {
-  let resolve, reject;
-  const map = new TreeMap();
-  map.promise = new Promise((good, bad) => { resolve = good; reject = bad; });
-  map.resolve = resolve;
-  map.reject = reject;
-
-  map.ready = () => {
-    const elements = map.elements();
-    const notReady = elements.filter(el => !el.marker);
-    if (notReady.length) return [undefined, undefined];
-    let rollbackIndex = elements.findIndex(el => el.marker === 'rollback');
-    if (rollbackIndex === -1) rollbackIndex = Infinity;
-    return [elements.slice(0, rollbackIndex), elements.slice(rollbackIndex)];
-  };
-
-  map.perform = () => {
-    const [commits, rollbacks] = map.ready();
-
-    if (commits && rollbacks) {
-      const rollbackData = rollbacks.map(tnx => tnx.data).flat();
-      const commitData = commits.map(tnx => tnx.data).flat();
-
-      Promise.all(rollbackData.map(rbd => rbd.$rollback())).then(() => {
-        if (commits.length) resolver.clearAll();
-        Promise.all(commitData.map(cd => cd.$commit())).then(d => map.resolve(d));
-      }).catch(e => map.reject(e));
-    }
-
-    return map.promise;
-  };
-
-  return map;
-};
-
-module.exports = class DataTransaction {
-  constructor(resolver, parentTxn) {
-    this.data = [];
-    this.resolver = resolver;
-    this.driverMap = new Map();
-    this.txnMap = get(parentTxn, 'txnMap') || makeMap(resolver);
-    this.txnMap.add(parentTxn, this);
-  }
-
-  match(modelish) {
-    const model = this.resolver.toModelMarked(modelish);
-    const driver = model.getDriver();
-    if (!this.driverMap.has(driver)) this.driverMap.set(driver, []);
-    const op = new QueryBuilderTransaction(this.resolver, model, this);
-    this.driverMap.get(driver).push(op);
-    return op;
-  }
-
-  exec() {
-    return Promise.all(Array.from(this.driverMap.entries()).map(([driver, ops]) => {
-      if (driver.getDirectives().transactions === false) {
-        return Promise.all(ops.map(op => op.exec())).then((results) => {
-          results.$commit = () => this.resolver.clearAll();
-          results.$rollback = () => this.resolver.clearAll();
-          return results;
-        });
-      }
-
-      return driver.transaction(ops);
-    })).then((results) => {
-      this.data = results;
-      return results.flat();
-    });
-  }
-
-  run() {
-    return this.exec().then((results) => {
-      if (this.txnMap.root(this) === this) return this.commit().then(() => results);
-      this.commit();
-      return results;
-    }).catch((e) => {
-      if (this.txnMap.root(this) === this) return this.rollback().then(() => Promise.reject(e));
-      this.rollback();
-      throw e;
-    });
-  }
-
-  commit() {
-    if (this.marker !== 'rollback') this.marker = 'commit';
-    return this.txnMap.perform();
-  }
-
-  rollback() {
-    this.marker = 'rollback';
-    return this.txnMap.perform();
-  }
-};