@woltz/rich-domain 0.2.2 → 1.1.0

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

@@ -6,49 +6,7 @@
 export { Mapper } from "../mapper";
 
 // Base implementations
-export { Repository as BaseRepository } from "./base-repository";
-export { InMemoryRepository } from "./in-memory-repository";
+export * from "./base-repository";
 
 // Unit of Work
-export {
-  UnitOfWork,
-  BaseTransactionContext,
-  InMemoryUnitOfWork,
-} from "./unit-of-work";
-
-/**
- * QUICK START:
- *
- * 1. For Testing:
- * ```ts
- * import { InMemoryRepository } from 'rich-domain';
- *
- * const userRepo = new InMemoryRepository<User>();
- * await userRepo.save(user);
- * const found = await userRepo.findById(user.id);
- * ```
- *
- * 2. For Production (Prisma, TypeORM, etc):
- * - Extend BaseRepository
- * - Implement abstract methods
- * - Create a Mapper
- * - See examples/ folder for reference
- *
- * 3. With Criteria:
- * ```ts
- * const result = await userRepo.find(
- *   Criteria.create<User>()
- *     .whereEquals('status', 'active')
- *     .orderByDesc('createdAt')
- *     .paginate(1, 10)
- * );
- * ```
- *
- * 4. With Unit of Work:
- * ```ts
- * await uow.transaction(async (ctx) => {
- *   const userRepo = uow.getRepository(UserRepository);
- *   await userRepo.save(user);
- * });
- * ```
- */
+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

@@ -1,6 +1,6 @@
 import { Primitive } from "./utils";
 
-export const FilterOperator = [
+export const FILTER_OPERATORS = [
   "equals",
   "notEquals",
   "greaterThan",
@@ -36,7 +36,7 @@ export type PathValue<
   ? T[P]
   : never;
 
-export type FilterOperator = (typeof FilterOperator)[number];
+export type FilterOperator = (typeof FILTER_OPERATORS)[number];
 
 export interface Filter<TField = string, TValue = unknown> {
   field: TField;
@@ -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."
       );
     }

package/tests/criteria.test.ts

@@ -113,6 +113,14 @@ describe("Criteria", () => {
       expect(result.data.every((u) => u.status === "inactive")).toBe(true);
     });
 
+    it("should filter by search", () => {
+      const criteria = Criteria.create<TestUser>().search(["name"], "Bob");
+
+      const result = PaginatedResult.fromArray(testUsers, criteria);
+      expect(result.data).toHaveLength(1);
+      expect(result.data[0].name).toBe("Bob");
+    });
+
     it("should filter by greaterThan", () => {
       const criteria = Criteria.create<TestUser>().where(
         "age",