@cosmneo/onion-lasagna 0.1.0

package/dist/backend/core/validators/arktype.cjs

@@ -0,0 +1,947 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/backend/core/validators/arktype/index.ts
+var arktype_exports = {};
+__export(arktype_exports, {
+  ArkTypeObjectValidator: () => ArkTypeObjectValidator,
+  AuditByVo: () => AuditByVo,
+  AuditInfoVo: () => AuditInfoVo,
+  AuditOnVo: () => AuditOnVo,
+  Dto: () => Dto,
+  EmailVo: () => EmailVo,
+  LongTextVo: () => LongTextVo,
+  MediumTextVo: () => MediumTextVo,
+  PaginationVo: () => PaginationVo,
+  ShortTextVo: () => ShortTextVo,
+  UuidV4Vo: () => UuidV4Vo,
+  UuidV7Vo: () => UuidV7Vo,
+  arkTypeObjectValidator: () => arkTypeObjectValidator,
+  createArkTypeValidator: () => createArkTypeValidator
+});
+module.exports = __toCommonJS(arktype_exports);
+
+// src/backend/core/validators/arktype/bootstrap.ts
+var import_arktype2 = require("arktype");
+
+// src/backend/core/validators/arktype/object-validator.arktype.ts
+var import_arktype = require("arktype");
+
+// src/backend/core/global/exceptions/coded-error.error.ts
+var CodedError = class extends Error {
+  /** Machine-readable error code for programmatic handling. */
+  code;
+  /**
+   * Creates a new CodedError instance.
+   *
+   * @param options - Error configuration
+   * @param options.message - Human-readable error message
+   * @param options.code - Machine-readable error code from ErrorCodes registry or custom string
+   * @param options.cause - Optional underlying error that caused this error
+   */
+  constructor({
+    message,
+    code,
+    cause
+  }) {
+    super(message);
+    this.name = this.constructor.name;
+    this.code = code;
+    if (cause !== void 0) {
+      Object.defineProperty(this, "cause", {
+        value: cause,
+        writable: false,
+        enumerable: false,
+        configurable: true
+      });
+    }
+  }
+  /**
+   * Factory method to create a typed error from a caught error.
+   *
+   * Subclasses should override this to provide proper error transformation.
+   * Designed for use with {@link wrapErrorAsync} and {@link wrapError}.
+   *
+   * @param _cause - The original caught error
+   * @returns A new CodedError instance
+   * @throws {Error} If not overridden by subclass
+   *
+   * @example
+   * ```typescript
+   * class NotFoundError extends UseCaseError {
+   *   static override fromError(cause: unknown): NotFoundError {
+   *     return new NotFoundError({
+   *       message: 'Resource not found',
+   *       cause,
+   *     });
+   *   }
+   * }
+   * ```
+   */
+  static fromError(_cause) {
+    throw new Error(`${this.name}.fromError() must be implemented by subclass`);
+  }
+};
+
+// src/backend/core/global/exceptions/error-codes.const.ts
+var ErrorCodes = {
+  /**
+   * Domain layer error codes.
+   * Used for business rule violations and invariant failures.
+   */
+  Domain: {
+    /** Generic domain error */
+    DOMAIN_ERROR: "DOMAIN_ERROR",
+    /** Business invariant was violated */
+    INVARIANT_VIOLATION: "INVARIANT_VIOLATION",
+    /** Aggregate was partially loaded (missing required relations) */
+    PARTIAL_LOAD: "PARTIAL_LOAD"
+  },
+  /**
+   * Application layer (use case) error codes.
+   * Used for orchestration failures and business operation errors.
+   */
+  App: {
+    /** Generic use case error */
+    USE_CASE_ERROR: "USE_CASE_ERROR",
+    /** Requested resource was not found */
+    NOT_FOUND: "NOT_FOUND",
+    /** Resource state conflict (e.g., duplicate, already exists) */
+    CONFLICT: "CONFLICT",
+    /** Request is valid but cannot be processed due to business rules */
+    UNPROCESSABLE: "UNPROCESSABLE"
+  },
+  /**
+   * Infrastructure layer error codes.
+   * Used for data access, external services, and I/O failures.
+   */
+  Infra: {
+    /** Generic infrastructure error */
+    INFRA_ERROR: "INFRA_ERROR",
+    /** Database operation failed */
+    DB_ERROR: "DB_ERROR",
+    /** Network connectivity or communication error */
+    NETWORK_ERROR: "NETWORK_ERROR",
+    /** Operation timed out */
+    TIMEOUT_ERROR: "TIMEOUT_ERROR",
+    /** External/third-party service error */
+    EXTERNAL_SERVICE_ERROR: "EXTERNAL_SERVICE_ERROR"
+  },
+  /**
+   * Presentation layer error codes.
+   * Used for controller, request handling, and authorization errors.
+   */
+  Presentation: {
+    /** Generic controller error */
+    CONTROLLER_ERROR: "CONTROLLER_ERROR",
+    /** Request denied due to authorization failure */
+    ACCESS_DENIED: "ACCESS_DENIED",
+    /** Request validation failed (malformed input) */
+    INVALID_REQUEST: "INVALID_REQUEST"
+  },
+  /**
+   * Global/cross-cutting error codes.
+   * Used for validation and other cross-layer concerns.
+   */
+  Global: {
+    /** Object/schema validation failed */
+    OBJECT_VALIDATION_ERROR: "OBJECT_VALIDATION_ERROR"
+  }
+};
+
+// src/backend/core/global/exceptions/object-validation.error.ts
+var ObjectValidationError = class _ObjectValidationError extends CodedError {
+  /**
+   * Array of field-level validation errors.
+   *
+   * Each entry contains:
+   * - `field`: Dot-notation path to the invalid field (e.g., 'user.email')
+   * - `message`: Human-readable validation failure message
+   */
+  validationErrors;
+  /**
+   * Creates a new ObjectValidationError instance.
+   *
+   * @param options - Error configuration
+   * @param options.message - Human-readable summary message
+   * @param options.code - Machine-readable error code (default: 'OBJECT_VALIDATION_ERROR')
+   * @param options.cause - Optional underlying error from validation library
+   * @param options.validationErrors - Array of field-level validation errors
+   */
+  constructor({
+    message,
+    code = ErrorCodes.Global.OBJECT_VALIDATION_ERROR,
+    cause,
+    validationErrors
+  }) {
+    super({ message, code, cause });
+    this.validationErrors = validationErrors;
+  }
+  /**
+   * Creates an ObjectValidationError from a caught error.
+   *
+   * @param cause - The original caught error
+   * @returns A new ObjectValidationError instance with the cause attached
+   */
+  static fromError(cause) {
+    return new _ObjectValidationError({
+      message: cause instanceof Error ? cause.message : "Validation failed",
+      cause,
+      validationErrors: []
+    });
+  }
+};
+
+// src/backend/core/validators/arktype/object-validator.arktype.ts
+var formatPath = (path) => {
+  if (!path.length) return "root";
+  return path.map((segment, index) => {
+    if (typeof segment === "number") return `[${segment}]`;
+    if (typeof segment === "symbol") return segment.description ?? String(segment);
+    return index === 0 ? String(segment) : `.${segment}`;
+  }).join("");
+};
+var toValidationErrors = (errors) => [...errors].map((error) => ({
+  field: formatPath(error?.path ?? []),
+  message: error?.message ?? "Validation failed"
+}));
+var ArkTypeObjectValidator = class {
+  validateObject(schema11, value) {
+    const result = schema11(value);
+    if (result instanceof import_arktype.type.errors) {
+      throw new ObjectValidationError({
+        message: "Object validation failed",
+        cause: result,
+        validationErrors: toValidationErrors(result)
+      });
+    }
+    return result;
+  }
+  withSchema(schema11) {
+    return {
+      validate: (value) => this.validateObject(schema11, value)
+    };
+  }
+};
+
+// src/backend/core/validators/arktype/bootstrap.ts
+var arkTypeObjectValidator = new ArkTypeObjectValidator();
+var createArkTypeValidator = (schema11) => arkTypeObjectValidator.withSchema(schema11);
+
+// src/backend/core/validators/arktype/wrappers/dto.ts
+var import_arktype3 = require("arktype");
+
+// src/backend/core/global/classes/base-dto.class.ts
+var SKIP_DTO_VALIDATION = "skip dto validation";
+var BaseDto = class {
+  _data;
+  /**
+   * Creates a new DTO instance.
+   *
+   * @param data - The raw data to validate and wrap
+   * @param validator - A bound validator or SKIP_DTO_VALIDATION to bypass
+   * @throws {ObjectValidationError} When validation fails
+   */
+  constructor(data, validator) {
+    this._data = validator === SKIP_DTO_VALIDATION ? data : validator.validate(data);
+  }
+  /**
+   * The validated data payload.
+   *
+   * @returns The validated data of type T
+   */
+  get data() {
+    return this._data;
+  }
+};
+
+// src/backend/core/validators/arktype/wrappers/dto.ts
+var Dto = class extends BaseDto {
+  constructor(schema11, value) {
+    super(value, createArkTypeValidator(schema11));
+  }
+};
+
+// src/backend/core/validators/arktype/wrappers/value-objects/audit-by.vo.ts
+var import_arktype5 = require("arktype");
+
+// src/backend/core/onion-layers/domain/classes/base-value-object.class.ts
+var SKIP_VALUE_OBJECT_VALIDATION = "skip value object validation";
+function deepEquals(a, b) {
+  if (a === b) return true;
+  if (a === null || a === void 0 || b === null || b === void 0) {
+    return a === b;
+  }
+  if (a instanceof Date && b instanceof Date) {
+    return a.getTime() === b.getTime();
+  }
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    return a.every((item, index) => deepEquals(item, b[index]));
+  }
+  if (typeof a === "object" && typeof b === "object") {
+    const aObj = a;
+    const bObj = b;
+    const aKeys = Object.keys(aObj);
+    const bKeys = Object.keys(bObj);
+    if (aKeys.length !== bKeys.length) return false;
+    return aKeys.every((key) => deepEquals(aObj[key], bObj[key]));
+  }
+  return false;
+}
+var BaseValueObject = class {
+  _value;
+  /**
+   * Creates a new Value Object instance.
+   *
+   * @param value - The raw value to wrap
+   * @param validator - A bound validator or SKIP_VALUE_OBJECT_VALIDATION to bypass
+   * @throws {ObjectValidationError} When validation fails
+   */
+  constructor(value, validator) {
+    this._value = validator === SKIP_VALUE_OBJECT_VALIDATION ? value : validator.validate(value);
+  }
+  /**
+   * Compares this Value Object with another for equality.
+   *
+   * Uses deep equality comparison to handle nested objects, arrays, and dates.
+   * Two Value Objects are equal if their underlying values are deeply equal.
+   *
+   * @param other - The Value Object to compare with
+   * @returns `true` if the values are deeply equal, `false` otherwise
+   */
+  equals(other) {
+    if (this === other) return true;
+    return deepEquals(this.value, other.value);
+  }
+  /**
+   * The underlying immutable value.
+   *
+   * @returns The wrapped value of type T
+   */
+  get value() {
+    return this._value;
+  }
+};
+
+// src/backend/core/onion-layers/domain/value-objects/base-audit-by.vo.ts
+var BaseAuditByVo = class extends BaseValueObject {
+  /**
+   * Creates a new BaseAuditByVo instance.
+   *
+   * @param value - The user tracking values
+   * @param value.createdBy - User who created the entity (optional for system ops)
+   * @param value.updatedBy - User who last updated the entity (optional)
+   * @param validator - Bound validator or skip validation symbol
+   */
+  constructor(value, validator) {
+    super(value, validator);
+  }
+  /**
+   * The user ID who created the entity.
+   * Returns `undefined` for system-created entities.
+   */
+  get createdBy() {
+    return this.value.createdBy;
+  }
+  /**
+   * The user ID who last updated the entity.
+   * Returns `undefined` for system-updated entities.
+   */
+  get updatedBy() {
+    return this.value.updatedBy;
+  }
+};
+
+// src/backend/core/validators/arktype/wrappers/value-objects/uuid-v4.vo.ts
+var import_arktype4 = require("arktype");
+
+// src/backend/core/onion-layers/domain/value-objects/base-uuid-v4.vo.ts
+var import_uuid = require("uuid");
+var BaseUuidV4Vo = class extends BaseValueObject {
+  /**
+   * Creates a new BaseUuidV4Vo instance.
+   *
+   * @param value - The UUID v4 string value
+   * @param validator - Bound validator or skip validation symbol
+   */
+  constructor(value, validator) {
+    super(value, validator);
+  }
+  /**
+   * Generates a new UUID v4 value object.
+   *
+   * Creates a random UUID, skipping validation since the
+   * `uuid` library guarantees format.
+   *
+   * @returns A new BaseUuidV4Vo with a freshly generated UUID
+   */
+  static generate() {
+    return new this((0, import_uuid.v4)(), SKIP_VALUE_OBJECT_VALIDATION);
+  }
+  /**
+   * Creates a UUID v4 value object from an existing string.
+   *
+   * **Important:** This base implementation skips validation and accepts
+   * any string value. Subclasses should override this method with a
+   * validator to ensure UUID format correctness.
+   *
+   * @param value - The UUID v4 string value (not validated at base level)
+   * @returns A new BaseUuidV4Vo with the provided value
+   *
+   * @example Subclass with validation (recommended)
+   * ```typescript
+   * class UserId extends BaseUuidV4Vo {
+   *   static override create(value: string): UserId {
+   *     return new UserId(value, uuidV4Validator);
+   *   }
+   * }
+   * ```
+   *
+   * @see generate - For creating new UUIDs (always valid)
+   */
+  static create(value) {
+    return new this(value, SKIP_VALUE_OBJECT_VALIDATION);
+  }
+};
+
+// src/backend/core/validators/arktype/wrappers/value-objects/uuid-v4.vo.ts
+var schema = (0, import_arktype4.type)("string.uuid.v4");
+var UuidV4Vo = class _UuidV4Vo extends BaseUuidV4Vo {
+  constructor(value) {
+    super(value, createArkTypeValidator(schema));
+  }
+  static create(value) {
+    return new _UuidV4Vo(value);
+  }
+};
+
+// src/backend/core/validators/arktype/wrappers/value-objects/audit-by.vo.ts
+var schema2 = (0, import_arktype5.type)({
+  "createdBy?": "string.uuid.v4",
+  "updatedBy?": "string.uuid.v4"
+});
+var AuditByVo = class _AuditByVo extends BaseAuditByVo {
+  constructor(value) {
+    super(value, SKIP_VALUE_OBJECT_VALIDATION);
+  }
+  static create({ createdBy, updatedBy }) {
+    const validated = createArkTypeValidator(schema2).validate({
+      createdBy,
+      updatedBy
+    });
+    return new _AuditByVo({
+      createdBy: validated.createdBy ? UuidV4Vo.create(validated.createdBy) : void 0,
+      updatedBy: validated.updatedBy ? UuidV4Vo.create(validated.updatedBy) : void 0
+    });
+  }
+  update(updatedBy) {
+    return new _AuditByVo({ createdBy: this.createdBy, updatedBy });
+  }
+};
+
+// src/backend/core/validators/arktype/wrappers/value-objects/audit-info.vo.ts
+var import_arktype7 = require("arktype");
+
+// src/backend/core/onion-layers/domain/value-objects/base-audit-info.vo.ts
+var BaseAuditInfoVo = class extends BaseValueObject {
+  /**
+   * Creates a new BaseAuditInfoVo instance.
+   *
+   * @param value - Composite value containing audit by and on VOs
+   * @param value.by - User tracking value object
+   * @param value.on - Timestamp tracking value object
+   * @param validator - Bound validator or skip validation symbol
+   */
+  constructor(value, validator) {
+    super(value, validator);
+  }
+  /**
+   * The user ID who created the entity.
+   * Returns `undefined` for system-created entities.
+   */
+  get createdBy() {
+    return this.value.by.createdBy;
+  }
+  /**
+   * The timestamp when the entity was created.
+   * Returns a cloned Date to prevent mutation.
+   */
+  get createdAt() {
+    return new Date(this.value.on.createdAt.getTime());
+  }
+  /**
+   * The user ID who last updated the entity.
+   * Returns `undefined` for system-updated entities.
+   */
+  get updatedBy() {
+    return this.value.by.updatedBy;
+  }
+  /**
+   * The timestamp when the entity was last updated.
+   * Returns a cloned Date to prevent mutation.
+   */
+  get updatedAt() {
+    return new Date(this.value.on.updatedAt.getTime());
+  }
+  /**
+   * Whether the entity has been modified since creation.
+   *
+   * Compares both timestamps and user IDs. Returns `true` if either:
+   * - The updatedAt timestamp differs from createdAt
+   * - The updatedBy user differs from createdBy
+   *
+   * Note: When both createdBy and updatedBy are undefined (system-created
+   * entities), this correctly returns false for the user comparison.
+   */
+  get isModified() {
+    const timestampChanged = this.updatedAt.getTime() !== this.createdAt.getTime();
+    const userChanged = this.updatedBy?.value !== this.createdBy?.value;
+    return timestampChanged || userChanged;
+  }
+  /**
+   * Alias for `updatedBy` for semantic clarity.
+   */
+  get lastModifiedBy() {
+    return this.updatedBy;
+  }
+  /**
+   * Alias for `updatedAt` for semantic clarity.
+   */
+  get lastModifiedAt() {
+    return this.updatedAt;
+  }
+};
+
+// src/backend/core/validators/arktype/wrappers/value-objects/audit-on.vo.ts
+var import_arktype6 = require("arktype");
+
+// src/backend/core/onion-layers/domain/exceptions/domain.error.ts
+var DomainError = class _DomainError extends CodedError {
+  /**
+   * Creates a new DomainError instance.
+   *
+   * @param options - Error configuration
+   * @param options.message - Human-readable error description
+   * @param options.code - Machine-readable error code (default: 'DOMAIN_ERROR')
+   * @param options.cause - Optional underlying error
+   */
+  constructor({
+    message,
+    code = ErrorCodes.Domain.DOMAIN_ERROR,
+    cause
+  }) {
+    super({ message, code, cause });
+  }
+  /**
+   * Creates a DomainError from a caught error.
+   *
+   * @param cause - The original caught error
+   * @returns A new DomainError instance with the cause attached
+   */
+  static fromError(cause) {
+    return new _DomainError({
+      message: cause instanceof Error ? cause.message : "Domain error",
+      cause
+    });
+  }
+};
+
+// src/backend/core/onion-layers/domain/exceptions/invariant-violation.error.ts
+var InvariantViolationError = class _InvariantViolationError extends DomainError {
+  /**
+   * Creates a new InvariantViolationError instance.
+   *
+   * @param options - Error configuration
+   * @param options.message - Description of the violated invariant
+   * @param options.code - Machine-readable error code (default: 'INVARIANT_VIOLATION')
+   * @param options.cause - Optional underlying error
+   */
+  constructor({
+    message,
+    code = ErrorCodes.Domain.INVARIANT_VIOLATION,
+    cause
+  }) {
+    super({ message, code, cause });
+  }
+  /**
+   * Creates an InvariantViolationError from a caught error.
+   *
+   * @param cause - The original caught error
+   * @returns A new InvariantViolationError instance with the cause attached
+   */
+  static fromError(cause) {
+    return new _InvariantViolationError({
+      message: cause instanceof Error ? cause.message : "Invariant violation",
+      cause
+    });
+  }
+};
+
+// src/backend/core/onion-layers/domain/value-objects/base-audit-on.vo.ts
+var BaseAuditOnVo = class extends BaseValueObject {
+  /**
+   * Creates a new BaseAuditOnVo instance.
+   *
+   * @param value - The timestamp values
+   * @param value.createdAt - When the entity was created
+   * @param value.updatedAt - When the entity was last updated
+   * @param validator - Bound validator or skip validation symbol
+   * @throws {InvariantViolationError} When `updatedAt < createdAt`
+   */
+  constructor(value, validator) {
+    if (value.updatedAt < value.createdAt) {
+      throw new InvariantViolationError({
+        message: "UpdatedAt cannot be earlier than createdAt",
+        code: "INVALID_AUDIT_TIMESTAMPS"
+      });
+    }
+    super(value, validator);
+  }
+  /**
+   * When the entity was created.
+   * Returns a cloned Date to prevent mutation.
+   */
+  get createdAt() {
+    return new Date(this.value.createdAt);
+  }
+  /**
+   * When the entity was last updated.
+   * Returns a cloned Date to prevent mutation.
+   */
+  get updatedAt() {
+    return new Date(this.value.updatedAt);
+  }
+};
+
+// src/backend/core/validators/arktype/wrappers/value-objects/audit-on.vo.ts
+var schema3 = (0, import_arktype6.type)({
+  "createdAt?": "Date",
+  "updatedAt?": "Date"
+});
+var AuditOnVo = class _AuditOnVo extends BaseAuditOnVo {
+  constructor(value) {
+    super(value, SKIP_VALUE_OBJECT_VALIDATION);
+  }
+  static create({ createdAt, updatedAt }) {
+    const validated = createArkTypeValidator(schema3).validate({
+      createdAt,
+      updatedAt
+    });
+    const finalCreatedAt = validated.createdAt ?? /* @__PURE__ */ new Date();
+    const finalUpdatedAt = validated.updatedAt ?? finalCreatedAt;
+    return new _AuditOnVo({
+      createdAt: new Date(finalCreatedAt),
+      updatedAt: new Date(finalUpdatedAt)
+    });
+  }
+  update() {
+    return new _AuditOnVo({ createdAt: this.createdAt, updatedAt: /* @__PURE__ */ new Date() });
+  }
+};
+
+// src/backend/core/validators/arktype/wrappers/value-objects/audit-info.vo.ts
+var schema4 = (0, import_arktype7.type)({
+  "createdBy?": "string.uuid.v4",
+  "createdAt?": "Date",
+  "updatedBy?": "string.uuid.v4",
+  "updatedAt?": "Date"
+});
+var AuditInfoVo = class _AuditInfoVo extends BaseAuditInfoVo {
+  constructor(value) {
+    super(value, SKIP_VALUE_OBJECT_VALIDATION);
+  }
+  static create({
+    createdBy,
+    createdAt,
+    updatedBy,
+    updatedAt
+  }) {
+    const validated = createArkTypeValidator(schema4).validate({
+      createdBy,
+      createdAt,
+      updatedBy,
+      updatedAt
+    });
+    const by = AuditByVo.create({
+      createdBy: validated.createdBy,
+      updatedBy: validated.updatedBy
+    });
+    const on = AuditOnVo.create({
+      createdAt: validated.createdAt,
+      updatedAt: validated.updatedAt
+    });
+    return new _AuditInfoVo({ by, on });
+  }
+  static createNew(createdBy) {
+    const by = AuditByVo.create({ createdBy });
+    const on = AuditOnVo.create({});
+    return new _AuditInfoVo({ by, on });
+  }
+  update(updatedBy) {
+    const by = this.value.by.update(updatedBy);
+    const on = this.value.on.update();
+    return new _AuditInfoVo({ by, on });
+  }
+};
+
+// src/backend/core/validators/arktype/wrappers/value-objects/email.vo.ts
+var import_arktype8 = require("arktype");
+
+// src/backend/core/onion-layers/domain/value-objects/base-email.vo.ts
+var BaseEmailVo = class extends BaseValueObject {
+  /**
+   * Creates a new BaseEmailVo instance.
+   *
+   * @param value - The email address string
+   * @param validator - Bound validator or skip validation symbol
+   */
+  constructor(value, validator) {
+    super(value, validator);
+  }
+};
+
+// src/backend/core/validators/arktype/wrappers/value-objects/email.vo.ts
+var schema5 = (0, import_arktype8.type)("string.email");
+var EmailVo = class _EmailVo extends BaseEmailVo {
+  constructor(value) {
+    super(value, createArkTypeValidator(schema5));
+  }
+  static create(value) {
+    return new _EmailVo(value);
+  }
+};
+
+// src/backend/core/validators/arktype/wrappers/value-objects/long-text.vo.ts
+var import_arktype9 = require("arktype");
+
+// src/backend/core/onion-layers/domain/value-objects/base-long-text.vo.ts
+var BaseLongTextVo = class extends BaseValueObject {
+  /**
+   * Creates a new BaseLongTextVo instance.
+   *
+   * @param value - The long text string
+   * @param validator - Bound validator or skip validation symbol
+   */
+  constructor(value, validator) {
+    super(value, validator);
+  }
+};
+
+// src/backend/core/validators/arktype/wrappers/value-objects/long-text.vo.ts
+var schema6 = (maxLength) => (0, import_arktype9.type)(`1 <= string <= ${maxLength}`);
+var LongTextVo = class _LongTextVo extends BaseLongTextVo {
+  constructor(value, maxLength = 2e3) {
+    super(value, createArkTypeValidator(schema6(maxLength)));
+  }
+  static create(value, maxLength = 2e3) {
+    return new _LongTextVo(value, maxLength);
+  }
+};
+
+// src/backend/core/validators/arktype/wrappers/value-objects/medium-text.vo.ts
+var import_arktype10 = require("arktype");
+
+// src/backend/core/onion-layers/domain/value-objects/base-medium-text.vo.ts
+var BaseMediumTextVo = class extends BaseValueObject {
+  /**
+   * Creates a new BaseMediumTextVo instance.
+   *
+   * @param value - The medium text string
+   * @param validator - Bound validator or skip validation symbol
+   */
+  constructor(value, validator) {
+    super(value, validator);
+  }
+};
+
+// src/backend/core/validators/arktype/wrappers/value-objects/medium-text.vo.ts
+var schema7 = (maxLength) => (0, import_arktype10.type)(`1 <= string <= ${maxLength}`);
+var MediumTextVo = class _MediumTextVo extends BaseMediumTextVo {
+  constructor(value, maxLength = 500) {
+    super(value, createArkTypeValidator(schema7(maxLength)));
+  }
+  static create(value, maxLength = 500) {
+    return new _MediumTextVo(value, maxLength);
+  }
+};
+
+// src/backend/core/validators/arktype/wrappers/value-objects/pagination.vo.ts
+var import_arktype11 = require("arktype");
+
+// src/backend/core/onion-layers/domain/value-objects/base-pagination.vo.ts
+var BasePaginationVo = class extends BaseValueObject {
+  /**
+   * Creates a new BasePaginationVo instance.
+   *
+   * @param value - The pagination parameters
+   * @param value.page - The page number (typically 1-indexed)
+   * @param value.pageSize - The number of items per page
+   * @param validator - Bound validator or skip validation symbol
+   */
+  constructor(value, validator) {
+    super(value, validator);
+  }
+  /**
+   * The current page number.
+   */
+  get page() {
+    return this.value.page;
+  }
+  /**
+   * The number of items per page.
+   */
+  get pageSize() {
+    return this.value.pageSize;
+  }
+};
+
+// src/backend/core/validators/arktype/wrappers/value-objects/pagination.vo.ts
+var coerceToInt = (v) => typeof v === "string" ? parseInt(v, 10) : v;
+var schema8 = (maxPageSize) => (0, import_arktype11.type)({
+  page: (0, import_arktype11.type)("string | number").pipe(coerceToInt, (0, import_arktype11.type)("number.integer >= 1")),
+  pageSize: (0, import_arktype11.type)("string | number").pipe(
+    coerceToInt,
+    (0, import_arktype11.type)(`1 <= number.integer <= ${maxPageSize}`)
+  )
+});
+var PaginationVo = class _PaginationVo extends BasePaginationVo {
+  constructor(value) {
+    super(value, SKIP_VALUE_OBJECT_VALIDATION);
+  }
+  static create({
+    page,
+    pageSize,
+    maxPageSize = 100
+  }) {
+    const validated = createArkTypeValidator(schema8(maxPageSize)).validate({
+      page,
+      pageSize
+    });
+    return new _PaginationVo(validated);
+  }
+};
+
+// src/backend/core/validators/arktype/wrappers/value-objects/short-text.vo.ts
+var import_arktype12 = require("arktype");
+
+// src/backend/core/onion-layers/domain/value-objects/base-short-text.vo.ts
+var BaseShortTextVo = class extends BaseValueObject {
+  /**
+   * Creates a new BaseShortTextVo instance.
+   *
+   * @param value - The short text string
+   * @param validator - Bound validator or skip validation symbol
+   */
+  constructor(value, validator) {
+    super(value, validator);
+  }
+};
+
+// src/backend/core/validators/arktype/wrappers/value-objects/short-text.vo.ts
+var schema9 = (maxLength) => (0, import_arktype12.type)(`1 <= string <= ${maxLength}`);
+var ShortTextVo = class _ShortTextVo extends BaseShortTextVo {
+  constructor(value, maxLength = 100) {
+    super(value, createArkTypeValidator(schema9(maxLength)));
+  }
+  static create(value, maxLength = 100) {
+    return new _ShortTextVo(value, maxLength);
+  }
+};
+
+// src/backend/core/validators/arktype/wrappers/value-objects/uuid-v7.vo.ts
+var import_arktype13 = require("arktype");
+
+// src/backend/core/onion-layers/domain/value-objects/base-uuid-v7.vo.ts
+var import_uuid2 = require("uuid");
+var BaseUuidV7Vo = class extends BaseValueObject {
+  /**
+   * Creates a new BaseUuidV7Vo instance.
+   *
+   * @param value - The UUID v7 string value
+   * @param validator - Bound validator or skip validation symbol
+   */
+  constructor(value, validator) {
+    super(value, validator);
+  }
+  /**
+   * Generates a new UUID v7 value object.
+   *
+   * Creates a time-ordered UUID using the current timestamp,
+   * skipping validation since the `uuid` library guarantees format.
+   *
+   * @returns A new BaseUuidV7Vo with a freshly generated UUID
+   */
+  static generate() {
+    return new this((0, import_uuid2.v7)(), SKIP_VALUE_OBJECT_VALIDATION);
+  }
+  /**
+   * Creates a UUID v7 value object from an existing string.
+   *
+   * **Important:** This base implementation skips validation and accepts
+   * any string value. Subclasses should override this method with a
+   * validator to ensure UUID format correctness.
+   *
+   * @param value - The UUID v7 string value (not validated at base level)
+   * @returns A new BaseUuidV7Vo with the provided value
+   *
+   * @example Subclass with validation (recommended)
+   * ```typescript
+   * class OrderId extends BaseUuidV7Vo {
+   *   static override create(value: string): OrderId {
+   *     return new OrderId(value, uuidV7Validator);
+   *   }
+   * }
+   * ```
+   *
+   * @see generate - For creating new UUIDs (always valid)
+   */
+  static create(value) {
+    return new this(value, SKIP_VALUE_OBJECT_VALIDATION);
+  }
+};
+
+// src/backend/core/validators/arktype/wrappers/value-objects/uuid-v7.vo.ts
+var schema10 = (0, import_arktype13.type)("string.uuid.v7");
+var UuidV7Vo = class _UuidV7Vo extends BaseUuidV7Vo {
+  constructor(value) {
+    super(value, createArkTypeValidator(schema10));
+  }
+  static create(value) {
+    return new _UuidV7Vo(value);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ArkTypeObjectValidator,
+  AuditByVo,
+  AuditInfoVo,
+  AuditOnVo,
+  Dto,
+  EmailVo,
+  LongTextVo,
+  MediumTextVo,
+  PaginationVo,
+  ShortTextVo,
+  UuidV4Vo,
+  UuidV7Vo,
+  arkTypeObjectValidator,
+  createArkTypeValidator
+});
+//# sourceMappingURL=arktype.cjs.map