@coderich/autograph 0.13.21 → 0.13.23

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@coderich/autograph",
   "main": "index.js",
-  "version": "0.13.21",
+  "version": "0.13.23",
   "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);
       });
     });
   }
@@ -237,7 +229,7 @@ module.exports = class Resolver {
                 return (...args) => {
                   switch (cmd) {
                     case 'save': {
-                      return queryResolver.save({ ...$doc, ...args[0] });
+                      return queryResolver.save({ ...$doc, ...args[0] }); // $doc incase it's mutated
                     }
                     case 'lookup': {
                       const field = self.toModel(model).fields[args[0]];
@@ -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

@@ -1,6 +1,6 @@
 const Util = require('@coderich/util');
 const Pipeline = require('../data/Pipeline');
-const { isGlob, globToRegex, mergeDeep, finalizeWhereClause } = require('../service/AppService');
+const { isGlob, globToRegex, mergeDeep, finalizeWhereClause, JSONParse } = require('../service/AppService');
 
 module.exports = class Query {
   #config;
@@ -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]));
   }
@@ -81,8 +82,8 @@ module.exports = class Query {
       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')),
+      before: (!isCursorPaging || !before) ? undefined : JSONParse(Buffer.from(before, 'base64').toString('ascii')),
+      after: (!isCursorPaging || !after) ? undefined : JSONParse(Buffer.from(after, 'base64').toString('ascii')),
       $schema: this.#schema.resolvePath,
     });
 
@@ -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/QueryBuilder.js

@@ -68,7 +68,7 @@ module.exports = class QueryBuilder {
   }
 
   info(info) {
-    this.select(getGQLSelectFields(this.#query.model, info));
+    // this.select(getGQLSelectFields(this.#query.model, info));
     return this;
   }
 
@@ -82,7 +82,7 @@ module.exports = class QueryBuilder {
   }
 
   where(clause) {
-    this.#propCheck('where', 'native', false);
+    this.#propCheck('where', 'native', false); // Allow redefine of "where" because we merge it
     const $clause = mergeDeep(this.#query.where || {}, clause);
     this.#query.where = $clause;
     this.#query.args.where = $clause;

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/schema/Schema.js

@@ -589,7 +589,7 @@ module.exports = class Schema {
             }
             ${connectionFields.length ? `
               extend type ${model} {
-                ${connectionFields.map(field => `${field}: ${field.model}Connection`)}
+                ${connectionFields.map(field => `${field}(${Schema.#getConnectionArguments(field.model)}): ${field.model}Connection`)}
               }
             ` : ''}
           `;
@@ -619,16 +619,7 @@ module.exports = class Schema {
           node(id: ID!): Node
           ${queryModels.map(model => `
             get${model}(id: ID!): ${model}
-            find${model}(
-              where: ${model}InputWhere
-              sortBy: ${model}InputSort
-              limit: Int
-              skip: Int
-              first: Int
-              after: String
-              last: Int
-              before: String
-            ): ${model}Connection!
+            find${model}(${Schema.#getConnectionArguments(model)}): ${model}Connection!
           `)}
         }
 
@@ -713,13 +704,7 @@ module.exports = class Schema {
         Query: queryModels.reduce((prev, model) => {
           return Object.assign(prev, {
             [`get${model}`]: (doc, args, context, info) => context[schema.namespace].resolver.match(model).args(args).info(info).one({ required: true }),
-            [`find${model}`]: (doc, args, context, info) => {
-              return {
-                edges: () => context[schema.namespace].resolver.match(model).args(args).info(info).many(),
-                count: () => context[schema.namespace].resolver.match(model).args(args).info(info).count(),
-                pageInfo: () => context[schema.namespace].resolver.match(model).args(args).info(info).many(),
-              };
-            },
+            [`find${model}`]: (doc, args, context, info) => context[schema.namespace].resolver.match(model).args(args).info(info).resolve(info),
           });
         }, {
           node: (doc, args, context, info) => {
@@ -746,7 +731,7 @@ module.exports = class Schema {
             [model]: Object.values(model.fields).filter(field => field.model?.isEntity).reduce((prev2, field) => {
               return Object.assign(prev2, {
                 [field]: (doc, args, context, info) => {
-                  return context[schema.namespace].resolver.match(field.model).where({ [field.linkBy]: doc[field.linkField.name] }).args(args).info(info).resolve(info);
+                  return doc.$.lookup(field).args(args).info(info).resolve(info);
                 },
               });
             }, {}),
@@ -767,6 +752,19 @@ module.exports = class Schema {
     return type;
   }
 
+  static #getConnectionArguments(model) {
+    return `
+      where: ${model}InputWhere
+      sortBy: ${model}InputSort
+      limit: Int
+      skip: Int
+      first: Int
+      after: String
+      last: Int
+      before: String
+    `;
+  }
+
   static #identifyOnDeletes(models, parentName) {
     return models.reduce((prev, model) => {
       Object.values(model.fields).filter(f => f.onDelete).forEach((field) => {

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,17 @@ 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 });
+//   }, {}));
+// };
+
+exports.JSONParse = (mixed) => {
+  try {
+    const json = JSON.parse(mixed);
+    return json;
+  } catch (e) {
+    return undefined;
+  }
 };