@coderich/autograph 0.12.0 → 0.13.1

package/src/query/Query.js

@@ -1,363 +1,187 @@
-const Boom = require('../core/Boom');
+const Util = require('@coderich/util');
+const Pipeline = require('../data/Pipeline');
+const { isGlob, globToRegex, mergeDeep, finalizeWhereClause } = require('../service/AppService');
 
 module.exports = class Query {
-  constructor(props = {}) {
-    this.props = {};
-    this.timers = {};
-    this.isCursorPaging = false;
-    this.isClassicPaging = false;
-    this.props.joins = this.props.joins || [];
-    this.props.match = this.props.match || {};
-    this.props.options = this.props.options || {};
-    this.props.flags = this.props.flags || {
-      debug: false,
-      silent: false,
-      validate: true, // { externals }
-      pipeline: true, // { instruct, construct, destruct, restruct, serialize, deserialize, transform, rekey }
-      required: false,
-    };
-    this.merge(props);
-  }
-
-  propCheck(prop, ...checks) {
-    checks.forEach((check) => {
-      if (this.props[check]) throw Boom.badRequest(`Cannot use "${prop}" while using "${check}"`);
-    });
-  }
-
-  id(id) {
-    this.propCheck('id', 'where', 'native', 'sort', 'skip', 'limit', 'before', 'after', 'first', 'last');
-    this.props.id = id;
-    this.props.batch = 'id';
-    this.props.where = { id };
-    return this.match({ id });
-  }
-
-  batch(batch) {
-    this.props.batch = batch;
-    return this;
-  }
-
-  where(where) {
-    this.propCheck('where', 'id', 'native');
-    this.props.where = where;
-    return this.match(where);
-  }
-
-  search(search) {
-    this.propCheck('search', 'id');
-    this.props.search = search;
-    return this;
-  }
+  #config;
+  #resolver;
+  #context;
+  #schema;
+  #model;
+  #query;
 
-  native(native) {
-    this.propCheck('native', 'id', 'where');
-    this.props.native = native;
-    return this.match(native);
+  constructor(config) {
+    const { schema, context, resolver, query } = config;
+    this.#config = config;
+    this.#resolver = resolver;
+    this.#context = context;
+    this.#schema = schema;
+    this.#model = schema.models[query.model];
+    this.#query = query;
   }
 
-  match(match) {
-    this.props.match = match;
-    return this;
+  clone(query) {
+    query = { ...this.#query, ...query }; // NO deepMerge here; must replace fields entirely
+    return new Query({ ...this.#config, query });
   }
 
-  select(select) {
-    this.props.select = select;
-    return this;
-  }
-
-  $select(select) {
-    this.props.$select = select;
-    return this;
-  }
-
-  fields(fields) {
-    this.props.select = fields;
-    return this;
-  }
-
-  joins(...joins) {
-    this.props.joins.push(...joins);
-    return this;
-  }
-
-  sort(sort) {
-    this.propCheck('sort', 'id');
-    this.props.sort = sort;
-    return this;
-  }
-
-  $sort(sort) {
-    this.props.$sort = sort;
-    return this;
-  }
-
-  sortBy(sort) {
-    return this.sort(sort);
-  }
-
-  skip(skip) {
-    this.propCheck('skip', 'id');
-    if (this.isCursorPaging) throw Boom.badRequest('Cannot use "skip" while using Cursor-Style Pagination');
-    this.isClassicPaging = true;
-    this.props.skip = skip;
-    return this;
-  }
-
-  limit(limit) {
-    this.propCheck('limit', 'id');
-    if (this.isCursorPaging) throw Boom.badRequest('Cannot use "limit" while using Cursor-Style Pagination');
-    this.isClassicPaging = true;
-    this.props.limit = limit;
-    return this;
-  }
-
-  first(first) {
-    this.propCheck('first', 'id', 'last');
-    if (this.isClassicPaging) throw Boom.badRequest('Cannot use "first" while using Classic-Style Pagination');
-    this.isCursorPaging = true;
-    this.props.first = first + 2; // Adding 2 for pagination meta info (hasNext hasPrev)
-    return this;
-  }
-
-  last(last) {
-    this.propCheck('last', 'id', 'first');
-    if (this.isClassicPaging) throw Boom.badRequest('Cannot use "last" while using Classic-Style Pagination');
-    this.isCursorPaging = true;
-    this.props.last = last + 2; // Adding 2 for pagination meta info (hasNext hasPrev)
-    return this;
-  }
-
-  before(before) {
-    this.propCheck('before', 'id');
-    if (this.isClassicPaging) throw Boom.badRequest('Cannot use "before" while using Classic-Style Pagination');
-    this.isCursorPaging = true;
-    this.props.before = before;
-    return this;
-  }
-
-  after(after) {
-    this.propCheck('after', 'id');
-    if (this.isClassicPaging) throw Boom.badRequest('Cannot use "after" while using Classic-Style Pagination');
-    this.isCursorPaging = true;
-    this.props.after = after;
-    return this;
-  }
-
-  options(options) {
-    this.props.options = options;
-    return this;
-  }
-
-  meta(meta) {
-    this.props.meta = meta;
-    return this;
-  }
-
-  flags(flags) {
-    Object.assign(this.props.flags, flags);
-    return this;
+  toObject() {
+    return this.#query;
   }
 
-  root(root) {
-    this.props.root = root;
-    return this;
+  toCacheKey() {
+    return {
+      op: this.#query.op,
+      where: this.#query.where,
+      sort: this.#query.sort,
+      joins: this.#query.joins,
+      skip: this.#query.skip,
+      limit: this.#query.limit,
+      before: this.#query.before,
+      after: this.#query.after,
+      first: this.#query.first,
+      last: this.#query.last,
+    };
   }
 
   /**
-   * Merge unknown attributes into props; hence the check to do a noop
+   * Run a portion of the pipeline against a data set
    */
-  merge(query) {
-    Object.entries(query).forEach(([key, value]) => { if (this[key]) this[key](value); }); // Call method only if exists
-    return this;
+  pipeline(target, data, transformers) {
+    data = Util.unflatten(data);
+    const crudMap = { create: ['$construct', '$serialize'], update: ['$restruct', '$serialize'] };
+    const crudLines = crudMap[this.#query.crud] || [];
+    const transformerMap = { where: ['$cast', '$instruct', '$serialize'], sort: [], input: [] };
+    if (this.#query.isMutation) transformerMap.input = ['$default', '$cast', '$normalize', '$instruct', ...crudLines];
+    transformers = transformers || transformerMap[target];
+    return this.#pipeline(this.#query, target, this.#model, data, transformers.map(el => Pipeline[el]));
   }
 
-  resolver(resolver) {
-    this.props.resolver = resolver;
-    this.props.context = resolver.getContext();
-    return this;
+  /**
+   * Transform entire query via pipeline. At minimum, pipeline is needed to unflatten the data...
+   */
+  transform() {
+    return Promise.all([
+      this.pipeline('input', this.#query.input),
+      this.#query.isNative ? this.#query.where : this.pipeline('where', this.#query.where),
+      this.pipeline('sort', this.#query.sort),
+    ]).then(([input, where, sort]) => this.clone({ input, where, sort }));
   }
 
-  context(context) {
-    this.props.context = context;
-    return this;
-  }
+  /**
+   * Transform entire query for driver
+   */
+  toDriver() {
+    const { input, where, sort, before, after, isNative, isCursorPaging } = this.#query;
+
+    const query = this.clone({
+      model: this.#model.key,
+      select: Object.values(this.#model.fields).map(field => field.key),
+      input: this.#model.walk(input, node => node.value !== undefined && Object.assign(node, { key: node.field.key })),
+      where: isNative ? where : this.#model.walk(where, node => Object.assign(node, { key: node.field.key })),
+      sort: this.#model.walk(sort, node => Object.assign(node, { key: node.field.key })),
+      before: (!isCursorPaging || !before) ? undefined : JSON.parse(Buffer.from(before, 'base64').toString('ascii')),
+      after: (!isCursorPaging || !after) ? undefined : JSON.parse(Buffer.from(after, 'base64').toString('ascii')),
+      $schema: this.#schema.resolvePath,
+    });
 
-  model(model) {
-    this.props.model = model;
-    return this;
-  }
+    if (!isNative) this.#finalize(query.toObject());
 
-  transaction(transaction) {
-    this.props.transaction = transaction;
-    return this;
+    return query;
   }
 
-  cmd(cmd) {
-    this.props.cmd = cmd; // Terminal cmd from QueryBuilder
-    return this;
+  /**
+   * Recursive pipeline function
+   */
+  #pipeline(query, target, model, data, transformers = [], paths = []) {
+    return Util.mapPromise(data, (doc, index) => {
+      const path = [...paths];
+      if (Array.isArray(data)) path.push(index);
+      if (target === 'input') doc = mergeDeep(model.pipelineFields.input, doc);
+      else if (target === 'where') doc = mergeDeep(model.pipelineFields.where, doc);
+
+      return Util.pipeline(Object.entries(doc).map(([key, startValue]) => async (prev) => {
+        const field = model.fields[key];
+        if (!field) return prev;
+
+        // Transform value
+        let $value = await Util.pipeline(transformers.map(t => async (value) => {
+          const v = await t({ query, model, field, value, path: path.concat(key), startValue, resolver: this.#resolver, context: this.#context, schema: this.#schema });
+          return v === undefined ? value : v;
+        }), startValue);
+
+        // If it's embedded - delegate
+        if (field.isEmbedded) $value = await this.#pipeline(query, target, field.model, $value, transformers, path.concat(key));
+
+        // Assign it back
+        if (target === 'input' && $value === undefined) return prev;
+        return Object.assign(prev, { [field.name]: $value });
+      }), {});
+    });
   }
 
-  method(method) {
-    this.props.method = method;
-
-    switch (method) {
-      case 'createOne': case 'createMany': {
-        this.props.crud = 'create';
-        this.props.key = `create${this.props.model}`;
-        break;
-      }
-      case 'updateOne': case 'updateMany': {
-        this.props.crud = 'update';
-        this.props.key = `update${this.props.model}`;
-        break;
-      }
-      case 'deleteOne': case 'deleteMany': case 'removeOne': case 'removeMany': {
-        this.props.crud = 'delete';
-        this.props.key = `delete${this.props.model}`;
-        break;
-      }
-      case 'count': {
-        this.props.crud = 'read';
-        this.props.key = `count${this.props.model}`;
-        break;
-      }
-      case 'findOne': {
-        this.props.crud = 'read';
-        this.props.key = `get${this.props.model}`;
-        break;
-      }
-      case 'findMany': {
-        this.props.crud = 'read';
-        this.props.key = `find${this.props.model}`;
-        break;
-      }
-      default: {
-        this.props.crud = 'read';
-        break;
+  /**
+   * Finalize the query for the driver
+   */
+  #finalize(query) {
+    const { where = {}, sort = {} } = query;
+    const flatSort = Util.flatten(sort, { safe: true });
+    const flatWhere = Util.flatten(where, { safe: true });
+    const $sort = Util.unflatten(Object.keys(flatSort).reduce((prev, key) => Object.assign(prev, { [key]: {} }), {}));
+
+    //
+    query.sort = this.#model.walk(sort, (node) => {
+      if (node.field.isVirtual || node.field.isFKReference) node.key = `join_${node.field.model.key}`;
+      return node;
+    }, { key: 'key' });
+
+    // Reconstruct the where clause by pulling out anything that requires a join
+    query.where = finalizeWhereClause(Util.unflatten(Object.entries(flatWhere).reduce((prev, [key, value]) => {
+      if (this.#model.isJoinPath(key, 'key')) return prev;
+      value = Util.map(value, el => (isGlob(el) ? globToRegex(el) : el));
+      return Object.assign(prev, { [key]: value });
+    }, {}), { safe: true }));
+
+    // Determine what join data is needed (derived from where + sort)
+    const joinData = mergeDeep($sort, Util.unflatten(Object.entries(flatWhere).reduce((prev, [key, value]) => {
+      if (this.#model.isJoinPath(key, 'key')) return Object.assign(prev, { [key]: value });
+      return prev;
+    }, {}), { safe: true }));
+
+    // Construct joins
+    query.joins = [];
+
+    this.#model.walk(joinData, (node) => {
+      const { model, field, key, value, isLeaf, path, run } = node;
+
+      if (field.join) {
+        let isArray;
+        const join = { ...field.join, where: {} };
+
+        if (run.length > 1) {
+          join.from = path.reduce((prev, curr, i) => {
+            const $field = this.#model.resolvePath(path.slice(0, i + 1).join('.'), 'key');
+            if ($field.isArray) isArray = true;
+            return prev.concat($field.linkField.key);
+          }, []).join('.');
+        }
+
+        join.isArray = isArray || model.resolvePath(join.from).isArray;
+
+        query.joins.push(join);
       }
-    }
-
-    return this;
-  }
-
-  crud(crud) {
-    this.props.crud = crud;
-    return this;
-  }
-
-  key(key) {
-    this.props.key = key;
-    return this;
-  }
-
-  input(input = {}) { // Allows .save(/* empty */);
-    // delete input.id; // We do not want to allow changing id via input
-    this.props.input = input;
-    return this;
-  }
-
-  $input(input) {
-    this.props.$input = input;
-    return this;
-  }
 
-  doc(doc) {
-    this.props.doc = doc;
-    return this;
-  }
-
-  merged(merged) {
-    this.props.merged = merged;
-    return this;
-  }
-
-  payload(payload) {
-    this.props.payload = payload;
-    return this;
-  }
-
-  result(result) {
-    this.props.result = result;
-    return this;
-  }
-
-  $doc($doc) {
-    this.props.$doc = $doc;
-    return this;
-  }
-
-  args(args) {
-    this.props.args = args;
-    return this;
-  }
-
-  clone() {
-    const clone = new Query();
-    clone.props = { ...this.props };
-    return clone;
-  }
-
-  toDriver() {
-    const self = this;
-    const { model } = this.props;
-    const isSorted = Boolean(Object.keys(this.props.$sort || {}).length);
-
-    return {
-      isNative: Boolean(this.props.native),
-      model: model.getKey(),
-      shape: model.getShape(),
-      method: this.props.method,
-      select: this.props.$select,
-      joins: this.props.joins,
-      where: this.props.match,
-      search: this.props.search,
-      sort: this.props.$sort,
-      skip: this.props.skip,
-      limit: this.props.limit,
-      first: isSorted ? this.props.first : undefined,
-      last: isSorted ? this.props.last : undefined,
-      // before: isSorted && this.props.before ? model.normalize(this, JSON.parse(Buffer.from(this.props.before, 'base64').toString('ascii')), 'serialize') : undefined,
-      get before() {
-        if (!isSorted || !self.props.before) return undefined;
-        const shape = model.getShape('create', 'sort');
-        const before = JSON.parse(Buffer.from(self.props.before, 'base64').toString('ascii'));
-        const $before = model.shapeObject(shape, before, self);
-        return $before;
-      },
-      get after() {
-        if (!isSorted || !self.props.after) return undefined;
-        const shape = model.getShape('create', 'sort');
-        const after = JSON.parse(Buffer.from(self.props.after, 'base64').toString('ascii'));
-        const $after = model.shapeObject(shape, after, self);
-        return $after;
-      },
-      options: this.props.options,
-      input: this.props.$input,
-      flags: this.props.flags,
-      $doc: this.props.$doc,
-      doc: this.props.doc,
-    };
-  }
-
-  toObject() {
-    return this.props;
-  }
+      if (isLeaf) {
+        const $model = field.model || model;
+        const join = query.joins.find(j => j.to === $model.key);
+        const $value = Util.map(value, el => (isGlob(el) ? globToRegex(el) : el));
+        const $$value = Array.isArray($value) ? { $in: $value } : $value;
+        const from = field.model ? join.from : key;
+        join.where[from] = $$value;
+        return false;
+      }
 
-  getCacheKey() {
-    return {
-      cmd: this.props.cmd,
-      method: this.props.method,
-      where: this.props.match,
-      search: this.props.search,
-      sort: this.props.sort,
-      skip: this.props.skip,
-      limit: this.props.limit,
-      before: this.props.before,
-      after: this.props.after,
-      first: this.props.first,
-      last: this.props.last,
-      options: this.props.options,
-    };
+      return node;
+    }, { key: 'key' });
   }
 };