@coderich/autograph 0.13.22 → 0.13.24

package/package.json

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

package/src/data/Pipeline.js

@@ -74,12 +74,14 @@ module.exports = class Pipeline {
 
     //
     Pipeline.define('$pk', (params) => {
-      const value = get(params.query.doc, params.path) || params.value?.id || params.value;
+      const { pkField } = params.model;
+      const value = get(params.query.doc, params.path) || params.value?.[pkField] || params.value; // I "think" the get() is for embedded documents
       return Pipeline[params.field.id]({ ...params, value });
     }, { ignoreNull: false });
 
     Pipeline.define('$fk', (params) => {
-      const value = params.value?.id || params.value;
+      const { fkField } = params.field;
+      const value = params.value?.[fkField] || params.value;
       return Pipeline[params.field.id]({ ...params, value });
     });
 
@@ -116,10 +118,10 @@ module.exports = class Pipeline {
     });
 
     //
-    Pipeline.define('ensureId', ({ query, resolver, model, field, value }) => {
-      const { type } = field;
+    Pipeline.define('ensureFK', ({ query, resolver, field, value }) => {
+      const { type, fkField } = field;
       const ids = Util.filterBy(Util.ensureArray(value), (a, b) => `${a}` === `${b}`);
-      return resolver.match(type).flags(query.flags).where({ id: ids }).count().then((count) => {
+      return resolver.match(type).flags(query.flags).where({ [fkField]: ids }).count().then((count) => {
         if (count !== ids.length) throw Boom.notFound(`${type} Not Found`);
       });
     }, { itemize: false });

package/src/data/Resolver.js

@@ -229,11 +229,11 @@ 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]];
-                      const where = { [field.linkBy]: $doc[field.linkField.name] };
+                      const where = field.isVirtual ? { [field.linkBy]: $doc[field.linkField] } : { [field.fkField]: $doc[field] };
                       return self.match(field.model).where(where);
                     }
                     default: {

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;
@@ -82,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,
     });
 

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

@@ -59,7 +59,7 @@ module.exports = class Schema {
 
           if (directive) {
             const arg = directive.arguments.find(({ name }) => name.value === 'decorate');
-            const value = arg?.value.value || 'default';
+            const value = Util.uvl(Schema.#resolveNodeValue(arg?.value), 'default');
             const decorator = this.#config.decorators?.[value];
 
             if (decorator) {
@@ -214,6 +214,10 @@ module.exports = class Schema {
                 break;
               }
               // Field specific directives
+              case `${directives.field}-fk`: {
+                target.fkField = value;
+                break;
+              }
               case `${directives.field}-default`: {
                 target.defaultValue = value;
                 break;
@@ -230,9 +234,14 @@ module.exports = class Schema {
                 target.pipelines.normalize = target.pipelines.normalize.concat(value).filter(Boolean);
                 break;
               }
+              case `${directives.link}-to`: {
+                target.linkTo = value;
+                target.isVirtual ??= true;
+                break;
+              }
               case `${directives.link}-by`: {
                 target.linkBy = value;
-                target.isVirtual = true;
+                target.isVirtual ??= true;
                 break;
               }
               // Generic by target directives
@@ -339,8 +348,10 @@ module.exports = class Schema {
           thunks.unshift(($schema) => {
             $field.id ??= $model.id;
             $field.model = $schema.models[$field.type];
-            $field.linkBy ??= $field.model?.pkField;
             $field.crud = Util.uvl($field.crud, $field.model?.scope, 'crud');
+            $field.linkTo ??= $field.model;
+            $field.linkBy ??= $field.linkTo?.pkField; // This defines join logic (below) for both straight+virtual references
+            $field.fkField ??= $field.model?.pkField; // This is the fkReference field for straight references
             $field.linkField = $field.isVirtual ? $model.fields[$model.pkField] : $field;
             $field.isFKReference = !$field.isPrimaryKey && $field.model?.isMarkedModel && !$field.model?.isEmbedded;
             $field.isEmbedded = Boolean($field.model && !$field.isFKReference && !$field.isPrimaryKey);
@@ -354,16 +365,16 @@ module.exports = class Schema {
 
             if ($field.isArray) $field.pipelines.normalize.unshift('toArray');
             if ($field.isPrimaryKey) $field.pipelines.serialize.unshift('$pk'); // Will create/convert to FK type always
-            if ($field.isFKReference) $field.pipelines.serialize.unshift('$fk'); // Will convert to FK type IFF defined in payload
-
             if ($field.isRequired && $field.isPersistable && !$field.isVirtual) $field.pipelines.finalize.push('required');
+
             if ($field.isFKReference) {
               const to = $field.model.key;
               const on = $field.model.fields[$field.linkBy].key;
               const from = $field.linkField.key;
               const as = `join_${to}`;
               $field.join = { to, on, from, as };
-              $field.pipelines.finalize.push('ensureId'); // Absolute Last
+              $field.pipelines.serialize.unshift('$fk'); // Will convert to FK type IFF defined in payload
+              $field.pipelines.finalize.push('ensureFK'); // Absolute Last
             }
           });
 
@@ -446,6 +457,8 @@ module.exports = class Schema {
   }
 
   static #resolveNodeValue(node) {
+    if (node == null) return node;
+
     switch (node.kind) {
       case 'NullValue': return null;
       case 'ListValue': return node.values.map(Schema.#resolveNodeValue);
@@ -493,6 +506,7 @@ module.exports = class Schema {
 
       directive @${field}(
         id: String # Specify the ID strategy (eg. "toObjectId")
+        fk: String # Specify the FK field (default model.pk)
         key: String # Specify db key
         persist: Boolean # Persist this field (default true)
         connection: Boolean # Treat this field as a connection type (default false - rolling this out slowly)
@@ -589,7 +603,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 +633,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 +718,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 +745,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 +766,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

@@ -43,3 +43,12 @@ exports.getGQLSelectFields = (model, info) => {
 //     return value === undefined ? prev : Object.assign(prev, { [key]: value });
 //   }, {}));
 // };
+
+exports.JSONParse = (mixed) => {
+  try {
+    const json = JSON.parse(mixed);
+    return json;
+  } catch (e) {
+    return undefined;
+  }
+};