@coderich/autograph 0.13.32 → 0.13.34

package/package.json

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

package/src/data/Pipeline.js

@@ -161,9 +161,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,7 +1,6 @@
 const { graphql } = require('graphql');
 const Boom = require('@hapi/boom');
 const Util = require('@coderich/util');
-const Pipeline = require('./Pipeline');
 const Emitter = require('./Emitter');
 const Loader = require('./Loader');
 const DataLoader = require('./DataLoader');
@@ -221,14 +220,10 @@ module.exports = class Resolver {
     const self = this;
     if (result == null) return result;
     if (typeof result !== 'object') return result;
+    model = this.#schema.models[model];
+
     return Object.defineProperties(Util.map(result, (doc) => {
-      // Transform result to domain model
-      const $doc = this.#schema.models[model].walk(doc, (node) => {
-        if (node.value === undefined) return undefined;
-        if (node.value != null && node.field.isArray) node.value = Util.ensureArray(node.value);
-        node.key = node.field.name;
-        return node;
-      }, { key: 'key' });
+      const $doc = model.transformers.doc.transform(doc);
 
       // Assign useful/needed meta data
       return Object.defineProperties($doc, {

package/src/data/Transformer.js

@@ -0,0 +1,65 @@
+const Util = require('@coderich/util');
+
+// { query, path: path.concat(key), context: this.#context }
+
+module.exports = class Transformer {
+  #config = {
+    args: {},
+    shape: {},
+    defaults: {},
+    operation: 'set',
+  };
+
+  #operations = {
+    get: {
+      get: () => {
+
+      },
+    },
+    set: {
+      set: (target, prop, startValue) => {
+        const transforms = this.#config.shape[prop] ?? [];
+
+        const result = transforms.reduce((value, t) => {
+          if (typeof t === 'function') return Util.uvl(t({ startValue, value, ...this.#config.args }), value);
+          prop = t;
+          return value;
+        }, startValue);
+
+        target[prop] = result;
+        return true;
+      },
+    },
+  };
+
+  #operation;
+
+  /**
+   * Allowing construction of object before knowing full configuration
+   */
+  constructor(config = {}) {
+    this.config(config);
+  }
+
+  /**
+   * Re-assign configuration after instantiation
+   */
+  config(config = {}) {
+    Object.assign(this.#config, config);
+    this.#operation = this.#operations[this.#config.operation];
+    return this;
+  }
+
+  /**
+   * Re-assign args after instantiation
+   */
+  args(args = {}) {
+    Object.assign(this.#config.args, args);
+    return this;
+  }
+
+  transform(mixed, args) {
+    this.args(args);
+    return Util.map(mixed, data => Object.assign(new Proxy({}, this.#operation), this.#config.defaults, data));
+  }
+};

package/src/query/Query.js

@@ -64,6 +64,7 @@ module.exports = class Query {
    */
   transform(asClone = true) {
     return Promise.all([
+      // this.#model.transformers.input.transform(this.#query.input),
       this.pipeline('input', this.#query.input),
       this.#query.isNative ? this.#query.where : this.pipeline('where', this.#query.where ?? {}),
       this.pipeline('sort', this.#query.sort),

package/src/schema/Schema.js

@@ -4,6 +4,7 @@ const Util = require('@coderich/util');
 const { Kind, parse, visit } = require('graphql');
 const { mergeTypeDefs, mergeFields, mergeDirectives } = require('@graphql-tools/merge');
 const { isLeafValue, mergeDeep, fromGUID } = require('../service/AppService');
+const Transformer = require('../data/Transformer');
 const Pipeline = require('../data/Pipeline');
 const Emitter = require('../data/Emitter');
 
@@ -143,6 +144,10 @@ module.exports = class Schema {
             loader: this.#config.dataLoaders?.default,
             generator: this.#config.generators?.default,
             pipelines: pipelines.reduce((prev, key) => Object.assign(prev, { [key]: [] }), {}),
+            transformers: {
+              input: new Transformer(),
+              doc: new Transformer({ args: { model, schema: this.#schema } }),
+            },
             directives: {},
             toString: () => name,
           };
@@ -153,6 +158,9 @@ module.exports = class Schema {
             name,
             key: name,
             pipelines: pipelines.reduce((prev, key) => Object.assign(prev, { [key]: [] }), {}),
+            transformers: {
+              input: new Transformer({ args: { model, field, schema: this.#schema } }),
+            },
             directives: {},
             toString: () => name,
           };
@@ -341,6 +349,31 @@ module.exports = class Schema {
               input: Object.values($model.fields).filter(f => f.defaultValue !== undefined || inputPipelines.some(k => f.pipelines[k].length)).reduce((prev, f) => Object.assign(prev, { [f.name]: undefined }), {}),
               where: Object.values($model.fields).filter(f => f.pipelines.instruct.length).reduce((prev, f) => Object.assign(prev, { [f.name]: undefined }), {}),
             };
+
+            $model.transformers.input.config({
+              shape: Object.values($model.fields).reduce((prev, curr) => {
+                const rules = [
+                  a => Pipeline.$default({ ...a, field: curr }),
+                  a => Pipeline.$cast({ ...a, field: curr }),
+                  a => Pipeline.$normalize({ ...a, field: curr }),
+                  a => Pipeline.$instruct({ ...a, field: curr }),
+                  // a => Pipeline.$finalize({ ...a, field: curr }),
+                ];
+                // if (curr.isEmbedded) rules.push(a => Util.map(a.value, value => curr.model.transformers.input.transform(value)));
+                if (curr.isEmbedded) rules.push(a => curr.model.transformers.input.transform(a.value));
+                // rules.push(curr.key); // rename
+                return Object.assign(prev, { [curr.name]: rules });
+              }, {}),
+            });
+
+            $model.transformers.doc.config({
+              shape: Object.values($model.fields).reduce((prev, curr) => {
+                const rules = [curr.name]; // Rename key
+                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 });
+              }, {}),
+            });
           });
         } else if (node.kind === Kind.FIELD_DEFINITION) {
           const $field = field;