@woltz/rich-domain 1.0.0 → 1.2.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,34 @@ export * from "./paginated-result";
 export * from "./repository";
 
 // Types
-export * from "./types";
-
-export * from "./constants";
-
-// Internal (for advanced usage)
-export { DeepProxy } from "./deep-proxy";
+export {
+  DomainEventHandler,
+  EntityHooks,
+  Filter,
+  EntityValidation,
+  IDomainEvent,
+  VOValidation,
+  VOHooks,
+  ValidationConfig,
+  Primitive,
+  TransactionContext,
+  PaginationMeta,
+  Pagination,
+  OrderDirection,
+  Order,
+  IUnitOfWork,
+  IDomainEventHandler,
+  EntityId,
+  FieldPath,
+  FilterOperator,
+  Search,
+  FilterValueFor,
+  PathValue,
+  OperatorsForType,
+  DateOperators,
+  NumberOperators,
+  StringOperators,
+  BooleanOperators,
+  ArrayOperators,
+  CriteriaOptions,
+} from "./types";

package/src/paginated-result.ts

@@ -64,14 +64,26 @@ export class PaginatedResult<T> {
    */
   static fromArray<T>(items: T[], criteria: Criteria<T>): PaginatedResult<T> {
     let result = [...items];
+    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.trim().toLowerCase());
+        });
+      });
+      total = result.length;
+    }
 
     // Apply filters
     for (const filter of criteria.getFilters()) {
       result = result.filter((item) => applyFilter(item, filter));
+      total = result.length;
     }
 
-    const total = result.length;
-
     // Apply ordering
     for (const order of criteria.getOrders().reverse()) {
       result.sort((a, b) => {
@@ -88,7 +100,7 @@ export class PaginatedResult<T> {
 
     // Apply pagination
     const pagination = criteria.getPagination();
-    if (pagination) {
+    if (pagination && !criteria.hasSearch()) {
       result = result.slice(
         pagination.offset,
         pagination.offset + pagination.limit

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

@@ -17,12 +17,65 @@ export const FILTER_OPERATORS = [
   "isNotNull",
 ] as const;
 
+export type FilterOperator = (typeof FILTER_OPERATORS)[number];
+
+export type StringOperators =
+  | "equals"
+  | "notEquals"
+  | "contains"
+  | "startsWith"
+  | "endsWith"
+  | "in"
+  | "notIn"
+  | "isNull"
+  | "isNotNull";
+
+export type NumberOperators =
+  | "equals"
+  | "notEquals"
+  | "greaterThan"
+  | "greaterThanOrEqual"
+  | "lessThan"
+  | "lessThanOrEqual"
+  | "in"
+  | "notIn"
+  | "between"
+  | "isNull"
+  | "isNotNull";
+
+export type DateOperators =
+  | "equals"
+  | "notEquals"
+  | "greaterThan"
+  | "greaterThanOrEqual"
+  | "lessThan"
+  | "lessThanOrEqual"
+  | "in"
+  | "notIn"
+  | "between"
+  | "isNull"
+  | "isNotNull";
+
+export type BooleanOperators = "equals" | "notEquals" | "isNull" | "isNotNull";
+
+export type ArrayOperators = "in" | "notIn" | "isNull" | "isNotNull";
+
+export type OperatorsForType<T> = T extends string
+  ? StringOperators
+  : T extends number
+  ? NumberOperators
+  : T extends Date
+  ? DateOperators
+  : T extends boolean
+  ? BooleanOperators
+  : T extends Array<any>
+  ? ArrayOperators
+  : FilterOperator;
+
 export type FilterValueFor<T> =
-  | T // equals, notEquals
-  | (T extends number | Date
-      ? [T, T] // between
-      : never)
-  | T[] // in, notIn
+  | T
+  | (T extends number | Date ? [T, T] : never)
+  | T[]
   | null;
 
 export type PathValue<
@@ -30,24 +83,34 @@ export type PathValue<
   P extends string
 > = P extends `${infer K}.${infer Rest}`
   ? K extends keyof T
-    ? PathValue<T[K], Rest>
+    ? T[K] extends Array<infer U>
+      ? PathValue<U, Rest>
+      : PathValue<T[K], Rest>
     : never
   : P extends keyof T
   ? T[P]
   : never;
 
-export type FilterOperator = (typeof FILTER_OPERATORS)[number];
-
 export interface Filter<TField = string, TValue = unknown> {
   field: TField;
-  operator: FilterOperator;
+  operator: unknown extends TValue ? FilterOperator : OperatorsForType<TValue>;
   value: TValue;
+  options?: CriteriaOptions;
 }
 
 export type TypedFilter<T> = {
-  [K in FieldPath<T>]: Filter<K, FilterValueFor<PathValue<T, K>>>;
+  [K in FieldPath<T>]: {
+    field: K;
+    operator: OperatorsForType<NonNullable<PathValue<T, K>>>;
+    value: FilterValueFor<NonNullable<PathValue<T, K>>>;
+    options?: CriteriaOptions;
+  };
 }[FieldPath<T>];
 
+export type CriteriaAdapter<Input, Output> = {
+  [K in FieldPath<Input>]?: FieldPath<Output>;
+};
+
 export type OrderDirection = "asc" | "desc";
 
 export interface Order {
@@ -61,6 +124,11 @@ export interface Pagination {
   offset: number;
 }
 
+export interface Search<T> {
+  fields: FieldPath<T>[];
+  value: string;
+}
+
 export interface PaginationMeta {
   page: number;
   limit: number;
@@ -70,10 +138,20 @@ export interface PaginationMeta {
   hasPrevious: boolean;
 }
 
-export type FieldPath<T> = {
-  [K in keyof T & string]: T[K] extends Primitive
-    ? K
-    : T[K] extends Array<infer U>
-    ? K | `${K}.${FieldPath<U>}`
-    : K | `${K}.${FieldPath<T[K]>}`;
-}[keyof T & string];
+export interface CriteriaOptions {
+  quantifier?: "some" | "every" | "none";
+}
+
+type ExcludeBuiltInKeys<T> = Exclude<keyof T, keyof any[] | number | symbol>;
+
+export type FieldPath<T> = T extends Primitive
+  ? never
+  : {
+      [K in ExcludeBuiltInKeys<T> & string]: NonNullable<T[K]> extends Primitive
+        ? K
+        : NonNullable<T[K]> extends Array<infer U>
+        ? U extends Primitive
+          ? K
+          : K | `${K}.${FieldPath<U>}`
+        : K | `${K}.${FieldPath<NonNullable<T[K]>>}`;
+    }[ExcludeBuiltInKeys<T> & string];

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";