@coderich/autograph 0.13.33 → 0.13.35

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@coderich/autograph",
   "main": "index.js",
-  "version": "0.13.33",
+  "version": "0.13.35",
   "publishConfig": {
     "access": "public"
   },

package/src/data/Pipeline.js

@@ -62,7 +62,7 @@ module.exports = class Pipeline {
     Pipeline.define('$construct', params => Pipeline.resolve(params, 'construct'), { ignoreNull: false });
     Pipeline.define('$restruct', params => Pipeline.resolve(params, 'restruct'), { ignoreNull: false });
     Pipeline.define('$serialize', params => Pipeline.resolve(params, 'serialize'), { ignoreNull: false });
-    Pipeline.define('$finalize', params => Pipeline.resolve(params, 'finalize'), { ignoreNull: false });
+    Pipeline.define('$validate', params => Pipeline.resolve(params, 'validate'), { ignoreNull: false });
 
     //
     Pipeline.define('$pk', (params) => {
@@ -114,14 +114,17 @@ module.exports = class Pipeline {
     Pipeline.define('ensureFK', ({ query, resolver, field, value }) => {
       const { type, fkField } = field;
       const ids = Util.filterBy(Util.ensureArray(value), (a, b) => `${a}` === `${b}`);
+      if (!ids.length) return undefined;
       return resolver.match(type).flags(query.flags).where({ [fkField]: ids }).count().then((count) => {
         if (count !== ids.length) throw Boom.notFound(`${type} Not Found`);
       });
     }, { itemize: false });
 
     // Required fields
-    Pipeline.define('required', ({ query, model, field, value }) => {
-      if ((query.crud === 'create' && value == null) || (query.crud === 'update' && value === null)) throw Boom.badRequest(`${model.name}.${field.name} is required`);
+    Pipeline.define('required', ({ query, model, field, value, path }) => {
+      if ((query.crud === 'create' && value == null) || (query.crud === 'update' && value === null)) {
+        throw Boom.badRequest(`${model.name}.${field.name} is required`);
+      }
     }, { ignoreNull: false });
 
     // A field cannot hold a reference to itself
@@ -161,9 +164,9 @@ module.exports = class Pipeline {
   static resolve(params, pipeline) {
     const transformers = params.field.pipelines[pipeline] || [];
 
-    return Util.pipeline(transformers.map(t => (value) => {
-      return Pipeline[t]({ ...params, value });
-    }), params.value);
+    return transformers.reduce((value, t) => {
+      return Util.uvl(Pipeline[t]({ ...params, value }), value);
+    }, params.value);
   }
 };
 

package/src/data/Resolver.js

@@ -1,11 +1,11 @@
 const { graphql } = require('graphql');
 const Boom = require('@hapi/boom');
 const Util = require('@coderich/util');
+const QueryResolver = require('../query/QueryResolver');
 const Emitter = require('./Emitter');
 const Loader = require('./Loader');
 const DataLoader = require('./DataLoader');
 const Transaction = require('./Transaction');
-const QueryResolver = require('../query/QueryResolver');
 
 const loaders = {};
 
@@ -291,7 +291,7 @@ module.exports = class Resolver {
       const tquery = await $query.transform(false);
       query = tquery.toObject();
       event = this.#createEvent(query);
-      if (query.isMutation) await Emitter.emit('validate', event);
+      if (query.isMutation) await Promise.all([...query.input.$thunks, Emitter.emit('validate', event)]);
       return thunk(tquery);
     }).then((result) => {
       event.doc ??= result; // Case of create

package/src/data/Transformer.js

@@ -1,30 +1,36 @@
 const Util = require('@coderich/util');
 
 module.exports = class Transformer {
-  #config;
-  #operation;
-  #operations = {
-    get: {
-      get: () => {
+  #config = { shape: {}, defaults: {}, args: {}, strictSchema: false, keepUndefined: false };
 
-      },
-    },
-    set: {
-      set: (target, prop, value) => {
-        const transforms = this.#config.shape[prop] ?? [];
-        const $value = transforms.reduce((prev, t) => {
-          if (typeof t === 'function') return t(prev);
+  #operation = {
+    set: (target, prop, startValue, proxy) => {
+      if (this.#config.shape[prop]) {
+        let previousValue;
+
+        const result = this.#config.shape[prop].reduce((value, t) => {
+          previousValue = value;
+          if (typeof t === 'function') return Util.uvl(t({ startValue, value, ...this.#config.args }), value);
           prop = t;
-          return prev;
-        }, value);
-        target[prop] = $value;
-        return true;
-      },
+          return value;
+        }, startValue);
+
+        if (result instanceof Promise) {
+          target[prop] = previousValue;
+          proxy.$thunks.push(result);
+        } else if (result !== undefined || this.#config.keepUndefined) {
+          target[prop] = result;
+        }
+      } else if (!this.#config.strictSchema) {
+        target[prop] = startValue;
+      }
+
+      return true;
     },
   };
 
   /**
-   * Allowing construction of object before knowing configuration
+   * Allowing construction of object before knowing full configuration
    */
   constructor(config = {}) {
     this.config(config);
@@ -34,14 +40,30 @@ module.exports = class Transformer {
    * Re-assign configuration after instantiation
    */
   config(config = {}) {
-    this.#config = config;
-    this.#config.shape ??= {};
-    this.#config.defaults ??= {};
-    this.#config.operation ??= 'set';
-    this.#operation = this.#operations[this.#config.operation];
+    Object.assign(this.#config, config);
+    return this;
   }
 
-  transform(mixed) {
-    return Util.map(mixed, data => Object.assign(new Proxy({}, this.#operation), this.#config.defaults, data));
+  /**
+   * Re-assign args after instantiation
+   */
+  args(args = {}) {
+    Object.assign(this.#config.args, args);
+    return this;
+  }
+
+  clone(config) {
+    return new Transformer({ ...this.#config }).config(config);
+  }
+
+  transform(mixed, args = {}) {
+    args.thunks ??= [];
+    this.args(args);
+
+    return Util.map(mixed, (data) => {
+      const thunks = Object.defineProperty({}, '$thunks', { value: args.thunks });
+      const $data = Object.assign({}, this.#config.defaults, data); // eslint-disable-line
+      return Object.assign(new Proxy(thunks, this.#operation), $data);
+    });
   }
 };

package/src/query/Query.js

@@ -1,5 +1,4 @@
 const Util = require('@coderich/util');
-const Pipeline = require('../data/Pipeline');
 const { isGlob, globToRegex, mergeDeep, finalizeWhereClause, JSONParse } = require('../service/AppService');
 
 module.exports = class Query {
@@ -46,34 +45,22 @@ module.exports = class Query {
   }
 
   /**
-   * Run a portion of the pipeline against a data set
-   */
-  pipeline(target, data, transformers) {
-    data = Util.unflatten(data, { safe: true });
-    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, '$finalize'];
-    // if (this.#query.crud === 'create') transformerMap.input.unshift('$default'); // Cant because embedded documents on update are really "creates"
-    transformers = transformers || transformerMap[target];
-    return this.#pipeline(this.#query, target, this.#model, data, transformers.map(el => Pipeline[el]));
-  }
-
-  /**
-   * Transform entire query via pipeline. At minimum, pipeline is needed to unflatten the data...
+   * Transform entire query for user consumption
    */
   transform(asClone = true) {
-    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]) => {
-      if (asClone) return this.clone({ input, where, sort });
-      this.#query.input = input;
-      this.#query.where = where;
-      this.#query.sort = sort;
-      return this;
-    });
+    const args = { query: this.#query, resolver: this.#resolver, context: this.#context };
+
+    const [input, where, sort] = [
+      this.#model.transformers.input.transform(Util.unflatten(this.#query.input, { safe: true }), args),
+      this.#query.isNative ? this.#query.where : this.#model.transformers.where.transform(Util.unflatten(this.#query.where ?? {}, { safe: true }), args),
+      this.#model.transformers.sort.transform(Util.unflatten(this.#query.sort, { safe: true }), args),
+    ];
+
+    if (asClone) return this.clone({ input, where, sort });
+    this.#query.input = input;
+    this.#query.where = where;
+    this.#query.sort = sort;
+    return this;
   }
 
   /**
@@ -85,7 +72,7 @@ module.exports = class Query {
     const query = this.clone({
       model: this.#model.key,
       select: this.#query.select.map(name => this.#model.fields[name].key),
-      input: this.#model.walk(input, node => node.value !== undefined && Object.assign(node, { key: node.field.key })),
+      input: this.#model.transformers.toDriver.transform(input),
       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 : JSONParse(Buffer.from(before, 'base64').toString('ascii')),
@@ -98,36 +85,6 @@ module.exports = class Query {
     return query;
   }
 
-  /**
-   * 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 });
-      }), {});
-    });
-  }
-
   /**
    * Finalize the query for the driver
    */

package/src/query/QueryBuilder.js

@@ -1,5 +1,5 @@
 const Query = require('./Query');
-const { getGQLReturnType, getGQLSelectFields, mergeDeep } = require('../service/AppService');
+const { getGQLReturnType, mergeDeep } = require('../service/AppService');
 
 module.exports = class QueryBuilder {
   #query;

package/src/query/QueryResolver.js

@@ -44,9 +44,9 @@ module.exports = class QueryResolver extends QueryBuilder {
         });
       }
       case 'pushOne': {
-        return this.#get(query).then(async (doc) => {
+        return this.#get(query).then((doc) => {
           const [key] = Object.keys(input);
-          const values = get(await query.pipeline('input', input), key);
+          const values = get(this.#model.transformers.input.transform(input), key);
           const $input = { [key]: (get(doc, key) || []).concat(...values) };
           return this.#resolver.match(this.#model.name).id(doc.id).save($input);
         });
@@ -58,9 +58,9 @@ module.exports = class QueryResolver extends QueryBuilder {
         });
       }
       case 'pullOne': {
-        return this.#get(query).then(async (doc) => {
+        return this.#get(query).then((doc) => {
           const [key] = Object.keys(input);
-          const values = get(await query.pipeline('input', input), key);
+          const values = get(this.#model.transformers.input.transform(input), key);
           const $input = { [key]: (get(doc, key) || []).filter(el => values.every(v => `${v}` !== `${el}`)) };
           return this.#resolver.match(this.#model.name).id(doc.id).save($input);
         });
@@ -72,9 +72,9 @@ module.exports = class QueryResolver extends QueryBuilder {
         });
       }
       case 'spliceOne': {
-        return this.#get(query).then(async (doc) => {
+        return this.#get(query).then((doc) => {
           const [key] = Object.keys(input);
-          const [find, replace] = get(await query.pipeline('input', input), key);
+          const [find, replace] = get(this.#model.transformers.input.transform(input), key);
           const $input = { [key]: (get(doc, key) || []).map(el => (`${el}` === `${find}` ? replace : el)) };
           return this.#resolver.match(this.#model.name).id(doc.id).save($input);
         });

package/src/schema/Schema.js

@@ -16,8 +16,8 @@ const scalarKinds = [Kind.SCALAR_TYPE_DEFINITION, Kind.SCALAR_TYPE_EXTENSION];
 const fieldKinds = [Kind.FIELD_DEFINITION];
 const modelKinds = [Kind.OBJECT_TYPE_DEFINITION, Kind.OBJECT_TYPE_EXTENSION].concat(interfaceKinds);
 const allowedKinds = modelKinds.concat(fieldKinds).concat(Kind.DOCUMENT, Kind.NON_NULL_TYPE, Kind.NAMED_TYPE, Kind.LIST_TYPE, Kind.DIRECTIVE).concat(scalarKinds).concat(enumKinds);
-const pipelines = ['finalize', 'construct', 'restruct', 'instruct', 'normalize', 'serialize'];
-const inputPipelines = ['finalize', 'construct', 'instruct', 'normalize', 'serialize'];
+const pipelines = ['validate', 'construct', 'restruct', 'instruct', 'normalize', 'serialize'];
+const inputPipelines = ['validate', 'construct', 'instruct', 'normalize', 'serialize'];
 const scalars = ['ID', 'String', 'Float', 'Int', 'Boolean'];
 
 module.exports = class Schema {
@@ -144,7 +144,11 @@ module.exports = class Schema {
             loader: this.#config.dataLoaders?.default,
             generator: this.#config.generators?.default,
             pipelines: pipelines.reduce((prev, key) => Object.assign(prev, { [key]: [] }), {}),
-            transformers: { doc: new Transformer() },
+            transformers: {
+              input: new Transformer({ args: { schema: this.#schema, path: [] } }),
+              where: new Transformer({ args: { schema: this.#schema, path: [] } }),
+              doc: new Transformer({ args: { schema: this.#schema, path: [] } }),
+            },
             directives: {},
             toString: () => name,
           };
@@ -155,7 +159,6 @@ module.exports = class Schema {
             name,
             key: name,
             pipelines: pipelines.reduce((prev, key) => Object.assign(prev, { [key]: [] }), {}),
-            transformers: { doc: new Transformer() },
             directives: {},
             toString: () => name,
           };
@@ -180,7 +183,7 @@ module.exports = class Schema {
 
           // Define (and assign) an Allow pipeline for the enumeration
           Pipeline.define(name, Pipeline.Allow(...values), { configurable: true });
-          target.pipelines.finalize.push(name);
+          target.pipelines.validate.push(name);
         }
 
         if (node.kind === Kind.NON_NULL_TYPE) {
@@ -234,8 +237,8 @@ module.exports = class Schema {
                 target.isConnection = value;
                 break;
               }
-              case `${directives.field}-validate`: { // Alias for finalize
-                target.pipelines.finalize = target.pipelines.finalize.concat(value).filter(Boolean);
+              case `${directives.field}-validate`: {
+                target.pipelines.validate = target.pipelines.validate.concat(value).filter(Boolean);
                 break;
               }
               case `${directives.field}-transform`: { // Deprecated
@@ -345,11 +348,79 @@ module.exports = class Schema {
               where: Object.values($model.fields).filter(f => f.pipelines.instruct.length).reduce((prev, f) => Object.assign(prev, { [f.name]: undefined }), {}),
             };
 
+            $model.transformers.toDriver = new Transformer({
+              shape: Object.values($model.fields).reduce((prev, curr) => {
+                const rules = [curr.key]; // Rename key
+                if (curr.isEmbedded) rules.unshift(({ value }) => Util.map(value, v => curr.model.transformers.toDriver.transform(v)));
+                return Object.assign(prev, { [curr.name]: rules });
+              }, {}),
+            });
+
+            $model.transformers.input.config({
+              strictSchema: true,
+              shape: Object.values($model.fields).reduce((prev, curr) => {
+                const args = { model: $model, field: curr };
+
+                const rules = [
+                  a => Pipeline.$default({ ...a, ...args, path: a.path.concat(curr.name) }),
+                  a => Pipeline.$cast({ ...a, ...args, path: a.path.concat(curr.name) }),
+                  a => Pipeline.$normalize({ ...a, ...args, path: a.path.concat(curr.name) }),
+                  a => Pipeline.$instruct({ ...a, ...args, path: a.path.concat(curr.name) }),
+                  (a) => {
+                    if (a.query.crud === 'create') return Pipeline.$construct({ ...a, ...args, path: a.path.concat(curr.name) });
+                    if (a.query.crud === 'update') return Pipeline.$restruct({ ...a, ...args, path: a.path.concat(curr.name) });
+                    return undefined;
+                  },
+                  a => Pipeline.$serialize({ ...a, ...args, path: a.path.concat(curr.name) }),
+                ];
+
+                if (curr.isEmbedded) {
+                  rules.push(a => Util.map(a.value, (value, i) => {
+                    const path = a.path.concat(curr.name);
+                    if (curr.isArray) path.push(i);
+                    return curr.model.transformers.input.transform(value, { ...args, thunks: a.thunks, query: a.query, resolver: a.resolver, context: a.context, path });
+                  }));
+                }
+
+                // Validate
+                rules.push(a => Pipeline.$validate({ ...a, ...args, path: a.path.concat(curr.name) }));
+
+                return Object.assign(prev, { [curr.name]: rules });
+              }, {}),
+              defaults: $model.pipelineFields.input,
+            });
+
+            $model.transformers.where.config({
+              keepUndefined: true,
+              shape: Object.values($model.fields).reduce((prev, curr) => {
+                const args = { model: $model, field: curr };
+
+                const rules = [
+                  a => Pipeline.$cast({ ...a, ...args, path: a.path.concat(curr.name) }),
+                  a => Pipeline.$instruct({ ...a, ...args, path: a.path.concat(curr.name) }),
+                  a => Pipeline.$serialize({ ...a, ...args, path: a.path.concat(curr.name) }),
+                ];
+
+                if (curr.isEmbedded) {
+                  rules.push(a => Util.map(a.value, (value, i) => {
+                    const path = a.path.concat(curr.name);
+                    if (curr.isArray) path.push(i);
+                    return curr.model.transformers.where.transform(value, { ...args, query: a.query, context: a.context, path });
+                  }));
+                }
+
+                return Object.assign(prev, { [curr.name]: rules });
+              }, {}),
+              defaults: $model.pipelineFields.where,
+            });
+
+            $model.transformers.sort = $model.transformers.where.clone({ defaults: {} });
+
             $model.transformers.doc.config({
               shape: Object.values($model.fields).reduce((prev, curr) => {
                 const rules = [curr.name]; // Rename key
-                if (curr.isArray) rules.unshift(v => (v == null ? v : Util.ensureArray(v)));
-                if (curr.isEmbedded) rules.unshift(v => Util.map(v, el => curr.model.transformers.doc.transform(el)));
+                if (curr.isArray) rules.unshift(({ value }) => (value == null ? value : Util.ensureArray(value)));
+                if (curr.isEmbedded) rules.unshift(({ value }) => Util.map(value, v => curr.model.transformers.doc.transform(v)));
                 return Object.assign(prev, { [curr.key]: rules });
               }, {}),
             });
@@ -385,7 +456,7 @@ module.exports = class Schema {
 
             if ($field.isArray) $field.pipelines.normalize.unshift('toArray');
             if ($field.isPrimaryKey) $field.pipelines.serialize.unshift('$pk'); // Will create/convert to FK type always
-            if ($field.isRequired && $field.isPersistable && !$field.isVirtual) $field.pipelines.finalize.push('required');
+            if ($field.isRequired && $field.isPersistable && !$field.isVirtual) $field.pipelines.validate.push('required');
 
             if ($field.isFKReference) {
               const to = $field.model.key;
@@ -394,7 +465,7 @@ module.exports = class Schema {
               const as = `join_${to}`;
               $field.join = { to, on, from, as };
               $field.pipelines.serialize.unshift('$fk'); // Will convert to FK type IFF defined in payload
-              $field.pipelines.finalize.push('ensureFK'); // Absolute Last
+              $field.pipelines.validate.push('ensureFK'); // Absolute Last
             }
           });
 
@@ -540,8 +611,7 @@ module.exports = class Schema {
         construct: [AutoGraphPipelineEnum!]
         restruct: [AutoGraphPipelineEnum!]
         serialize: [AutoGraphPipelineEnum!]
-        finalize: [AutoGraphPipelineEnum!]
-        validate: [AutoGraphPipelineEnum!] # Alias for finalize
+        validate: [AutoGraphPipelineEnum!]
 
         # TEMP TO APPEASE TRANSITION
         ref: AutoGraphMixed # Specify the modelRef field's name (overrides isEmbedded)