@dzeio/schema 0.9.0 → 0.11.0

package/dist/Schema.js

@@ -46,10 +46,12 @@ __export(Schema_exports, {
   SchemaObject: () => SchemaObject,
   SchemaRecord: () => SchemaRecord,
   SchemaString: () => SchemaString,
+  SchemaTuple: () => SchemaTuple,
   SchemaUndefined: () => SchemaUndefined,
   SchemaUnion: () => SchemaUnion,
   SchemaVoid: () => SchemaVoid,
   default: () => Schema,
+  getSchemaItemAtPath: () => getSchemaItemAtPath,
   isNull: () => isNull,
   parsable: () => parsable,
   parseForm: () => parseForm,
@@ -60,12 +62,104 @@ __export(Schema_exports, {
 module.exports = __toCommonJS(Schema_exports);
 
 // src/helpers.ts
-var import_object_util3 = require("@dzeio/object-util");
+var import_object_util = require("@dzeio/object-util");
+function isNull(value) {
+  return value === void 0 || value === null;
+}
+function parseQuery(schema, query, opts) {
+  const record = {};
+  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 allValues = query.getAll(key);
+    const finalValue = (schemaItem == null ? void 0 : schemaItem.parse(allValues).valid) ? allValues : value;
+    (0, import_object_util.objectSet)(record, keys, finalValue);
+  }
+  return schema.parse(record, opts);
+}
+function parseFormData(schema, data, opts) {
+  const record = {};
+  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 allValues = data.getAll(key);
+    const finalValue = (schemaItem == null ? void 0 : schemaItem.parse(allValues).valid) ? allValues : value;
+    (0, import_object_util.objectSet)(record, keys, finalValue);
+  }
+  const handleBoolean = (value, keys) => {
+    var _a;
+    if (value instanceof SchemaNullable) {
+      handleBoolean(value.unwrap(), keys);
+    }
+    if (value instanceof SchemaArray) {
+      const elements = (0, import_object_util.objectGet)(record, keys);
+      for (let it = 0; it < ((_a = elements == null ? void 0 : elements.length) != null ? _a : 0); it++) {
+        handleBoolean(value.unwrap(), [...keys, it]);
+      }
+    }
+    if (value instanceof SchemaObject) {
+      handleSchemaForBoolean(value.model, keys);
+    }
+    if (value instanceof SchemaBoolean && typeof (0, import_object_util.objectGet)(record, keys) === "undefined") {
+      (0, import_object_util.objectSet)(record, keys, false);
+    }
+  };
+  const handleSchemaForBoolean = (model, keys = []) => {
+    (0, import_object_util.objectLoop)(model, (value, key) => {
+      handleBoolean(value, [...keys, key]);
+    });
+  };
+  if (schema instanceof SchemaObject) {
+    handleSchemaForBoolean(schema.model);
+  }
+  return schema.parse(record, opts);
+}
+function parseForm(model, form, opts) {
+  return parseFormData(model, new FormData(form), opts);
+}
+function getSchemaItemAtPath(schema, path) {
+  while (schema instanceof SchemaNullable || schema instanceof SchemaDefault) {
+    schema = schema.unwrap();
+  }
+  if (path.length === 0 || !schema) {
+    return schema;
+  }
+  if (schema instanceof SchemaUnion || schema instanceof SchemaIntersection) {
+    for (const child of schema.unwrap()) {
+      try {
+        const result = getSchemaItemAtPath(child, path);
+        if (!result) {
+          continue;
+        }
+        return result;
+      } catch {
+        continue;
+      }
+    }
+    return void 0;
+  }
+  const key = path[0];
+  const next = path.slice(1);
+  if (schema instanceof SchemaArray && typeof key === "number") {
+    return getSchemaItemAtPath(schema.unwrap(), next);
+  }
+  if (schema instanceof SchemaTuple && typeof key === "number") {
+    return getSchemaItemAtPath(schema.unwrap()[key], next);
+  }
+  if (schema instanceof SchemaObject && typeof key === "string") {
+    return getSchemaItemAtPath(schema.model[key], next);
+  }
+  if (schema instanceof SchemaRecord && schema.isKeyOfType(key)) {
+    return getSchemaItemAtPath(schema.unwrap(), next);
+  }
+  return void 0;
+}
 
 // src/SchemaItem.ts
-var import_object_util = require("@dzeio/object-util");
+var import_object_util2 = require("@dzeio/object-util");
 var _SchemaItem = class _SchemaItem {
   constructor(items) {
+    this.id = this.constructor.id;
     // standard Schema V1 spec
     this["~standard"] = {
       vendor: "aptatio",
@@ -102,7 +196,6 @@ var _SchemaItem = class _SchemaItem {
      *
      * note: The type of the final Pre-Process MUST be valid
      */
-    // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
     this.preProcess = [];
     /**
      * post process the variable after it being validated
@@ -119,6 +212,10 @@ var _SchemaItem = class _SchemaItem {
       this.items = Array.isArray(items) ? items : Array.from(items);
     }
   }
+  setInvalidError(err) {
+    this.invalidError = err;
+    return this;
+  }
   parseJSON() {
     this.addPreProcess((input) => {
       try {
@@ -140,10 +237,6 @@ var _SchemaItem = class _SchemaItem {
   attr(...attributes) {
     return this.attrs(...attributes);
   }
-  setInvalidError(err) {
-    this.invalidError = err;
-    return this;
-  }
   clone() {
     return Schema.fromJSON(this.toJSON());
   }
@@ -216,24 +309,13 @@ var _SchemaItem = class _SchemaItem {
       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 });
+    (0, import_object_util2.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;
   }
-  // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
   addPreProcess(fn) {
     this.preProcess.push(fn);
     return this;
@@ -248,8 +330,8 @@ var _SchemaItem = class _SchemaItem {
   }
   /** 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);
+    if (path && (0, import_object_util2.isObject)(input)) {
+      (0, import_object_util2.objectSet)(input, path.split("."), value);
       return input;
     } else {
       return value;
@@ -273,220 +355,27 @@ var _SchemaItem = class _SchemaItem {
     }
     return result;
   }
-};
-__decorateClass([
-  parsable()
-], _SchemaItem.prototype, "parseJSON", 1);
-__decorateClass([
-  parsable()
-], _SchemaItem.prototype, "in", 1);
-__decorateClass([
-  parsable()
-], _SchemaItem.prototype, "setInvalidError", 1);
-var SchemaItem = _SchemaItem;
-
-// src/items/array.ts
-var SchemaArray = class extends SchemaItem {
-  constructor(values) {
-    super([values]);
-    this.values = values;
-  }
-  unique() {
-    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;
-  }
-  unwrap() {
-    return this.values;
-  }
-  isOfType(input) {
-    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() })) : [];
-  }
-};
-SchemaArray.id = "array";
-__decorateClass([
-  parsable()
-], SchemaArray.prototype, "unique", 1);
-__decorateClass([
-  parsable()
-], SchemaArray.prototype, "clean", 1);
-__decorateClass([
-  parsable()
-], SchemaArray.prototype, "split", 1);
-
-// src/items/boolean.ts
-var SchemaBoolean = class extends SchemaItem {
-  parseString(trueValue = "true", falseValue = "false") {
-    this.addPreProcess((input) => {
-      if (typeof input !== "string") {
-        return input;
-      }
-      if (input === trueValue) {
-        return true;
-      }
-      if (input === falseValue) {
-        return false;
-      }
-      return input;
-    });
-    return this;
-  }
-  isOfType(input) {
-    return typeof input === "boolean";
-  }
-};
-SchemaBoolean.id = "boolean";
-__decorateClass([
-  parsable()
-], SchemaBoolean.prototype, "parseString", 1);
-
-// src/items/nullable.ts
-var SchemaNullable = class extends SchemaItem {
-  constructor(child) {
-    super([child]);
-    this.child = child;
-  }
-  falsyAsNull() {
-    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 }];
-  }
-  parseSubItems(input, options) {
-    if (isNull(input)) {
-      return { input: void 0 };
+  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_util2.isObject)(item)) {
+      return (0, import_object_util2.objectRemap)(item, (value, key) => ({ value: this.deepSerializeItem(value), key }));
     }
-    return super.parseSubItems(input, options);
+    return item;
   }
 };
-SchemaNullable.id = "nullable";
 __decorateClass([
   parsable()
-], SchemaNullable.prototype, "falsyAsNull", 1);
+], _SchemaItem.prototype, "setInvalidError", 1);
 __decorateClass([
   parsable()
-], SchemaNullable.prototype, "emptyAsNull", 1);
+], _SchemaItem.prototype, "parseJSON", 1);
 __decorateClass([
   parsable()
-], SchemaNullable.prototype, "emptyFileAsNull", 1);
-
-// src/items/object.ts
-var import_object_util2 = require("@dzeio/object-util");
-var SchemaObject = class extends SchemaItem {
-  constructor(model) {
-    super([model]);
-    this.model = model;
-  }
-  isOfType(input) {
-    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() })) : [];
-  }
-};
-SchemaObject.id = "object";
-
-// src/helpers.ts
-function isNull(value) {
-  return typeof value === "undefined" || value === null;
-}
-function parseQuery(schema, query, opts) {
-  const record = {};
-  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 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);
-}
-function parseFormData(schema, data, opts) {
-  const record = {};
-  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 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;
-    if (value instanceof SchemaNullable) {
-      handleBoolean(value.unwrap(), keys);
-    }
-    if (value instanceof SchemaArray) {
-      const elements = (0, import_object_util3.objectGet)(record, keys);
-      for (let it = 0; it < ((_a = elements == null ? void 0 : elements.length) != null ? _a : 0); it++) {
-        handleBoolean(value.unwrap(), [...keys, it]);
-      }
-    }
-    if (value instanceof SchemaObject) {
-      handleSchemaForBoolean(value.model, keys);
-    }
-    if (value instanceof SchemaBoolean && typeof (0, import_object_util3.objectGet)(record, keys) === "undefined") {
-      (0, import_object_util3.objectSet)(record, keys, false);
-    }
-  };
-  const handleSchemaForBoolean = (model, keys = []) => {
-    (0, import_object_util3.objectLoop)(model, (value, key) => {
-      handleBoolean(value, [...keys, key]);
-    });
-  };
-  if (schema instanceof SchemaObject) {
-    handleSchemaForBoolean(schema.model);
-  }
-  return schema.parse(record, 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;
-}
+], _SchemaItem.prototype, "in", 1);
+var SchemaItem = _SchemaItem;
 
 // src/items/any.ts
 var SchemaAny = class extends SchemaItem {
@@ -498,6 +387,12 @@ SchemaAny.id = "any";
 
 // src/items/date.ts
 var SchemaDate = class extends SchemaItem {
+  // overide the basic constructor to check that the date has a valid format
+  // purpose : reject incorrect date like '2020-30-45'
+  constructor() {
+    super();
+    this.addValidation((input) => !Number.isNaN(input.getDate()));
+  }
   parseString(format = "default") {
     this.addPreProcess((input) => {
       if (typeof input !== "string") {
@@ -527,7 +422,7 @@ var SchemaDate = class extends SchemaItem {
           break;
         }
       }
-      if (!date || isNaN(date.getDate())) {
+      if (!date || Number.isNaN(date.getDate())) {
         return input;
       }
       return date;
@@ -544,21 +439,27 @@ __decorateClass([
 ], SchemaDate.prototype, "parseString", 1);
 
 // src/items/record.ts
-var import_object_util4 = require("@dzeio/object-util");
+var import_object_util3 = require("@dzeio/object-util");
 var SchemaRecord = class extends SchemaItem {
   constructor(keys, values) {
     super([keys, values]);
     this.keys = keys;
     this.values = values;
   }
+  unwrap() {
+    return this.values;
+  }
+  isKeyOfType(key) {
+    return this.keys.parse(key).valid;
+  }
   isOfType(input) {
-    return (0, import_object_util4.isObject)(input) && Object.prototype.toString.call(input) === "[object Object]";
+    return (0, import_object_util3.isObject)(input) && Object.prototype.toString.call(input) === "[object Object]";
   }
   parseSubItems(input, options) {
     const result = { input, errors: [] };
-    if ((0, import_object_util4.isObject)(input)) {
+    if ((0, import_object_util3.isObject)(input)) {
       const clone = {};
-      (0, import_object_util4.objectLoop)(input, (value, key) => {
+      (0, import_object_util3.objectLoop)(input, (value, key) => {
         var _a, _b;
         const res1 = this.keys.parse(key);
         const res2 = this.values.parse(value);
@@ -579,6 +480,71 @@ var SchemaRecord = class extends SchemaItem {
 };
 SchemaRecord.id = "record";
 
+// src/items/array.ts
+var SchemaArray = class extends SchemaItem {
+  constructor(values) {
+    super([values]);
+    this.values = values;
+  }
+  unique() {
+    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;
+  }
+  unwrap() {
+    return this.values;
+  }
+  isOfType(input) {
+    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() })) : [];
+  }
+};
+SchemaArray.id = "array";
+__decorateClass([
+  parsable()
+], SchemaArray.prototype, "unique", 1);
+__decorateClass([
+  parsable()
+], SchemaArray.prototype, "clean", 1);
+__decorateClass([
+  parsable()
+], SchemaArray.prototype, "split", 1);
+
+// src/items/boolean.ts
+var SchemaBoolean = class extends SchemaItem {
+  parseString(trueValue = "true", falseValue = "false") {
+    this.addPreProcess((input) => {
+      if (typeof input !== "string") {
+        return input;
+      }
+      if (input === trueValue) {
+        return true;
+      }
+      if (input === falseValue) {
+        return false;
+      }
+      return input;
+    });
+    return this;
+  }
+  isOfType(input) {
+    return typeof input === "boolean";
+  }
+};
+SchemaBoolean.id = "boolean";
+__decorateClass([
+  parsable()
+], SchemaBoolean.prototype, "parseString", 1);
+
 // src/items/enum.ts
 var SchemaEnum = class extends SchemaItem {
   constructor(templateEnum) {
@@ -613,6 +579,51 @@ var SchemaLiteral = class extends SchemaItem {
 };
 SchemaLiteral.id = "literal";
 
+// src/items/nullable.ts
+var SchemaNullable = class extends SchemaItem {
+  constructor(child) {
+    super([child]);
+    this.child = child;
+  }
+  falsyAsNull() {
+    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 input === void 0 || this.child.isOfType(input);
+  }
+  getSubInputs(input) {
+    return [{ value: input, item: this.child, path: void 0 }];
+  }
+  parseSubItems(input, options) {
+    if (isNull(input)) {
+      return { input: void 0 };
+    }
+    return super.parseSubItems(input, options);
+  }
+};
+SchemaNullable.id = "nullable";
+__decorateClass([
+  parsable()
+], SchemaNullable.prototype, "falsyAsNull", 1);
+__decorateClass([
+  parsable()
+], SchemaNullable.prototype, "emptyAsNull", 1);
+__decorateClass([
+  parsable()
+], SchemaNullable.prototype, "emptyFileAsNull", 1);
+
 // src/items/number.ts
 var SchemaNumber = class extends SchemaItem {
   lte(value, message) {
@@ -682,6 +693,22 @@ __decorateClass([
   parsable()
 ], SchemaNumber.prototype, "parseString", 1);
 
+// src/items/object.ts
+var import_object_util4 = require("@dzeio/object-util");
+var SchemaObject = class extends SchemaItem {
+  constructor(model) {
+    super([model]);
+    this.model = model;
+  }
+  isOfType(input) {
+    return (0, import_object_util4.isObject)(input) && !(0, import_object_util4.objectFind)(this.model, (item, key) => !item.isOfType(input[key]));
+  }
+  getSubInputs(input) {
+    return (0, import_object_util4.isObject)(input) ? (0, import_object_util4.objectMap)(this.model, (schema, key) => ({ item: schema, value: input[key], path: key.toString() })) : [];
+  }
+};
+SchemaObject.id = "object";
+
 // src/items/string.ts
 var SchemaString = class extends SchemaItem {
   min(value, message) {
@@ -707,6 +734,15 @@ var SchemaString = class extends SchemaItem {
     });
     return this;
   }
+  trim() {
+    this.addPreProcess((input) => {
+      if (typeof input !== "string") {
+        return input;
+      }
+      return input.trim();
+    });
+    return this;
+  }
   notEmpty(message) {
     this.addValidation({
       fn(input) {
@@ -754,6 +790,9 @@ __decorateClass([
 __decorateClass([
   parsable()
 ], SchemaString.prototype, "max", 1);
+__decorateClass([
+  parsable()
+], SchemaString.prototype, "trim", 1);
 __decorateClass([
   parsable()
 ], SchemaString.prototype, "notEmpty", 1);
@@ -770,6 +809,9 @@ var SchemaUnion = class extends SchemaItem {
     super(schemas);
     this.schemas = schemas;
   }
+  unwrap() {
+    return this.schemas;
+  }
   isOfType(input) {
     return this.schemas.some((it) => it.isOfType(input));
   }
@@ -795,6 +837,9 @@ var SchemaIntersection = class extends SchemaItem {
     super(schemas);
     this.schemas = schemas;
   }
+  unwrap() {
+    return this.schemas;
+  }
   isOfType(input) {
     return this.schemas.every((it) => it.isOfType(input));
   }
@@ -869,6 +914,9 @@ var SchemaTuple = class extends SchemaItem {
     super(children);
     this.children = children;
   }
+  unwrap() {
+    return this.children;
+  }
   isOfType(input) {
     if (!Array.isArray(input) || input.length > this.items.length) {
       return false;
@@ -889,7 +937,7 @@ SchemaTuple.id = "tuple";
 // src/items/nullish.ts
 var SchemaUndefined = class extends SchemaItem {
   isOfType(input) {
-    return typeof input === "undefined";
+    return input === void 0;
   }
 };
 SchemaUndefined.id = "undefined";
@@ -901,7 +949,7 @@ var SchemaNull = class extends SchemaItem {
 SchemaNull.id = "null";
 var SchemaVoid = class extends SchemaItem {
   isOfType(input) {
-    return typeof input === "undefined";
+    return input === void 0;
   }
 };
 SchemaVoid.id = "void";
@@ -1117,9 +1165,11 @@ var s = Schema;
   SchemaObject,
   SchemaRecord,
   SchemaString,
+  SchemaTuple,
   SchemaUndefined,
   SchemaUnion,
   SchemaVoid,
+  getSchemaItemAtPath,
   isNull,
   parsable,
   parseForm,