@coderich/autograph 0.13.12 → 0.13.14

package/package.json

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

package/src/data/Pipeline.js

@@ -63,6 +63,7 @@ module.exports = class Pipeline {
     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 });
+    Pipeline.define('toId', ({ model, value }) => model.source.idValue(value.id || value)); // Deprecate
 
     // Structures
     Pipeline.define('$instruct', params => Pipeline.resolve(params, 'instruct'), { ignoreNull: false });

package/src/data/Resolver.js

@@ -280,8 +280,11 @@ module.exports = class Resolver {
     const event = { schema: this.#schema, context: this.#context, resolver: this, query };
 
     // Backwards compat
-    query.match = { ...query.where };
+    Object.assign(event, query);
+    query.match = query.where;
     query.toObject = () => query;
+    event.merged = { ...event.input };
+    event.input = event.args?.input;
 
     return Emitter.emit(`pre${type}`, event).then(async (resultEarly) => {
       if (resultEarly !== undefined) return resultEarly;
@@ -289,13 +292,16 @@ module.exports = class Resolver {
       if (query.isMutation) query.input = await tquery.pipeline('input', query.input, ['$finalize']);
       if (query.isMutation) await Emitter.emit('finalize', event);
       return thunk().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) => {

package/src/schema/Schema.js

@@ -8,14 +8,15 @@ const Pipeline = require('../data/Pipeline');
 const Emitter = require('../data/Emitter');
 
 const operations = ['Query', 'Mutation', 'Subscription'];
-// const interfaceKinds = [Kind.INTERFACE_TYPE_DEFINITION, Kind.INTERFACE_TYPE_EXTENSION];
-const scalarKinds = [Kind.SCALAR_TYPE_DEFINITION, Kind.SCALAR_TYPE_EXTENSION];
-const modelKinds = [Kind.OBJECT_TYPE_DEFINITION, Kind.OBJECT_TYPE_EXTENSION, Kind.INTERFACE_TYPE_DEFINITION, Kind.INTERFACE_TYPE_EXTENSION];
+const interfaceKinds = [Kind.INTERFACE_TYPE_DEFINITION, Kind.INTERFACE_TYPE_EXTENSION];
+// const unionKinds = [Kind.UNION_TYPE_DEFINITION, Kind.UNION_TYPE_EXTENSION];
+const scalarKinds = [Kind.SCALAR_TYPE_DEFINITION, Kind.SCALAR_TYPE_EXTENSION, Kind.ENUM_TYPE_DEFINITION, Kind.ENUM_TYPE_EXTENSION];
 const fieldKinds = [Kind.FIELD_DEFINITION].concat(scalarKinds);
-const allowedKinds = modelKinds.concat(fieldKinds).concat(Kind.DOCUMENT, Kind.NON_NULL_TYPE, Kind.NAMED_TYPE, Kind.LIST_TYPE, Kind.DIRECTIVE);
+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);
 const pipelines = ['finalize', 'construct', 'restruct', 'instruct', 'normalize', 'serialize'];
 const inputPipelines = ['finalize', 'construct', 'instruct', 'normalize', 'serialize'];
-// const scalars = ['ID', 'String', 'Float', 'Int', 'Boolean'];
+const scalars = ['ID', 'String', 'Float', 'Int', 'Boolean'];
 
 module.exports = class Schema {
   #config;
@@ -112,7 +113,6 @@ module.exports = class Schema {
   parse() {
     if (this.#schema) return this.#schema;
 
-    // const schema = buildASTSchema(this.#typeDefs);
     const { directives, namespace } = this.#config;
     this.#schema = { types: {}, models: {}, indexes: [], namespace };
     let model, field, isField, isList;
@@ -121,7 +121,7 @@ module.exports = class Schema {
     // Deprecate
     this.#schema.getModel = name => this.#schema.models[`${name}`];
 
-    // Parse AST
+    // Parse AST (build/defined this.#schema)
     visit(this.#typeDefs, {
       enter: (node) => {
         const name = node.name?.value;
@@ -153,6 +153,10 @@ module.exports = class Schema {
             toString: () => name,
           };
           if (model) model.fields[name] = field;
+        }
+
+        if (scalarKinds.includes(node.kind)) {
+          scalars.push(node.name.value);
         } else if (node.kind === Kind.NON_NULL_TYPE) {
           field[isList ? 'isArrayRequired' : 'isRequired'] = true;
         } else if (node.kind === Kind.NAMED_TYPE) {
@@ -169,8 +173,7 @@ module.exports = class Schema {
 
           node.arguments.forEach((arg) => {
             const key = arg.name.value;
-            const { value: val, values = { value: val }, kind } = arg.value;
-            const value = kind === 'NullValue' ? null : Util.map(values, n => n.value);
+            const value = Schema.#resolveNodeValue(arg.value);
             target.directives[name][key] = value;
 
             if (name === directives.index) this.#schema.indexes[this.#schema.indexes.length - 1][key] = value;
@@ -313,8 +316,8 @@ module.exports = class Schema {
             $field.linkBy ??= $field.model?.idField;
             $field.linkField = $field.isVirtual ? $model.fields[$model.idField] : $field;
             $field.isFKReference = !$field.isPrimaryKey && $field.model?.isMarkedModel && !$field.model?.isEmbedded;
-            // $field.isScalar = Boolean(!$field.model || scalars.includes($field.type));
             $field.isEmbedded = Boolean($field.model && !$field.isFKReference && !$field.isPrimaryKey);
+            $field.isScalar = scalars.includes($field.type);
 
             if ($field.isArray) $field.pipelines.normalize.unshift('toArray');
             if ($field.isPrimaryKey) $field.pipelines.serialize.unshift('$pk'); // Will create/convert to FK type always
@@ -334,6 +337,8 @@ module.exports = class Schema {
           isField = false;
         } else if (node.kind === Kind.LIST_TYPE) {
           isList = false;
+        } else if (scalarKinds.includes(node.kind)) {
+          isField = false;
         }
       },
     });
@@ -362,6 +367,23 @@ module.exports = class Schema {
       return fieldKeys.reduce((parent, key) => Object.values(parent.fields || parent.model.fields).find(el => el[prop] === key) || parent, $model);
     };
 
+    // Mutate typeDefs
+    let $model;
+    this.#typeDefs = visit(this.#typeDefs, {
+      enter: (node) => {
+        const name = node.name?.value;
+        if (!allowedKinds.includes(node.kind) || operations.includes(name)) return false;
+
+        if (modelKinds.includes(node.kind)) {
+          $model = this.#schema.models[name];
+        } else if (fieldKinds.includes(node.kind)) {
+          if (!Util.uvl($model?.fields[name]?.crud, 'crud')?.includes('r')) return null;
+        }
+
+        return undefined;
+      },
+    });
+
     // Return schema
     return this.#schema;
   }
@@ -390,6 +412,15 @@ module.exports = class Schema {
     return this.#config.makeExecutableSchema(this.toObject());
   }
 
+  static #resolveNodeValue(node) {
+    switch (node.kind) {
+      case 'NullValue': return null;
+      case 'ListValue': return node.values.map(Schema.#resolveNodeValue);
+      case 'ObjectValue': return node.fields.reduce((prev, field) => Object.assign(prev, { [field.name.value]: Schema.#resolveNodeValue(field.value) }), {});
+      default: return node.value ?? node;
+    }
+  }
+
   static #framework(directives) {
     const { model, field, link, index } = directives;
 
@@ -480,6 +511,7 @@ module.exports = class Schema {
     return {
       typeDefs: `
         scalar AutoGraphMixed
+        scalar AutoGraphDateTime
 
         interface Node { id: ID! }
 
@@ -506,10 +538,10 @@ module.exports = class Schema {
 
           return `
             input ${model}InputWhere {
-              ${fields.map(field => `${field}: ${field.model?.isEntity ? `${field.model}InputWhere` : 'AutoGraphMixed'}`)}
+              ${fields.map(field => `${field}: ${field.model ? `${field.model}InputWhere` : 'AutoGraphMixed'}`)}
             }
             input ${model}InputSort {
-              ${fields.map(field => `${field}: ${field.model?.isEntity ? `${field.model}InputSort` : 'SortOrderEnum'}`)}
+              ${fields.map(field => `${field}: ${field.model ? `${field.model}InputSort` : 'SortOrderEnum'}`)}
             }
             type ${model}Connection {
               count: Int!
@@ -598,7 +630,7 @@ module.exports = class Schema {
               }
 
               input ${model}SubscriptionInputWhere {
-                ${fields.map(field => `${field}: ${field.model?.isEntity ? `${field.model}InputWhere` : 'AutoGraphMixed'}`)}
+                ${fields.map(field => `${field}: ${field.model ? `${field.model}InputWhere` : 'AutoGraphMixed'}`)}
               }
 
               type ${model}SubscriptionPayload {
@@ -691,12 +723,12 @@ module.exports = class Schema {
 
   static #getGQLType(field, suffix) {
     let { type } = field;
-    const { isEmbedded, isRequired, isScalar, isArray, isArrayRequired, defaultValue } = field;
+    const { isEmbedded, isRequired, isScalar, isArray, isArrayRequired, isPrimaryKey, defaultValue } = field;
     const modelType = `${type}${suffix}`;
     if (suffix && !isScalar) type = isEmbedded ? modelType : 'ID';
     type = isArray ? `[${type}${isArrayRequired ? '!' : ''}]` : type;
     if (!suffix && isRequired) type += '!';
-    if (suffix === 'InputCreate' && isRequired && defaultValue != null) type += '!';
+    if (suffix === 'InputCreate' && !isPrimaryKey && isRequired && defaultValue == null) type += '!';
     return type;
   }