@coderich/autograph 0.13.25 → 0.13.27

package/package.json

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

package/src/data/DataLoader.js

@@ -6,9 +6,11 @@ const { hashObject } = require('../service/AppService');
 module.exports = class Loader {
   #model;
   #loader;
+  #resolver;
 
-  constructor(model) {
+  constructor(model, resolver) {
     this.#model = model;
+    this.#resolver = resolver;
     model.loader.cacheKeyFn ??= (query => hashObject(query.toCacheKey()));
     this.#loader = new DataLoader(keys => this.#resolve(keys), model.loader);
   }
@@ -28,8 +30,8 @@ module.exports = class Loader {
 
       return this.#model.source.client.resolve($query).then((data) => {
         if (data == null) return null; // Explicit return null;
-        if ($query.isCursorPaging && Array.isArray(data)) return Loader.#paginateResults(data, query.toObject());
-        return data;
+        if ($query.isCursorPaging && Array.isArray(data)) data = Loader.#paginateResults(data, query.toObject());
+        return this.#resolver.toResultSet(this.#model, data);
       });
     }));
   }

package/src/data/Resolver.js

@@ -190,7 +190,7 @@ module.exports = class Resolver {
    */
   async resolve(query) {
     let thunk;
-    const { model, doc, crud, isMutation, flags } = query.toObject();
+    const { doc, model, crud, isMutation, flags } = query.toObject();
     const currSession = this.#sessions.slice(-1).pop();
 
     if (isMutation) {
@@ -202,7 +202,8 @@ module.exports = class Resolver {
         currSession?.thunks.push(...this.#sessions.map(s => () => s.parent.clear(model)));
 
         // Return results
-        return crud === 'delete' ? doc : results;
+        if (crud === 'delete') return doc;
+        return this.toResultSet(model, results);
       });
     } else {
       thunk = tquery => this.#dataLoaders[model].resolve(tquery);
@@ -211,7 +212,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();
-        return crud === 'delete' ? result : this.toResultSet(model, result);
+        return result;
       });
     });
   }
@@ -224,8 +225,8 @@ module.exports = class Resolver {
       // 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;
-        node.value = Pipeline.$cast(node);
         return node;
       }, { key: 'key' });
 
@@ -257,6 +258,15 @@ module.exports = class Resolver {
         },
         $model: { value: model },
         $cursor: { value: doc.$cursor },
+        // Backwards compat
+        $save: { value: (...args) => $doc.$.save(...args) },
+        $lookup: {
+          value: async (prop, args) => {
+            const field = model.fields[prop];
+            const method = field.isArray ? 'many' : 'one';
+            return $doc.$.lookup(prop).args(args)[method]();
+          },
+        },
       });
     }), {
       $pageInfo: { value: result.$pageInfo },
@@ -271,7 +281,7 @@ module.exports = class Resolver {
     return Object.entries(this.#schema.models).filter(([key, value]) => {
       return value.loader && value.isEntity;
     }).reduce((prev, [key, value]) => {
-      return Object.assign(prev, { [key]: new DataLoader(value) });
+      return Object.assign(prev, { [key]: new DataLoader(value, this) });
     }, {});
   }
 
@@ -292,11 +302,12 @@ module.exports = class Resolver {
       // 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);
-      });
+      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);
     }).then((result = query.result) => result).catch((e) => {
       const { data = {} } = e;
       throw Boom.boomify(e, { data: { ...event, ...data } });

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, { safe: true }), Util.unflatten(input, { safe: true }));
+          const merged = mergeDeep({}, doc, Util.unflatten(input, { safe: true }));
           return this.#resolver.resolve(query.clone({ doc, input: merged }));
         });
       }

package/src/schema/Schema.js

@@ -164,13 +164,15 @@ module.exports = class Schema {
         }
 
         if (enumKinds.includes(node.kind)) {
+          const values = Schema.#resolveNodeValue(node);
+
           target = this.#schema.enums[name] = {
+            values,
             directives: {},
             pipelines: pipelines.reduce((prev, key) => Object.assign(prev, { [key]: [] }), {}),
           };
 
           // Define (and assign) an Allow pipeline for the enumeration
-          const values = Schema.#resolveNodeValue(node);
           Pipeline.define(name, Pipeline.Allow(...values), { configurable: true });
           target.pipelines.finalize.push(name);
         }
@@ -360,7 +362,10 @@ module.exports = class Schema {
             // Merge Enums and Scalar type definitions
             const enumer = this.#schema.enums[$field.type];
             const scalar = this.#schema.scalars[$field.type];
-            if (enumer) Object.entries(enumer.pipelines).forEach(([key, values]) => $field.pipelines[key].push(...values));
+            if (enumer) {
+              $field.allows = enumer.values;
+              Object.entries(enumer.pipelines).forEach(([key, values]) => $field.pipelines[key].push(...values));
+            }
             if (scalar) Object.entries(scalar.pipelines).forEach(([key, values]) => $field.pipelines[key].push(...values));
 
             if ($field.isArray) $field.pipelines.normalize.unshift('toArray');
@@ -745,6 +750,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) => {
+                  if (!doc.$) doc = context[schema.namespace].resolver.toResultSet(model, doc); // Ensure resultSet
                   return doc.$.lookup(field).args(args).info(info).resolve(info);
                 },
               });