@woltz/rich-domain 1.0.0 → 1.1.0

package/src/id.ts

@@ -1,94 +1,107 @@
-import { randomUUID } from "crypto";
-// ============================================================================
-// Id Class - Smart Identity Management
-// ============================================================================
-
-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) {
-    if (value !== undefined) {
-      // ID was provided - this is an existing entity
-      this._value = value;
-      this._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 randomUUID();
-  }
-
-  /**
-   * 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);
-  }
-}
+// ============================================================================
+// Id Class - Smart Identity Management
+// ============================================================================
+
+function randomUUID(): string {
+  // If we are in the browser, use the browser's crypto API
+  // @ts-expect-error - window.crypto is not defined in the browser
+  if (typeof window !== "undefined" && window.crypto) {
+    // @ts-expect-error - window.crypto is not defined in the browser
+    return window.crypto.randomUUID();
+  }
+  // If we are in the server, use the crypto library
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  const crypto = require("crypto");
+
+  return crypto.randomUUID();
+}
+
+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) {
+    if (value !== undefined) {
+      // ID was provided - this is an existing entity
+      this._value = value;
+      this._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 randomUUID();
+  }
+
+  /**
+   * 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

@@ -4,7 +4,6 @@
 
 // Core Classes
 export { Id } from "./id";
-export { BaseEntity } from "./base-entity";
 export { Entity, Aggregate } from "./entity";
 export { ValueObject } from "./value-object";
 export { Mapper } from "./mapper";
@@ -13,8 +12,8 @@ export * from "./validation-error";
 
 // Domain Events
 export * from "./domain-event";
-
 export * from "./domain-event-bus";
+export * from "./exceptions";
 
 // Criteria
 export * from "./criteria";
@@ -24,9 +23,29 @@ export * from "./paginated-result";
 export * from "./repository";
 
 // Types
-export * from "./types";
-
-export * from "./constants";
+export {
+  DomainEventHandler,
+  EntityHooks,
+  Filter,
+  EntityValidation,
+  IDomainEvent,
+  VOValidation,
+  VOHooks,
+  ValidationConfig,
+  Primitive,
+  TransactionContext,
+  PaginationMeta,
+  Pagination,
+  OrderDirection,
+  Order,
+  IUnitOfWork,
+  IDomainEventHandler,
+  EntityId,
+  FieldPath,
+  FilterOperator,
+  Search,
+  FilterValueFor,
+  PathValue,
+} from "./types";
 
 // Internal (for advanced usage)
-export { DeepProxy } from "./deep-proxy";

package/src/paginated-result.ts

@@ -70,7 +70,20 @@ export class PaginatedResult<T> {
       result = result.filter((item) => applyFilter(item, filter));
     }
 
-    const total = result.length;
+    let total = result.length;
+
+    const search = criteria.getSearch();
+    if (search) {
+      result = result.filter((item) => {
+        return search.fields.some((field) => {
+          return String(getNestedValue(item, field))
+            .toLowerCase()
+            .includes(search.value.toLowerCase());
+        });
+      });
+
+      total = result.length;
+    }
 
     // Apply ordering
     for (const order of criteria.getOrders().reverse()) {

package/src/repository/index.ts

@@ -7,11 +7,6 @@ export { Mapper } from "../mapper";
 
 // Base implementations
 export * from "./base-repository";
-export { InMemoryRepository } from "./in-memory-repository";
 
 // Unit of Work
-export {
-  UnitOfWork,
-  BaseTransactionContext,
-  InMemoryUnitOfWork,
-} from "./unit-of-work";
+export { UnitOfWork, BaseTransactionContext } from "./unit-of-work";

package/src/repository/unit-of-work.ts

@@ -66,9 +66,7 @@ export abstract class UnitOfWork implements IUnitOfWork {
   /**
    * Get repository instance (cached per transaction)
    */
-  getRepository<TRepo>(
-    RepositoryClass: new (...args: any[]) => TRepo
-  ): TRepo {
+  getRepository<TRepo>(RepositoryClass: new (...args: any[]) => TRepo): TRepo {
     const key = RepositoryClass.name;
 
     if (this.repositoryCache.has(key)) {
@@ -105,44 +103,3 @@ export abstract class BaseTransactionContext implements TransactionContext {
     this._isActive = false;
   }
 }
-
-/**
- * In-Memory Unit of Work (for testing)
- */
-export class InMemoryUnitOfWork extends UnitOfWork {
-  private committed = false;
-  private rolledBack = false;
-
-  async begin(): Promise<TransactionContext> {
-    this.currentContext = new InMemoryTransactionContext();
-    this.committed = false;
-    this.rolledBack = false;
-    return this.currentContext;
-  }
-
-  protected createRepository<TRepo>(
-    RepositoryClass: new (...args: any[]) => TRepo
-  ): TRepo {
-    // For in-memory, just create a new instance
-    // In real implementation, pass transaction client
-    return new RepositoryClass();
-  }
-
-  isCommitted(): boolean {
-    return this.committed;
-  }
-
-  isRolledBack(): boolean {
-    return this.rolledBack;
-  }
-}
-
-class InMemoryTransactionContext extends BaseTransactionContext {
-  async commit(): Promise<void> {
-    this.markInactive();
-  }
-
-  async rollback(): Promise<void> {
-    this.markInactive();
-  }
-}

package/src/types/criteria.ts

@@ -61,6 +61,11 @@ export interface Pagination {
   offset: number;
 }
 
+export interface Search<T> {
+  fields: FieldPath<T>[];
+  value: string;
+}
+
 export interface PaginationMeta {
   page: number;
   limit: number;

package/src/types/domain-event.ts

@@ -0,0 +1,38 @@
+/**
+ * Interface for all domain events
+ */
+export interface IDomainEvent {
+  /**
+   * Unique identifier for this event occurrence
+   */
+  readonly eventId: string;
+
+  /**
+   * When the event occurred
+   */
+  readonly occurredOn: Date;
+
+  /**
+   * Name/type of the event (e.g., "UserCreated", "OrderPlaced")
+   */
+  readonly eventName: string;
+
+  /**
+   * ID of the aggregate that raised this event
+   */
+  readonly aggregateId: string;
+}
+
+/**
+ * Event handler function type
+ */
+export type DomainEventHandler<T extends IDomainEvent = IDomainEvent> = (
+  event: T
+) => void | Promise<void>;
+
+/**
+ * Event handler class type
+ */
+export interface IDomainEventHandler<T extends IDomainEvent = IDomainEvent> {
+  handle(event: T): void | Promise<void>;
+}

package/src/types/domain.ts

@@ -1,5 +1,6 @@
-import { StandardSchema, ValidationConfig } from "..";
+import { ValidationConfig } from "..";
 import { Id } from "../id";
+import { StandardSchema } from "./standard-schema";
 
 export type EntityId = string | number;
 
@@ -15,12 +16,10 @@ interface DomainValidation<T> {
 export type EntityValidation<T> = DomainValidation<T>;
 export type VOValidation<T> = DomainValidation<T>;
 
-
 export interface VOHooks<T, E> {
   onBeforeUpdate?: (entity: E, snapshot: T) => boolean;
   onCreate?: (entity: E) => void;
   rules?: (entity: E) => void;
-  defaultValues?: Partial<T>;
 }
 
 // Specialized hooks for entities (with BaseProps)

package/src/types/history-tracker.ts

@@ -1,4 +1,4 @@
-import { BaseProps } from "..";
+import { BaseProps } from "./domain";
 import { IsArray, NonUndefined, UnwrapArray } from "./utils";
 
 export interface ChangeEvent<T> {

package/src/types/index.ts

@@ -4,3 +4,4 @@ export * from "./history-tracker";
 export * from "./standard-schema";
 export * from "./utils";
 export * from "./unit-of-work";
+export * from "./domain-event";

package/src/validation-error.ts

@@ -1,97 +1,97 @@
-// ============================================================================
-// Validation Error - Domain Validation Errors
-// ============================================================================
-
-export interface ValidationIssue {
-  path: string[];
-  message: string;
-}
-
-export class ValidationError extends Error {
-  public readonly issues: ValidationIssue[];
-  public readonly __isValidationError = true; // Brand for identification
-
-  constructor(issues: ValidationIssue[], message?: string) {
-    const errorMessage =
-      message || `Validation failed: ${issues.map(i => i.message).join(', ')}`;
-    super(errorMessage);
-    this.name = 'ValidationError';
-    this.issues = issues;
-
-    // Maintain proper stack trace
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, ValidationError);
-    }
-  }
-
-  /**
-   * Check if an error is a ValidationError (works across module boundaries)
-   */
-  static isValidationError(error: unknown): error is ValidationError {
-    if (error instanceof ValidationError) {
-      return true;
-    }
-    // Check by duck typing for cross-module compatibility
-    return (
-      error instanceof Error &&
-      error.name === 'ValidationError' &&
-      'issues' in error &&
-      Array.isArray((error as any).issues)
-    );
-  }
-
-  /**
-   * Get all error messages as a simple array
-   */
-  getMessages(): string[] {
-    return this.issues.map(i => i.message);
-  }
-
-  /**
-   * Get errors for a specific field path
-   */
-  getErrorsForPath(path: string): ValidationIssue[] {
-    return this.issues.filter(i => i.path.join('.') === path);
-  }
-
-  /**
-   * Check if a specific path has errors
-   */
-  hasErrorsForPath(path: string): boolean {
-    return this.getErrorsForPath(path).length > 0;
-  }
-
-  /**
-   * Convert to a plain object for serialization
-   */
-  toJSON(): { name: string; message: string; issues: ValidationIssue[] } {
-    return {
-      name: this.name,
-      message: this.message,
-      issues: this.issues,
-    };
-  }
-}
-
-/**
- * Helper to create a single validation issue
- */
-export function createValidationIssue(
-  path: string | string[],
-  message: string
-): ValidationIssue {
-  return {
-    path: Array.isArray(path) ? path : path.split('.'),
-    message,
-  };
-}
-
-/**
- * Helper to throw a validation error with a single issue
- */
-export function throwValidationError(
-  path: string | string[],
-  message: string
-): never {
-  throw new ValidationError([createValidationIssue(path, message)]);
-}
+// ============================================================================
+// Validation Error - Domain Validation Errors
+// ============================================================================
+
+export interface ValidationIssue {
+  path: string[];
+  message: string;
+}
+
+export class ValidationError extends Error {
+  public readonly issues: ValidationIssue[];
+  public readonly __isValidationError = true; // Brand for identification
+
+  constructor(issues: ValidationIssue[], message?: string) {
+    const errorMessage =
+      message || `Validation failed: ${issues.map(i => i.message).join(', ')}`;
+    super(errorMessage);
+    this.name = 'ValidationError';
+    this.issues = issues;
+
+    // Maintain proper stack trace
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, ValidationError);
+    }
+  }
+
+  /**
+   * Check if an error is a ValidationError (works across module boundaries)
+   */
+  static isValidationError(error: unknown): error is ValidationError {
+    if (error instanceof ValidationError) {
+      return true;
+    }
+    // Check by duck typing for cross-module compatibility
+    return (
+      error instanceof Error &&
+      error.name === 'ValidationError' &&
+      'issues' in error &&
+      Array.isArray((error as any).issues)
+    );
+  }
+
+  /**
+   * Get all error messages as a simple array
+   */
+  getMessages(): string[] {
+    return this.issues.map(i => i.message);
+  }
+
+  /**
+   * Get errors for a specific field path
+   */
+  getErrorsForPath(path: string): ValidationIssue[] {
+    return this.issues.filter(i => i.path.join('.') === path);
+  }
+
+  /**
+   * Check if a specific path has errors
+   */
+  hasErrorsForPath(path: string): boolean {
+    return this.getErrorsForPath(path).length > 0;
+  }
+
+  /**
+   * Convert to a plain object for serialization
+   */
+  toJSON(): { name: string; message: string; issues: ValidationIssue[] } {
+    return {
+      name: this.name,
+      message: this.message,
+      issues: this.issues,
+    };
+  }
+}
+
+/**
+ * Helper to create a single validation issue
+ */
+export function createValidationIssue(
+  path: string | string[],
+  message: string
+): ValidationIssue {
+  return {
+    path: Array.isArray(path) ? path : path.split('.'),
+    message,
+  };
+}
+
+/**
+ * Helper to throw a validation error with a single issue
+ */
+export function throwValidationError(
+  path: string | string[],
+  message: string
+): never {
+  throw new ValidationError([createValidationIssue(path, message)]);
+}

package/src/value-object.ts

@@ -3,7 +3,7 @@
 // ============================================================================
 
 import { ValidationError } from "./validation-error";
-import { IDomainEvent } from "./domain-event";
+import { IDomainEvent } from ".";
 import {
   VOHooks,
   ValidationConfig,
@@ -11,6 +11,7 @@ import {
   EntityValidation,
 } from "./types";
 import { DEFAULT_VALIDATION_CONFIG } from "./constants";
+import { DomainError } from "./exceptions";
 
 // Helper to get static properties from constructor
 function getStaticProperty<T>(
@@ -50,11 +51,7 @@ export abstract class ValueObject<T> {
       ...validation?.config,
     };
 
-    // Apply defaultValues
     let finalProps = { ...props } as T;
-    if (hooks?.defaultValues) {
-      finalProps = { ...hooks.defaultValues, ...props } as T;
-    }
 
     // Validate schema on creation
     if (this.domainSchema && this.validationConfig.onCreate) {
@@ -84,7 +81,7 @@ export abstract class ValueObject<T> {
     const result = this.domainSchema["~standard"].validate(props);
 
     if (result instanceof Promise) {
-      throw new Error(
+      throw new DomainError(
         "Async validation not supported in constructor. Use sync validation schema."
       );
     }