@coderich/autograph 0.13.49 → 0.13.51

package/package.json

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

package/src/data/Emitter.js

@@ -27,8 +27,8 @@ class Emitter extends EventEmitter {
 
       // Next functions are async and control the timing of the next phase
       Promise.all(nextFuncs.sort(Emitter.sort).map((fn) => {
-        return new Promise((next) => {
-          Promise.resolve(fn(data, next));
+        return new Promise((next, err) => {
+          Promise.resolve().then(() => fn(data, next)).catch(err);
         }).then((result) => {
           if (result !== undefined) throw new AbortEarlyError(result);
         }).catch(reject);
@@ -89,7 +89,7 @@ class Emitter extends EventEmitter {
     } : (event, next) => {
       if (arr.includes(`${event.query[prop]}`)) {
         if (once) this.removeListener(eventName, wrapper);
-        return next(listener(event, next));
+        return listener(event, next);
       }
       return next();
     };

package/src/data/Pipeline.js

@@ -49,10 +49,10 @@ module.exports = class Pipeline {
     // Additional Transformers
     Pipeline.define('toArray', ({ value }) => (Array.isArray(value) ? value : [value]), { itemize: false });
     Pipeline.define('toDate', ({ value }) => new Date(value), { configurable: true });
+    Pipeline.define('createdAt', ({ query, model, value }) => value || (query.crud === 'create' || model.isEmbedded ? new Date() : undefined), { ignoreNull: false });
     Pipeline.define('updatedAt', () => new Date(), { ignoreNull: false });
     Pipeline.define('toTitleCase', ({ value }) => value.replace(/\w\S*/g, w => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()));
     Pipeline.define('toSentenceCase', ({ value }) => value.charAt(0).toUpperCase() + value.slice(1));
-    Pipeline.define('createdAt', ({ value }) => value || new Date(), { ignoreNull: false });
     Pipeline.define('timestamp', () => Date.now(), { ignoreNull: false });
     Pipeline.define('dedupe', ({ value }) => uniqWith(value, (b, c) => hashObject(b) === hashObject(c)), { itemize: false });
 

package/src/data/Resolver.js

@@ -2,6 +2,7 @@ const { graphql } = require('graphql');
 const Boom = require('@hapi/boom');
 const Util = require('@coderich/util');
 const QueryResolver = require('../query/QueryResolver');
+const AppService = require('../service/AppService');
 const Emitter = require('./Emitter');
 const Loader = require('./Loader');
 const DataLoader = require('./DataLoader');
@@ -225,7 +226,7 @@ module.exports = class Resolver {
 
     return this.#createSystemEvent(query, (tquery) => {
       return thunk(tquery).then((result) => {
-        if (flags?.required && (result == null || result?.length === 0)) throw Boom.notFound();
+        if (flags?.required && (result == null || result?.length === 0)) throw Boom.notFound(`${model} Not Found`);
         return result;
       });
     });
@@ -306,10 +307,9 @@ module.exports = class Resolver {
       const tquery = await $query.transform(false);
       query = tquery.toObject();
       event = this.#createEvent(query);
-      if (query.isMutation) await Promise.all([...query.input.$thunks, Emitter.emit('validate', event)]);
+      if (['create', 'update'].includes(query.crud)) await Promise.all([...query.input.$thunks, Emitter.emit('validate', event)]);
       return thunk(tquery);
     }).then((result) => {
-      event.doc ??= result; // Case of create
       event.result = result; // backwards compat
       query.result = result;
       return Emitter.emit(`post${type}`, event);
@@ -326,8 +326,9 @@ module.exports = class Resolver {
     Object.assign(event, query);
     query.match = query.where;
     query.toObject = () => query;
-    event.merged = event.input;
-    event.input = event.args?.input;
+    event.doc ??= {};
+    event.input ??= {};
+    event.merged = AppService.mergeDeep(event.doc, event.input);
 
     return event;
   }

package/src/query/Query.js

@@ -51,7 +51,7 @@ module.exports = class Query {
     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.#model.transformers[this.#query.crud]?.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),
     ];

package/src/query/QueryResolver.js

@@ -1,7 +1,6 @@
 const get = require('lodash.get');
 const Util = require('@coderich/util');
 const QueryBuilder = require('./QueryBuilder');
-const { mergeDeep } = require('../service/AppService');
 
 module.exports = class QueryResolver extends QueryBuilder {
   #model;
@@ -34,12 +33,7 @@ module.exports = class QueryResolver extends QueryBuilder {
       }
       case 'updateOne': {
         return this.#get(query).then((doc) => {
-          // const $input = this.#model.walk(doc, (node) => {
-          //   if (node.field.defaultValue !== undefined || ['instruct', 'restruct', 'serialize'].some(el => node.field.pipelines[el]?.length)) return node;
-          //   return false;
-          // });
-          const merged = mergeDeep({}, doc, Util.unflatten(input, { safe: true }));
-          return this.#resolver.resolve(query.clone({ doc, input: merged }));
+          return this.#resolver.resolve(query.clone({ doc }));
         });
       }
       case 'updateMany': {
@@ -50,7 +44,8 @@ module.exports = class QueryResolver extends QueryBuilder {
       case 'pushOne': {
         return this.#get(query).then((doc) => {
           const [key] = Object.keys(input);
-          const values = get(this.#model.transformers.input.transform(input), key);
+          const $query = Object.assign(query.toObject(), { doc });
+          const values = get(this.#model.transformers.create.transform(input, { query: $query }), key);
           const $input = { [key]: (get(doc, key) || []).concat(...values) };
           return this.#resolver.match(this.#model.name).id(doc.id).save($input);
         });
@@ -64,7 +59,8 @@ module.exports = class QueryResolver extends QueryBuilder {
       case 'pullOne': {
         return this.#get(query).then((doc) => {
           const [key] = Object.keys(input);
-          const values = get(this.#model.transformers.input.transform(input), key, []);
+          const $query = Object.assign(query.toObject(), { doc });
+          const values = get(this.#model.transformers.create.transform(input, { query: $query }), key, []);
           const $doc = Util.pathmap(key, doc, (arr) => {
             return arr.filter(el => values.every(v => `${v}` !== `${el}`));
           });
@@ -80,7 +76,8 @@ module.exports = class QueryResolver extends QueryBuilder {
       case 'spliceOne': {
         return this.#get(query).then((doc) => {
           const [key] = Object.keys(input);
-          const [find, replace] = get(this.#model.transformers.input.transform(input), key);
+          const $query = Object.assign(query.toObject(), { doc });
+          const [find, replace] = get(this.#model.transformers.create.transform(input, { query: $query }), 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

@@ -17,7 +17,8 @@ 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 = ['validate', 'construct', 'restruct', 'instruct', 'normalize', 'serialize', 'deserialize'];
-const inputPipelines = ['validate', 'construct', 'instruct', 'normalize', 'serialize'];
+const createPipelines = ['validate', 'construct', 'instruct', 'normalize', 'serialize'];
+const updatePipelines = ['validate', 'restruct', 'instruct', 'normalize', 'serialize'];
 const scalars = ['ID', 'String', 'Float', 'Int', 'Boolean'];
 
 module.exports = class Schema {
@@ -146,7 +147,8 @@ module.exports = class Schema {
             generator: this.#config.generators?.default,
             pipelines: pipelines.reduce((prev, key) => Object.assign(prev, { [key]: [] }), {}),
             transformers: {
-              input: new Transformer({ args: { schema: this.#schema, path: [] } }),
+              create: new Transformer({ args: { schema: this.#schema, path: [] } }),
+              update: new Transformer({ args: { schema: this.#schema, path: [] } }),
               where: new Transformer({ args: { schema: this.#schema, path: [] } }),
               doc: new Transformer({ args: { schema: this.#schema, path: [] } }),
             },
@@ -351,7 +353,7 @@ module.exports = class Schema {
               }, {}),
             });
 
-            $model.transformers.input.config({
+            $model.transformers.create.config({
               strictSchema: true,
               shape: Object.values($model.fields).reduce((prev, curr) => {
                 const args = { model: $model, field: curr };
@@ -360,11 +362,7 @@ module.exports = class Schema {
                   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.$construct({ ...a, ...args, path: a.path.concat(curr.name) }),
                   a => Pipeline.$serialize({ ...a, ...args, path: a.path.concat(curr.name) }),
                 ];
 
@@ -372,18 +370,51 @@ module.exports = class Schema {
                   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 });
+                    return curr.model.transformers.create.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) }));
+                rules.push(a => (a.query.op === 'createOne' ? Pipeline.$validate({ ...a, ...args, path: a.path.concat(curr.name) }) : undefined));
 
                 return Object.assign(prev, { [curr.name]: rules });
               }, {}),
               defaults: Object.values($model.fields).reduce((prev, curr) => {
                 if (curr.defaultValue !== undefined) return Object.assign(prev, { [curr.name]: curr.defaultValue });
-                if (inputPipelines.some(el => curr.pipelines[el].length)) return Object.assign(prev, { [curr.name]: undefined });
+                if (createPipelines.some(el => curr.pipelines[el].length)) return Object.assign(prev, { [curr.name]: undefined });
+                return prev;
+              }, {}),
+            });
+
+            $model.transformers.update.config({
+              strictSchema: 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.$normalize({ ...a, ...args, path: a.path.concat(curr.name) }),
+                  a => Pipeline.$instruct({ ...a, ...args, path: a.path.concat(curr.name) }),
+                  a => Pipeline.$restruct({ ...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.update.transform(value, { ...args, thunks: a.thunks, query: a.query, resolver: a.resolver, context: a.context, path });
+                  }));
+                }
+
+                // Validate
+                rules.push(a => (a.query.op === 'updateOne' ? Pipeline.$validate({ ...a, ...args, path: a.path.concat(curr.name) }) : undefined));
+
+                return Object.assign(prev, { [curr.name]: rules });
+              }, {}),
+              defaults: Object.values($model.fields).reduce((prev, curr) => {
+                // if (curr.defaultValue !== undefined) return Object.assign(prev, { [curr.name]: curr.defaultValue });
+                if (updatePipelines.some(el => curr.pipelines[el].length)) return Object.assign(prev, { [curr.name]: undefined });
                 return prev;
               }, {}),
             });