@coderich/autograph 0.13.53 → 0.13.54

package/package.json

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

package/src/data/Resolver.js

@@ -296,17 +296,21 @@ module.exports = class Resolver {
   }
 
   #createSystemEvent($query, thunk = () => {}) {
-    let query = $query.toObject();
+    let tquery = $query.transform(false);
+    let query = tquery.toObject();
     const type = query.isMutation ? 'Mutation' : 'Query';
     let event = this.#createEvent(query);
 
     return Emitter.emit(`pre${type}`, event).then(async (resultEarly) => {
       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(false);
+      tquery = $query.transform(false);
       query = tquery.toObject();
       event = this.#createEvent(query);
-      if (['create', 'update'].includes(query.crud)) await Promise.all([...query.input.$thunks, Emitter.emit('validate', event)]);
+      if (['create', 'update'].includes(query.crud)) {
+        tquery.validate();
+        await Promise.all([...query.input.$thunks, Emitter.emit('validate', event)]);
+      }
       return thunk(tquery);
     }).then((result) => {
       event.result = result; // backwards compat

package/src/query/Query.js

@@ -63,6 +63,11 @@ module.exports = class Query {
     return this;
   }
 
+  validate() {
+    const args = { query: this.#query, resolver: this.#resolver, context: this.#context };
+    this.#query.input = this.#model.transformers.validate.transform(this.#query.input, args);
+  }
+
   /**
    * Transform entire query for driver
    */

package/src/query/QueryBuilder.js

@@ -221,7 +221,7 @@ module.exports = class QueryBuilder {
     const suffix = id || limit === 1 || (crud === 'create' && args.length < 2) ? 'One' : 'Many';
     let input = suffix === 'One' ? args[0] : args;
     if (input === undefined) input = {};
-    input.id = id;
+    if (id !== undefined) input.id = id;
     this.#query.args.input = input;
     return this.terminate(Object.assign(this.#query, {
       op: `${crud}${suffix}`,

package/src/schema/Schema.js

@@ -19,6 +19,7 @@ const allowedKinds = modelKinds.concat(fieldKinds).concat(Kind.DOCUMENT, Kind.NO
 const pipelines = ['validate', 'construct', 'restruct', 'instruct', 'normalize', 'serialize', 'deserialize'];
 const createPipelines = ['validate', 'construct', 'instruct', 'normalize', 'serialize'];
 const updatePipelines = ['validate', 'restruct', 'instruct', 'normalize', 'serialize'];
+const validatePipelines = ['validate', 'instruct', 'normalize', 'serialize'];
 const scalars = ['ID', 'String', 'Float', 'Int', 'Boolean'];
 
 module.exports = class Schema {
@@ -147,6 +148,7 @@ module.exports = class Schema {
             generator: this.#config.generators?.default,
             pipelines: pipelines.reduce((prev, key) => Object.assign(prev, { [key]: [] }), {}),
             transformers: {
+              validate: new Transformer({ args: { schema: this.#schema, path: [] } }),
               create: new Transformer({ args: { schema: this.#schema, path: [] } }),
               update: new Transformer({ args: { schema: this.#schema, path: [] } }),
               where: new Transformer({ args: { schema: this.#schema, path: [] } }),
@@ -355,6 +357,7 @@ module.exports = class Schema {
 
             $model.transformers.create.config({
               strictSchema: true,
+              keepUndefined: true,
               shape: Object.values($model.fields).reduce((prev, curr) => {
                 const args = { model: $model, field: curr };
 
@@ -374,9 +377,6 @@ module.exports = class Schema {
                   }));
                 }
 
-                // Validate
-                rules.push(a => (a.query.op === 'createOne' ? Pipeline.$validate({ ...a, ...args, path: a.path.concat(curr.name) }) : undefined));
-
                 return Object.assign(prev, { [curr.name]: rules });
               }, {}),
               defaults: Object.values($model.fields).reduce((prev, curr) => {
@@ -388,6 +388,7 @@ module.exports = class Schema {
 
             $model.transformers.update.config({
               strictSchema: true,
+              keepUndefined: true,
               shape: Object.values($model.fields).reduce((prev, curr) => {
                 const args = { model: $model, field: curr };
 
@@ -407,13 +408,9 @@ module.exports = class Schema {
                   }));
                 }
 
-                // Validate
-                rules.push(a => (a.query.op === 'updateOne' ? Pipeline.$validate({ ...a, ...args, path: a.path.concat(curr.name) }) : undefined));
-
                 return Object.assign(prev, { [curr.name]: rules });
               }, {}),
               defaults: Object.values($model.fields).reduce((prev, curr) => {
-                // if (curr.defaultValue !== undefined) return Object.assign(prev, { [curr.name]: curr.defaultValue });
                 if (updatePipelines.some(el => curr.pipelines[el].length)) return Object.assign(prev, { [curr.name]: undefined });
                 return prev;
               }, {}),
@@ -474,6 +471,26 @@ module.exports = class Schema {
                 return Object.assign(prev, { [curr.key]: curr.defaultValue });
               }, {}),
             });
+
+            $model.transformers.validate.config({
+              strictSchema: true,
+              shape: Object.values($model.fields).reduce((prev, curr) => {
+                const args = { model: $model, field: curr };
+                const rules = [];
+
+                if (curr.isEmbedded) {
+                  rules.push(a => Util.map(a.value, (value, i) => {
+                    const path = a.path.concat(curr.name);
+                    if (curr.isArray) path.push(i);
+                    return curr.model.transformers.validate.transform(value, { ...args, thunks: a.thunks, query: a.query, resolver: a.resolver, context: a.context, path });
+                  }));
+                }
+
+                rules.push(a => Pipeline.$validate({ ...a, ...args, path: a.path.concat(curr.name) }));
+
+                return Object.assign(prev, { [curr.name]: rules });
+              }, {}),
+            });
           });
         } else if (node.kind === Kind.FIELD_DEFINITION) {
           const $field = field;