@dzeio/schema 0.0.1

package/dist/Schema.js

@@ -0,0 +1,810 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+
+// src/Schema.ts
+var Schema_exports = {};
+__export(Schema_exports, {
+  SchemaArray: () => SchemaArray,
+  SchemaBoolean: () => SchemaBoolean,
+  SchemaDate: () => SchemaDate,
+  SchemaEnum: () => SchemaEnum,
+  SchemaItem: () => SchemaItem,
+  SchemaLiteral: () => SchemaLiteral,
+  SchemaNullable: () => SchemaNullable,
+  SchemaNumber: () => SchemaNumber,
+  SchemaObject: () => SchemaObject,
+  SchemaRecord: () => SchemaRecord,
+  SchemaString: () => SchemaString,
+  SchemaUnion: () => SchemaUnion,
+  Types: () => Types,
+  default: () => Schema,
+  parceable: () => parceable,
+  parseForm: () => parseForm,
+  parseFormData: () => parseFormData,
+  parseQuery: () => parseQuery,
+  s: () => s
+});
+module.exports = __toCommonJS(Schema_exports);
+
+// src/helpers.ts
+var import_object_util3 = require("@dzeio/object-util");
+
+// src/SchemaItem.ts
+var import_object_util = require("@dzeio/object-util");
+var SchemaItem = class _SchemaItem {
+  constructor(items) {
+    // standard Schema V1 spec
+    this["~standard"] = {
+      vendor: "aptatio",
+      version: 1,
+      validate: (value) => {
+        const res = this.parse(value);
+        if (!res.valid) {
+          return {
+            issues: res.errors
+          };
+        }
+        return {
+          value: res.object,
+          issues: res.errors
+        };
+      }
+    };
+    /**
+     * keep public ?
+     */
+    this.validations = [];
+    /**
+     * Function calls saved for serialization
+     */
+    this.savedCalls = [];
+    /**
+     * Pre process the variable for various reasons
+     *
+     * It will execute every pre-process sequentially in order of being added
+     *
+     * 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
+     *
+     * it will execute each post-processes sequentially
+     *
+     * 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";
+    if (items && items.length > 0) {
+      this.items = Array.isArray(items) ? items : Array.from(items);
+    }
+  }
+  attrs(...attributes) {
+    this.attributes.concat(attributes);
+    return this;
+  }
+  attr(...attributes) {
+    return this.attrs(...attributes);
+  }
+  setInvalidError(err) {
+    this.invalidError = err;
+    return this;
+  }
+  clone() {
+    return Schema.fromJSON(this.toJSON());
+  }
+  parse(input, options) {
+    var _a;
+    for (const preProcess of this.preProcess) {
+      input = preProcess(input);
+    }
+    if (!this.isOfType(input)) {
+      return {
+        valid: false,
+        errors: [{ message: "invalid type" }]
+      };
+    }
+    const errors = [];
+    for (const validation of this.validations) {
+      if (!validation.fn(input)) {
+        errors.push({
+          message: (_a = validation.error) != null ? _a : this.invalidError
+        });
+        if (options == null ? void 0 : options.fast) {
+          return {
+            valid: false,
+            object: input,
+            errors
+          };
+        }
+      }
+    }
+    if (errors.length > 0) {
+      return {
+        valid: false,
+        object: input,
+        errors
+      };
+    }
+    for (const postProcess of this.postProcess) {
+      input = postProcess(input);
+    }
+    return {
+      valid: true,
+      object: input
+    };
+  }
+  toJSON() {
+    var _a;
+    const res = {
+      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),
+      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;
+  }
+  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;
+  }
+  addPostProcess(fn) {
+    this.postProcess.push(fn);
+    return this;
+  }
+};
+
+// 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;
+  }
+  parse(input, options) {
+    const { valid, object, errors = [] } = super.parse(input, options);
+    if (!valid) {
+      return {
+        valid,
+        object,
+        errors
+      };
+    }
+    const clone = [];
+    const errs = [];
+    for (let idx = 0; idx < object.length; idx++) {
+      const item = object[idx];
+      const res = this.values.parse(item);
+      if (res.valid) {
+        clone.push(res.object);
+        continue;
+      }
+      const errss = res.errors.map((it) => ({
+        ...it,
+        field: it.field ? `${idx}.${it.field}` : idx.toString()
+      }));
+      if (options == null ? void 0 : options.fast) {
+        return {
+          valid: false,
+          object: clone,
+          errors: errss
+        };
+      }
+      errs.push(...errss);
+    }
+    if (errs.length > 0) {
+      return {
+        valid: false,
+        object: clone,
+        errors: errs
+      };
+    }
+    return {
+      valid: true,
+      object: clone
+    };
+  }
+  unwrap() {
+    return this.values;
+  }
+  isOfType(input) {
+    return Array.isArray(input);
+  }
+};
+__decorateClass([
+  parceable()
+], SchemaArray.prototype, "unique", 1);
+
+// src/items/boolean.ts
+var SchemaBoolean = class extends SchemaItem {
+  parseString(trueValue = "true", falseValue = "false") {
+    this.addPreProcess((it) => {
+      if (typeof it !== "string") {
+        return it;
+      }
+      if (it === trueValue) {
+        return true;
+      }
+      if (it === falseValue) {
+        return false;
+      }
+      return it;
+    });
+    return this;
+  }
+  isOfType(input) {
+    return typeof input === "boolean";
+  }
+};
+__decorateClass([
+  parceable()
+], SchemaBoolean.prototype, "parseString", 1);
+
+// src/items/nullable.ts
+var SchemaNullable = class extends SchemaItem {
+  constructor(child) {
+    super([child]);
+    this.child = child;
+  }
+  unwrap() {
+    return this.child;
+  }
+  parse(input, options) {
+    if (this.isNull(input)) {
+      return {
+        valid: true,
+        object: void 0
+      };
+    }
+    return this.child.parse(input, options);
+  }
+  isOfType(input) {
+    return Array.isArray(input);
+  }
+  isNull(value) {
+    return typeof value === "undefined" || value === null;
+  }
+};
+
+// src/items/object.ts
+var import_object_util2 = require("@dzeio/object-util");
+var SchemaObject = class extends SchemaItem {
+  constructor(model) {
+    super([model]);
+    this.model = model;
+    this.id = "object";
+  }
+  parse(input, options) {
+    const { valid, object, errors = [] } = super.parse(input, options);
+    if (!valid) {
+      return {
+        valid,
+        object,
+        errors
+      };
+    }
+    const clone = (0, import_object_util2.objectClone)(object);
+    (0, import_object_util2.objectLoop)(this.model, (childSchema, key) => {
+      const childValue = clone[key];
+      const child = childSchema.parse(childValue);
+      if (!child.valid) {
+        errors.push(...child.errors.map((it) => ({
+          ...it,
+          field: it.field ? `${key}.${it.field}` : key
+        })));
+      }
+      clone[key] = child.object;
+      return child.valid || !(options == null ? void 0 : options.fast);
+    });
+    return {
+      valid: errors.length === 0,
+      errors,
+      object: clone
+    };
+  }
+  isOfType(input) {
+    return (0, import_object_util2.isObject)(input);
+  }
+};
+
+// src/helpers.ts
+function parseQuery(model, query, opts) {
+  const record = {};
+  for (const [key, value] of query) {
+    record[key] = value;
+  }
+  return model.parse(record, opts);
+}
+function parseFormData(model, data, opts) {
+  var _a;
+  const record = {};
+  for (const [key, value] of data) {
+    const isArray = (_a = model.model[key].isOfType([])) != null ? _a : false;
+    (0, import_object_util3.objectSet)(record, key.split(".").map((it) => /^\d+$/g.test(it) ? parseInt(it, 10) : it), isArray ? data.getAll(key) : value);
+  }
+  const handleBoolean = (value, keys) => {
+    var _a2;
+    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 < ((_a2 = elements == null ? void 0 : elements.length) != null ? _a2 : 0); it++) {
+        handleBoolean(value.unwrap(), [...keys, it]);
+      }
+    }
+    if (value instanceof SchemaObject) {
+      handleSchemaForBoolean(value.model, keys);
+    }
+    if (value instanceof SchemaBoolean) {
+      (0, import_object_util3.objectSet)(record, keys, !!data.get(keys.join(".")));
+    }
+  };
+  const handleSchemaForBoolean = (modl, keys = []) => {
+    (0, import_object_util3.objectLoop)(modl, (value, key) => {
+      handleBoolean(value, [...keys, key]);
+    });
+  };
+  handleSchemaForBoolean(model.model);
+  return model.parse(record, opts);
+}
+function parseForm(model, form, opts) {
+  return parseFormData(model, new FormData(form), opts);
+}
+
+// src/items/date.ts
+var SchemaDate = class extends SchemaItem {
+  isOfType(input) {
+    return input instanceof Date;
+  }
+};
+
+// src/items/record.ts
+var import_object_util4 = require("@dzeio/object-util");
+var SchemaRecord = class extends SchemaItem {
+  constructor(keys, values) {
+    super([keys, values]);
+    this.keys = keys;
+    this.values = values;
+  }
+  parse(input, options) {
+    const { valid, object, errors = [] } = super.parse(input, options);
+    if (!valid) {
+      return {
+        valid,
+        object,
+        errors
+      };
+    }
+    const clone = {};
+    (0, import_object_util4.objectLoop)(object, (value, key) => {
+      var _a, _b;
+      const res1 = this.keys.parse(key);
+      const res2 = this.values.parse(value);
+      if (!res1.valid || !res2.valid) {
+        errors.push(...((_a = res1.errors) != null ? _a : []).concat(...(_b = res2.errors) != null ? _b : []).map((it) => ({
+          message: it.message,
+          field: it.field ? `${key}.${it.field}` : key.toString()
+        })));
+      } else {
+        clone[res1.object] = res2.object;
+      }
+      return errors.length === 0 || !(options == null ? void 0 : options.fast);
+    });
+    return {
+      valid: errors.length === 0,
+      errors,
+      object: clone
+    };
+  }
+  isOfType(input) {
+    return (0, import_object_util4.isObject)(input) && Object.prototype.toString.call(input) === "[object Object]";
+  }
+};
+
+// src/items/enum.ts
+var SchemaEnum = class extends SchemaItem {
+  constructor(templateEnum) {
+    super();
+    this.templateEnum = templateEnum;
+    this.type = "string";
+    const firstValue = Object.values(templateEnum)[0];
+    if (typeof firstValue === "number" || typeof templateEnum[firstValue] === "number") {
+      this.type = "number";
+    }
+    this.validations.push({
+      fn: (input) => Object.values(this.templateEnum).includes(input),
+      error: `Input is not part of ${templateEnum.constructor.name}`
+    });
+  }
+  isOfType(input) {
+    return typeof input === this.type;
+  }
+};
+
+// src/items/literal.ts
+var SchemaLiteral = class extends SchemaItem {
+  constructor(value) {
+    super([value]);
+    this.value = value;
+    this.validations.push({ fn: (it) => it === this.value });
+  }
+  isOfType(input) {
+    return typeof input === typeof this.value;
+  }
+};
+
+// src/items/number.ts
+var SchemaNumber = class extends SchemaItem {
+  lte(value, message) {
+    this.addValidation({
+      fn(input) {
+        return input <= value;
+      },
+      error: message
+    });
+    return this;
+  }
+  gte(value, message) {
+    this.addValidation({
+      fn(input) {
+        return input >= value;
+      },
+      error: message
+    });
+    return this;
+  }
+  lt(value, message) {
+    this.addValidation({
+      fn(input) {
+        return input < value;
+      },
+      error: message
+    });
+    return this;
+  }
+  gt(value, message) {
+    this.addValidation({
+      fn(input) {
+        return input > value;
+      },
+      error: message
+    });
+    return this;
+  }
+  parseString() {
+    this.addPreProcess(
+      (input) => typeof input === "string" ? Number.parseFloat(input) : input
+    );
+    return this;
+  }
+  isOfType(input) {
+    return typeof input === "number" && !Number.isNaN(input);
+  }
+  min(...params) {
+    return this.gte(...params);
+  }
+  max(...params) {
+    return this.lte(...params);
+  }
+};
+__decorateClass([
+  parceable()
+], SchemaNumber.prototype, "lte", 1);
+__decorateClass([
+  parceable()
+], SchemaNumber.prototype, "gte", 1);
+__decorateClass([
+  parceable()
+], SchemaNumber.prototype, "lt", 1);
+__decorateClass([
+  parceable()
+], SchemaNumber.prototype, "gt", 1);
+__decorateClass([
+  parceable()
+], SchemaNumber.prototype, "parseString", 1);
+
+// src/items/string.ts
+var SchemaString = class extends SchemaItem {
+  min(value, message) {
+    this.addValidation({
+      fn(input) {
+        return input.length >= value;
+      },
+      error: message
+    });
+    return this;
+  }
+  toCasing(casing) {
+    const fn = casing === "lower" ? "toLowerCase" : "toUpperCase";
+    this.addPostProcess((it) => it[fn]());
+    return this;
+  }
+  max(value, message) {
+    this.addValidation({
+      fn(input) {
+        return input.length <= value;
+      },
+      error: message
+    });
+    return this;
+  }
+  notEmpty(message) {
+    this.addValidation({
+      fn(input) {
+        return input !== "";
+      },
+      error: message
+    });
+    return this;
+  }
+  regex(regex, message) {
+    this.addValidation({
+      fn(input) {
+        return regex.test(input);
+      },
+      error: message
+    });
+    return this;
+  }
+  minLength(value, message) {
+    return this.min(value, message);
+  }
+  maxLength(value, message) {
+    return this.max(value, message);
+  }
+  isOfType(input) {
+    return typeof input === "string";
+  }
+};
+__decorateClass([
+  parceable()
+], SchemaString.prototype, "min", 1);
+__decorateClass([
+  parceable()
+], SchemaString.prototype, "toCasing", 1);
+__decorateClass([
+  parceable()
+], SchemaString.prototype, "max", 1);
+__decorateClass([
+  parceable()
+], SchemaString.prototype, "notEmpty", 1);
+__decorateClass([
+  parceable()
+], SchemaString.prototype, "regex", 1);
+
+// src/items/union.ts
+var SchemaUnion = class extends SchemaItem {
+  constructor(...schemas) {
+    super();
+    this.schemas = schemas;
+  }
+  parse(input, options) {
+    const { valid, object, errors = [] } = super.parse(input, options);
+    if (!valid) {
+      return {
+        valid,
+        object,
+        errors
+      };
+    }
+    for (const schema of this.schemas) {
+      const validation = schema.parse(input, options);
+      if (validation.valid) {
+        return validation;
+      } else {
+        errors.push(...validation.errors);
+      }
+    }
+    return {
+      valid: false,
+      errors,
+      object
+    };
+  }
+  isOfType(input) {
+    return this.schemas.some((it) => it.isOfType(input));
+  }
+};
+
+// src/Schema.ts
+function parceable() {
+  return (target, propertyKey, descriptor) => {
+    if (!(target instanceof SchemaItem)) {
+      throw new Error("the decorator is only usable on Schema");
+    }
+    if (!(propertyKey in target)) {
+      throw new Error("property not set in object");
+    }
+    const original = target[propertyKey];
+    descriptor.value = function(...args) {
+      this.savedCalls.push({ name: propertyKey, args });
+      const res = original.call(this, ...args);
+      return res;
+    };
+    return descriptor;
+  };
+}
+var Types = {
+  Array: SchemaArray,
+  Boolean: SchemaBoolean,
+  Date: SchemaDate,
+  Enum: SchemaEnum,
+  Literal: SchemaLiteral,
+  Nullable: SchemaNullable,
+  Object: SchemaObject,
+  Record: SchemaRecord,
+  String: SchemaString,
+  Union: SchemaUnion
+};
+var _Schema = class _Schema extends SchemaObject {
+  static register(module2) {
+    this.registeredModules.push(module2);
+  }
+  static getModule(name) {
+    return this.registeredModules.find((it) => it.name === name);
+  }
+  static array(...inputs) {
+    return new SchemaArray(...inputs);
+  }
+  static boolean(...inputs) {
+    return new SchemaBoolean(...inputs);
+  }
+  static date(...inputs) {
+    return new SchemaDate(...inputs);
+  }
+  static enum(...inputs) {
+    return new SchemaEnum(...inputs);
+  }
+  /**
+  *
+  * @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 nullable(...inputs) {
+    return new SchemaNullable(...inputs);
+  }
+  static number(...inputs) {
+    return new SchemaNumber(...inputs);
+  }
+  static object(...inputs) {
+    return new SchemaObject(...inputs);
+  }
+  static record(...inputs) {
+    return new SchemaRecord(...inputs);
+  }
+  /**
+   * See {@link SchemaString}
+   */
+  static string(...inputs) {
+    return new SchemaString(...inputs);
+  }
+  static union(...inputs) {
+    return new SchemaUnion(...inputs);
+  }
+  static fromJSON(json) {
+    var _a, _b, _c, _d, _e, _f;
+    const fn = this.getModule(json.i);
+    if (!fn) {
+      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 : []);
+    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.attrs(...(_f = json.a) != null ? _f : []);
+    return item;
+  }
+  static isSchemaJSON(data) {
+    if (typeof data !== "object" || data === null) {
+      return false;
+    }
+    if (!("i" in data)) {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * @deprecated use helper `parseQuery`
+   */
+  validateQuery(query, fast = false) {
+    return parseQuery(this, query, { fast });
+  }
+  /**
+  * @deprecated use `parse`
+  */
+  validate(input, fast = false) {
+    return this.parse(input, { fast });
+  }
+  /**
+   * @deprecated use helper `parseForm`
+   */
+  validateForm(form, fast = false) {
+    return parseForm(this, form, { fast });
+  }
+  /**
+   * @deprecated use helper `parseFormData`
+   */
+  validateFormData(data, fast = false) {
+    return parseFormData(this, data, { fast });
+  }
+};
+_Schema.registeredModules = [
+  SchemaArray,
+  SchemaBoolean,
+  SchemaDate,
+  SchemaEnum,
+  SchemaLiteral,
+  SchemaNullable,
+  SchemaObject,
+  SchemaRecord,
+  SchemaString,
+  SchemaUnion
+];
+var Schema = _Schema;
+var s = Schema;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SchemaArray,
+  SchemaBoolean,
+  SchemaDate,
+  SchemaEnum,
+  SchemaItem,
+  SchemaLiteral,
+  SchemaNullable,
+  SchemaNumber,
+  SchemaObject,
+  SchemaRecord,
+  SchemaString,
+  SchemaUnion,
+  Types,
+  parceable,
+  parseForm,
+  parseFormData,
+  parseQuery,
+  s
+});