@dzeio/schema 0.6.0 → 0.7.0

package/dist/Schema.d.mts

@@ -67,6 +67,7 @@ declare abstract class SchemaItem<Output = any, Input = Output> implements Stand
     unwrap?(): SchemaItem;
     parse(input: unknown, options?: ValidationOptions): ValidationResult<Output>;
     toJSON(): SchemaJSON;
+    private deepSerializeItem;
     addValidation(fn: ((input: Output) => boolean) | {
         fn: (input: Output) => boolean;
         error?: string;
@@ -128,7 +129,7 @@ type ValidationResultOld<T> = {
  */
 interface SchemaJSON {
 	/** Id of the schema item (name of the constructor) */
-	i: string
+	_i: string
 	/** Attributes */
 	a?: Array<string> | undefined
 	/** Children schema items */
@@ -159,6 +160,8 @@ type ModelInfer$1<M extends Model> = {
 	[key in keyof M]: SchemaInfer<M[key]>
 }
 
+type Literal = string | number | bigint | boolean | null | undefined
+
 declare class SchemaAny extends SchemaItem {
     isOfType(_input: unknown): _input is any;
 }
@@ -187,6 +190,7 @@ declare class SchemaArray<Child extends SchemaItem, Output = SchemaInfer<Child>,
      * transform the array so it only contains one of each elements
      */
     unique(): this;
+    clean(): this;
     /**
     * split a string into an array
     * @param [separator] default:`,` the separator to use
@@ -221,16 +225,18 @@ declare class SchemaEnum<E extends EnumLike> extends SchemaItem<E[keyof E]> {
     isOfType(input: unknown): input is E[keyof E];
 }
 
-declare class SchemaLiteral<Type> extends SchemaItem<Type> {
-    private readonly value;
-    constructor(value: Type);
-    isOfType(input: unknown): input is Type;
+declare class SchemaLiteral<Types extends Array<Literal>> extends SchemaItem<Types[number]> {
+    private readonly values;
+    constructor(...values: Types);
+    isOfType(input: unknown): input is Types[number];
 }
 
 declare class SchemaNullable<Child extends SchemaItem, Output = SchemaInfer<Child>, Input = SchemaInputInfer<Child>> extends SchemaItem<Output | undefined, Input | null | undefined> {
     private readonly child;
     constructor(child: Child);
     falsyAsNull(): this;
+    emptyAsNull(): this;
+    emptyFileAsNull(): this;
     unwrap(): Child;
     isOfType(input: unknown): input is Output | undefined;
     protected getSubInputs(input: unknown): Array<{
@@ -323,6 +329,11 @@ declare class SchemaString extends SchemaItem<string> {
      * @param message the message to display on an error
      */
     regex(regex: RegExp, message?: string): this;
+    /**
+     * force the input text to be an email
+     * @param message the message to display on an error
+     */
+    email(message?: string): this;
     minLength(value: number, message?: string): this;
     maxLength(value: number, message?: string): this;
     isOfType(input: unknown): input is string;
@@ -415,30 +426,10 @@ declare function parseForm<T extends SchemaItem>(model: T, form: HTMLFormElement
  */
 declare function parsable(): (target: object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<any>) => TypedPropertyDescriptor<any>;
 type SchemaItemStatic = new (...args: Array<any>) => SchemaItem;
-declare const Types: {
-    readonly Any: typeof SchemaAny;
-    readonly Array: typeof SchemaArray;
-    readonly Tuple: typeof SchemaTuple;
-    readonly Boolean: typeof SchemaBoolean;
-    readonly Date: typeof SchemaDate;
-    readonly Enum: typeof SchemaEnum;
-    readonly Literal: typeof SchemaLiteral;
-    readonly Nullable: typeof SchemaNullable;
-    readonly Object: typeof SchemaObject;
-    readonly Record: typeof SchemaRecord;
-    readonly String: typeof SchemaString;
-    readonly Union: typeof SchemaUnion;
-    readonly Intersection: typeof SchemaIntersection;
-    readonly Default: typeof SchemaDefault;
-    readonly Undefined: typeof SchemaUndefined;
-    readonly Void: typeof SchemaVoid;
-    readonly Null: typeof SchemaNull;
-    readonly Nullish: typeof SchemaNullish;
-};
 declare class Schema<T extends Record<string, SchemaItem> = Record<string, SchemaItem>> extends SchemaObject<T> {
     private static readonly registeredModules;
     static register(module: SchemaItemStatic): void;
-    static getModule(name: string): SchemaItemStatic | undefined;
+    static getModule(name: string): SchemaItemStatic;
     static any(): SchemaAny;
     static array<Type extends SchemaItem>(...inputs: ConstructorParameters<typeof SchemaArray<Type>>): SchemaArray<Type>;
     static boolean(...inputs: ConstructorParameters<typeof SchemaBoolean>): SchemaBoolean;
@@ -449,7 +440,7 @@ declare class Schema<T extends Record<string, SchemaItem> = Record<string, Schem
     * @param input the literal value (note: append `as const` else the typing won't work correctly)
     * @returns
     */
-    static literal<Type>(input: Type): SchemaLiteral<Type>;
+    static literal<Type extends Array<Literal>>(...inputs: ConstructorParameters<typeof SchemaLiteral<Type>>): SchemaLiteral<Type>;
     static nullable<Type extends SchemaItem>(...inputs: ConstructorParameters<typeof SchemaNullable<Type>>): SchemaNullable<Type>;
     static number(...inputs: ConstructorParameters<typeof SchemaNumber>): SchemaNumber;
     static object<Type extends Record<string, SchemaItem>>(...inputs: ConstructorParameters<typeof SchemaObject<Type>>): SchemaObject<Type>;
@@ -468,6 +459,7 @@ declare class Schema<T extends Record<string, SchemaItem> = Record<string, Schem
     static void(...inputs: ConstructorParameters<typeof SchemaVoid>): SchemaVoid;
     static never(...inputs: ConstructorParameters<typeof SchemaNever>): SchemaNever;
     static fromJSON(json: SchemaJSON): SchemaItem;
+    static deepParseSchemaJSON(item: unknown): unknown;
     static isSchemaJSON(data: unknown): data is SchemaJSON;
     /**
      * @deprecated use helper `parseQuery`
@@ -488,4 +480,4 @@ declare class Schema<T extends Record<string, SchemaItem> = Record<string, Schem
 }
 declare const s: typeof Schema;
 
-export { type Infer, type InputInfer, type Model, type ModelInfer$1 as ModelInfer, SchemaAny, SchemaArray, SchemaBoolean, SchemaDate, SchemaDefault, SchemaEnum, SchemaFile, type SchemaInfer, type SchemaInputInfer, SchemaIntersection, SchemaItem, type SchemaItemJSON, type SchemaJSON, SchemaLiteral, SchemaNever, SchemaNull, SchemaNullable, SchemaNullish, SchemaNumber, SchemaObject, SchemaRecord, SchemaString, SchemaUndefined, SchemaUnion, SchemaVoid, Types, type ValidationError, type ValidationOptions, type ValidationResult, type ValidationResultOld, Schema as default, isNull, parsable, parseForm, parseFormData, parseQuery, s };
+export { type Infer, type InputInfer, type Literal, type Model, type ModelInfer$1 as ModelInfer, SchemaAny, SchemaArray, SchemaBoolean, SchemaDate, SchemaDefault, SchemaEnum, SchemaFile, type SchemaInfer, type SchemaInputInfer, SchemaIntersection, SchemaItem, type SchemaItemJSON, type SchemaJSON, SchemaLiteral, SchemaNever, SchemaNull, SchemaNullable, SchemaNullish, SchemaNumber, SchemaObject, SchemaRecord, SchemaString, SchemaUndefined, SchemaUnion, SchemaVoid, type ValidationError, type ValidationOptions, type ValidationResult, type ValidationResultOld, Schema as default, isNull, parsable, parseForm, parseFormData, parseQuery, s };

package/dist/Schema.d.ts

@@ -67,6 +67,7 @@ declare abstract class SchemaItem<Output = any, Input = Output> implements Stand
     unwrap?(): SchemaItem;
     parse(input: unknown, options?: ValidationOptions): ValidationResult<Output>;
     toJSON(): SchemaJSON;
+    private deepSerializeItem;
     addValidation(fn: ((input: Output) => boolean) | {
         fn: (input: Output) => boolean;
         error?: string;
@@ -128,7 +129,7 @@ type ValidationResultOld<T> = {
  */
 interface SchemaJSON {
 	/** Id of the schema item (name of the constructor) */
-	i: string
+	_i: string
 	/** Attributes */
 	a?: Array<string> | undefined
 	/** Children schema items */
@@ -159,6 +160,8 @@ type ModelInfer$1<M extends Model> = {
 	[key in keyof M]: SchemaInfer<M[key]>
 }
 
+type Literal = string | number | bigint | boolean | null | undefined
+
 declare class SchemaAny extends SchemaItem {
     isOfType(_input: unknown): _input is any;
 }
@@ -187,6 +190,7 @@ declare class SchemaArray<Child extends SchemaItem, Output = SchemaInfer<Child>,
      * transform the array so it only contains one of each elements
      */
     unique(): this;
+    clean(): this;
     /**
     * split a string into an array
     * @param [separator] default:`,` the separator to use
@@ -221,16 +225,18 @@ declare class SchemaEnum<E extends EnumLike> extends SchemaItem<E[keyof E]> {
     isOfType(input: unknown): input is E[keyof E];
 }
 
-declare class SchemaLiteral<Type> extends SchemaItem<Type> {
-    private readonly value;
-    constructor(value: Type);
-    isOfType(input: unknown): input is Type;
+declare class SchemaLiteral<Types extends Array<Literal>> extends SchemaItem<Types[number]> {
+    private readonly values;
+    constructor(...values: Types);
+    isOfType(input: unknown): input is Types[number];
 }
 
 declare class SchemaNullable<Child extends SchemaItem, Output = SchemaInfer<Child>, Input = SchemaInputInfer<Child>> extends SchemaItem<Output | undefined, Input | null | undefined> {
     private readonly child;
     constructor(child: Child);
     falsyAsNull(): this;
+    emptyAsNull(): this;
+    emptyFileAsNull(): this;
     unwrap(): Child;
     isOfType(input: unknown): input is Output | undefined;
     protected getSubInputs(input: unknown): Array<{
@@ -323,6 +329,11 @@ declare class SchemaString extends SchemaItem<string> {
      * @param message the message to display on an error
      */
     regex(regex: RegExp, message?: string): this;
+    /**
+     * force the input text to be an email
+     * @param message the message to display on an error
+     */
+    email(message?: string): this;
     minLength(value: number, message?: string): this;
     maxLength(value: number, message?: string): this;
     isOfType(input: unknown): input is string;
@@ -415,30 +426,10 @@ declare function parseForm<T extends SchemaItem>(model: T, form: HTMLFormElement
  */
 declare function parsable(): (target: object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<any>) => TypedPropertyDescriptor<any>;
 type SchemaItemStatic = new (...args: Array<any>) => SchemaItem;
-declare const Types: {
-    readonly Any: typeof SchemaAny;
-    readonly Array: typeof SchemaArray;
-    readonly Tuple: typeof SchemaTuple;
-    readonly Boolean: typeof SchemaBoolean;
-    readonly Date: typeof SchemaDate;
-    readonly Enum: typeof SchemaEnum;
-    readonly Literal: typeof SchemaLiteral;
-    readonly Nullable: typeof SchemaNullable;
-    readonly Object: typeof SchemaObject;
-    readonly Record: typeof SchemaRecord;
-    readonly String: typeof SchemaString;
-    readonly Union: typeof SchemaUnion;
-    readonly Intersection: typeof SchemaIntersection;
-    readonly Default: typeof SchemaDefault;
-    readonly Undefined: typeof SchemaUndefined;
-    readonly Void: typeof SchemaVoid;
-    readonly Null: typeof SchemaNull;
-    readonly Nullish: typeof SchemaNullish;
-};
 declare class Schema<T extends Record<string, SchemaItem> = Record<string, SchemaItem>> extends SchemaObject<T> {
     private static readonly registeredModules;
     static register(module: SchemaItemStatic): void;
-    static getModule(name: string): SchemaItemStatic | undefined;
+    static getModule(name: string): SchemaItemStatic;
     static any(): SchemaAny;
     static array<Type extends SchemaItem>(...inputs: ConstructorParameters<typeof SchemaArray<Type>>): SchemaArray<Type>;
     static boolean(...inputs: ConstructorParameters<typeof SchemaBoolean>): SchemaBoolean;
@@ -449,7 +440,7 @@ declare class Schema<T extends Record<string, SchemaItem> = Record<string, Schem
     * @param input the literal value (note: append `as const` else the typing won't work correctly)
     * @returns
     */
-    static literal<Type>(input: Type): SchemaLiteral<Type>;
+    static literal<Type extends Array<Literal>>(...inputs: ConstructorParameters<typeof SchemaLiteral<Type>>): SchemaLiteral<Type>;
     static nullable<Type extends SchemaItem>(...inputs: ConstructorParameters<typeof SchemaNullable<Type>>): SchemaNullable<Type>;
     static number(...inputs: ConstructorParameters<typeof SchemaNumber>): SchemaNumber;
     static object<Type extends Record<string, SchemaItem>>(...inputs: ConstructorParameters<typeof SchemaObject<Type>>): SchemaObject<Type>;
@@ -468,6 +459,7 @@ declare class Schema<T extends Record<string, SchemaItem> = Record<string, Schem
     static void(...inputs: ConstructorParameters<typeof SchemaVoid>): SchemaVoid;
     static never(...inputs: ConstructorParameters<typeof SchemaNever>): SchemaNever;
     static fromJSON(json: SchemaJSON): SchemaItem;
+    static deepParseSchemaJSON(item: unknown): unknown;
     static isSchemaJSON(data: unknown): data is SchemaJSON;
     /**
      * @deprecated use helper `parseQuery`
@@ -488,4 +480,4 @@ declare class Schema<T extends Record<string, SchemaItem> = Record<string, Schem
 }
 declare const s: typeof Schema;
 
-export { type Infer, type InputInfer, type Model, type ModelInfer$1 as ModelInfer, SchemaAny, SchemaArray, SchemaBoolean, SchemaDate, SchemaDefault, SchemaEnum, SchemaFile, type SchemaInfer, type SchemaInputInfer, SchemaIntersection, SchemaItem, type SchemaItemJSON, type SchemaJSON, SchemaLiteral, SchemaNever, SchemaNull, SchemaNullable, SchemaNullish, SchemaNumber, SchemaObject, SchemaRecord, SchemaString, SchemaUndefined, SchemaUnion, SchemaVoid, Types, type ValidationError, type ValidationOptions, type ValidationResult, type ValidationResultOld, Schema as default, isNull, parsable, parseForm, parseFormData, parseQuery, s };
+export { type Infer, type InputInfer, type Literal, type Model, type ModelInfer$1 as ModelInfer, SchemaAny, SchemaArray, SchemaBoolean, SchemaDate, SchemaDefault, SchemaEnum, SchemaFile, type SchemaInfer, type SchemaInputInfer, SchemaIntersection, SchemaItem, type SchemaItemJSON, type SchemaJSON, SchemaLiteral, SchemaNever, SchemaNull, SchemaNullable, SchemaNullish, SchemaNumber, SchemaObject, SchemaRecord, SchemaString, SchemaUndefined, SchemaUnion, SchemaVoid, type ValidationError, type ValidationOptions, type ValidationResult, type ValidationResultOld, Schema as default, isNull, parsable, parseForm, parseFormData, parseQuery, s };

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,
@@ -180,7 +179,7 @@ var _SchemaItem = class _SchemaItem {
     if (!this.isOfType(input)) {
       return {
         valid: false,
-        errors: [{ message: "invalid type" }]
+        errors: [{ message: this.invalidError }]
       };
     }
     const validationErrors = [];
@@ -212,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;
@@ -283,6 +292,10 @@ 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;
@@ -300,6 +313,9 @@ var SchemaArray = class extends SchemaItem {
 __decorateClass([
   parsable()
 ], SchemaArray.prototype, "unique", 1);
+__decorateClass([
+  parsable()
+], SchemaArray.prototype, "clean", 1);
 __decorateClass([
   parsable()
 ], SchemaArray.prototype, "split", 1);
@@ -339,6 +355,14 @@ 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;
   }
@@ -358,6 +382,12 @@ var SchemaNullable = class extends SchemaItem {
 __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");
@@ -384,7 +414,8 @@ function parseQuery(schema, query, opts) {
   for (const [key, value] of query) {
     const keys = key.split(".").map((it) => /^\d+$/g.test(it) ? Number.parseInt(it, 10) : it);
     const schemaItem = getSchemaItemAtPath(schema, keys);
-    const finalValue = schemaItem instanceof SchemaArray ? query.getAll(key) : value;
+    const allValues = query.getAll(key);
+    const finalValue = schemaItem && schemaItem.parse(allValues).valid ? allValues : value;
     (0, import_object_util3.objectSet)(record, keys, finalValue);
   }
   return schema.parse(record, opts);
@@ -394,7 +425,8 @@ function parseFormData(schema, data, opts) {
   for (const [key, value] of data) {
     const keys = key.split(".").map((it) => /^\d+$/g.test(it) ? Number.parseInt(it, 10) : it);
     const schemaItem = getSchemaItemAtPath(schema, keys);
-    const finalValue = schemaItem instanceof SchemaArray ? data.getAll(key) : value;
+    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) => {
@@ -560,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);
   }
 };
 
@@ -681,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);
   }
@@ -706,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 {
@@ -852,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)) {
@@ -866,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();
@@ -913,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);
@@ -963,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;
@@ -1028,7 +1067,10 @@ _Schema.registeredModules = [
   SchemaUndefined,
   SchemaVoid,
   SchemaNull,
-  SchemaNullish
+  SchemaNullish,
+  SchemaFile,
+  SchemaAny,
+  SchemaNumber
 ];
 var Schema = _Schema;
 var s = Schema;
@@ -1055,7 +1097,6 @@ var s = Schema;
   SchemaUndefined,
   SchemaUnion,
   SchemaVoid,
-  Types,
   isNull,
   parsable,
   parseForm,

package/dist/Schema.mjs

@@ -13,7 +13,7 @@ var __decorateClass = (decorators, target, key, kind) => {
 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
@@ -129,7 +129,7 @@ var _SchemaItem = class _SchemaItem {
     if (!this.isOfType(input)) {
       return {
         valid: false,
-        errors: [{ message: "invalid type" }]
+        errors: [{ message: this.invalidError }]
       };
     }
     const validationErrors = [];
@@ -161,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;
@@ -232,6 +242,10 @@ 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;
@@ -249,6 +263,9 @@ var SchemaArray = class extends SchemaItem {
 __decorateClass([
   parsable()
 ], SchemaArray.prototype, "unique", 1);
+__decorateClass([
+  parsable()
+], SchemaArray.prototype, "clean", 1);
 __decorateClass([
   parsable()
 ], SchemaArray.prototype, "split", 1);
@@ -288,6 +305,14 @@ 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;
   }
@@ -307,6 +332,12 @@ var SchemaNullable = class extends SchemaItem {
 __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";
@@ -333,7 +364,8 @@ function parseQuery(schema, query, opts) {
   for (const [key, value] of query) {
     const keys = key.split(".").map((it) => /^\d+$/g.test(it) ? Number.parseInt(it, 10) : it);
     const schemaItem = getSchemaItemAtPath(schema, keys);
-    const finalValue = schemaItem instanceof SchemaArray ? query.getAll(key) : value;
+    const allValues = query.getAll(key);
+    const finalValue = schemaItem && schemaItem.parse(allValues).valid ? allValues : value;
     objectSet2(record, keys, finalValue);
   }
   return schema.parse(record, opts);
@@ -343,7 +375,8 @@ function parseFormData(schema, data, opts) {
   for (const [key, value] of data) {
     const keys = key.split(".").map((it) => /^\d+$/g.test(it) ? Number.parseInt(it, 10) : it);
     const schemaItem = getSchemaItemAtPath(schema, keys);
-    const finalValue = schemaItem instanceof SchemaArray ? data.getAll(key) : value;
+    const allValues = data.getAll(key);
+    const finalValue = schemaItem && schemaItem.parse(allValues).valid ? allValues : value;
     objectSet2(record, keys, finalValue);
   }
   const handleBoolean = (value, keys) => {
@@ -509,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);
   }
 };
 
@@ -630,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);
   }
@@ -655,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 {
@@ -801,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)) {
@@ -815,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();
@@ -862,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);
@@ -912,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;
@@ -977,7 +1017,10 @@ _Schema.registeredModules = [
   SchemaUndefined,
   SchemaVoid,
   SchemaNull,
-  SchemaNullish
+  SchemaNullish,
+  SchemaFile,
+  SchemaAny,
+  SchemaNumber
 ];
 var Schema = _Schema;
 var s = Schema;
@@ -1003,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.6.0",
+	"version": "0.7.0",
 	"dependencies": {
 		"@dzeio/object-util": "^1.9.2"
 	},