@woltz/rich-domain 1.3.1 → 1.3.2

package/src/exceptions.ts

@@ -1,435 +0,0 @@
-/**
- * Base exception class for all Rich Domain exceptions
- */
-abstract class DomainException extends Error {
-  public readonly code: string;
-  public readonly timestamp: Date;
-  public readonly __isDomainException = true;
-
-  constructor(message: string, code?: string) {
-    super(message);
-    this.name = this.constructor.name;
-    this.code = code || this.constructor.name;
-    this.timestamp = new Date();
-
-    // Maintain proper stack trace
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, this.constructor);
-    }
-  }
-
-  /**
-   * Check if an error is a DomainException
-   */
-  static isDomainException(error: unknown): error is DomainException {
-    return (
-      error instanceof DomainException ||
-      (error instanceof Error &&
-        "__isDomainException" in error &&
-        (error as any).__isDomainException === true)
-    );
-  }
-
-  /**
-   * Convert to JSON for serialization
-   */
-  toJSON(): {
-    name: string;
-    message: string;
-    code: string;
-    timestamp: string;
-  } {
-    return {
-      name: this.name,
-      message: this.message,
-      code: this.code,
-      timestamp: this.timestamp.toISOString(),
-    };
-  }
-}
-
-/**
- * Thrown when a domain rule or business logic is violated
- */
-export class DomainError extends DomainException {
-  constructor(message: string, code?: string) {
-    super(message, code || "DOMAIN_ERROR");
-  }
-}
-
-// ============================================================================
-// Entity & Aggregate Exceptions
-// ============================================================================
-
-/**
- * Thrown when an entity or aggregate is not found
- */
-export class EntityNotFoundError extends DomainException {
-  public readonly entityType: string;
-  public readonly entityId?: string;
-
-  constructor(entityType: string, entityId?: string, message?: string) {
-    const defaultMessage = entityId
-      ? `${entityType} with id '${entityId}' not found`
-      : `${entityType} not found`;
-
-    super(message || defaultMessage, "ENTITY_NOT_FOUND");
-    this.entityType = entityType;
-    this.entityId = entityId;
-  }
-
-  toJSON() {
-    return {
-      ...super.toJSON(),
-      entityType: this.entityType,
-      entityId: this.entityId,
-    };
-  }
-}
-
-/**
- * Thrown when trying to create an entity that already exists
- */
-export class EntityAlreadyExistsError extends DomainException {
-  public readonly entityType: string;
-  public readonly entityId?: string;
-
-  constructor(entityType: string, entityId?: string, message?: string) {
-    const defaultMessage = entityId
-      ? `${entityType} with id '${entityId}' already exists`
-      : `${entityType} already exists`;
-
-    super(message || defaultMessage, "ENTITY_ALREADY_EXISTS");
-    this.entityType = entityType;
-    this.entityId = entityId;
-  }
-
-  toJSON() {
-    return {
-      ...super.toJSON(),
-      entityType: this.entityType,
-      entityId: this.entityId,
-    };
-  }
-}
-
-// ============================================================================
-// Repository & Persistence Exceptions
-// ============================================================================
-
-/**
- * Base exception for repository operations
- */
-export class RepositoryError extends DomainException {
-  constructor(message: string, code?: string) {
-    super(message, code || "REPOSITORY_ERROR");
-  }
-}
-
-/**
- * Thrown when a persistence operation fails
- */
-export class PersistenceError extends RepositoryError {
-  public readonly operation: string;
-  public readonly cause?: Error;
-
-  constructor(operation: string, message?: string, cause?: Error) {
-    const defaultMessage = `Persistence operation '${operation}' failed${
-      message ? `: ${message}` : ""
-    }`;
-
-    super(defaultMessage, "PERSISTENCE_ERROR");
-    this.operation = operation;
-    this.cause = cause;
-  }
-
-  toJSON() {
-    return {
-      ...super.toJSON(),
-      operation: this.operation,
-      cause: this.cause?.message,
-    };
-  }
-}
-
-/**
- * Thrown when a concurrency conflict occurs (optimistic locking)
- */
-export class ConcurrencyError extends RepositoryError {
-  public readonly entityType: string;
-  public readonly entityId: string;
-
-  constructor(entityType: string, entityId: string, message?: string) {
-    const defaultMessage =
-      message ||
-      `Concurrency conflict detected for ${entityType} with id '${entityId}'`;
-
-    super(defaultMessage, "CONCURRENCY_ERROR");
-    this.entityType = entityType;
-    this.entityId = entityId;
-  }
-
-  toJSON() {
-    return {
-      ...super.toJSON(),
-      entityType: this.entityType,
-      entityId: this.entityId,
-    };
-  }
-}
-
-/**
- * Thrown when a database constraint is violated
- */
-export class ConstraintViolationError extends RepositoryError {
-  public readonly constraint: string;
-
-  constructor(constraint: string, message?: string) {
-    const defaultMessage =
-      message || `Database constraint '${constraint}' violated`;
-
-    super(defaultMessage, "CONSTRAINT_VIOLATION");
-    this.constraint = constraint;
-  }
-
-  toJSON() {
-    return {
-      ...super.toJSON(),
-      constraint: this.constraint,
-    };
-  }
-}
-
-// ============================================================================
-// Value Object Exceptions
-// ============================================================================
-
-/**
- * Thrown when a value object has invalid data
- */
-export class InvalidValueObjectError extends DomainException {
-  public readonly valueObjectType: string;
-  public readonly invalidValue?: any;
-
-  constructor(valueObjectType: string, message: string, invalidValue?: any) {
-    super(message, "INVALID_VALUE_OBJECT");
-    this.valueObjectType = valueObjectType;
-    this.invalidValue = invalidValue;
-  }
-
-  toJSON() {
-    return {
-      ...super.toJSON(),
-      valueObjectType: this.valueObjectType,
-      invalidValue: this.invalidValue,
-    };
-  }
-}
-
-// ============================================================================
-// Domain Event Exceptions
-// ============================================================================
-
-/**
- * Thrown when a domain event operation fails
- */
-export class DomainEventError extends DomainException {
-  public readonly eventType?: string;
-
-  constructor(message: string, eventType?: string) {
-    super(message, "DOMAIN_EVENT_ERROR");
-    this.eventType = eventType;
-  }
-
-  toJSON() {
-    return {
-      ...super.toJSON(),
-      eventType: this.eventType,
-    };
-  }
-}
-
-/**
- * Thrown when an event handler fails
- */
-export class EventHandlerError extends DomainEventError {
-  public readonly handlerName: string;
-  public readonly cause?: Error;
-
-  constructor(handlerName: string, eventType: string, cause?: Error) {
-    const message = `Event handler '${handlerName}' failed for event '${eventType}'${
-      cause ? `: ${cause.message}` : ""
-    }`;
-
-    super(message, eventType);
-    this.handlerName = handlerName;
-    this.cause = cause;
-  }
-
-  toJSON() {
-    return {
-      ...super.toJSON(),
-      handlerName: this.handlerName,
-      cause: this.cause?.message,
-    };
-  }
-}
-
-// ============================================================================
-// Criteria & Query Exceptions
-// ============================================================================
-
-/**
- * Thrown when a criteria or query is invalid
- */
-export class InvalidCriteriaError extends DomainException {
-  public readonly field?: string;
-
-  constructor(message: string, field?: string) {
-    super(message, "INVALID_CRITERIA");
-    this.field = field;
-  }
-
-  toJSON() {
-    return {
-      ...super.toJSON(),
-      field: this.field,
-    };
-  }
-}
-
-// ============================================================================
-// Unit of Work Exceptions
-// ============================================================================
-
-/**
- * Thrown when a transaction operation fails
- */
-export class TransactionError extends DomainException {
-  public readonly operation: string;
-  public readonly cause?: Error;
-
-  constructor(operation: string, message?: string, cause?: Error) {
-    const defaultMessage = `Transaction ${operation} failed${
-      message ? `: ${message}` : ""
-    }`;
-
-    super(defaultMessage, "TRANSACTION_ERROR");
-    this.operation = operation;
-    this.cause = cause;
-  }
-
-  toJSON() {
-    return {
-      ...super.toJSON(),
-      operation: this.operation,
-      cause: this.cause?.message,
-    };
-  }
-}
-
-// ============================================================================
-// Generic/Unknown Exceptions
-// ============================================================================
-
-/**
- * Thrown when an unexpected or unknown error occurs
- */
-export class UnknownError extends DomainException {
-  public readonly originalError?: Error;
-
-  constructor(message?: string, originalError?: Error) {
-    const defaultMessage =
-      message || originalError?.message || "An unknown error occurred";
-
-    super(defaultMessage, "UNKNOWN_ERROR");
-    this.originalError = originalError;
-  }
-
-  toJSON() {
-    return {
-      ...super.toJSON(),
-      originalError: this.originalError?.message,
-    };
-  }
-}
-
-/**
- * Thrown when a feature is not implemented yet
- */
-export class NotImplementedError extends DomainException {
-  public readonly feature: string;
-
-  constructor(feature: string, message?: string) {
-    const defaultMessage = message || `Feature '${feature}' is not implemented`;
-
-    super(defaultMessage, "NOT_IMPLEMENTED");
-    this.feature = feature;
-  }
-
-  toJSON() {
-    return {
-      ...super.toJSON(),
-      feature: this.feature,
-    };
-  }
-}
-
-/**
- * Thrown when a required configuration is missing
- */
-export class ConfigurationError extends DomainException {
-  public readonly configKey?: string;
-
-  constructor(message: string, configKey?: string) {
-    super(message, "CONFIGURATION_ERROR");
-    this.configKey = configKey;
-  }
-
-  toJSON() {
-    return {
-      ...super.toJSON(),
-      configKey: this.configKey,
-    };
-  }
-}
-
-// ============================================================================
-// Mapper Exceptions
-// ============================================================================
-
-/**
- * Thrown when mapping between domain and persistence fails
- */
-export class MapperError extends DomainException {
-  public readonly direction: "toDomain" | "toPersistence";
-  public readonly entityType: string;
-  public readonly cause?: Error;
-
-  constructor(
-    direction: "toDomain" | "toPersistence",
-    entityType: string,
-    message?: string,
-    cause?: Error
-  ) {
-    const defaultMessage =
-      message ||
-      `Failed to map ${entityType} ${
-        direction === "toDomain" ? "to domain" : "to persistence"
-      }`;
-
-    super(defaultMessage, "MAPPER_ERROR");
-    this.direction = direction;
-    this.entityType = entityType;
-    this.cause = cause;
-  }
-
-  toJSON() {
-    return {
-      ...super.toJSON(),
-      direction: this.direction,
-      entityType: this.entityType,
-      cause: this.cause?.message,
-    };
-  }
-}

package/src/id.ts

@@ -1,98 +0,0 @@
-// ============================================================================
-// Id Class - Smart Identity Management
-// ============================================================================
-
-import UUID from "./crypto";
-
-export class Id {
-  private readonly _value: string;
-  private readonly _isNew: boolean;
-
-
-  /**
-   * Create a new Id
-   * @param value - Optional existing ID value. If not provided, generates a new UUID.
-  *
-  * @example
-  * // New entity (generates UUID)
-  * const newId = new Id();
-  * newuser.isNew() // true
-  *
-  * // Existing entity (uses provided ID)
-  * const existingId = new Id("550e8400-e29b-41d4-a716-446655440000");
-  * existinguser.isNew() // false
-  */
-  constructor(value: string, isNew?: boolean);
-  constructor(value?: string);
-  constructor(value?: string, isNew?: boolean) {
-    if (value !== undefined) {
-      // ID was provided - this is an existing entity
-      this._value = value;
-      this._isNew = isNew ?? false;
-    } else {
-      // No ID provided - generate new one, this is a new entity
-      this._value = this.generateUUID();
-      this._isNew = true;
-    }
-  }
-
-  /**
-   * Get the string value of the ID
-   */
-  get value(): string {
-    return this._value;
-  }
-
-  /**
-   * Check if this ID represents a new entity
-   */
-  public isNew(): boolean {
-    return this._isNew;
-  }
-
-  /**
-   * Convert to string (for JSON serialization and comparisons)
-   */
-  toString(): string {
-    return this._value;
-  }
-
-  /**
-   * Convert to JSON (returns the string value)
-   */
-  toJSON(): string {
-    return this._value;
-  }
-
-  /**
-   * Check equality with another Id or string
-   */
-  equals(other: Id | string): boolean {
-    if (other instanceof Id) {
-      return this._value === other._value;
-    }
-    return this._value === other;
-  }
-
-  /**
-   * Generate a UUID v4
-   */
-  private generateUUID(): string {
-    // Simple UUID v4 implementation
-    return UUID();
-  }
-
-  /**
-   * Create a new Id (convenience static method)
-   */
-  static create(): Id {
-    return new Id();
-  }
-
-  /**
-   * Create an Id from an existing value
-   */
-  static from(value: string): Id {
-    return new Id(value);
-  }
-}

package/src/index.ts

@@ -1,52 +0,0 @@
-export * from "./validation-error";
-export * from "./domain-event";
-export * from "./domain-event-bus";
-export * from "./exceptions";
-export * from "./criteria";
-export * from "./paginated-result";
-export * from "./repository";
-export { Id } from "./id";
-export { Entity, Aggregate } from "./entity";
-export { ValueObject } from "./value-object";
-export { Mapper } from "./mapper";
-export { EntitySchemaRegistry } from "./entity-schema-registry";
-export { AggregateChanges } from "./aggregate-changes";
-export type {
-  DomainEventHandler,
-  EntityHooks,
-  Filter,
-  EntityValidation,
-  IDomainEvent,
-  VOValidation,
-  VOHooks,
-  ValidationConfig,
-  Primitive,
-  TransactionContext,
-  PaginationMeta,
-  Pagination,
-  OrderDirection,
-  Order,
-  IUnitOfWork,
-  IDomainEventHandler,
-  FieldPath,
-  FilterOperator,
-  Search,
-  FilterValueFor,
-  PathValue,
-  OperatorsForType,
-  DateOperators,
-  NumberOperators,
-  StringOperators,
-  BooleanOperators,
-  ArrayOperators,
-  CriteriaOptions,
-} from "./types";
-export {
-  ARRAY_OPERATORS,
-  BOOLEAN_OPERATORS,
-  DATE_OPERATORS,
-  NUMBER_OPERATORS,
-  STRING_OPERATORS,
-  FILTER_OPERATORS,
-} from "./constants";
-export { isValidOperatorForType } from "./utils/criteria-operator-validation";

package/src/mapper.ts

@@ -1,6 +0,0 @@
-export abstract class Mapper<Input, Output> {
-  public abstract build(
-    input: Input,
-    ...args: unknown[]
-  ): Output | Promise<Output>;
-}