@coderich/autograph 0.13.21 → 0.13.22

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@coderich/autograph",
   "main": "index.js",
-  "version": "0.13.21",
+  "version": "0.13.22",
   "publishConfig": {
     "access": "public"
   },
@@ -15,7 +15,7 @@
     "dev": "coderich-dev"
   },
   "dependencies": {
-    "@coderich/util": "1.0.2",
+    "@coderich/util": "1.0.3",
     "@graphql-tools/merge": "9.0.0",
     "@graphql-tools/resolvers-composition": "7.0.0",
     "@hapi/boom": "10.0.1",

package/src/data/Emitter.js

@@ -12,20 +12,21 @@ class Emitter extends EventEmitter {
   emit(event, data) {
     // Here we pull out functions with "next" vs those without
     const [basicFuncs, nextFuncs] = this.rawListeners(event).reduce((prev, wrapper) => {
-      const listener = wrapper.listener || wrapper;
+      const { listener = wrapper } = wrapper;
       const isBasic = listener.length < 2;
+      wrapper.priority = listener.priority ?? 0;
       return prev[isBasic ? 0 : 1].push(wrapper) && prev;
     }, [[], []]);
 
     return new Promise((resolve, reject) => {
       // Basic functions run first; if they return a value they abort the flow of execution
-      basicFuncs.forEach((fn) => {
+      basicFuncs.sort(Emitter.sort).forEach((fn) => {
         const value = fn(data);
         if (value !== undefined && !(value instanceof Promise)) throw new AbortEarlyError(value);
       });
 
       // Next functions are async and control the timing of the next phase
-      Promise.all(nextFuncs.map((fn) => {
+      Promise.all(nextFuncs.sort(Emitter.sort).map((fn) => {
         return new Promise((next) => {
           Promise.resolve(fn(data, next));
         }).then((result) => {
@@ -38,35 +39,45 @@ class Emitter extends EventEmitter {
     });
   }
 
+  on(event, listener, priority = 0) {
+    listener.priority = priority;
+    return super.on(event, listener);
+  }
+
+  prependListener(event, listener, priority = 0) {
+    listener.priority = priority;
+    return super.prependListener(event, listener);
+  }
+
   /**
    * Syntactic sugar to listen on query keys
    */
   onKeys(...args) {
-    return this.#createWrapper(...args, 'key');
+    return this.#createWrapper('key', false, ...args,);
   }
 
   /**
    * Syntactic sugar to listen once on query keys
    */
   onceKeys(...args) {
-    return this.#createWrapper(...args, 'key', true);
+    return this.#createWrapper('key', true, ...args);
   }
 
   /**
    * Syntactic sugar to listen on query models
    */
   onModels(...args) {
-    return this.#createWrapper(...args, 'model');
+    return this.#createWrapper('model', false, ...args);
   }
 
   /**
    * Syntactic sugar to listen once on query models
    */
   onceModels(...args) {
-    return this.#createWrapper(...args, 'model', true);
+    return this.#createWrapper('model', true, ...args);
   }
 
-  #createWrapper(eventName, arr, listener, prop, once) {
+  #createWrapper(prop, once, eventName, arr, listener, priority) {
     arr = Util.ensureArray(arr);
 
     const wrapper = listener.length < 2 ? (event) => {
@@ -83,7 +94,13 @@ class Emitter extends EventEmitter {
       return next();
     };
 
-    return this.on(eventName, wrapper);
+    return this.on(eventName, wrapper, priority);
+  }
+
+  static sort(a, b) {
+    if (a.priority > b.priority) return -1;
+    if (a.priority < b.priority) return 1;
+    return 0;
   }
 }
 

package/src/data/Resolver.js

@@ -189,19 +189,11 @@ module.exports = class Resolver {
    */
   async resolve(query) {
     let thunk;
-    const tquery = await query.transform();
-    const oquery = Object.defineProperties(tquery.toObject(), {
-      changeset: {
-        get: function get() {
-          return oquery.crud === 'update' ? Util.changeset(this.doc, this.input) : undefined;
-        },
-      },
-    });
-    const model = this.#schema.models[oquery.model];
+    const { model, doc, crud, isMutation, flags } = query.toObject();
     const currSession = this.#sessions.slice(-1).pop();
 
-    if (oquery.isMutation) {
-      thunk = () => model.source.client.resolve(tquery.toDriver().toObject()).then((results) => {
+    if (isMutation) {
+      thunk = tquery => this.#schema.models[model].source.client.resolve(tquery.toDriver().toObject()).then((results) => {
         // We clear the cache immediately (regardless if we're in transaction or not)
         this.clear(model);
 
@@ -209,16 +201,16 @@ module.exports = class Resolver {
         currSession?.thunks.push(...this.#sessions.map(s => () => s.parent.clear(model)));
 
         // Return results
-        return oquery.crud === 'delete' ? oquery.doc : results;
+        return crud === 'delete' ? doc : results;
       });
     } else {
-      thunk = () => this.#dataLoaders[model].resolve(tquery);
+      thunk = tquery => this.#dataLoaders[model].resolve(tquery);
     }
 
-    return this.#createSystemEvent(tquery, () => {
-      return thunk().then((result) => {
-        if (oquery.flags?.required && (result == null || result?.length === 0)) throw Boom.notFound();
-        return oquery.crud === 'delete' ? result : this.toResultSet(model, result);
+    return this.#createSystemEvent(query, (tquery) => {
+      return thunk(tquery).then((result) => {
+        if (flags?.required && (result == null || result?.length === 0)) throw Boom.notFound();
+        return crud === 'delete' ? result : this.toResultSet(model, result);
       });
     });
   }
@@ -274,8 +266,8 @@ module.exports = class Resolver {
     }, {});
   }
 
-  #createSystemEvent(tquery, thunk = () => {}) {
-    const query = tquery.toObject();
+  #createSystemEvent($query, thunk = () => {}) {
+    const query = $query.toObject();
     const type = query.isMutation ? 'Mutation' : 'Query';
     const event = { schema: this.#schema, context: this.#context, resolver: this, query };
 
@@ -287,23 +279,15 @@ module.exports = class Resolver {
     event.input = event.args?.input;
 
     return Emitter.emit(`pre${type}`, event).then(async (resultEarly) => {
-      if (resultEarly !== undefined) return resultEarly;
-      if (Util.isEqual(query.changeset, { added: {}, updated: {}, deleted: {} })) return query.doc;
-      if (query.isMutation) query.input = await tquery.pipeline('input', query.input, ['$finalize']);
-      if (query.isMutation) await Emitter.emit('finalize', event);
-      return thunk().then((result) => {
+      if (resultEarly !== undefined) return resultEarly; // Nothing to validate/transform
+      // if (query.crud === 'update' && Util.isEqual({ added: {}, updated: {}, deleted: {} }, Util.changeset(query.doc, query.input))) return query.doc;
+      const tquery = await $query.transform();
+      // await Emitter.emit('validate', event); // We need to re-connect tquery to event
+      return thunk(tquery).then((result) => {
         event.result = result; // backwards compat
         query.result = result;
         return Emitter.emit(`post${type}`, event);
       });
-    }).then((result = query.result) => {
-      event.result = result; // backwards compat
-      query.result = result;
-      return Emitter.emit('preResponse', event);
-    }).then((result = query.result) => {
-      event.result = result; // backwards compat
-      query.result = result;
-      return Emitter.emit('postResponse', event);
     }).then((result = query.result) => result).catch((e) => {
       const { data = {} } = e;
       throw Boom.boomify(e, { data: { ...event, ...data } });

package/src/query/Query.js

@@ -49,11 +49,12 @@ module.exports = class Query {
    * Run a portion of the pipeline against a data set
    */
   pipeline(target, data, transformers) {
-    data = Util.unflatten(data);
+    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];
+    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]));
   }
@@ -128,7 +129,7 @@ module.exports = class 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]: {} }), {}));
+    const $sort = Util.unflatten(Object.keys(flatSort).reduce((prev, key) => Object.assign(prev, { [key]: {} }), {}), { safe: true });
 
     //
     query.sort = this.#model.walk(sort, (node) => {

package/src/query/QueryResolver.js

@@ -34,7 +34,7 @@ module.exports = class QueryResolver extends QueryBuilder {
       }
       case 'updateOne': {
         return this.#get(query).then((doc) => {
-          const merged = mergeDeep({}, Util.unflatten(doc), Util.unflatten(input));
+          const merged = mergeDeep({}, Util.unflatten(doc, { safe: true }), Util.unflatten(input, { safe: true }));
           return this.#resolver.resolve(query.clone({ doc, input: merged }));
         });
       }

package/src/service/AppService.js

@@ -11,8 +11,7 @@ exports.isGlob = str => PicoMatch.scan(str).isGlob;
 exports.globToRegex = (glob, options = {}) => PicoMatch.makeRe(glob, { nocase: true, ...options, expandRange: (a, b) => `(${FillRange(a, b, { toRegex: true })})` });
 
 const smartMerge = (target, source, options) => source;
-exports.isScalarValue = value => typeof value !== 'object' && typeof value !== 'function';
-exports.isLeafValue = value => Array.isArray(value) || value instanceof Date || ObjectId.isValid(value) || exports.isScalarValue(value);
+exports.isLeafValue = value => Array.isArray(value) || value instanceof Date || ObjectId.isValid(value) || Util.isScalarValue(value);
 exports.mergeDeep = (...args) => DeepMerge.all(args, { isMergeableObject: obj => (Util.isPlainObjectOrArray(obj)), arrayMerge: smartMerge });
 exports.hashObject = obj => ObjectHash(obj, { respectType: false, respectFunctionNames: false, respectFunctionProperties: false, unorderedArrays: true, ignoreUnknown: true, replacer: r => (ObjectId.isValid(r) ? `${r}` : r) });
 exports.fromGUID = guid => Buffer.from(`${guid}`, 'base64').toString('ascii').split(',');
@@ -39,8 +38,8 @@ exports.getGQLSelectFields = (model, info) => {
   return Object.keys(node || fields);
 };
 
-exports.removeUndefinedDeep = (obj) => {
-  return Util.unflatten(Object.entries(Util.flatten(obj)).reduce((prev, [key, value]) => {
-    return value === undefined ? prev : Object.assign(prev, { [key]: value });
-  }, {}));
-};
+// exports.removeUndefinedDeep = (obj) => {
+//   return Util.unflatten(Object.entries(Util.flatten(obj)).reduce((prev, [key, value]) => {
+//     return value === undefined ? prev : Object.assign(prev, { [key]: value });
+//   }, {}));
+// };