@dzeio/schema 0.5.0 → 0.7.0

package/dist/Schema.mjs

@@ -10,10 +10,10 @@ var __decorateClass = (decorators, target, key, kind) => {
 };
 
 // src/helpers.ts
-import { objectGet, objectLoop, objectSet as objectSet2 } from "@dzeio/object-util";
+import { objectClone, objectGet, objectLoop, objectSet as objectSet2 } from "@dzeio/object-util";
 
 // src/SchemaItem.ts
-import { isObject, objectClean, objectSet } from "@dzeio/object-util";
+import { isObject, objectClean, objectRemap, objectSet } from "@dzeio/object-util";
 var _SchemaItem = class _SchemaItem {
   constructor(items) {
     // standard Schema V1 spec
@@ -33,14 +33,18 @@ var _SchemaItem = class _SchemaItem {
         };
       }
     };
-    /**
-     * keep public ?
-     */
-    this.validations = [];
     /**
      * Function calls saved for serialization
      */
     this.savedCalls = [];
+    /**
+     * list of attributes for custom works
+     */
+    this.attributes = [];
+    /**
+     * keep public ?
+     */
+    this.validations = [];
     /**
      * Pre process the variable for various reasons
      *
@@ -58,16 +62,23 @@ var _SchemaItem = class _SchemaItem {
      * note: the type of the final post-process MUST be valid
      */
     this.postProcess = [];
-    /**
-     * list of attributes for custom works
-     */
-    this.attributes = [];
     this.invalidError = "the field is invalid";
+    // eslint-disable-next-line @typescript-eslint/member-ordering, @typescript-eslint/unbound-method
     this.default = this.defaultValue;
     if (items && items.length > 0) {
       this.items = Array.isArray(items) ? items : Array.from(items);
     }
   }
+  parseJSON() {
+    this.addPreProcess((input) => {
+      try {
+        return typeof input === "string" ? JSON.parse(input) : input;
+      } catch {
+        return input;
+      }
+    });
+    return this;
+  }
   in(...values) {
     this.addValidation((input) => values.includes(input));
     return this;
@@ -101,37 +112,7 @@ var _SchemaItem = class _SchemaItem {
   array() {
     return new SchemaArray(this);
   }
-  /** Returns the sub values of the input, the schema item to handle them, and the path to it */
-  getSubInputs(_input) {
-    return [];
-  }
-  /** Sets the "part" of the input that this sub schema handles. Overrides the input with the result */
-  updateSubItemInput(path, input, value) {
-    if (path && isObject(input)) {
-      objectSet(input, path.split("."), value);
-      return input;
-    } else {
-      return value;
-    }
-  }
-  parseSubItems(input, options) {
-    const result = { errors: [], input };
-    for (const { item, value, path } of this.getSubInputs(result.input)) {
-      const parsed = item.parse(value, options);
-      if (parsed.valid) {
-        result.input = this.updateSubItemInput(path, result.input, parsed.object);
-      } else {
-        for (const error of parsed.errors) {
-          error.field = error.field ? `${path}.${error.field}` : path;
-          result.errors.push(error);
-        }
-        if (options == null ? void 0 : options.fast) {
-          break;
-        }
-      }
-    }
-    return result;
-  }
+  // eslint-disable-next-line complexity
   parse(input, options) {
     var _a, _b;
     for (const preProcess of this.preProcess) {
@@ -148,7 +129,7 @@ var _SchemaItem = class _SchemaItem {
     if (!this.isOfType(input)) {
       return {
         valid: false,
-        errors: [{ message: "invalid type" }]
+        errors: [{ message: this.invalidError }]
       };
     }
     const validationErrors = [];
@@ -180,14 +161,24 @@ var _SchemaItem = class _SchemaItem {
   toJSON() {
     var _a;
     const res = {
-      i: this.constructor.name,
+      _i: this.constructor.name,
       a: this.attributes.length > 0 ? this.attributes : void 0,
-      c: (_a = this.items) == null ? void 0 : _a.map((it) => it instanceof _SchemaItem ? it.toJSON() : it),
+      c: (_a = this.items) == null ? void 0 : _a.map((it) => this.deepSerializeItem(it)),
       f: this.savedCalls.map((it) => it.args ? { n: it.name, a: Array.from(it.args) } : { n: it.name })
     };
     objectClean(res, { deep: false });
     return res;
   }
+  deepSerializeItem(item) {
+    if (item instanceof _SchemaItem) {
+      return item.toJSON();
+    } else if (Array.isArray(item)) {
+      return item.map((it) => this.deepSerializeItem(it));
+    } else if (isObject(item)) {
+      return objectRemap(item, (value, key) => ({ value: this.deepSerializeItem(value), key }));
+    }
+    return item;
+  }
   addValidation(fn, error) {
     this.validations.push(typeof fn === "function" ? { fn, error } : fn);
     return this;
@@ -201,23 +192,44 @@ var _SchemaItem = class _SchemaItem {
     this.postProcess.push(fn);
     return this;
   }
-  parseJSON() {
-    this.addPreProcess((input) => {
-      try {
-        return typeof input === "string" ? JSON.parse(input) : input;
-      } catch {
-        return input;
+  /** Returns the sub values of the input, the schema item to handle them, and the path to it */
+  getSubInputs(_input) {
+    return [];
+  }
+  /** Sets the "part" of the input that this sub schema handles. Overrides the input with the result */
+  updateSubItemInput(path, input, value) {
+    if (path && isObject(input)) {
+      objectSet(input, path.split("."), value);
+      return input;
+    } else {
+      return value;
+    }
+  }
+  parseSubItems(input, options) {
+    const result = { errors: [], input };
+    for (const { item, value, path } of this.getSubInputs(result.input)) {
+      const parsed = item.parse(value, options);
+      if (parsed.valid) {
+        result.input = this.updateSubItemInput(path, result.input, parsed.object);
+      } else {
+        for (const error of parsed.errors) {
+          error.field = error.field ? `${path}.${error.field}` : path;
+          result.errors.push(error);
+        }
+        if (options == null ? void 0 : options.fast) {
+          break;
+        }
       }
-    });
-    return this;
+    }
+    return result;
   }
 };
 __decorateClass([
   parsable()
-], _SchemaItem.prototype, "in", 1);
+], _SchemaItem.prototype, "parseJSON", 1);
 __decorateClass([
   parsable()
-], _SchemaItem.prototype, "parseJSON", 1);
+], _SchemaItem.prototype, "in", 1);
 var SchemaItem = _SchemaItem;
 
 // src/items/array.ts
@@ -230,23 +242,30 @@ var SchemaArray = class extends SchemaItem {
     this.postProcess.push((input) => input.filter((it, idx) => input.indexOf(it) === idx));
     return this;
   }
+  clean() {
+    this.postProcess.push((input) => input.filter((it) => !isNull(it)));
+    return this;
+  }
   split(separator = ",") {
     this.addPreProcess((it) => typeof it === "string" ? it.split(separator) : it);
     return this;
   }
-  getSubInputs(input) {
-    return Array.isArray(input) ? input.map((e, i) => ({ item: this.values, value: e, path: i.toString() })) : [];
-  }
   unwrap() {
     return this.values;
   }
   isOfType(input) {
-    return Array.isArray(input) && input.every((e) => this.values.isOfType(e));
+    return Array.isArray(input) && input.every((entry) => this.values.isOfType(entry));
+  }
+  getSubInputs(input) {
+    return Array.isArray(input) ? input.map((entry, index) => ({ item: this.values, value: entry, path: index.toString() })) : [];
   }
 };
 __decorateClass([
   parsable()
 ], SchemaArray.prototype, "unique", 1);
+__decorateClass([
+  parsable()
+], SchemaArray.prototype, "clean", 1);
 __decorateClass([
   parsable()
 ], SchemaArray.prototype, "split", 1);
@@ -286,9 +305,20 @@ var SchemaNullable = class extends SchemaItem {
     this.addPreProcess((it) => !it ? void 0 : it);
     return this;
   }
+  emptyAsNull() {
+    this.addPreProcess((it) => it === "" ? void 0 : it);
+    return this;
+  }
+  emptyFileAsNull() {
+    this.addPreProcess((it) => it instanceof File && it.size === 0 ? void 0 : it);
+    return this;
+  }
   unwrap() {
     return this.child;
   }
+  isOfType(input) {
+    return typeof input === "undefined" || this.child.isOfType(input);
+  }
   getSubInputs(input) {
     return [{ value: input, item: this.child, path: void 0 }];
   }
@@ -298,13 +328,16 @@ var SchemaNullable = class extends SchemaItem {
     }
     return super.parseSubItems(input, options);
   }
-  isOfType(input) {
-    return typeof input === "undefined" || this.child.isOfType(input);
-  }
 };
 __decorateClass([
   parsable()
 ], SchemaNullable.prototype, "falsyAsNull", 1);
+__decorateClass([
+  parsable()
+], SchemaNullable.prototype, "emptyAsNull", 1);
+__decorateClass([
+  parsable()
+], SchemaNullable.prototype, "emptyFileAsNull", 1);
 
 // src/items/object.ts
 import { isObject as isObject2, objectFind, objectMap } from "@dzeio/object-util";
@@ -314,14 +347,11 @@ var SchemaObject = class extends SchemaItem {
     this.model = model;
     this.id = "object";
   }
-  getSubInputs(input) {
-    return isObject2(input) ? objectMap(
-      input,
-      (v, k) => this.model[k] ? { item: this.model[k], value: v, path: k.toString() } : void 0
-    ).filter((e) => !isNull(e)) : [];
-  }
   isOfType(input) {
-    return isObject2(input) && !objectFind(this.model, (item, k) => !item.isOfType(input[k]));
+    return isObject2(input) && !objectFind(this.model, (item, key) => !item.isOfType(input[key]));
+  }
+  getSubInputs(input) {
+    return isObject2(input) ? objectMap(this.model, (schema, key) => ({ item: schema, value: input[key], path: key.toString() })) : [];
   }
 };
 
@@ -329,19 +359,25 @@ var SchemaObject = class extends SchemaItem {
 function isNull(value) {
   return typeof value === "undefined" || value === null;
 }
-function parseQuery(model, query, opts) {
+function parseQuery(schema, query, opts) {
   const record = {};
   for (const [key, value] of query) {
-    const hasMultipleValues = query.getAll(key).length > 1;
-    objectSet2(record, key.split(".").map((it) => /^\d+$/g.test(it) ? parseInt(it, 10) : it), hasMultipleValues ? query.getAll(key) : value);
+    const keys = key.split(".").map((it) => /^\d+$/g.test(it) ? Number.parseInt(it, 10) : it);
+    const schemaItem = getSchemaItemAtPath(schema, keys);
+    const allValues = query.getAll(key);
+    const finalValue = schemaItem && schemaItem.parse(allValues).valid ? allValues : value;
+    objectSet2(record, keys, finalValue);
   }
-  return model.parse(record, opts);
+  return schema.parse(record, opts);
 }
 function parseFormData(schema, data, opts) {
   const record = {};
   for (const [key, value] of data) {
-    const hasMultipleValues = data.getAll(key).length > 1;
-    objectSet2(record, key.split(".").map((it) => /^\d+$/g.test(it) ? parseInt(it, 10) : it), hasMultipleValues ? data.getAll(key) : value);
+    const keys = key.split(".").map((it) => /^\d+$/g.test(it) ? Number.parseInt(it, 10) : it);
+    const schemaItem = getSchemaItemAtPath(schema, keys);
+    const allValues = data.getAll(key);
+    const finalValue = schemaItem && schemaItem.parse(allValues).valid ? allValues : value;
+    objectSet2(record, keys, finalValue);
   }
   const handleBoolean = (value, keys) => {
     var _a;
@@ -374,6 +410,27 @@ function parseFormData(schema, data, opts) {
 function parseForm(model, form, opts) {
   return parseFormData(model, new FormData(form), opts);
 }
+function getSchemaItemAtPath(schema, path) {
+  let current = schema;
+  const internalPath = objectClone(path);
+  for (const key of path) {
+    if (!current) {
+      return void 0;
+    }
+    internalPath.shift();
+    while (current instanceof SchemaNullable || current instanceof SchemaDefault) {
+      current = current.unwrap();
+    }
+    if (current instanceof SchemaObject) {
+      current = current.model[key];
+      current = getSchemaItemAtPath(current, internalPath);
+    }
+  }
+  while (current instanceof SchemaNullable || current instanceof SchemaDefault) {
+    current = current.unwrap();
+  }
+  return current;
+}
 
 // src/items/any.ts
 var SchemaAny = class extends SchemaItem {
@@ -389,7 +446,7 @@ var SchemaDate = class extends SchemaItem {
       if (typeof input !== "string") {
         return input;
       }
-      let date = void 0;
+      let date;
       switch (format) {
         case "default": {
           date = new Date(input);
@@ -436,6 +493,9 @@ var SchemaRecord = class extends SchemaItem {
     this.keys = keys;
     this.values = values;
   }
+  isOfType(input) {
+    return isObject3(input) && Object.prototype.toString.call(input) === "[object Object]";
+  }
   parseSubItems(input, options) {
     const result = { input, errors: [] };
     if (isObject3(input)) {
@@ -458,9 +518,6 @@ var SchemaRecord = class extends SchemaItem {
     }
     return result;
   }
-  isOfType(input) {
-    return isObject3(input) && Object.prototype.toString.call(input) === "[object Object]";
-  }
 };
 
 // src/items/enum.ts
@@ -485,13 +542,13 @@ var SchemaEnum = class extends SchemaItem {
 
 // src/items/literal.ts
 var SchemaLiteral = class extends SchemaItem {
-  constructor(value) {
-    super([value]);
-    this.value = value;
-    this.validations.push({ fn: (it) => it === this.value });
+  constructor(...values) {
+    super(values);
+    this.values = values;
+    this.validations.push({ fn: (it) => this.values.includes(it) });
   }
   isOfType(input) {
-    return typeof input === typeof this.value;
+    return this.values.some((it) => typeof input === typeof it);
   }
 };
 
@@ -534,7 +591,7 @@ var SchemaNumber = class extends SchemaItem {
     return this;
   }
   parseString() {
-    this.addPreProcess((input) => typeof input === "string" ? parseFloat(input) : input);
+    this.addPreProcess((input) => typeof input === "string" ? Number.parseFloat(input) : input);
     return this;
   }
   isOfType(input) {
@@ -606,6 +663,15 @@ var SchemaString = class extends SchemaItem {
     });
     return this;
   }
+  email(message) {
+    this.addValidation({
+      fn(input) {
+        return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(input);
+      },
+      error: message
+    });
+    return this;
+  }
   minLength(value, message) {
     return this.min(value, message);
   }
@@ -631,6 +697,9 @@ __decorateClass([
 __decorateClass([
   parsable()
 ], SchemaString.prototype, "regex", 1);
+__decorateClass([
+  parsable()
+], SchemaString.prototype, "email", 1);
 
 // src/items/union.ts
 var SchemaUnion = class extends SchemaItem {
@@ -638,6 +707,9 @@ var SchemaUnion = class extends SchemaItem {
     super(schemas);
     this.schemas = schemas;
   }
+  isOfType(input) {
+    return this.schemas.some((it) => it.isOfType(input));
+  }
   parseSubItems(input, options) {
     const result = { input, errors: [] };
     for (const schema of this.schemas) {
@@ -650,9 +722,6 @@ var SchemaUnion = class extends SchemaItem {
     }
     return result;
   }
-  isOfType(input) {
-    return this.schemas.some((it) => it.isOfType(input));
-  }
 };
 
 // src/items/intersection.ts
@@ -662,6 +731,9 @@ var SchemaIntersection = class extends SchemaItem {
     super(schemas);
     this.schemas = schemas;
   }
+  isOfType(input) {
+    return this.schemas.every((it) => it.isOfType(input));
+  }
   parseSubItems(input, options) {
     const result = { input, errors: [] };
     for (const schema of this.schemas) {
@@ -678,9 +750,6 @@ var SchemaIntersection = class extends SchemaItem {
     }
     return result;
   }
-  isOfType(input) {
-    return this.schemas.every((it) => it.isOfType(input));
-  }
 };
 
 // src/items/default.ts
@@ -694,12 +763,12 @@ var SchemaDefault = class extends SchemaItem {
   unwrap() {
     return this.child;
   }
-  getSubInputs(input) {
-    return [{ item: this.child, value: isNull(input) || !this.strict && !input ? this.defaultVal : input, path: void 0 }];
-  }
   isOfType(input) {
     return this.child.isOfType(input);
   }
+  getSubInputs(input) {
+    return [{ item: this.child, value: isNull(input) || !this.strict && !input ? this.defaultVal : input, path: void 0 }];
+  }
 };
 
 // src/items/file.ts
@@ -709,10 +778,7 @@ var SchemaFile = class extends SchemaItem {
     this.addPreProcess((input) => this.isOfType(input) && input.size > 0 ? input : void 0);
   }
   extension(ext, error) {
-    this.addValidation({ fn: (input) => {
-      var _a;
-      return (_a = input.name) == null ? void 0 : _a.endsWith(ext);
-    }, error });
+    this.addValidation({ fn: (input) => input.name.endsWith(ext), error });
     return this;
   }
   maxSize(size, error) {
@@ -736,20 +802,20 @@ var SchemaTuple = class extends SchemaItem {
     super(children);
     this.children = children;
   }
-  getSubInputs(input) {
-    return Array.isArray(input) ? this.children.map((e, i) => ({ value: input[i], item: e, path: i.toString() })) : [];
-  }
   isOfType(input) {
     if (!Array.isArray(input) || input.length > this.items.length) {
       return false;
     }
-    for (const [i, item] of this.children.entries()) {
-      if (item instanceof SchemaItem && !item.isOfType(input[i])) {
+    for (const [index, item] of this.children.entries()) {
+      if (item instanceof SchemaItem && !item.isOfType(input[index])) {
         return false;
       }
     }
     return true;
   }
+  getSubInputs(input) {
+    return Array.isArray(input) ? this.children.map((entry, index) => ({ value: input[index], item: entry, path: index.toString() })) : [];
+  }
 };
 
 // src/items/nullish.ts
@@ -780,6 +846,7 @@ var SchemaNever = class extends SchemaItem {
 };
 
 // src/Schema.ts
+import { isObject as isObject5, objectRemap as objectRemap2 } from "@dzeio/object-util";
 function parsable() {
   return (target, propertyKey, descriptor) => {
     if (!(propertyKey in target)) {
@@ -794,32 +861,16 @@ function parsable() {
     return descriptor;
   };
 }
-var Types = {
-  Any: SchemaAny,
-  Array: SchemaArray,
-  Tuple: SchemaTuple,
-  Boolean: SchemaBoolean,
-  Date: SchemaDate,
-  Enum: SchemaEnum,
-  Literal: SchemaLiteral,
-  Nullable: SchemaNullable,
-  Object: SchemaObject,
-  Record: SchemaRecord,
-  String: SchemaString,
-  Union: SchemaUnion,
-  Intersection: SchemaIntersection,
-  Default: SchemaDefault,
-  Undefined: SchemaUndefined,
-  Void: SchemaVoid,
-  Null: SchemaNull,
-  Nullish: SchemaNullish
-};
 var _Schema = class _Schema extends SchemaObject {
   static register(module) {
     this.registeredModules.push(module);
   }
   static getModule(name) {
-    return this.registeredModules.find((it) => it.name === name);
+    const module = this.registeredModules.find((it) => it.name === name);
+    if (!module) {
+      console.log("Couldn't find module", name);
+    }
+    return module != null ? module : SchemaAny;
   }
   static any() {
     return new SchemaAny();
@@ -841,8 +892,8 @@ var _Schema = class _Schema extends SchemaObject {
   * @param input the literal value (note: append `as const` else the typing won't work correctly)
   * @returns
   */
-  static literal(input) {
-    return new SchemaLiteral(input);
+  static literal(...inputs) {
+    return new SchemaLiteral(...inputs);
   }
   static nullable(...inputs) {
     return new SchemaNullable(...inputs);
@@ -891,25 +942,35 @@ var _Schema = class _Schema extends SchemaObject {
   }
   static fromJSON(json) {
     var _a, _b, _c, _d, _e, _f;
-    const fn = this.getModule(json.i);
+    const fn = this.getModule(json._i);
     if (!fn) {
-      throw new Error(`Schema cannot parse ${json.i}`);
+      throw new Error(`Schema cannot parse ${json._i}`);
     }
-    const item = new fn(...(_b = (_a = json.c) == null ? void 0 : _a.map((it) => this.isSchemaJSON(it) ? _Schema.fromJSON(it) : it)) != null ? _b : []);
+    const item = new fn(...(_b = (_a = json.c) == null ? void 0 : _a.map((it) => this.deepParseSchemaJSON(it))) != null ? _b : []);
     for (const validation of (_c = json.f) != null ? _c : []) {
       if (!(validation.n in item)) {
         throw new Error("validation not available in Schema Item");
       }
-      item[validation.n](...(_e = (_d = validation.a) == null ? void 0 : _d.map((it) => _Schema.isSchemaJSON(it) ? _Schema.fromJSON(it) : it)) != null ? _e : []);
+      item[validation.n](...(_e = (_d = validation.a) == null ? void 0 : _d.map((it) => this.deepParseSchemaJSON(it))) != null ? _e : []);
     }
     item.attrs(...(_f = json.a) != null ? _f : []);
     return item;
   }
+  static deepParseSchemaJSON(item) {
+    if (this.isSchemaJSON(item)) {
+      return _Schema.fromJSON(item);
+    } else if (Array.isArray(item)) {
+      return item.map((it) => this.deepParseSchemaJSON(it));
+    } else if (isObject5(item)) {
+      return objectRemap2(item, (value, key) => ({ value: this.deepParseSchemaJSON(value), key }));
+    }
+    return item;
+  }
   static isSchemaJSON(data) {
     if (typeof data !== "object" || data === null) {
       return false;
     }
-    if (!("i" in data)) {
+    if (!("_i" in data)) {
       return false;
     }
     return true;
@@ -956,7 +1017,10 @@ _Schema.registeredModules = [
   SchemaUndefined,
   SchemaVoid,
   SchemaNull,
-  SchemaNullish
+  SchemaNullish,
+  SchemaFile,
+  SchemaAny,
+  SchemaNumber
 ];
 var Schema = _Schema;
 var s = Schema;
@@ -982,7 +1046,6 @@ export {
   SchemaUndefined,
   SchemaUnion,
   SchemaVoid,
-  Types,
   Schema as default,
   isNull,
   parsable,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@dzeio/schema",
-	"version": "0.5.0",
+	"version": "0.7.0",
 	"dependencies": {
 		"@dzeio/object-util": "^1.9.2"
 	},