@thisisagile/easy 15.26.1 → 15.27.0

package/dist/chunk-YTWFWQNB.mjs

@@ -0,0 +1,866 @@
+import {
+  isValidatable
+} from "./chunk-CMRS457E.mjs";
+import {
+  json
+} from "./chunk-5AF55QCJ.mjs";
+import {
+  isA,
+  isAn
+} from "./chunk-4QX4EMLL.mjs";
+import {
+  ofGet,
+  ofProperty
+} from "./chunk-SJGQU3OG.mjs";
+import {
+  toArray
+} from "./chunk-FAAERRP2.mjs";
+import {
+  ofConstruct,
+  on,
+  toName,
+  use
+} from "./chunk-GI5TZOAG.mjs";
+import {
+  isFunc
+} from "./chunk-PIRWVOO2.mjs";
+import {
+  isArray,
+  isDefined,
+  isEmpty,
+  isFunction,
+  isIn,
+  isNotEmpty,
+  isTrue
+} from "./chunk-OXBQSJDF.mjs";
+
+// src/types/Meta.ts
+import "reflect-metadata";
+
+// src/validation/When.ts
+var When = class _When {
+  constructor(subject, valid = true, results) {
+    this.subject = subject;
+    this.valid = valid;
+    this.results = results;
+  }
+  get not() {
+    return this.clone(!this.valid);
+  }
+  get and() {
+    return this.clone(this.valid);
+  }
+  get isDefined() {
+    return this.clone(this.valid === isDefined(this.subject));
+  }
+  get isEmpty() {
+    return this.clone(this.valid === isEmpty(this.subject));
+  }
+  get isTrue() {
+    return this.clone(this.valid === !!this.subject);
+  }
+  get isValid() {
+    this.results = validate(this.subject);
+    return this.clone(this.valid === this.results.isValid);
+  }
+  isInstance = (c) => this.clone(this.valid === this.subject instanceof c);
+  with = (pred) => this.clone(this.valid === ofGet(pred, this.subject));
+  contains = (property) => this.clone(this.valid === isDefined(ofGet(property, this.subject)));
+  in = (...items) => this.clone(this.valid === isIn(this.subject, toArray(...items)));
+  is = (item) => this.clone(this.valid === (this.subject === item));
+  reject = (error) => !this.valid ? resolve(this.subject) : reject(ofGet(error, this.subject) ?? this.results ?? Exception.Unknown);
+  recover = (f) => resolve(!this.valid ? this.subject : f(this.subject));
+  clone = (result = true) => new _When(this.subject, result, this.results);
+};
+var when = (subject) => new When(subject);
+
+// src/validation/Validate.ts
+var asResults = (subject, template2, options = {}) => toResults(toResult(text(template2).parse(subject, options), toName(subject)));
+var validators = (subject) => meta(subject).keys("constraint").reduce((list, vs) => list.add(vs), toList());
+var runValidator = (v, subject) => tryTo(() => isFunction(subject[v.property]) ? subject[v.property]() : subject[v.property]).map((actual) => [actual, v.constraint(actual)]).map(([actual, res]) => isResults(res) ? res : !res ? asResults(subject, v.text, { ...v, actual }) : toResults()).recover((e) => asResults(subject, asString(e))).value;
+var constraints = (subject) => tryTo(() => validators(subject)).map((vs) => vs.mapDefined((v) => runValidator(v, subject))).map((res) => res.reduce((rs, r) => rs.add(...r.results), toResults())).value;
+var validate = (subject) => choose(subject).is.not.defined(
+  (s) => s,
+  () => toResults("Subject is not defined.")
+).type(isEnum, (e) => e.isValid ? toResults() : asResults(e, "This is not a valid {type}.")).type(isValue, (v) => v.isValid ? toResults() : asResults(v, "This is not a valid {type}.")).type(isArray, (a) => a.map((i) => validate(i)).reduce((rs, r) => rs.add(...r.results), toResults())).type(isValidatable, (v) => constraints(v)).else(toResults());
+var validateReject = (subject) => when(subject).not.isValid.reject();
+var isValid = (t) => validate(t).isValid;
+
+// src/types/Try.ts
+var Try = class _Try {
+  is = {
+    defined: (prop) => this.filter((v) => isDefined(prop ? prop(v) : v)),
+    empty: (prop) => this.filter((v) => isEmpty(prop ? prop(v) : v)),
+    valid: (prop) => this.filter((v) => validate(prop ? prop(v) : v).isValid),
+    true: (prop) => this.filter((v) => isTrue(prop ? prop(v) : v)),
+    false: (prop) => this.filter((v) => !isTrue(prop ? prop(v) : v)),
+    not: {
+      defined: (prop) => this.filter((v) => !isDefined(prop ? prop(v) : v)),
+      empty: (prop) => this.filter((v) => !isEmpty(prop ? prop(v) : v)),
+      valid: (prop) => this.filter((v) => !validate(prop ? prop(v) : v).isValid)
+    }
+  };
+  if = this.is;
+  static of = (c, ...args) => {
+    try {
+      const out = ofGet(c, ...args);
+      return new Success(out instanceof _Try ? out.value : out);
+    } catch (e) {
+      return new Failure(e);
+    }
+  };
+};
+var Success = class extends Try {
+  constructor(value) {
+    super();
+    this.value = value;
+  }
+  get error() {
+    throw new Error("No error found");
+  }
+  get isValid() {
+    return true;
+  }
+  map(f) {
+    return tryTo(f, this.value);
+  }
+  recover(f) {
+    return this;
+  }
+  recoverFrom(type, f) {
+    return this;
+  }
+  accept(f) {
+    return tryTo(() => {
+      f(this.value);
+      return this;
+    });
+  }
+  filter(predicate) {
+    return tryTo(() => {
+      if (predicate(this.value))
+        return this;
+      throw new Error(`Applying filter(${predicate.toString()}) failed.`);
+    });
+  }
+  or(value) {
+    return this.value;
+  }
+  orElse(value) {
+    return this.value;
+  }
+  orThrow(_error) {
+    return this.value;
+  }
+};
+var Failure = class _Failure extends Try {
+  constructor(error) {
+    super();
+    this.error = error;
+  }
+  get value() {
+    throw this.error;
+  }
+  get isValid() {
+    return false;
+  }
+  map(f) {
+    return new _Failure(this.error);
+  }
+  recover(f) {
+    return tryTo(f, this.error);
+  }
+  recoverFrom(type, f) {
+    return tryTo(() => this.error instanceof type ? this.recover(f) : this);
+  }
+  accept(f) {
+    return this;
+  }
+  filter(predicate) {
+    return this;
+  }
+  or(value) {
+    return ofGet(value);
+  }
+  orElse(value) {
+    return ofGet(value);
+  }
+  orThrow(error) {
+    throw ofConstruct(error);
+  }
+};
+var tryTo = (c, ...args) => Try.of(c, ...args);
+
+// src/types/List.ts
+var List2 = class extends Array {
+  asc(p) {
+    return this.sort((e1, e2) => ofProperty(e1, p) > ofProperty(e2, p) ? 1 : -1);
+  }
+  desc(p) {
+    return this.sort((e1, e2) => ofProperty(e1, p) < ofProperty(e2, p) ? 1 : -1);
+  }
+  first(p, params) {
+    return p ? this.find(p, params) : this[0];
+  }
+  firstValue(f, alt) {
+    return tryTo(() => this.first((t) => !!f(t))).map((i) => i ? f(i) : ofGet(alt, i)).value;
+  }
+  isFirst(value) {
+    return value === this.first();
+  }
+  next(p, params) {
+    return p ? this[this.findIndex(p, params) + 1] : this[0];
+  }
+  prev(p, params) {
+    return p ? this[this.findIndex(p, params) - 1] : this[0];
+  }
+  last(p, params) {
+    return p ? this.filter(p, params).last() : this[this.length - 1];
+  }
+  isLast(value) {
+    return value === this.last();
+  }
+  overlaps(...items) {
+    return toList(...items).some((i) => this.some((t) => i === t));
+  }
+  diff(others) {
+    return this.filter((i) => !others.includes(i));
+  }
+  diffByKey(others, key) {
+    return this.filter((i) => !others.some((o) => o[key] === i[key]));
+  }
+  symmetricDiff(others) {
+    return this.diff(others).concat(toList(...others).diff(this));
+  }
+  symmetricDiffByKey(others, key) {
+    return this.diffByKey(others, key).concat(toList(...others).diffByKey(this, key));
+  }
+  intersect(others) {
+    return this.filter((i) => others.includes(i));
+  }
+  intersectByKey(others, key) {
+    return this.filter((i) => others.some((o) => o[key] === i[key]));
+  }
+  toJSON() {
+    return this.reduce((a, i) => {
+      a.push(json.parse(i));
+      return a;
+    }, new Array());
+  }
+  map(f, params) {
+    return toList(super.map(f, params));
+  }
+  flatMap(f, params) {
+    return toList(super.flatMap(f, params));
+  }
+  mapDefined(f, params) {
+    return this.map(f, params).defined();
+  }
+  mapAsync(f) {
+    return Promise.all(super.map((e) => f(e))).then((a) => toList(a));
+  }
+  distinct() {
+    return this.filter((i, index) => this.indexOf(i) === index);
+  }
+  distinctByKey(key) {
+    return meta(this.toObject(key)).values();
+  }
+  filter(p, params) {
+    return toList(super.filter(p, params));
+  }
+  sum(p) {
+    return this.reduce((sum, i) => sum + p(i), 0);
+  }
+  max(key) {
+    return this.desc(key).first();
+  }
+  min(key) {
+    return this.asc(key).first();
+  }
+  byId(id) {
+    return this.first((i) => asString(i.id) === asString(id));
+  }
+  add(...items) {
+    super.push(...toArray(...items));
+    return this;
+  }
+  concat(...items) {
+    return toList(super.concat(...items));
+  }
+  reverse() {
+    return toList(super.reverse());
+  }
+  splice(start, deleteCount, ...items) {
+    return toList(super.splice(start, deleteCount, ...items));
+  }
+  remove(item) {
+    const index = this.indexOf(item);
+    if (index > -1) {
+      this.splice(index, 1);
+    }
+    return this;
+  }
+  replace(key, item) {
+    tryTo(() => item[key]).map((k) => this.findIndex((i) => i[key] === k)).filter((i) => i > -1).map((i) => this[i] = item);
+    return this;
+  }
+  switch(item) {
+    return this.includes(item) ? this.remove(item) : this.add(item);
+  }
+  defined() {
+    return this.reduce((l, v) => isDefined(v) ? l.add(v) : l, toList());
+  }
+  toObject(key, options = {}) {
+    return this.reduce((o, i) => {
+      o[i[key]] = i;
+      if (options.deleteKey)
+        delete o[i[key]][key];
+      return o;
+    }, {});
+  }
+  toObjectList(key) {
+    return this.reduce(
+      (a, t) => {
+        const k = t[key];
+        a[k] = a[k] ?? toList();
+        a[k].push(t);
+        return a;
+      },
+      {}
+    );
+  }
+  orElse(...alt) {
+    return !isEmpty(this) ? this : !isEmpty(...alt) ? toList(...alt) : void 0;
+  }
+  weave(insertFrom, interval) {
+    for (let i = interval, n = 0; i <= this.length && n < insertFrom.length; i += interval + 1) {
+      this.splice(i, 0, insertFrom[n++]);
+    }
+    return this;
+  }
+  slice(start, end) {
+    return toList(super.slice(start, end));
+  }
+  none(p) {
+    return !this.some(p);
+  }
+  chunk(chunkSize) {
+    return this.reduce((acc, _, index) => index % chunkSize === 0 ? on(acc, (a) => a.push(this.slice(index, index + chunkSize))) : acc, toList());
+  }
+};
+var toList = (...items) => new List2().add(...items);
+var isList = (l) => isDefined(l) && isArray(l) && isA(l, "first", "last", "asc", "desc");
+var asList = (c, items = []) => toList(toArray(items).map((i) => new c(i)));
+var maxValue = (l, key) => l.desc(key).first()?.[key];
+var minValue = (l, key) => l.asc(key).first()?.[key];
+
+// src/types/Meta.ts
+var ClassMeta = class {
+  constructor(subject, data = (subject.prototype ?? subject).constructor) {
+    this.subject = subject;
+    this.data = data;
+  }
+  get = (key) => Reflect.getMetadata(key, this.data);
+  set = (key, value) => {
+    Reflect.defineMetadata(key, value, this.data);
+    return value;
+  };
+  entries = () => toList([...Object.entries(this.subject), ...Object.entries(Object.getPrototypeOf(this.subject))]);
+  parse = (f, options = {}) => {
+    const { initial = {}, skipUndefined = false } = options;
+    return this.entries().reduce((a, [k, val]) => use(f(val), (v) => isDefined(v) || !skipUndefined ? on(a, (a2) => a2[k] = v) : a), initial);
+  };
+  properties = (key) => toList([...Object.getOwnPropertyNames(this.subject), ...Object.getOwnPropertyNames(Object.getPrototypeOf(this.subject))]).map((p) => this.property(p)).filter((p) => key ? p.get(key) : p);
+  keys = (key) => this.properties().map((p) => p.get(key)).reduce((list, u) => u ? list.add(u) : list, toList());
+  values = () => toList([...Object.values(this.subject), ...Object.values(Object.getPrototypeOf(this.subject))]);
+  property = (property) => new PropertyMeta(this.subject, property);
+};
+var PropertyMeta = class {
+  constructor(subject, property, data = Reflect.getMetadata(property, subject)) {
+    this.subject = subject;
+    this.property = property;
+    this.data = data;
+  }
+  get value() {
+    return this.subject[this.property];
+  }
+  get = (key) => isDefined(this.data) && isDefined(this.data[key]) ? this.data[key] : void 0;
+  set = (key, value) => {
+    Reflect.defineMetadata(this.property, { ...this.data, [key]: value }, this.subject);
+    return value;
+  };
+};
+var meta = (subject) => new ClassMeta(subject ?? {});
+var entries = (subject) => meta(subject).entries();
+
+// src/types/Template.ts
+var Template = class {
+  constructor(template2, subject = {}, options = {}) {
+    this.template = template2;
+    this.subject = subject;
+    this.options = options;
+  }
+  toString = () => {
+    return meta(this.options).entries().reduce((t, [k]) => this.option(t, k), this.object()).replace("  ", " ");
+  };
+  value = (subject, prop) => tryTo(() => prop.split(".")).map((p) => [p, p.splice(1)]).map(([p, ps]) => ps.reduce((t, s) => t[s], text(subject[p[0]]))).map((p) => p.toString()).value;
+  props = (tmpl, key, result = toList()) => {
+    const i1 = tmpl.indexOf(`{${key}`);
+    if (i1 < 0) {
+      return result;
+    }
+    const i2 = tmpl.indexOf("}", i1);
+    return this.props(tmpl.slice(i2 + 1), key, result.add(tmpl.substring(i1 + 1, i2)));
+  };
+  object = () => {
+    return this.props(this.template, "this").reduce((t, p) => t.replace(`{${p}}`, this.value(this.subject, p.replace("this.", ""))), this.template);
+  };
+  option = (tmpl, prop) => {
+    return this.props(tmpl, prop).reduce((t, p) => t.replace(`{${p}}`, this.value(this.options, p)), tmpl);
+  };
+};
+var template = (tmpl, subject, options = {}) => new Template(asString(tmpl), subject, {
+  type: toName(subject),
+  subject: text(JSON.stringify(subject)),
+  ...options
+});
+
+// src/types/Text.ts
+var isText = (t) => isDefined(t) && isFunc(t.toString);
+var asString = (t, alt = "") => (isText(t) ? t : ofGet(alt)).toString();
+var replaceAll = (origin, search, replace = "") => asString(origin).split(asString(search)).join(asString(replace));
+var toWords = (input) => {
+  return asString(input).replace(/(\p{Lower})(\p{Upper})/gu, "$1 $2").replace(/(\p{Upper})(\p{Upper}\p{Lower})/gu, "$1 $2").split(/[_\W]+/g).filter(Boolean);
+};
+var kebab = (s = "") => toWords(s).join("-").toLowerCase();
+var ToText2 = class {
+  constructor(subject) {
+    this.subject = subject;
+  }
+  get cap() {
+    return this.map((s) => s.charAt(0).toUpperCase() + s.slice(1).toLowerCase());
+  }
+  get title() {
+    return this.map(
+      (s) => s.split(" ").map((w) => text(w).cap).join(" ")
+    );
+  }
+  get pascal() {
+    return this.title.replace(" ", "");
+  }
+  get lower() {
+    return this.map((s) => s.toLowerCase());
+  }
+  get upper() {
+    return this.map((s) => s.toUpperCase());
+  }
+  get camel() {
+    return this.title.trim.map((s) => `${s.charAt(0).toLowerCase()}${s.slice(1)}`);
+  }
+  get kebab() {
+    return this.lower.replace(" ", "-");
+  }
+  get strictKebab() {
+    return this.map((s) => s.replace(/[^a-z\d]+/gi, " ").trim()).kebab;
+  }
+  get slug() {
+    return this.map(
+      (s) => s.replace(/ß/g, "ss").normalize("NFKD").replace(/[\u0300-\u036F]/g, "").toLowerCase().replace(/[^a-z\d]+/g, "-").replace(/(^-)|(-$)/g, "")
+    );
+  }
+  get snake() {
+    return this.upper.replace(" ", "_");
+  }
+  get plural() {
+    return this.ifLike("") ?? this.add("s");
+  }
+  get space() {
+    return this.map((s) => s.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_-]/g, " "));
+  }
+  get sentence() {
+    return this.isEmpty ? this : this.map((s) => `${s.charAt(0).toUpperCase()}${s.slice(1)}.`);
+  }
+  get initials() {
+    return this.map(
+      (s) => s.split(" ").map((w) => w[0]).join("")
+    );
+  }
+  get trim() {
+    return this.map((s) => s.replace(/[- ,_#]/g, ""));
+  }
+  get isEmpty() {
+    return isEmpty(this.toString());
+  }
+  parse = (subject, options = {}) => text(template(this.subject, subject, { type: toName(subject), ...options }));
+  is = (...others) => others.some((o) => this.toString() === text(o).toString());
+  equals = this.is;
+  isLike = (...others) => others.some((o) => this.trim.lower.is(text(o).trim.lower));
+  ifLike = (...others) => this.isLike(...others) ? this : void 0;
+  endsWith = (end) => this.subject.endsWith(asString(end));
+  startsWith = (end) => this.subject.startsWith(asString(end));
+  first = (n) => this.map((s) => s.substring(0, n));
+  last = (n) => this.map((s) => s.substring(s.length - n));
+  map = (func) => text(ofGet(func, this.subject));
+  replace = (search, replace) => this.map((s) => replaceAll(s, search, replace));
+  add = (add, separator = "") => this.map((s) => isNotEmpty(add) ? `${s}${separator}${text(add)}` : s);
+  with = (separator, ...other) => this.map(
+    (s) => toList(s).add(...other.map((u) => text(u).toString())).filter((s2) => isNotEmpty(s2)).join(separator)
+  );
+  toString() {
+    return this.subject;
+  }
+  toJSON() {
+    return this.subject;
+  }
+};
+var text = (subject, alt = "") => {
+  const sub = subject ? asString(subject) : alt;
+  return new ToText2(sub !== "[object Object]" ? sub : "");
+};
+
+// src/types/Case.ts
+var CaseBuilder = class {
+  constructor(v) {
+    this.v = v;
+  }
+  case(pred, out) {
+    return new Case(this.v).case(pred, out);
+  }
+  type(guard, out) {
+    return new Case(this.v).type(guard, out);
+  }
+  equals(value, out) {
+    return new Case(this.v).equals(value, out);
+  }
+  is = {
+    defined: (prop, out) => new Case(this.v).case(isDefined(prop(this.v)), out),
+    empty: (prop, out) => new Case(this.v).case(isEmpty(prop(this.v)), out),
+    valid: (prop, out) => new Case(this.v).case(validate(prop(this.v)).isValid, out),
+    not: {
+      defined: (prop, out) => new Case(this.v).case(!isDefined(prop(this.v)), out),
+      empty: (prop, out) => new Case(this.v).case(!isEmpty(prop(this.v)), out),
+      valid: (prop, out) => new Case(this.v).case(!validate(prop(this.v)).isValid, out)
+    }
+  };
+  if = this.is;
+};
+var Case = class _Case {
+  constructor(value, outcome) {
+    this.value = value;
+    this.outcome = outcome;
+  }
+  case(pred, out) {
+    return tryTo(pred, this.value).is.true().map(() => ofGet(out, this.value)).map((res) => new Found(this.value, res)).or(this);
+  }
+  type(guard, out) {
+    return tryTo(guard, this.value).is.true().map(() => out(this.value)).map((res) => new Found(this.value, res)).or(this);
+  }
+  equals(value, out) {
+    return this.case(this.value === value, out);
+  }
+  is = {
+    defined: (prop, out) => new _Case(this.value).case(isDefined(prop(this.value)), out),
+    empty: (prop, out) => new _Case(this.value).case(isEmpty(prop(this.value)), out),
+    valid: (prop, out) => new _Case(this.value).case(validate(prop(this.value)).isValid, out),
+    not: {
+      defined: (prop, out) => new _Case(this.value).case(!isDefined(prop(this.value)), out),
+      empty: (prop, out) => new _Case(this.value).case(!isEmpty(prop(this.value)), out),
+      valid: (prop, out) => new _Case(this.value).case(!validate(prop(this.value)).isValid, out)
+    }
+  };
+  if = this.is;
+  else(alt) {
+    return ofGet(alt, this.value);
+  }
+};
+var Found = class extends Case {
+  constructor(value, outcome) {
+    super(value, outcome);
+    this.value = value;
+    this.outcome = outcome;
+  }
+  case(pred, out) {
+    return this;
+  }
+  type(guard, out) {
+    return this;
+  }
+  equals(value, out) {
+    return this;
+  }
+  is = {
+    defined: (_prop, _out) => this,
+    empty: (_prop, _out) => this,
+    valid: (_prop, _out) => this,
+    not: {
+      defined: (_prop, _out) => this,
+      empty: (_prop, _out) => this,
+      valid: (_prop, _out) => this
+    }
+  };
+  if = this.is;
+  else(alt) {
+    return this.outcome;
+  }
+};
+var choose = (value) => new CaseBuilder(value);
+
+// src/types/Context.ts
+var DotEnvContext = class {
+  domain = process.env.DOMAIN ?? "easy";
+  name = process.env.ENVIRONMENT_NAME ?? "";
+  host = process.env.HOST ?? "";
+  port = Number.parseInt(process.env.PORT ?? "8080");
+  app = process.env.APP ?? "";
+  get = (key, alt) => tryTo(
+    () => text(key).map((k) => k.replace(/([a-z])([A-Z])/g, "$1 $2")).snake.toString()
+  ).map((k) => process.env[k] ?? alt).value;
+};
+var BaseRequestContext = class {
+  state = {};
+  get token() {
+    return this.get("token");
+  }
+  set token(token) {
+    this.set("token", token);
+  }
+  get identity() {
+    return this.token;
+  }
+  get jwt() {
+    return this.get("jwt");
+  }
+  set jwt(jwt) {
+    this.set("jwt", jwt);
+  }
+  get correlationId() {
+    return this.get("correlationId");
+  }
+  set correlationId(id) {
+    this.set("correlationId", id);
+  }
+  get lastError() {
+    return this.get("lastError");
+  }
+  set lastError(error) {
+    this.set("lastError", error);
+  }
+  get(key) {
+    return this.state[key];
+  }
+  set(key, value) {
+    return this.state[key] = value;
+  }
+  create = (f) => f();
+  wrap = (f) => f();
+};
+var BaseContext = class extends BaseRequestContext {
+};
+var Context = class {
+  constructor(state = {}) {
+    this.state = state;
+    this.state = {
+      ...{
+        env: new DotEnvContext(),
+        request: new BaseRequestContext(),
+        other: {}
+      },
+      ...this.state
+    };
+  }
+  get env() {
+    return this.state.env;
+  }
+  set env(env) {
+    this.state.env = env;
+  }
+  get request() {
+    return this.state.request;
+  }
+  set request(request) {
+    this.state.request = request;
+  }
+  get other() {
+    return this.state.other;
+  }
+};
+var ctx = new Context();
+
+// src/types/Enum.ts
+var Enum = class {
+  constructor(name, id = name.toLowerCase(), code = id.toString()) {
+    this.name = name;
+    this.id = id;
+    this.code = code;
+  }
+  get isValid() {
+    return isDefined(this.id);
+  }
+  static all() {
+    return meta(this.allTuple()).values();
+  }
+  static allTuple() {
+    return meta(this).get(`all-${this.name}`) ?? meta(this).set(`all-${this.name}`, meta(this).values().filter(isEnum).toObject("id"));
+  }
+  static filter(p, params) {
+    return this.all().filter(p, params);
+  }
+  static first(p, params) {
+    return this.all().first(p, params);
+  }
+  static byIds(ids = []) {
+    return toList(ids).mapDefined((id) => this.byId(id)).distinct();
+  }
+  static byId(id, alt) {
+    return this.allTuple()[id] ?? ofGet(alt);
+  }
+  equals(other) {
+    return this.id === (isEnum(other) ? other.id : other);
+  }
+  isIn(...items) {
+    return items.some((i) => this.equals(i));
+  }
+  toJSON() {
+    return this.id;
+  }
+  toString() {
+    return this.id.toString();
+  }
+};
+var isEnum = (e) => isDefined(e) && e instanceof Enum && isAn(e, "name", "id", "code");
+
+// src/types/Exception.ts
+var Exception = class _Exception extends Enum {
+  constructor(message, id, reason) {
+    super(message, id ?? text(message).pascal.toString());
+    this.message = message;
+    this.reason = reason;
+  }
+  static AlreadyExists = new _Exception("Subject already exists");
+  static DoesNotExist = new _Exception("Does not exist");
+  static IsMissingId = new _Exception("Subject is missing an id");
+  static IsNotImplemented = new _Exception("Is not implemented");
+  static IsNotValid = new _Exception("Is not valid");
+  static Unknown = new _Exception("Unknown error");
+  static CouldNotExecute = (target) => new _Exception(`Could not execute ${target}.`, "CouldNotExecute");
+  static CouldNotValidate = (target) => new _Exception(`Could not validate ${target}.`, "CouldNotValidate");
+  static EnvironmentVariableNotFound = (variable) => new _Exception(`Environment variable ${text(variable).upper} could not be found.`, "EnvironmentVariableNotFound");
+  because = (reason) => new _Exception(this.message, this.id, reason);
+};
+var isException = (e, t) => e instanceof Exception && (isDefined(t) ? e.equals(asString(t)) : true);
+var isDoesNotExist = (e) => e instanceof Exception && Exception.DoesNotExist.equals(e);
+
+// src/types/Result.ts
+var toResult = (message, location, domain = ctx.env.domain) => ({
+  message: message.toString(),
+  location: location?.toString(),
+  domain: domain?.toString()
+});
+var isResult = (r) => isA(r, "message");
+
+// src/types/Results.ts
+var parse = (...rs) => toArray(...rs).map((r) => isResult(r) ? r : toResult(r));
+var Results3 = class {
+  results;
+  constructor(...rs) {
+    this.results = parse(...rs);
+  }
+  get length() {
+    return this.results.length;
+  }
+  get isValid() {
+    return this.results.length === 0;
+  }
+  add = (...rs) => toResults(...this.results, ...parse(...rs));
+};
+var toResults = (...r) => new Results3(...r);
+var isResults = (r) => isDefined(r) && r instanceof Results3;
+
+// src/types/Value.ts
+var Value = class {
+  constructor(value) {
+    this.value = value;
+    this.value = value;
+  }
+  get isValid() {
+    return isDefined(this.value);
+  }
+  toJSON() {
+    return this.value;
+  }
+  toString() {
+    return asString(this.value);
+  }
+};
+var isValue = (v) => v instanceof Value;
+
+// src/utils/Promise.ts
+var resolve = (subject) => Promise.resolve(subject);
+var reject = (e) => Promise.reject(e);
+var tuple = {
+  2: (first, second) => Promise.all([first, second]),
+  3: (first, second, third) => Promise.all([first, second, third]),
+  4: (first, second, third, forth) => Promise.all([first, second, third, forth]),
+  5: (first, second, third, forth, fifth) => Promise.all([first, second, third, forth, fifth]),
+  all: (first, second) => Promise.all([first, Promise.all(second)]),
+  spread: (first, ...second) => Promise.all([first, Promise.all(toArray(second))]),
+  list: (list) => Promise.all([...list]).then(toList)
+};
+var tuple2 = tuple[2];
+var tuple3 = tuple[3];
+var tuple4 = tuple[4];
+var tuple5 = tuple[5];
+
+export {
+  resolve,
+  reject,
+  tuple,
+  tuple2,
+  tuple3,
+  tuple4,
+  tuple5,
+  When,
+  when,
+  asResults,
+  validate,
+  validateReject,
+  isValid,
+  Try,
+  tryTo,
+  List2 as List,
+  toList,
+  isList,
+  asList,
+  maxValue,
+  minValue,
+  meta,
+  entries,
+  Template,
+  template,
+  isText,
+  asString,
+  replaceAll,
+  toWords,
+  kebab,
+  ToText2 as ToText,
+  text,
+  choose,
+  DotEnvContext,
+  BaseRequestContext,
+  BaseContext,
+  Context,
+  ctx,
+  Enum,
+  isEnum,
+  Exception,
+  isException,
+  isDoesNotExist,
+  toResult,
+  isResult,
+  Results3 as Results,
+  toResults,
+  isResults,
+  Value,
+  isValue
+};
+//# sourceMappingURL=chunk-YTWFWQNB.mjs.map