@dzeio/schema 0.9.0 → 0.10.0

package/dist/Schema.mjs

@@ -10,12 +10,104 @@ var __decorateClass = (decorators, target, key, kind) => {
 };
 
 // src/helpers.ts
-import { objectClone, objectGet, objectLoop, objectSet as objectSet2 } from "@dzeio/object-util";
+import { objectGet, objectLoop, objectSet } from "@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;
+    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;
+    objectSet(record, keys, finalValue);
+  }
+  const handleBoolean = (value, keys) => {
+    var _a;
+    if (value instanceof SchemaNullable) {
+      handleBoolean(value.unwrap(), keys);
+    }
+    if (value instanceof SchemaArray) {
+      const elements = 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 objectGet(record, keys) === "undefined") {
+      objectSet(record, keys, false);
+    }
+  };
+  const handleSchemaForBoolean = (model, keys = []) => {
+    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
-import { isObject, objectClean, objectRemap, objectSet } from "@dzeio/object-util";
+import { isObject, objectClean, objectRemap, objectSet as objectSet2 } from "@dzeio/object-util";
 var _SchemaItem = class _SchemaItem {
   constructor(items) {
+    this.id = this.constructor.id;
     // standard Schema V1 spec
     this["~standard"] = {
       vendor: "aptatio",
@@ -52,7 +144,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
@@ -69,6 +160,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 {
@@ -90,10 +185,6 @@ var _SchemaItem = class _SchemaItem {
   attr(...attributes) {
     return this.attrs(...attributes);
   }
-  setInvalidError(err) {
-    this.invalidError = err;
-    return this;
-  }
   clone() {
     return Schema.fromJSON(this.toJSON());
   }
@@ -169,21 +260,10 @@ var _SchemaItem = class _SchemaItem {
     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;
   }
-  // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
   addPreProcess(fn) {
     this.preProcess.push(fn);
     return this;
@@ -199,7 +279,7 @@ 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 && isObject(input)) {
-      objectSet(input, path.split("."), value);
+      objectSet2(input, path.split("."), value);
       return input;
     } else {
       return value;
@@ -223,220 +303,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 (isObject(item)) {
+      return 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
-import { isObject as isObject2, objectFind, objectMap } from "@dzeio/object-util";
-var SchemaObject = class extends SchemaItem {
-  constructor(model) {
-    super([model]);
-    this.model = model;
-  }
-  isOfType(input) {
-    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() })) : [];
-  }
-};
-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;
-    objectSet2(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;
-    objectSet2(record, keys, finalValue);
-  }
-  const handleBoolean = (value, keys) => {
-    var _a;
-    if (value instanceof SchemaNullable) {
-      handleBoolean(value.unwrap(), keys);
-    }
-    if (value instanceof SchemaArray) {
-      const elements = 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 objectGet(record, keys) === "undefined") {
-      objectSet2(record, keys, false);
-    }
-  };
-  const handleSchemaForBoolean = (model, keys = []) => {
-    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 = 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 {
@@ -477,7 +364,7 @@ var SchemaDate = class extends SchemaItem {
           break;
         }
       }
-      if (!date || isNaN(date.getDate())) {
+      if (!date || Number.isNaN(date.getDate())) {
         return input;
       }
       return date;
@@ -494,19 +381,25 @@ __decorateClass([
 ], SchemaDate.prototype, "parseString", 1);
 
 // src/items/record.ts
-import { isObject as isObject3, objectLoop as objectLoop2 } from "@dzeio/object-util";
+import { isObject as isObject2, objectLoop as objectLoop2 } from "@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 isObject3(input) && Object.prototype.toString.call(input) === "[object Object]";
+    return isObject2(input) && Object.prototype.toString.call(input) === "[object Object]";
   }
   parseSubItems(input, options) {
     const result = { input, errors: [] };
-    if (isObject3(input)) {
+    if (isObject2(input)) {
       const clone = {};
       objectLoop2(input, (value, key) => {
         var _a, _b;
@@ -529,6 +422,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) {
@@ -563,6 +521,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) {
@@ -632,6 +635,22 @@ __decorateClass([
   parsable()
 ], SchemaNumber.prototype, "parseString", 1);
 
+// src/items/object.ts
+import { isObject as isObject3, objectFind, objectMap } from "@dzeio/object-util";
+var SchemaObject = class extends SchemaItem {
+  constructor(model) {
+    super([model]);
+    this.model = model;
+  }
+  isOfType(input) {
+    return isObject3(input) && !objectFind(this.model, (item, key) => !item.isOfType(input[key]));
+  }
+  getSubInputs(input) {
+    return isObject3(input) ? 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) {
@@ -657,6 +676,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) {
@@ -704,6 +732,9 @@ __decorateClass([
 __decorateClass([
   parsable()
 ], SchemaString.prototype, "max", 1);
+__decorateClass([
+  parsable()
+], SchemaString.prototype, "trim", 1);
 __decorateClass([
   parsable()
 ], SchemaString.prototype, "notEmpty", 1);
@@ -720,6 +751,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));
   }
@@ -745,6 +779,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));
   }
@@ -819,6 +856,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;
@@ -839,7 +879,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";
@@ -851,7 +891,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";
@@ -1066,10 +1106,12 @@ export {
   SchemaObject,
   SchemaRecord,
   SchemaString,
+  SchemaTuple,
   SchemaUndefined,
   SchemaUnion,
   SchemaVoid,
   Schema as default,
+  getSchemaItemAtPath,
   isNull,
   parsable,
   parseForm,

package/package.json

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