@thisisagile/easy 15.29.2 → 15.29.3

package/dist/chunk-PFAEQQXA.mjs

@@ -1,900 +0,0 @@
-import {
-  isValidatable
-} from "./chunk-4ROYPQPC.mjs";
-import {
-  ifDefined
-} from "./chunk-PWCGCUT7.mjs";
-import {
-  isA,
-  isAn
-} from "./chunk-Q5ATL34D.mjs";
-import {
-  ofGet,
-  ofProperty
-} from "./chunk-SJGQU3OG.mjs";
-import {
-  toArray
-} from "./chunk-ZELLSP3E.mjs";
-import {
-  isArray,
-  isDefined,
-  isEmpty,
-  isFunction,
-  isIn,
-  isNotEmpty,
-  isObject,
-  isTrue,
-  ofConstruct,
-  on,
-  toName,
-  use
-} from "./chunk-UWNXWKBU.mjs";
-import {
-  isFunc
-} from "./chunk-PIRWVOO2.mjs";
-
-// src/types/Meta.ts
-import "reflect-metadata";
-
-// src/types/Json.ts
-var isJson = (subject) => isA(subject, "toJSON");
-var json = {
-  parse: (subject) => JSON.parse(JSON.stringify(subject ?? {})),
-  merge: (...subjects) => json.parse(subjects.map((s) => asJson(s, (s2) => json.parse(s2))).reduce((js, j) => ({ ...js, ...j }), {})),
-  delete: (subject, key) => {
-    ifDefined(subject, () => delete subject[key]);
-    return subject;
-  },
-  set: (subject, key = "", value) => isEmpty(key) ? subject : value !== void 0 ? { ...subject, ...{ [key]: value } } : json.delete(subject, key),
-  omit: (subject, ...keys) => keys.reduce((js, k) => json.delete(js, k), json.parse(subject)),
-  defaults: (options = {}, defaults = {}) => json.merge(defaults, options),
-  isSubset: (subject, subset) => !entries(subset).some(([k, v]) => subject[k] !== v)
-};
-var toJson = json.merge;
-var asJson = (j, alt = {}) => isJson(j) ? j.toJSON() : isObject(j) ? j : ofGet(alt, j);
-var Any = class {
-  constructor(value) {
-    this.value = value;
-  }
-  merge = (...subjects) => any(json.merge(this.value, ...subjects));
-  delete = (key) => any(json.delete(this.value, key));
-  omit = (...keys) => any(json.omit(this.value, ...keys));
-  set = (key, value) => any(json.set(this.value, key, value));
-  toJSON() {
-    return this.value;
-  }
-};
-var any = (value) => new Any(value);
-
-// 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,
-  isJson,
-  json,
-  toJson,
-  asJson,
-  any,
-  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-PFAEQQXA.mjs.map