@dzeio/schema 0.5.0 → 0.7.0

package/dist/Schema.js

@@ -49,7 +49,6 @@ __export(Schema_exports, {
   SchemaUndefined: () => SchemaUndefined,
   SchemaUnion: () => SchemaUnion,
   SchemaVoid: () => SchemaVoid,
-  Types: () => Types,
   default: () => Schema,
   isNull: () => isNull,
   parsable: () => parsable,
@@ -84,14 +83,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
      *
@@ -109,16 +112,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;
@@ -152,37 +162,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 && (0, import_object_util.isObject)(input)) {
-      (0, import_object_util.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) {
@@ -199,7 +179,7 @@ var _SchemaItem = class _SchemaItem {
     if (!this.isOfType(input)) {
       return {
         valid: false,
-        errors: [{ message: "invalid type" }]
+        errors: [{ message: this.invalidError }]
       };
     }
     const validationErrors = [];
@@ -231,14 +211,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 })
     };
     (0, import_object_util.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 ((0, import_object_util.isObject)(item)) {
+      return (0, import_object_util.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;
@@ -252,23 +242,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 && (0, import_object_util.isObject)(input)) {
+      (0, import_object_util.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
@@ -281,23 +292,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);
@@ -337,9 +355,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 }];
   }
@@ -349,13 +378,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
 var import_object_util2 = require("@dzeio/object-util");
@@ -365,14 +397,11 @@ var SchemaObject = class extends SchemaItem {
     this.model = model;
     this.id = "object";
   }
-  getSubInputs(input) {
-    return (0, import_object_util2.isObject)(input) ? (0, import_object_util2.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 (0, import_object_util2.isObject)(input) && !(0, import_object_util2.objectFind)(this.model, (item, k) => !item.isOfType(input[k]));
+    return (0, import_object_util2.isObject)(input) && !(0, import_object_util2.objectFind)(this.model, (item, key) => !item.isOfType(input[key]));
+  }
+  getSubInputs(input) {
+    return (0, import_object_util2.isObject)(input) ? (0, import_object_util2.objectMap)(this.model, (schema, key) => ({ item: schema, value: input[key], path: key.toString() })) : [];
   }
 };
 
@@ -380,19 +409,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;
-    (0, import_object_util3.objectSet)(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;
+    (0, import_object_util3.objectSet)(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;
-    (0, import_object_util3.objectSet)(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;
+    (0, import_object_util3.objectSet)(record, keys, finalValue);
   }
   const handleBoolean = (value, keys) => {
     var _a;
@@ -425,6 +460,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 = (0, import_object_util3.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 {
@@ -440,7 +496,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);
@@ -487,6 +543,9 @@ var SchemaRecord = class extends SchemaItem {
     this.keys = keys;
     this.values = values;
   }
+  isOfType(input) {
+    return (0, import_object_util4.isObject)(input) && Object.prototype.toString.call(input) === "[object Object]";
+  }
   parseSubItems(input, options) {
     const result = { input, errors: [] };
     if ((0, import_object_util4.isObject)(input)) {
@@ -509,9 +568,6 @@ var SchemaRecord = class extends SchemaItem {
     }
     return result;
   }
-  isOfType(input) {
-    return (0, import_object_util4.isObject)(input) && Object.prototype.toString.call(input) === "[object Object]";
-  }
 };
 
 // src/items/enum.ts
@@ -536,13 +592,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);
   }
 };
 
@@ -585,7 +641,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) {
@@ -657,6 +713,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);
   }
@@ -682,6 +747,9 @@ __decorateClass([
 __decorateClass([
   parsable()
 ], SchemaString.prototype, "regex", 1);
+__decorateClass([
+  parsable()
+], SchemaString.prototype, "email", 1);
 
 // src/items/union.ts
 var SchemaUnion = class extends SchemaItem {
@@ -689,6 +757,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) {
@@ -701,9 +772,6 @@ var SchemaUnion = class extends SchemaItem {
     }
     return result;
   }
-  isOfType(input) {
-    return this.schemas.some((it) => it.isOfType(input));
-  }
 };
 
 // src/items/intersection.ts
@@ -713,6 +781,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) {
@@ -729,9 +800,6 @@ var SchemaIntersection = class extends SchemaItem {
     }
     return result;
   }
-  isOfType(input) {
-    return this.schemas.every((it) => it.isOfType(input));
-  }
 };
 
 // src/items/default.ts
@@ -745,12 +813,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
@@ -760,10 +828,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) {
@@ -787,20 +852,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
@@ -831,6 +896,7 @@ var SchemaNever = class extends SchemaItem {
 };
 
 // src/Schema.ts
+var import_object_util6 = require("@dzeio/object-util");
 function parsable() {
   return (target, propertyKey, descriptor) => {
     if (!(propertyKey in target)) {
@@ -845,32 +911,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(module2) {
     this.registeredModules.push(module2);
   }
   static getModule(name) {
-    return this.registeredModules.find((it) => it.name === name);
+    const module2 = this.registeredModules.find((it) => it.name === name);
+    if (!module2) {
+      console.log("Couldn't find module", name);
+    }
+    return module2 != null ? module2 : SchemaAny;
   }
   static any() {
     return new SchemaAny();
@@ -892,8 +942,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);
@@ -942,25 +992,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 ((0, import_object_util6.isObject)(item)) {
+      return (0, import_object_util6.objectRemap)(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;
@@ -1007,7 +1067,10 @@ _Schema.registeredModules = [
   SchemaUndefined,
   SchemaVoid,
   SchemaNull,
-  SchemaNullish
+  SchemaNullish,
+  SchemaFile,
+  SchemaAny,
+  SchemaNumber
 ];
 var Schema = _Schema;
 var s = Schema;
@@ -1034,7 +1097,6 @@ var s = Schema;
   SchemaUndefined,
   SchemaUnion,
   SchemaVoid,
-  Types,
   isNull,
   parsable,
   parseForm,