@thisisagile/easy 17.31.0 → 17.32.0

package/dist/chunk-ZBS4A3QI.mjs

@@ -0,0 +1,614 @@
+import {
+  reject,
+  resolve
+} from "./chunk-2EJYJ4HI.mjs";
+import {
+  isValidatable
+} from "./chunk-OFGI5FLG.mjs";
+import {
+  isValue
+} from "./chunk-WSBULPUZ.mjs";
+import {
+  Enum,
+  isEnum
+} from "./chunk-AG3P2RCU.mjs";
+import {
+  meta
+} from "./chunk-MK2UX4IH.mjs";
+import {
+  entries
+} from "./chunk-ZKLQJX4N.mjs";
+import {
+  toList
+} from "./chunk-HOVTNDHS.mjs";
+import {
+  toArray
+} from "./chunk-CO2AFYVD.mjs";
+import {
+  asString,
+  capitalize,
+  replaceAll
+} from "./chunk-BDA5LB4S.mjs";
+import {
+  ofGet
+} from "./chunk-SJGQU3OG.mjs";
+import {
+  isA
+} from "./chunk-ZHXKBOK2.mjs";
+import {
+  ofConstruct,
+  toName
+} from "./chunk-ZPNFXK7Y.mjs";
+import {
+  isArray,
+  isDefined,
+  isEmpty,
+  isFunction,
+  isIn,
+  isNotEmpty,
+  isTrue
+} from "./chunk-DEJ7A5PY.mjs";
+
+// 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/Template.ts
+var Template = class {
+  constructor(template2, subject = {}, options = {}) {
+    this.template = template2;
+    this.subject = subject;
+    this.options = options;
+  }
+  knownPrefixes = /* @__PURE__ */ new Set(["type", "property", "actual", "subject"]);
+  toString = () => {
+    return entries(this.options).reduce((t, [k]) => this.option(t, k), this.object()).replace("  ", " ");
+  };
+  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 = () => tryTo(() => this.template.replace(/\{this\./g, "{")).map((t) => t.replace(/\{([^}]+)}/g, (match, p) => this.knownPrefixes.has(p.split(".")[0]) ? match : textValue(this.subject, p))).or("");
+  option = (tmpl, prop) => {
+    return this.props(tmpl, prop).reduce((t, p) => t.replace(`{${p}}`, textValue(this.options, p)), tmpl);
+  };
+};
+function template(tmpl, subject, options = {}) {
+  return new Template(asString(tmpl), subject, {
+    type: toName(subject),
+    subject: text(JSON.stringify(subject)),
+    ...options
+  });
+}
+
+// src/types/ToText.ts
+var ToText = class {
+  constructor(subject) {
+    this.subject = subject;
+  }
+  get cap() {
+    return this.map((s) => capitalize(s?.toLowerCase()));
+  }
+  get capFirst() {
+    return this.map((s) => capitalize(s));
+  }
+  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 trimSentence() {
+    return this.map(
+      (s) => s.replace(/[\u200B-\u200D\uFEFF]/g, "").replace(/[\s\u00A0]+/g, " ").replace(/\s+([.,;:!?])/g, "$1").trim()
+    );
+  }
+  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;
+  like = (...others) => others.some((o) => this.trim.lower.toString().includes(text(o).trim.lower.toString()));
+  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)
+  );
+  split = (separator = " ") => toList(this.subject.split(separator));
+  toString() {
+    return this.subject;
+  }
+  toJSON() {
+    return this.subject;
+  }
+};
+function text(subject, alt = "") {
+  const sub = subject ? asString(subject) : alt;
+  return new ToText(sub !== "[object Object]" ? sub : "");
+}
+function textValue(subject, prop) {
+  const p = prop.split(".");
+  const root = subject?.[p[0]];
+  const initial = typeof root === "object" && root !== null ? root : text(root);
+  return p.splice(1).reduce((t, s) => (typeof t === "object" && t !== null ? t : text(t))?.[s], initial)?.toString() ?? "";
+}
+
+// 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) => {
+    const k = text(key).map((k2) => k2.replace(/([a-z])([A-Z])/g, "$1 $2")).snake.toString();
+    return process.env[k] ?? alt;
+  };
+};
+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/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 Results = 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 Results(...r);
+var isResults = (r) => isDefined(r) && r instanceof Results;
+
+// src/types/Case.ts
+var CaseBuilder = class {
+  constructor(v) {
+    this.v = v;
+  }
+  is = {
+    true: (pred, out) => new Case(this.v).case(pred, out),
+    false: (pred, out) => new Case(this.v).case(!ofGet(pred, this.v), out),
+    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),
+    in: (prop, out) => new Case(this.v).case(ofGet(prop, this.v).includes(this.v), out),
+    not: {
+      true: (pred, out) => new Case(this.v).case(!ofGet(pred, this.v), out),
+      false: (pred, out) => new Case(this.v).case(pred, out),
+      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),
+      in: (prop, out) => new Case(this.v).case(!ofGet(prop, this.v).includes(this.v), out)
+    }
+  };
+  if = this.is;
+  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);
+  }
+};
+var Case = class _Case {
+  constructor(value, outcome) {
+    this.value = value;
+    this.outcome = outcome;
+  }
+  is = {
+    true: (pred, out) => new _Case(this.value).case(pred, out),
+    false: (pred, out) => new _Case(this.value).case(!ofGet(pred, this.value), out),
+    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),
+    in: (prop, out) => new _Case(this.value).case(ofGet(prop, this.value).includes(this.value), out),
+    not: {
+      true: (pred, out) => new _Case(this.value).case(!ofGet(pred, this.value), out),
+      false: (pred, out) => new _Case(this.value).case(pred, out),
+      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),
+      in: (prop, out) => new _Case(this.value).case(!ofGet(prop, this.value).includes(this.value), out)
+    }
+  };
+  if = this.is;
+  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);
+  }
+  else(alt) {
+    return ofGet(alt, this.value);
+  }
+};
+var Found = class extends Case {
+  constructor(value, outcome) {
+    super(value, outcome);
+    this.value = value;
+    this.outcome = outcome;
+  }
+  is = {
+    true: (_pred, _out) => this,
+    false: (_pred, _out) => this,
+    defined: (_prop, _out) => this,
+    empty: (_prop, _out) => this,
+    valid: (_prop, _out) => this,
+    in: (_prop, _out) => this,
+    not: {
+      true: (_pred, _out) => this,
+      false: (_pred, _out) => this,
+      defined: (_prop, _out) => this,
+      empty: (_prop, _out) => this,
+      valid: (_prop, _out) => this,
+      in: (_prop, _out) => this
+    }
+  };
+  if = this.is;
+  case(pred, out) {
+    return this;
+  }
+  type(guard, out) {
+    return this;
+  }
+  equals(value, out) {
+    return this;
+  }
+  else(alt) {
+    return this.outcome;
+  }
+};
+var choose = (value) => new CaseBuilder(value);
+
+// 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) => {
+  try {
+    const actual = isFunction(subject[v.property]) ? subject[v.property]() : subject[v.property];
+    const constraint = v.constraint(actual);
+    return isResults(constraint) ? constraint : !constraint ? asResults(subject, v.text, {
+      ...v,
+      actual
+    }) : toResults();
+  } catch (e) {
+    return asResults(subject, asString(e));
+  }
+};
+var constraints = (subject) => validators(subject).map((vs) => runValidator(vs, subject)).reduce((rs, r) => rs.add(...r.results), toResults());
+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/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/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);
+
+export {
+  When,
+  when,
+  DotEnvContext,
+  BaseRequestContext,
+  BaseContext,
+  Context,
+  ctx,
+  toResult,
+  isResult,
+  Results,
+  toResults,
+  isResults,
+  choose,
+  asResults,
+  validate,
+  validateReject,
+  isValid,
+  Try,
+  tryTo,
+  Template,
+  template,
+  ToText,
+  text,
+  textValue,
+  Exception,
+  isException,
+  isDoesNotExist
+};
+//# sourceMappingURL=chunk-ZBS4A3QI.mjs.map