@cosmneo/onion-lasagna 0.1.0

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

@@ -0,0 +1,939 @@
+"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/typebox/index.ts
+var typebox_exports = {};
+__export(typebox_exports, {
+  AuditByVo: () => AuditByVo,
+  AuditInfoVo: () => AuditInfoVo,
+  AuditOnVo: () => AuditOnVo,
+  Dto: () => Dto,
+  EmailVo: () => EmailVo,
+  LongTextVo: () => LongTextVo,
+  MediumTextVo: () => MediumTextVo,
+  PaginationVo: () => PaginationVo,
+  ShortTextVo: () => ShortTextVo,
+  TypeBoxObjectValidator: () => TypeBoxObjectValidator,
+  UuidV4Vo: () => UuidV4Vo,
+  UuidV7Vo: () => UuidV7Vo,
+  createTypeBoxValidator: () => createTypeBoxValidator,
+  typeBoxObjectValidator: () => typeBoxObjectValidator
+});
+module.exports = __toCommonJS(typebox_exports);
+
+// src/backend/core/validators/typebox/object-validator.typebox.ts
+var import_value = require("@sinclair/typebox/value");
+
+// 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/typebox/object-validator.typebox.ts
+var formatPath = (path) => {
+  if (!path || path === "/") return "root";
+  return path.slice(1).split("/").map((segment, index) => {
+    const num = Number(segment);
+    if (!isNaN(num)) return `[${num}]`;
+    return index === 0 ? segment : `.${segment}`;
+  }).join("");
+};
+var toValidationErrors = (errors) => [...errors].map((error) => ({
+  field: formatPath(error?.path ?? "/"),
+  message: error?.message ?? "Validation failed"
+}));
+var TypeBoxObjectValidator = class {
+  validateObject(schema11, value) {
+    const errors = [...import_value.Value.Errors(schema11, value)];
+    if (errors.length === 0) {
+      return import_value.Value.Decode(schema11, value);
+    }
+    throw new ObjectValidationError({
+      message: "Object validation failed",
+      cause: errors,
+      validationErrors: toValidationErrors(errors)
+    });
+  }
+  withSchema(schema11) {
+    return {
+      validate: (value) => this.validateObject(schema11, value)
+    };
+  }
+};
+
+// src/backend/core/validators/typebox/bootstrap.ts
+var typeBoxObjectValidator = new TypeBoxObjectValidator();
+var createTypeBoxValidator = (schema11) => typeBoxObjectValidator.withSchema(schema11);
+
+// 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/typebox/wrappers/dto.ts
+var Dto = class extends BaseDto {
+  constructor(schema11, value) {
+    super(value, createTypeBoxValidator(schema11));
+  }
+};
+
+// src/backend/core/validators/typebox/wrappers/value-objects/audit-by.vo.ts
+var import_typebox2 = require("@sinclair/typebox");
+
+// 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/typebox/wrappers/value-objects/uuid-v4.vo.ts
+var import_typebox = require("@sinclair/typebox");
+
+// 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/typebox/wrappers/value-objects/uuid-v4.vo.ts
+var schema = import_typebox.Type.String({ format: "uuid" });
+var UuidV4Vo = class _UuidV4Vo extends BaseUuidV4Vo {
+  constructor(value) {
+    super(value, createTypeBoxValidator(schema));
+  }
+  static create(value) {
+    return new _UuidV4Vo(value);
+  }
+};
+
+// src/backend/core/validators/typebox/wrappers/value-objects/audit-by.vo.ts
+var schema2 = import_typebox2.Type.Object({
+  createdBy: import_typebox2.Type.Optional(import_typebox2.Type.String({ format: "uuid" })),
+  updatedBy: import_typebox2.Type.Optional(import_typebox2.Type.String({ format: "uuid" }))
+});
+var AuditByVo = class _AuditByVo extends BaseAuditByVo {
+  constructor(value) {
+    super(value, SKIP_VALUE_OBJECT_VALIDATION);
+  }
+  static create({ createdBy, updatedBy }) {
+    const validated = createTypeBoxValidator(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/typebox/wrappers/value-objects/audit-info.vo.ts
+var import_typebox4 = require("@sinclair/typebox");
+
+// 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/typebox/wrappers/value-objects/audit-on.vo.ts
+var import_typebox3 = require("@sinclair/typebox");
+
+// 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/typebox/wrappers/value-objects/audit-on.vo.ts
+var schema3 = import_typebox3.Type.Object({
+  createdAt: import_typebox3.Type.Optional(import_typebox3.Type.Date()),
+  updatedAt: import_typebox3.Type.Optional(import_typebox3.Type.Date())
+});
+var AuditOnVo = class _AuditOnVo extends BaseAuditOnVo {
+  constructor(value) {
+    super(value, SKIP_VALUE_OBJECT_VALIDATION);
+  }
+  static create({ createdAt, updatedAt }) {
+    const validated = createTypeBoxValidator(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/typebox/wrappers/value-objects/audit-info.vo.ts
+var schema4 = import_typebox4.Type.Object({
+  createdBy: import_typebox4.Type.Optional(import_typebox4.Type.String({ format: "uuid" })),
+  createdAt: import_typebox4.Type.Optional(import_typebox4.Type.Date()),
+  updatedBy: import_typebox4.Type.Optional(import_typebox4.Type.String({ format: "uuid" })),
+  updatedAt: import_typebox4.Type.Optional(import_typebox4.Type.Date())
+});
+var AuditInfoVo = class _AuditInfoVo extends BaseAuditInfoVo {
+  constructor(value) {
+    super(value, SKIP_VALUE_OBJECT_VALIDATION);
+  }
+  static create({
+    createdBy,
+    createdAt,
+    updatedBy,
+    updatedAt
+  }) {
+    const validated = createTypeBoxValidator(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/typebox/wrappers/value-objects/email.vo.ts
+var import_typebox5 = require("@sinclair/typebox");
+
+// 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/typebox/wrappers/value-objects/email.vo.ts
+var schema5 = import_typebox5.Type.String({ format: "email" });
+var EmailVo = class _EmailVo extends BaseEmailVo {
+  constructor(value) {
+    super(value, createTypeBoxValidator(schema5));
+  }
+  static create(value) {
+    return new _EmailVo(value);
+  }
+};
+
+// src/backend/core/validators/typebox/wrappers/value-objects/long-text.vo.ts
+var import_typebox6 = require("@sinclair/typebox");
+
+// 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/typebox/wrappers/value-objects/long-text.vo.ts
+var schema6 = (maxLen) => import_typebox6.Type.String({ minLength: 1, maxLength: maxLen });
+var LongTextVo = class _LongTextVo extends BaseLongTextVo {
+  constructor(value, maxLen = 2e3) {
+    super(value, createTypeBoxValidator(schema6(maxLen)));
+  }
+  static create(value, maxLen = 2e3) {
+    return new _LongTextVo(value, maxLen);
+  }
+};
+
+// src/backend/core/validators/typebox/wrappers/value-objects/medium-text.vo.ts
+var import_typebox7 = require("@sinclair/typebox");
+
+// 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/typebox/wrappers/value-objects/medium-text.vo.ts
+var schema7 = (maxLen) => import_typebox7.Type.String({ minLength: 1, maxLength: maxLen });
+var MediumTextVo = class _MediumTextVo extends BaseMediumTextVo {
+  constructor(value, maxLen = 500) {
+    super(value, createTypeBoxValidator(schema7(maxLen)));
+  }
+  static create(value, maxLen = 500) {
+    return new _MediumTextVo(value, maxLen);
+  }
+};
+
+// src/backend/core/validators/typebox/wrappers/value-objects/pagination.vo.ts
+var import_typebox8 = require("@sinclair/typebox");
+
+// 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/typebox/wrappers/value-objects/pagination.vo.ts
+var schema8 = (maxPageSize) => import_typebox8.Type.Object({
+  page: import_typebox8.Type.Integer({ minimum: 1 }),
+  pageSize: import_typebox8.Type.Integer({ minimum: 1, maximum: maxPageSize })
+});
+var PaginationVo = class _PaginationVo extends BasePaginationVo {
+  constructor(value) {
+    super(value, SKIP_VALUE_OBJECT_VALIDATION);
+  }
+  static create({
+    page,
+    pageSize,
+    maxPageSize = 100
+  }) {
+    const validated = createTypeBoxValidator(
+      schema8(maxPageSize)
+    ).validate({
+      page,
+      pageSize
+    });
+    return new _PaginationVo(validated);
+  }
+};
+
+// src/backend/core/validators/typebox/wrappers/value-objects/short-text.vo.ts
+var import_typebox9 = require("@sinclair/typebox");
+
+// 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/typebox/wrappers/value-objects/short-text.vo.ts
+var schema9 = (maxLen) => import_typebox9.Type.String({ minLength: 1, maxLength: maxLen });
+var ShortTextVo = class _ShortTextVo extends BaseShortTextVo {
+  constructor(value, maxLen = 100) {
+    super(value, createTypeBoxValidator(schema9(maxLen)));
+  }
+  static create(value, maxLen = 100) {
+    return new _ShortTextVo(value, maxLen);
+  }
+};
+
+// src/backend/core/validators/typebox/wrappers/value-objects/uuid-v7.vo.ts
+var import_typebox10 = require("@sinclair/typebox");
+
+// 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/typebox/wrappers/value-objects/uuid-v7.vo.ts
+var schema10 = import_typebox10.Type.String({ format: "uuid" });
+var UuidV7Vo = class _UuidV7Vo extends BaseUuidV7Vo {
+  constructor(value) {
+    super(value, createTypeBoxValidator(schema10));
+  }
+  static create(value) {
+    return new _UuidV7Vo(value);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AuditByVo,
+  AuditInfoVo,
+  AuditOnVo,
+  Dto,
+  EmailVo,
+  LongTextVo,
+  MediumTextVo,
+  PaginationVo,
+  ShortTextVo,
+  TypeBoxObjectValidator,
+  UuidV4Vo,
+  UuidV7Vo,
+  createTypeBoxValidator,
+  typeBoxObjectValidator
+});
+//# sourceMappingURL=typebox.cjs.map