@coderich/autograph 0.11.1 → 0.13.0

package/src/query/QueryBuilder.js

@@ -1,120 +1,234 @@
 const Query = require('./Query');
-const QueryResolver = require('./QueryResolver');
-const { unravelObject } = require('../service/app.service');
-
-/*
-* QueryBuilder
-*
-* Facilitates the creation and execution of a Query. It provides a chainable API to build a query
-* plus a list of terminal commands to execute the query.
-*/
+const { getGQLReturnType, mergeDeep } = require('../service/AppService');
+
 module.exports = class QueryBuilder {
-  constructor(resolver, model) {
-    // this.terminated = false; // Prevent accidental re-use of the QueryBuilder
-    this.query = new Query({ model, resolver });
-
-    // Chainable commands
-    this.id = (id) => { this.query.id(id); return this; };
-    this.select = (select) => { this.query.select(unravelObject(select)); return this; };
-    // this.select = (select) => { this.query.select(Object.entries(toKeyObj(select)).reduce((prev, [key, value]) => Object.assign(prev, { [key.replace(/edges.node./g, '')]: !!value }), {})); return this; };
-    this.where = (where) => { this.query.where(unravelObject(where)); return this; };
-    this.match = (match) => { this.query.match(unravelObject(match)); return this; };
-    this.native = (native) => { this.query.native(native); return this; };
-    this.sort = (sort) => { this.query.sort(unravelObject(sort)); return this; };
-    this.sortBy = (sortBy) => { this.query.sort(unravelObject(sortBy)); return this; };
-    this.limit = (limit) => { this.query.limit(limit); return this; };
-    this.skip = (skip) => { this.query.skip(skip); return this; };
-    this.before = (cursor) => { this.query.before(cursor); return this; };
-    this.after = (cursor) => { this.query.after(cursor); return this; };
-    this.meta = (meta) => { this.query.meta(meta); return this; };
-    this.flags = (flags) => { this.query.flags(flags); return this; };
-    this.merge = (merge) => { this.query.merge(unravelObject(merge)); return this; };
-    this.batch = (batch) => { this.query.batch(batch); return this; };
-    this.transaction = (txn) => { this.query.transaction(txn); return this; };
-
-    // Terminal commands
-    this.one = (...args) => this.execute('one', args);
-    this.many = (...args) => this.execute('many', args);
-    this.save = (...args) => this.execute('save', args.map(arg => unravelObject(arg)));
-    this.delete = (...args) => this.execute('delete', args);
-    this.remove = (...args) => this.execute('remove', args);
-    this.resolve = (...args) => this.execute('resolve', args);
-    //
-    this.count = (...args) => this.execute('count', args);
-    this.push = (...args) => this.execute('push', args.map(arg => unravelObject(arg)));
-    this.pull = (...args) => this.execute('pull', args.map(arg => unravelObject(arg)));
-    this.splice = (...args) => this.execute('splice', args.map(arg => unravelObject(arg)));
-    this.first = (...args) => { this.query.first(...args); return this.execute('first', args); };
-    this.last = (...args) => { this.query.last(...args); return this.execute('last', args); };
-    //
-    // this.min = (...args) => this.makeTheCall(query, 'min', args);
-    // this.max = (...args) => this.makeTheCall(query, 'max', args);
-    // this.avg = (...args) => this.makeTheCall(query, 'avg', args);
-    // this.sum = (...args) => this.makeTheCall(query, 'sum', args); // Would sum be different than count?
-    // // Food for thought...
-    // this.archive = (...args) => this.makeTheCall(query, 'archive', args); // Soft Delete
-    // this.stream = (...args) => this.makeTheCall(query, 'stream', args); // Stream records 1 by 1
-    // this.rollup = (...args) => this.makeTheCall(query, 'rollup', args); // Like sum, but for nested attributes (eg. Person.rollupAuthoredChaptersPages)
-  }
-
-  execute(cmd, args) {
-    // // Do not allow re-use
-    // if (this.terminated) return Promise.reject(new Error('This query has already been executed'));
-    // this.terminated = true;
-
-    let method, crud, input, flags = {};
-    const { id, where } = this.query.toObject();
-
-    switch (cmd) {
-      case 'resolve': {
-        crud = 'read';
-        method = 'autoResolve';
-        break;
-      }
-      case 'one': case 'many': {
-        crud = 'read';
-        [flags] = args;
-        method = cmd === 'one' ? 'findOne' : 'findMany';
-        break;
-      }
-      case 'first': case 'last': {
-        crud = 'read';
-        [, flags] = args;
-        method = cmd;
-        break;
-      }
-      case 'save': {
-        [input, flags] = args;
-        crud = id || where ? 'update' : 'create';
-        if (crud === 'update') { method = id ? 'updateOne' : 'updateMany'; }
-        if (crud === 'create') { method = Array.isArray(input) ? 'createMany' : 'createOne'; }
-        break;
-      }
-      case 'push': case 'pull': case 'splice': {
-        // [target, input, flags] = args;
-        crud = 'update'; // Your logic wants this to be a simple "update". Sub documents systemEvents will emit either "create" or "udpate"
-        method = id ? `${cmd}One` : `${cmd}Many`;
-        break;
-      }
-      case 'remove': case 'delete': {
-        crud = 'delete';
-        [flags] = args;
-        if (id) method = 'deleteOne';
-        else if (where) method = 'deleteMany';
-        else return Promise.reject(new Error('Remove requires an id() or where()'));
-        break;
-      }
-      case 'count': {
-        crud = 'read';
-        [flags] = args;
-        method = 'count';
-        break;
-      }
-      default: {
-        return Promise.reject(new Error(`Unknown query command: ${cmd}`));
-      }
+  #config;
+  #query;
+  #terminalCommands = ['one', 'many', 'count', 'save', 'delete', 'first', 'last', 'push', 'pull', 'splice'];
+
+  constructor(config) {
+    const { query } = config;
+
+    this.#config = config;
+
+    this.#query = Object.defineProperties(query, {
+      id: { writable: true, enumerable: true, value: query.id },
+      args: { writable: true, enumerable: true, value: query.args || {} },
+      flags: { writable: true, enumerable: true, value: query.flags || {} },
+      options: { writable: true, enumerable: true, value: query.options || {} },
+    });
+
+    // Aliases
+    this.opts = this.options;
+    this.sortBy = this.sort;
+    this.remove = this.delete;
+  }
+
+  isTerminal(cmd) {
+    return this.#terminalCommands.includes(cmd);
+  }
+
+  /**
+   * When a termnial command is called, terminate() returns the Query object
+   * We have to clone() the Query because we mutate this.#config all while the query is being built
+   * However there is a "bug" when using .resolve() (below) and the QueryBuilder is re-used to resolve each thunk
+   */
+  terminate() {
+    return new Query(this.#config).clone();
+  }
+
+  /**
+   * For use in GraphQL resolver methods to return the "correct" response
+   */
+  resolve(info) {
+    switch (getGQLReturnType(`${info.returnType}`)) {
+      case 'array': return this.many();
+      case 'number': return this.count();
+      case 'connection': return { count: () => this.count(), edges: () => this.many(), pageInfo: () => this.many() };
+      case 'scalar': default: return this.one();
     }
+  }
+
+  /**
+   * Chainable methods
+   */
+  id(id) {
+    this.#propCheck('id', 'native', 'sort', 'skip', 'limit', 'before', 'after');
+    this.#query.id = id;
+    this.#query.where = mergeDeep(this.#query.where || {}, { id });
+    this.#query.args.id = id;
+    return this;
+  }
+
+  args(args) {
+    Object.entries(args).forEach(([key, value]) => { if (this[key]) this[key](value); }); // Call method only if exists
+    return this;
+  }
+
+  native(clause) {
+    this.#propCheck('native', 'id', 'where');
+    this.#query.isNative = true;
+    this.#query.native = clause;
+    this.#query.where = clause;
+    this.#query.args.native = clause;
+    return this;
+  }
+
+  where(clause) {
+    this.#propCheck('where', 'native', false);
+    const $clause = mergeDeep(this.#query.where || {}, clause);
+    this.#query.where = $clause;
+    this.#query.args.where = $clause;
+    return this;
+  }
+
+  select(...select) {
+    this.#propCheck('select');
+    select = select.flat();
+    this.#query.select = select;
+    this.#query.args.select = select;
+    return this;
+  }
+
+  skip(skip) {
+    this.#propCheck('skip', 'id');
+    this.isClassicPaging = true;
+    this.#query.skip = skip;
+    this.#query.args.skip = skip;
+    return this;
+  }
+
+  limit(limit) {
+    this.#propCheck('limit', 'id');
+    this.isClassicPaging = true;
+    this.#query.limit = limit;
+    this.#query.args.limit = limit;
+    return this;
+  }
+
+  before(before) {
+    this.#propCheck('before', 'id');
+    this.#query.isCursorPaging = true;
+    this.#query.before = before;
+    this.#query.args.before = before;
+    return this;
+  }
+
+  after(after) {
+    this.#propCheck('after', 'id');
+    this.#query.isCursorPaging = true;
+    this.#query.after = after;
+    this.#query.args.after = after;
+    return this;
+  }
+
+  sort(sort) {
+    this.#propCheck('sort', 'id');
+    this.#query.sort = sort;
+    this.#query.args.sort = sort;
+    return this;
+  }
+
+  meta(meta) {
+    this.#query.meta = meta;
+    this.#query.args.meta = meta;
+    return this;
+  }
+
+  options(options) {
+    Object.assign(this.#query.options, options);
+    return this;
+  }
+
+  flags(flags) {
+    Object.assign(this.#query.flags, flags);
+    return this;
+  }
+
+  /**
+   * Core terminal commands
+   */
+  one(flags) {
+    return this.flags(flags).terminate(Object.assign(this.#query, { op: 'findOne', crud: 'read', key: `get${this.#query.model}` }));
+  }
+
+  many(flags) {
+    return this.flags(flags).terminate(Object.assign(this.#query, { op: 'findMany', crud: 'read', key: `find${this.#query.model}` }));
+  }
+
+  count() {
+    return this.terminate(Object.assign(this.#query, { op: 'count', crud: 'read', key: `count${this.#query.model}` }));
+  }
+
+  save(...args) {
+    const { id, where } = this.#query;
+    const crud = (id || where ? (args[1] ? 'upsert' : 'update') : 'create'); // eslint-disable-line
+    return this.#mutation(crud, ...args);
+  }
+
+  delete(...args) {
+    const { id, where } = this.#query;
+    if (!id && !where) throw new Error('Delete requires id() or where()');
+    return this.#mutation('delete', ...args);
+  }
+
+  /**
+   * Proxy terminial commands
+   */
+  first(first) {
+    this.#query.isCursorPaging = true;
+    this.#query.first = first + 2; // Adding 2 for pagination meta info (hasNext hasPrev)
+    this.#query.args.first = first;
+    return this.many();
+  }
+
+  last(last) {
+    this.#query.isCursorPaging = true;
+    this.#query.last = last + 2; // Adding 2 for pagination meta info (hasNext hasPrev)
+    this.#query.args.last = last;
+    return this.many();
+  }
+
+  /**
+   * Array terminal commands
+   */
+  push(path, ...values) {
+    values = values.flat();
+    return this.#mutation('push', { [path]: values });
+  }
+
+  pull(path, ...values) {
+    values = values.flat();
+    return this.#mutation('pull', { [path]: values });
+  }
+
+  splice(path, ...values) {
+    values = values.flat();
+    return this.#mutation('splice', { [path]: values });
+  }
+
+  /**
+   */
+  #mutation(crud, ...args) {
+    args = args.flat();
+    const { id, limit } = this.#query;
+    const suffix = id || limit === 1 || (crud === 'create' && args.length < 2) ? 'One' : 'Many';
+    let input = suffix === 'One' ? args[0] : args;
+    if (input === undefined) input = {};
+    this.#query.args.input = input;
+    return this.terminate(Object.assign(this.#query, {
+      op: `${crud}${suffix}`,
+      key: `${crud}${this.#query.model}`,
+      crud: ['push', 'pull', 'splice'].includes(crud) ? 'update' : crud,
+      input,
+      isMutation: true,
+    }));
+  }
 
-    return new QueryResolver(this.query.method(method).cmd(cmd).crud(crud).input(input).flags(flags).args(args)).resolve();
+  #propCheck(prop, ...checks) {
+    if (checks[checks.length - 1] !== false && this.#query[prop]) throw new Error(`Cannot redefine "${prop}"`);
+    if (['skip', 'limit'].includes(prop) && this.#query.isCursorPaging) throw new Error(`Cannot use "${prop}" while using Cursor-Style Pagination`);
+    if (['first', 'last', 'before', 'after'].includes(prop) && this.isClassicPaging) throw new Error(`Cannot use "${prop}" while using Classic-Style Pagination`);
+    checks.forEach((check) => { if (this.#query[check]) throw new Error(`Cannot use "${prop}" while using "${check}"`); });
   }
 };