@orieljs/validation 0.1.0-alpha.1

package/dist/index.js

@@ -0,0 +1,870 @@
+// errors.ts
+var ValidationErrorImpl = class extends Error {
+  constructor(errors, errorBag = "default", redirectTo) {
+    super("The given data was invalid.");
+    this.errors = errors;
+    this.errorBag = errorBag;
+    this.redirectTo = redirectTo;
+  }
+  errors;
+  errorBag;
+  redirectTo;
+  kind = "Validation";
+  status = 422;
+  name = "ValidationError";
+};
+var AuthorizationErrorImpl = class extends Error {
+  kind = "Authorization";
+  status = 403;
+  name = "AuthorizationError";
+  constructor(message = "This action is unauthorized.") {
+    super(message);
+  }
+};
+var UnknownValidationRuleError = class extends Error {
+  kind = "Server";
+  status = 500;
+  name = "UnknownValidationRuleError";
+  constructor(name) {
+    super(`Validation rule "${name}" is not registered. Register it with ValidationFactory.extend() first.`);
+  }
+};
+var InvalidRuleParameterError = class extends Error {
+  kind = "Server";
+  status = 500;
+  name = "InvalidRuleParameterError";
+  constructor(rule, parameter, reason) {
+    super(`Validation rule "${rule}" has an invalid parameter "${parameter}": ${reason}`);
+  }
+};
+
+// FormRequest.ts
+import { HttpRequest, ValidationFactory } from "@orieljs/contracts";
+import { inject } from "@orieljs/container";
+var FormRequest = class {
+  authorize() {
+    return true;
+  }
+  messages() {
+    return {};
+  }
+  attributes() {
+    return {};
+  }
+  /**
+   * `const data = await StorePostRequest.validate()` (spec §4.3). Resolves the current request and the
+   * ValidationFactory from the active container, runs authorize() first (throwing AuthorizationErrorImpl if it
+   * returns false), then validates request.all() against rules()/messages()/attributes() and returns the typed
+   * validated data (or throws the 422 ValidationError — see ValidatorImpl.validated()).
+   */
+  static async validate() {
+    const instance = new this();
+    if (!await instance.authorize()) throw new AuthorizationErrorImpl();
+    const request = inject(HttpRequest);
+    const factory = inject(ValidationFactory);
+    const validator = factory.make(request.all(), instance.rules(), instance.messages(), instance.attributes());
+    return validator.validated();
+  }
+};
+
+// messages.ts
+import { Str } from "@orieljs/support";
+function defaultAttributeName(key) {
+  return key.split(".").map((segment) => Str.snake(segment).replace(/_/g, " ")).join(".");
+}
+function applyReplacements(template, replacements) {
+  return Object.entries(replacements).reduce((message, [key, value]) => message.replaceAll(`:${key}`, value), template);
+}
+var DEFAULT_MESSAGES = {
+  required: "The :attribute field is required.",
+  required_if: "The :attribute field is required when :other is :value.",
+  required_unless: "The :attribute field is required unless :other is in :values.",
+  required_with: "The :attribute field is required when :values is present.",
+  required_with_all: "The :attribute field is required when :values are present.",
+  required_without: "The :attribute field is required when :values is not present.",
+  required_without_all: "The :attribute field is required when none of :values are present.",
+  string: "The :attribute field must be a string.",
+  integer: "The :attribute field must be an integer.",
+  numeric: "The :attribute field must be a number.",
+  boolean: "The :attribute field must be true or false.",
+  array: "The :attribute field must be an array.",
+  email: "The :attribute field must be a valid email address.",
+  url: "The :attribute field must be a valid URL.",
+  uuid: "The :attribute field must be a valid UUID.",
+  alpha: "The :attribute field must only contain letters.",
+  alpha_num: "The :attribute field must only contain letters and numbers.",
+  alpha_dash: "The :attribute field must only contain letters, numbers, dashes and underscores.",
+  regex: "The :attribute field format is invalid.",
+  confirmed: "The :attribute field confirmation does not match.",
+  same: "The :attribute field must match :other.",
+  different: "The :attribute field must be different from :other.",
+  accepted: "The :attribute field must be accepted.",
+  digits: "The :attribute field must be :digits digits.",
+  date: "The :attribute field must be a valid date.",
+  before: "The :attribute field must be a date before :date.",
+  after: "The :attribute field must be a date after :date.",
+  in: "The selected :attribute is invalid.",
+  not_in: "The selected :attribute is invalid.",
+  unique: "The :attribute has already been taken.",
+  exists: "The selected :attribute is invalid.",
+  file: "The :attribute field must be a file.",
+  image: "The :attribute field must be an image.",
+  mimes: "The :attribute field must be a file of type: :values.",
+  "max.string": "The :attribute field must not be greater than :max characters.",
+  "max.numeric": "The :attribute field must not be greater than :max.",
+  "max.array": "The :attribute field must not have more than :max items.",
+  "max.file": "The :attribute field must not be greater than :max kilobytes.",
+  "min.string": "The :attribute field must be at least :min characters.",
+  "min.numeric": "The :attribute field must be at least :min.",
+  "min.array": "The :attribute field must have at least :min items.",
+  "min.file": "The :attribute field must be at least :min kilobytes.",
+  "between.string": "The :attribute field must be between :min and :max characters.",
+  "between.numeric": "The :attribute field must be between :min and :max.",
+  "between.array": "The :attribute field must have between :min and :max items.",
+  "between.file": "The :attribute field must be between :min and :max kilobytes.",
+  "size.string": "The :attribute field must be :size characters.",
+  "size.numeric": "The :attribute field must be :size.",
+  "size.array": "The :attribute field must contain :size items.",
+  "size.file": "The :attribute field must be :size kilobytes."
+};
+
+// MessageBag.ts
+var MessageBagImpl = class {
+  items = {};
+  /** Not part of the MessageBag contract — used internally by ValidatorImpl and by after() hooks. */
+  add(key, message) {
+    ;
+    (this.items[key] ??= []).push(message);
+  }
+  has(key) {
+    return (this.items[key]?.length ?? 0) > 0;
+  }
+  first(key) {
+    if (key !== void 0) return this.items[key]?.[0];
+    for (const messages of Object.values(this.items)) {
+      if (messages[0] !== void 0) return messages[0];
+    }
+    return void 0;
+  }
+  get(key) {
+    return this.items[key] ?? [];
+  }
+  all() {
+    return Object.values(this.items).flat();
+  }
+  isEmpty() {
+    return Object.keys(this.items).length === 0;
+  }
+  count() {
+    return this.all().length;
+  }
+  toObject() {
+    return structuredClone(this.items);
+  }
+};
+
+// rules/database.ts
+import { DatabaseManager } from "@orieljs/contracts";
+import { inject as inject2 } from "@orieljs/container";
+function guessColumn(attribute, expandedFromWildcard = false) {
+  if (!expandedFromWildcard) return attribute;
+  return attribute.split(".").filter((segment) => !/^\d+$/.test(segment)).at(-1) ?? attribute;
+}
+function isNoExcept(except) {
+  return except === void 0 || except === null || except === "" || except === "NULL";
+}
+async function matchingRecordExists(table, column, value, except, idColumn = "id") {
+  const db = inject2(DatabaseManager);
+  let query = db.connection().table(table).where(column, value);
+  if (!isNoExcept(except)) query = query.where(idColumn, "!=", except);
+  return query.exists();
+}
+var databaseRules = {
+  unique: {
+    validate: async (ctx) => {
+      const [table, column, except, idColumn] = ctx.parameters;
+      return !await matchingRecordExists(table, column || guessColumn(ctx.attribute, ctx.expandedFromWildcard), ctx.value, except, idColumn || "id");
+    },
+    messageKey: () => "unique"
+  },
+  exists: {
+    validate: async (ctx) => {
+      const [table, column] = ctx.parameters;
+      return matchingRecordExists(table, column || guessColumn(ctx.attribute, ctx.expandedFromWildcard), ctx.value);
+    },
+    messageKey: () => "exists"
+  }
+};
+
+// parse.ts
+import { Arr } from "@orieljs/support";
+function splitParameters(name, raw) {
+  return name === "regex" || name === "not_regex" ? [raw] : raw.split(",");
+}
+function splitOnce(value, separator) {
+  const index = value.indexOf(separator);
+  return index === -1 ? [value, void 0] : [value.slice(0, index), value.slice(index + 1)];
+}
+function parseRuleSpec(spec) {
+  const items = typeof spec === "string" ? spec.split("|") : spec;
+  return items.filter((item) => item !== "").map((item) => {
+    if (typeof item !== "string") return { kind: "object", rule: item };
+    const [name, raw] = splitOnce(item, ":");
+    return { kind: "named", name, parameters: raw === void 0 ? [] : splitParameters(name, raw) };
+  });
+}
+function isEmptyValue(value) {
+  if (value === null || value === void 0) return true;
+  if (typeof value === "string") return value === "";
+  if (Array.isArray(value)) return value.length === 0;
+  return false;
+}
+function isUploadedFileLike(value) {
+  return typeof value === "object" && value !== null && typeof value.clientName === "string" && typeof value.arrayBuffer === "function";
+}
+var UNSAFE_KEYS = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
+function expandWildcardKeys(pattern, data) {
+  const segments = pattern.split(".");
+  let paths = [""];
+  for (const segment of segments) {
+    const next = [];
+    for (const base of paths) {
+      const prefix = base === "" ? "" : `${base}.`;
+      if (segment !== "*") {
+        next.push(`${prefix}${segment}`);
+        continue;
+      }
+      const container = Arr.get(data, base === "" ? void 0 : base);
+      if (Array.isArray(container)) {
+        container.forEach((_, index) => next.push(`${prefix}${index}`));
+      } else if (container !== null && typeof container === "object") {
+        Object.keys(container).filter((key) => !UNSAFE_KEYS.has(key)).forEach((key) => next.push(`${prefix}${key}`));
+      }
+    }
+    paths = next;
+  }
+  return paths;
+}
+
+// rules/file.ts
+var IMAGE_EXTENSIONS = /* @__PURE__ */ new Set(["jpg", "jpeg", "png", "bmp", "gif", "svg", "webp"]);
+var fileRules = {
+  file: { validate: (ctx) => isUploadedFileLike(ctx.value), messageKey: () => "file" },
+  image: {
+    validate: (ctx) => {
+      if (!isUploadedFileLike(ctx.value)) return false;
+      if (ctx.value.mimeType.startsWith("image/")) return true;
+      return IMAGE_EXTENSIONS.has(ctx.value.extension().toLowerCase());
+    },
+    messageKey: () => "image"
+  },
+  mimes: {
+    validate: (ctx) => {
+      if (!isUploadedFileLike(ctx.value)) return false;
+      const allowed = ctx.parameters.map((p) => p.toLowerCase());
+      return allowed.includes(ctx.value.extension().toLowerCase());
+    },
+    messageKey: () => "mimes",
+    replacements: (ctx) => ({ values: ctx.parameters.join(", ") })
+  }
+};
+
+// rules/format.ts
+import { Arr as Arr2 } from "@orieljs/support";
+var EMAIL_RE = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+var ALPHA_RE = /^[A-Za-z]+$/;
+var ALPHA_NUM_RE = /^[A-Za-z0-9]+$/;
+var ALPHA_DASH_RE = /^[A-Za-z0-9_-]+$/;
+var ACCEPTED_VALUES = ["yes", "on", 1, "1", true, "true"];
+function compileRegex(raw) {
+  const match = /^\/(.*)\/([a-z]*)$/.exec(raw);
+  try {
+    return match ? new RegExp(match[1], match[2]) : new RegExp(raw);
+  } catch (error) {
+    throw new InvalidRuleParameterError("regex", raw, error instanceof Error ? error.message : String(error));
+  }
+}
+var DATE_SHAPES = [
+  /^\d{4}-\d{1,2}-\d{1,2}(?:[T\s].*)?$/,
+  /^\d{1,2}[/.-]\d{1,2}[/.-]\d{2,4}(?:\s.*)?$/,
+  /^(?=.*\d).*\b(?:jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)[a-z]*\b/i
+];
+var DATE_ONLY_RE = /^(\d{4})-(\d{2})-(\d{2})$/;
+function parseDate(value) {
+  const trimmed = value.trim();
+  if (!DATE_SHAPES.some((shape) => shape.test(trimmed))) return Number.NaN;
+  const dateOnly = DATE_ONLY_RE.exec(trimmed);
+  if (dateOnly) {
+    const [, y, m, d] = dateOnly.map(Number);
+    const local = new Date(y, m - 1, d);
+    return local.getMonth() === m - 1 && local.getDate() === d ? local.getTime() : Number.NaN;
+  }
+  return Date.parse(trimmed);
+}
+function startOfDay(offsetDays) {
+  const date = /* @__PURE__ */ new Date();
+  date.setHours(0, 0, 0, 0);
+  date.setDate(date.getDate() + offsetDays);
+  return date.getTime();
+}
+var RELATIVE_RE = /^([+-]\d+)\s*(second|minute|hour|day|week|month|year)s?$/i;
+function relativeDate(param) {
+  switch (param.trim().toLowerCase()) {
+    case "now":
+      return Date.now();
+    case "today":
+      return startOfDay(0);
+    case "tomorrow":
+      return startOfDay(1);
+    case "yesterday":
+      return startOfDay(-1);
+  }
+  const match = RELATIVE_RE.exec(param.trim());
+  if (!match) return void 0;
+  const amount = Number(match[1]);
+  const date = /* @__PURE__ */ new Date();
+  switch (match[2].toLowerCase()) {
+    case "second":
+      date.setSeconds(date.getSeconds() + amount);
+      break;
+    case "minute":
+      date.setMinutes(date.getMinutes() + amount);
+      break;
+    case "hour":
+      date.setHours(date.getHours() + amount);
+      break;
+    case "day":
+      date.setDate(date.getDate() + amount);
+      break;
+    case "week":
+      date.setDate(date.getDate() + amount * 7);
+      break;
+    case "month":
+      date.setMonth(date.getMonth() + amount);
+      break;
+    case "year":
+      date.setFullYear(date.getFullYear() + amount);
+      break;
+  }
+  return date.getTime();
+}
+var FIELD_REFERENCE_RE = /^[A-Za-z_][\w-]*(?:\.[\w-]+)*$/;
+function resolveDateParam(rule, param, data) {
+  const fieldValue = Arr2.get(data, param);
+  if (typeof fieldValue === "string") {
+    const parsed = parseDate(fieldValue);
+    if (!Number.isNaN(parsed)) return parsed;
+  }
+  const relative = relativeDate(param);
+  if (relative !== void 0) return relative;
+  const literal = parseDate(param);
+  if (!Number.isNaN(literal)) return literal;
+  if (FIELD_REFERENCE_RE.test(param)) return Number.NaN;
+  throw new InvalidRuleParameterError(rule, param, 'expected a date, today/tomorrow/yesterday/now, "+N unit", or a field name');
+}
+function compareDate(ctx, rule) {
+  const target = resolveDateParam(rule, ctx.parameters[0] ?? "", ctx.data);
+  if (typeof ctx.value !== "string") return false;
+  const value = parseDate(ctx.value);
+  if (Number.isNaN(value) || Number.isNaN(target)) return false;
+  return rule === "before" ? value < target : value > target;
+}
+var formatRules = {
+  email: { validate: (ctx) => typeof ctx.value === "string" && EMAIL_RE.test(ctx.value), messageKey: () => "email" },
+  url: {
+    validate: (ctx) => {
+      if (typeof ctx.value !== "string") return false;
+      try {
+        new URL(ctx.value);
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    messageKey: () => "url"
+  },
+  uuid: { validate: (ctx) => typeof ctx.value === "string" && UUID_RE.test(ctx.value), messageKey: () => "uuid" },
+  alpha: { validate: (ctx) => typeof ctx.value === "string" && ALPHA_RE.test(ctx.value), messageKey: () => "alpha" },
+  alpha_num: {
+    validate: (ctx) => typeof ctx.value === "string" && ALPHA_NUM_RE.test(ctx.value),
+    messageKey: () => "alpha_num"
+  },
+  alpha_dash: {
+    validate: (ctx) => typeof ctx.value === "string" && ALPHA_DASH_RE.test(ctx.value),
+    messageKey: () => "alpha_dash"
+  },
+  regex: {
+    validate: (ctx) => typeof ctx.value === "string" && compileRegex(ctx.parameters[0] ?? "").test(ctx.value),
+    messageKey: () => "regex"
+  },
+  confirmed: {
+    validate: (ctx) => ctx.value === Arr2.get(ctx.data, `${ctx.attribute}_confirmation`),
+    messageKey: () => "confirmed"
+  },
+  same: {
+    validate: (ctx) => ctx.value === Arr2.get(ctx.data, ctx.parameters[0] ?? ""),
+    messageKey: () => "same",
+    replacements: (ctx) => ({ other: defaultAttributeName(ctx.parameters[0] ?? "") })
+  },
+  different: {
+    validate: (ctx) => ctx.value !== Arr2.get(ctx.data, ctx.parameters[0] ?? ""),
+    messageKey: () => "different",
+    replacements: (ctx) => ({ other: defaultAttributeName(ctx.parameters[0] ?? "") })
+  },
+  accepted: { implicit: true, validate: (ctx) => ACCEPTED_VALUES.includes(ctx.value), messageKey: () => "accepted" },
+  digits: {
+    validate: (ctx) => typeof ctx.value !== "object" && new RegExp(`^\\d{${ctx.parameters[0]}}$`).test(String(ctx.value)),
+    messageKey: () => "digits",
+    replacements: (ctx) => ({ digits: ctx.parameters[0] ?? "" })
+  },
+  date: {
+    validate: (ctx) => typeof ctx.value === "string" && !Number.isNaN(parseDate(ctx.value)),
+    messageKey: () => "date"
+  },
+  before: {
+    validate: (ctx) => compareDate(ctx, "before"),
+    messageKey: () => "before",
+    replacements: (ctx) => ({ date: ctx.parameters[0] ?? "" })
+  },
+  after: {
+    validate: (ctx) => compareDate(ctx, "after"),
+    messageKey: () => "after",
+    replacements: (ctx) => ({ date: ctx.parameters[0] ?? "" })
+  }
+};
+
+// rules/presence.ts
+import { Arr as Arr3 } from "@orieljs/support";
+function isFieldPresent(field, data) {
+  return Arr3.has(data, field) && !isEmptyValue(Arr3.get(data, field));
+}
+function anyPresent(fields, data) {
+  return fields.some((field) => isFieldPresent(field, data));
+}
+function allPresent(fields, data) {
+  return fields.every((field) => isFieldPresent(field, data));
+}
+var presenceRules = {
+  required: {
+    implicit: true,
+    validate: (ctx) => !isEmptyValue(ctx.value),
+    messageKey: () => "required"
+  },
+  required_if: {
+    implicit: true,
+    validate: (ctx) => {
+      const [other, ...values] = ctx.parameters;
+      const applies = values.includes(String(Arr3.get(ctx.data, other)));
+      return !applies || !isEmptyValue(ctx.value);
+    },
+    messageKey: () => "required_if",
+    replacements: (ctx) => ({ other: ctx.parameters[0] ?? "", value: ctx.parameters.slice(1).join(", ") })
+  },
+  required_unless: {
+    implicit: true,
+    validate: (ctx) => {
+      const [other, ...values] = ctx.parameters;
+      const applies = !values.includes(String(Arr3.get(ctx.data, other)));
+      return !applies || !isEmptyValue(ctx.value);
+    },
+    messageKey: () => "required_unless",
+    replacements: (ctx) => ({ other: ctx.parameters[0] ?? "", values: ctx.parameters.slice(1).join(", ") })
+  },
+  required_with: {
+    implicit: true,
+    validate: (ctx) => !anyPresent(ctx.parameters, ctx.data) || !isEmptyValue(ctx.value),
+    messageKey: () => "required_with",
+    replacements: (ctx) => ({ values: ctx.parameters.join(" / ") })
+  },
+  required_with_all: {
+    implicit: true,
+    validate: (ctx) => !allPresent(ctx.parameters, ctx.data) || !isEmptyValue(ctx.value),
+    messageKey: () => "required_with_all",
+    replacements: (ctx) => ({ values: ctx.parameters.join(" / ") })
+  },
+  required_without: {
+    implicit: true,
+    validate: (ctx) => ctx.parameters.every((f) => isFieldPresent(f, ctx.data)) || !isEmptyValue(ctx.value),
+    messageKey: () => "required_without",
+    replacements: (ctx) => ({ values: ctx.parameters.join(" / ") })
+  },
+  required_without_all: {
+    implicit: true,
+    validate: (ctx) => anyPresent(ctx.parameters, ctx.data) || !isEmptyValue(ctx.value),
+    messageKey: () => "required_without_all",
+    replacements: (ctx) => ({ values: ctx.parameters.join(" / ") })
+  }
+};
+
+// rules/type.ts
+var BOOLEAN_VALUES = [true, false, 0, 1, "0", "1"];
+var NUMERIC_STRING_RE = /^\s*[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?\s*$/;
+function isNumeric(value) {
+  if (typeof value === "number") return Number.isFinite(value);
+  return typeof value === "string" && NUMERIC_STRING_RE.test(value);
+}
+var typeRules = {
+  string: { validate: (ctx) => typeof ctx.value === "string", messageKey: () => "string" },
+  integer: {
+    validate: (ctx) => typeof ctx.value !== "object" && /^-?\d+$/.test(String(ctx.value).trim()),
+    messageKey: () => "integer"
+  },
+  numeric: {
+    validate: (ctx) => isNumeric(ctx.value),
+    messageKey: () => "numeric"
+  },
+  boolean: { validate: (ctx) => BOOLEAN_VALUES.includes(ctx.value), messageKey: () => "boolean" },
+  array: { validate: (ctx) => Array.isArray(ctx.value), messageKey: () => "array" }
+};
+
+// rules/size.ts
+function hasAny(ctx, names) {
+  return names.some((name) => ctx.ruleNames.includes(name));
+}
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function measure(ctx) {
+  const { value } = ctx;
+  if (hasAny(ctx, ["numeric", "integer"])) {
+    return { type: "numeric", size: isNumeric(value) ? Number(value) : stringLength(value) };
+  }
+  if (Array.isArray(value)) return { type: "array", size: value.length };
+  if (isUploadedFileLike(value)) return { type: "file", size: value.size / 1024 };
+  if (hasAny(ctx, ["file", "image"])) return { type: "file", size: Number.NaN };
+  if (isPlainObject(value)) return { type: "array", size: Object.keys(value).length };
+  if (hasAny(ctx, ["array"])) return { type: "array", size: stringLength(value) };
+  return { type: "string", size: stringLength(value) };
+}
+function stringLength(value) {
+  if (value === null || value === void 0) return 0;
+  return [...String(value)].length;
+}
+function sizeOf(ctx) {
+  return measure(ctx).size;
+}
+function sizeType(ctx) {
+  return measure(ctx).type;
+}
+var sizeRules = {
+  max: {
+    validate: (ctx) => sizeOf(ctx) <= Number(ctx.parameters[0]),
+    messageKey: (ctx) => `max.${sizeType(ctx)}`,
+    replacements: (ctx) => ({ max: ctx.parameters[0] ?? "" })
+  },
+  min: {
+    validate: (ctx) => sizeOf(ctx) >= Number(ctx.parameters[0]),
+    messageKey: (ctx) => `min.${sizeType(ctx)}`,
+    replacements: (ctx) => ({ min: ctx.parameters[0] ?? "" })
+  },
+  between: {
+    validate: (ctx) => {
+      const size = sizeOf(ctx);
+      return size >= Number(ctx.parameters[0]) && size <= Number(ctx.parameters[1]);
+    },
+    messageKey: (ctx) => `between.${sizeType(ctx)}`,
+    replacements: (ctx) => ({ min: ctx.parameters[0] ?? "", max: ctx.parameters[1] ?? "" })
+  },
+  size: {
+    validate: (ctx) => sizeOf(ctx) === Number(ctx.parameters[0]),
+    messageKey: (ctx) => `size.${sizeType(ctx)}`,
+    replacements: (ctx) => ({ size: ctx.parameters[0] ?? "" })
+  },
+  in: { validate: (ctx) => ctx.parameters.includes(String(ctx.value)), messageKey: () => "in" },
+  not_in: { validate: (ctx) => !ctx.parameters.includes(String(ctx.value)), messageKey: () => "not_in" }
+};
+
+// registry.ts
+var builtinRules = {
+  ...presenceRules,
+  ...typeRules,
+  ...formatRules,
+  ...sizeRules,
+  ...fileRules,
+  ...databaseRules
+};
+
+// Rule.ts
+var BuiltinRuleObject = class {
+  // Declares all 4 contract parameters so a subclass's inferred type (from `Rule.in(...)` etc.) still accepts a
+  // call with the full 4-arg ValidationRule.validate signature, as Rule.test.ts makes.
+  async validate(attribute, value, fail, data, expandedFromWildcard = false) {
+    if (await this.passes(attribute, value, data, expandedFromWildcard)) return;
+    fail(applyReplacements(DEFAULT_MESSAGES[this.ruleName], { attribute: defaultAttributeName(attribute) }));
+  }
+};
+var InRule = class extends BuiltinRuleObject {
+  constructor(values) {
+    super();
+    this.values = values;
+  }
+  values;
+  ruleName = "in";
+  passes(_attribute, value) {
+    return this.values.map(String).includes(String(value));
+  }
+};
+function isModelInstance(value) {
+  return typeof value === "object" && value !== null && typeof value.getKey === "function" && typeof value.getKeyName === "function";
+}
+var UniqueRule = class extends BuiltinRuleObject {
+  constructor(table, column) {
+    super();
+    this.table = table;
+    this.column = column;
+  }
+  table;
+  column;
+  ruleName = "unique";
+  exceptId;
+  idColumnName;
+  /**
+   * Excludes the current record from the uniqueness check. Laravel's `Rule::unique('users')->ignore($user)` accepts
+   * a model directly (the common case: "update your profile without changing your email"), so a model instance is
+   * bound by its key (`getKey()`/`getKeyName()`), not the object itself — the object would reach the query builder
+   * as an opaque value and either be rejected by the driver or stringified (B27). A plain id still works as before;
+   * null (or "NULL") excludes nothing.
+   */
+  ignore(id, idColumn) {
+    if (isModelInstance(id)) {
+      this.exceptId = id.getKey();
+      this.idColumnName = idColumn ?? id.getKeyName();
+    } else {
+      this.exceptId = id;
+      this.idColumnName = idColumn ?? "id";
+    }
+    return this;
+  }
+  async passes(attribute, value, _data, expandedFromWildcard = false) {
+    const column = this.column ?? guessColumn(attribute, expandedFromWildcard);
+    return !await matchingRecordExists(this.table, column, value, this.exceptId, this.idColumnName ?? "id");
+  }
+};
+var ExistsRule = class extends BuiltinRuleObject {
+  constructor(table, column) {
+    super();
+    this.table = table;
+    this.column = column;
+  }
+  table;
+  column;
+  ruleName = "exists";
+  passes(attribute, value, _data, expandedFromWildcard = false) {
+    return matchingRecordExists(this.table, this.column ?? guessColumn(attribute, expandedFromWildcard), value);
+  }
+};
+var Rule = {
+  in: (values) => new InRule(values),
+  unique: (table, column) => new UniqueRule(table, column),
+  exists: (table, column) => new ExistsRule(table, column)
+};
+
+// Validator.ts
+import { Arr as Arr4 } from "@orieljs/support";
+var SKIPPED_MODIFIERS = /* @__PURE__ */ new Set(["bail", "nullable", "sometimes"]);
+function buildNested(flat) {
+  const root = {};
+  const created = /* @__PURE__ */ new Set([root]);
+  for (const [path, value] of Object.entries(flat)) {
+    const parts = path.split(".");
+    if (parts.some((part) => UNSAFE_KEYS.has(part))) continue;
+    let current = root;
+    for (const part of parts.slice(0, -1)) {
+      const existing = Object.hasOwn(current, part) ? current[part] : void 0;
+      if (typeof existing === "object" && existing !== null && created.has(existing)) {
+        current = existing;
+        continue;
+      }
+      const container = cloneContainer(existing);
+      created.add(container);
+      current[part] = container;
+      current = container;
+    }
+    current[parts.at(-1)] = value;
+  }
+  return arrayify(root, created);
+}
+function isPlainContainer(value) {
+  if (Array.isArray(value)) return true;
+  if (typeof value !== "object" || value === null) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function cloneContainer(existing) {
+  const container = {};
+  if (!isPlainContainer(existing)) return container;
+  for (const [key, value] of Object.entries(existing)) {
+    if (!UNSAFE_KEYS.has(key)) container[key] = value;
+  }
+  return container;
+}
+function arrayify(node, created) {
+  if (node === null || typeof node !== "object" || !created.has(node)) return node;
+  const entries = Object.entries(node).map(([k, v]) => [k, arrayify(v, created)]);
+  const keys = entries.map(([k]) => k);
+  const isArrayLike = keys.length > 0 && keys.every((k, i) => k === String(i));
+  return isArrayLike ? entries.map(([, v]) => v) : Object.fromEntries(entries);
+}
+var ValidatorImpl = class {
+  constructor(data, rules, customMessages, customAttributes, registry, errorBagName = "default") {
+    this.data = data;
+    this.rules = rules;
+    this.customMessages = customMessages;
+    this.customAttributes = customAttributes;
+    this.registry = registry;
+    this.errorBagName = errorBagName;
+  }
+  data;
+  rules;
+  customMessages;
+  customAttributes;
+  registry;
+  errorBagName;
+  bag;
+  ranPromise;
+  afterCallbacks = [];
+  after(callback) {
+    this.afterCallbacks.push(callback);
+    return this;
+  }
+  /** Not part of the Validator contract — lets an after() hook add a failure (MessageBag itself is read-only). */
+  fail(field, message) {
+    this.bag ??= new MessageBagImpl();
+    this.bag.add(field, message);
+  }
+  async passes() {
+    this.ranPromise ??= this.run();
+    return this.ranPromise;
+  }
+  async fails() {
+    return !await this.passes();
+  }
+  errors() {
+    return this.bag ?? new MessageBagImpl();
+  }
+  async validated() {
+    if (!await this.passes()) throw new ValidationErrorImpl(this.bag.toObject(), this.errorBagName);
+    const flat = {};
+    for (const pattern of Object.keys(this.rules)) {
+      for (const field of this.fieldsFor(pattern)) {
+        if (Arr4.has(this.data, field)) flat[field] = Arr4.get(this.data, field);
+      }
+    }
+    return buildNested(flat);
+  }
+  fieldsFor(pattern) {
+    return pattern.includes("*") ? expandWildcardKeys(pattern, this.data) : [pattern];
+  }
+  async run() {
+    this.bag = new MessageBagImpl();
+    for (const [pattern, spec] of Object.entries(this.rules)) {
+      const parsed = parseRuleSpec(spec);
+      const names = parsed.filter((r) => r.kind === "named").map((r) => r.name);
+      const bail = names.includes("bail");
+      const nullable = names.includes("nullable");
+      const sometimes = names.includes("sometimes");
+      for (const field of this.fieldsFor(pattern)) {
+        const present = Arr4.has(this.data, field);
+        if (sometimes && !present) continue;
+        const value = Arr4.get(this.data, field);
+        const isNull = value === null || value === void 0;
+        const isBlank = typeof value === "string" && value.trim() === "";
+        for (const rule of parsed) {
+          if (rule.kind === "named" && SKIPPED_MODIFIERS.has(rule.name)) continue;
+          const implicit = rule.kind === "named" && (this.registry[rule.name]?.implicit ?? false);
+          if (!implicit && (!present || isBlank)) continue;
+          if (!implicit && nullable && isNull) continue;
+          const message = await this.runRule(rule, field, pattern, value, names);
+          if (message !== void 0) {
+            this.bag.add(field, message);
+            if (bail || implicit) break;
+          }
+        }
+      }
+    }
+    for (const callback of this.afterCallbacks) await callback(this);
+    return this.bag.isEmpty();
+  }
+  async runRule(rule, field, pattern, value, ruleNames) {
+    const expanded = pattern.includes("*");
+    if (rule.kind === "object") {
+      if (rule.rule instanceof BuiltinRuleObject) {
+        if (await rule.rule.passes(field, value, this.data, expanded)) return void 0;
+        const ctx2 = { attribute: field, expandedFromWildcard: expanded, value, parameters: [], data: this.data, ruleNames };
+        return this.failureMessage(rule.rule.ruleName, this.registry[rule.rule.ruleName], ctx2, pattern);
+      }
+      let failure;
+      await rule.rule.validate(field, value, (message) => {
+        failure = message;
+      }, this.data);
+      return failure;
+    }
+    const builtin = this.registry[rule.name];
+    if (!builtin) throw new UnknownValidationRuleError(rule.name);
+    const ctx = { attribute: field, expandedFromWildcard: expanded, value, parameters: rule.parameters, data: this.data, ruleNames };
+    if (await builtin.validate(ctx)) return void 0;
+    return this.failureMessage(rule.name, builtin, ctx, pattern);
+  }
+  /** Custom message (concrete field, then wildcard pattern, then rule name) or the default, with :attribute filled. */
+  failureMessage(name, builtin, ctx, pattern) {
+    const field = ctx.attribute;
+    const template = this.customMessages[`${field}.${name}`] ?? this.customMessages[`${pattern}.${name}`] ?? this.customMessages[name] ?? DEFAULT_MESSAGES[builtin?.messageKey(ctx) ?? name] ?? builtin?.defaultMessage ?? "The :attribute field is invalid.";
+    const display = this.customAttributes[field] ?? this.customAttributes[pattern] ?? defaultAttributeName(field);
+    return applyReplacements(template, { attribute: display, ...builtin?.replacements?.(ctx) ?? {} });
+  }
+};
+
+// ValidationFactory.ts
+var ValidationFactoryImpl = class {
+  extended = {};
+  make(data, rules, messages = {}, attributes = {}) {
+    return new ValidatorImpl(data, rules, messages, attributes, { ...builtinRules, ...this.extended });
+  }
+  extend(name, callback, message) {
+    this.extended[name] = {
+      validate: (ctx) => callback(ctx.attribute, ctx.value, ctx.parameters, ctx.data),
+      messageKey: () => name,
+      defaultMessage: message ?? "The :attribute field is invalid."
+    };
+  }
+};
+
+// facade.ts
+import { ValidationFactory as ValidationFactoryToken } from "@orieljs/contracts";
+import { facade } from "@orieljs/support";
+var Validator = facade(ValidationFactoryToken);
+
+// ValidationServiceProvider.ts
+import { ValidationFactory as ValidationFactoryToken2 } from "@orieljs/contracts";
+import { ServiceProvider } from "@orieljs/support";
+var ValidationServiceProvider = class extends ServiceProvider {
+  register() {
+    this.app.singleton(ValidationFactoryToken2, () => new ValidationFactoryImpl());
+  }
+};
+export {
+  AuthorizationErrorImpl,
+  BuiltinRuleObject,
+  DEFAULT_MESSAGES,
+  FormRequest,
+  InvalidRuleParameterError,
+  MessageBagImpl,
+  Rule,
+  UnknownValidationRuleError,
+  ValidationErrorImpl,
+  ValidationFactoryImpl,
+  ValidationServiceProvider,
+  Validator,
+  ValidatorImpl,
+  applyReplacements,
+  builtinRules,
+  defaultAttributeName,
+  expandWildcardKeys,
+  isEmptyValue,
+  isUploadedFileLike,
+  parseRuleSpec
+};
+//# sourceMappingURL=index.js.map