@woltz/rich-domain 1.3.0 → 1.3.2

package/src/paginated-result.ts

@@ -1,238 +0,0 @@
-import { Id } from "./id";
-import type { Criteria } from "./criteria";
-import type { Pagination, PaginationMeta, Filter } from "./types";
-
-/**
- * Infers the JSON result type from T
- * - If T has toJSON(), returns its return type
- * - Otherwise returns T as-is
- */
-type InferJsonResult<T> = T extends { toJSON(): infer R } ? R : T;
-
-/**
- * Type for the serialized result of PaginatedResult.toJSON()
- */
-export type PaginatedJsonResult<T> = {
-  data: InferJsonResult<T>[];
-  meta: PaginationMeta;
-};
-
-export class PaginatedResult<T> {
-  constructor(
-    public readonly data: T[],
-    public readonly meta: PaginationMeta
-  ) {}
-
-  /**
-   * Creates a PaginatedResult with calculated metadata
-   */
-  static create<T>(
-    data: T[],
-    pagination: Pagination,
-    total: number
-  ): PaginatedResult<T> {
-    const meta = this.createMeta(pagination, total);
-    return new PaginatedResult(data, meta);
-  }
-
-  /**
-   * Creates pagination metadata from total count
-   */
-  static createMeta(pagination: Pagination, total: number): PaginationMeta {
-    const totalPages = Math.ceil(total / pagination.limit);
-
-    return {
-      page: pagination.page,
-      limit: pagination.limit,
-      total,
-      totalPages,
-      hasNext: pagination.page < totalPages,
-      hasPrevious: pagination.page > 1,
-    };
-  }
-
-  /**
-   * Applies criteria to an in-memory array (useful for testing)
-   */
-  static fromArray<T>(items: T[], criteria: Criteria<T>): PaginatedResult<T> {
-    let result = [...items];
-    let total = result.length;
-
-    for (const filter of criteria.getFilters()) {
-      result = result.filter((item) => applyFilter(item, filter));
-      total = result.length;
-    }
-
-    for (const order of criteria.getOrders().reverse()) {
-      result.sort((a, b) => {
-        const aVal = getNestedValue(a, order.field);
-        const bVal = getNestedValue(b, order.field);
-
-        let comparison = 0;
-        if (aVal < bVal) comparison = -1;
-        if (aVal > bVal) comparison = 1;
-
-        return order.direction === "desc" ? -comparison : comparison;
-      });
-    }
-
-    const pagination = criteria.getPagination();
-    result = result.slice(
-      pagination.offset,
-      pagination.offset + pagination.limit
-    );
-    return PaginatedResult.create(result, pagination, total);
-  }
-
-  /**
-   * Converts the result to JSON, deeply serializing all entities/aggregates/value objects
-   * - Entities/Aggregates → calls toJSON() recursively
-   * - Value Objects → calls toJSON()
-   * - Id → converts to string
-   * - Arrays → maps recursively
-   * - Plain objects → serializes properties recursively
-   * - Primitives → returns as-is
-   */
-  toJSON(): PaginatedJsonResult<T> {
-    return {
-      data: this.data.map((item) =>
-        this.deepSerialize(item)
-      ) as InferJsonResult<T>[],
-      meta: this.meta,
-    };
-  }
-
-  /**
-   * Deep serialization logic (similar to BaseEntity.deepToJson)
-   */
-  private deepSerialize(obj: any): any {
-    if (obj === null || obj === undefined) return obj;
-
-    if (obj instanceof Id) return obj.value;
-
-    if (Array.isArray(obj)) {
-      return obj.map((item) => this.deepSerialize(item));
-    }
-
-    if (obj && typeof obj.toJSON === "function") {
-      return obj.toJSON();
-    }
-
-    if (typeof obj === "object") {
-      const result: any = {};
-      for (const key in obj) {
-        if (obj.hasOwnProperty(key)) {
-          result[key] = this.deepSerialize(obj[key]);
-        }
-      }
-      return result;
-    }
-
-    return obj;
-  }
-
-  /**
-   * Transform each item in the result using a mapper function
-   */
-  map<U>(fn: (item: T) => U): PaginatedResult<U> {
-    return new PaginatedResult(this.data.map(fn), this.meta);
-  }
-
-  /**
-   * Check if result has no data
-   */
-  get isEmpty(): boolean {
-    return this.data.length === 0;
-  }
-
-  /**
-   * Check if there are more pages available
-   */
-  get hasMore(): boolean {
-    return this.meta.hasNext;
-  }
-}
-
-function applyFilter<T>(item: T, filter: Filter): boolean {
-  const value = getNestedValue(item, filter.field);
-
-  const isValueDate = value instanceof Date;
-
-  const parseValue = (v: any) => {
-    if (isValueDate && typeof v === "string") return new Date(v);
-    if (isValueDate && typeof v === "number") return new Date(v);
-    return v;
-  };
-
-  switch (filter.operator) {
-    case "equals":
-      return value === filter.value;
-
-    case "notEquals":
-      return value !== filter.value;
-
-    case "greaterThan": {
-      const compareTo = parseValue(filter.value);
-      return isValueDate ? value > compareTo : value > (filter.value as any);
-    }
-
-    case "greaterThanOrEqual": {
-      const compareTo = parseValue(filter.value);
-      return isValueDate ? value >= compareTo : value >= (filter.value as any);
-    }
-
-    case "lessThan":
-      const lt = parseValue(filter.value);
-      return isValueDate ? value < lt : value < (filter.value as any);
-
-    case "lessThanOrEqual":
-      const lte = parseValue(filter.value);
-      return isValueDate ? value <= lte : value <= (filter.value as any);
-
-    case "contains":
-      return String(value)
-        .toLowerCase()
-        .includes(String(filter.value).toLowerCase());
-
-    case "startsWith":
-      return String(value)
-        .toLowerCase()
-        .startsWith(String(filter.value).toLowerCase());
-
-    case "endsWith":
-      return String(value)
-        .toLowerCase()
-        .endsWith(String(filter.value).toLowerCase());
-
-    case "in":
-      return Array.isArray(filter.value) && filter.value.includes(value);
-
-    case "notIn":
-      return Array.isArray(filter.value) && !filter.value.includes(value);
-
-    case "between":
-      if (Array.isArray(filter.value) && filter.value.length === 2) {
-        const [min, max] = filter.value.map(parseValue);
-        return isValueDate
-          ? value >= min && value <= max
-          : value >= filter.value[0] && value <= filter.value[1];
-      }
-      return false;
-
-    case "isNull":
-      return value === null || value === undefined;
-
-    case "isNotNull":
-      return value !== null && value !== undefined;
-
-    default:
-      return true;
-  }
-}
-
-function getNestedValue(obj: any, path: string): any {
-  return path.split(".").reduce((current, key) => {
-    if (current === null || current === undefined) return undefined;
-    return current[key];
-  }, obj);
-}

package/src/repository/base-repository.ts

@@ -1,33 +0,0 @@
-import type { Aggregate } from "../entity";
-import type { Criteria } from "../criteria";
-import { PaginatedResult } from "../paginated-result";
-import { Mapper } from "../mapper";
-
-export abstract class ReadRepository<Agg extends Aggregate<any>> {
-  abstract find(criteria?: Criteria<Agg>): Promise<PaginatedResult<Agg>>;
-  abstract findById(id: string): Promise<Agg | null>;
-  abstract count(criteria?: Criteria<Agg>): Promise<number>;
-  abstract exists(id: string): Promise<boolean>;
-}
-
-export abstract class WriteRepository<Agg extends Aggregate<any>> {
-  abstract save(entity: Agg): Promise<void>;
-  abstract delete(entity: Agg): Promise<void>;
-}
-
-export abstract class WriteAndRead<Agg extends Aggregate<any>> {
-  abstract find(criteria?: Criteria<Agg>): Promise<PaginatedResult<Agg>>;
-  abstract findById(id: string): Promise<Agg | null>;
-  abstract save(entity: Agg): Promise<void>;
-  abstract delete(entity: Agg): Promise<void>;
-  abstract count(criteria?: Criteria<Agg>): Promise<number>;
-  abstract exists(id: string): Promise<boolean>;
-}
-
-export abstract class Repository<
-  TDomain extends Aggregate<any>
-> extends WriteAndRead<TDomain> {
-  protected abstract readonly mapperToDomain: Mapper<unknown, TDomain>;
-  protected abstract readonly mapperToPersistence: Mapper<TDomain, unknown>;
-  protected abstract get model(): any;
-}

package/src/repository/index.ts

@@ -1,3 +0,0 @@
-export { Mapper } from "../mapper";
-export * from "./base-repository";
-export { UnitOfWork, BaseTransactionContext } from "./unit-of-work";

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

@@ -1,76 +0,0 @@
-import type { IUnitOfWork, TransactionContext } from "../types";
-
-/**
- * Abstract Unit of Work
- * Provides transaction management across multiple repositories
- */
-export abstract class UnitOfWork implements IUnitOfWork {
-  protected currentContext: TransactionContext | null = null;
-  protected repositoryCache: Map<string, any> = new Map();
-
-  abstract begin(): Promise<TransactionContext>;
-
-  /**
-   * Execute work within a transaction
-   * Auto-commits on success, rolls back on error
-   */
-  async transaction<T>(
-    work: (ctx: TransactionContext) => Promise<T>
-  ): Promise<T> {
-    const ctx = await this.begin();
-
-    try {
-      const result = await work(ctx);
-      await ctx.commit();
-      return result;
-    } catch (error) {
-      if (ctx.isActive()) {
-        await ctx.rollback();
-      }
-      throw error;
-    } finally {
-      this.currentContext = null;
-      this.repositoryCache.clear();
-    }
-  }
-
-  /**
-   * Get repository instance (cached per transaction)
-   */
-  getRepository<TRepo>(RepositoryClass: new (...args: any[]) => TRepo): TRepo {
-    const key = RepositoryClass.name;
-
-    if (this.repositoryCache.has(key)) {
-      return this.repositoryCache.get(key);
-    }
-
-    const repo = this.createRepository(RepositoryClass);
-    this.repositoryCache.set(key, repo);
-    return repo;
-  }
-
-  /**
-   * Create repository instance - implement in subclass
-   */
-  protected abstract createRepository<TRepo>(
-    RepositoryClass: new (...args: any[]) => TRepo
-  ): TRepo;
-}
-
-/**
- * Base Transaction Context
- */
-export abstract class BaseTransactionContext implements TransactionContext {
-  protected _isActive = true;
-
-  abstract commit(): Promise<void>;
-  abstract rollback(): Promise<void>;
-
-  isActive(): boolean {
-    return this._isActive;
-  }
-
-  protected markInactive(): void {
-    this._isActive = false;
-  }
-}

package/src/types/change-tracker.ts

@@ -1,264 +0,0 @@
-import { Entity } from "../entity";
-import { ValueObject } from "../value-object";
-
-/**
- * Base operation with common information.
- */
-export interface BaseOperation {
-  /** Entity name in the domain (e.g., 'User', 'Post', 'Comment') */
-  entity: string;
-  /** Depth in the aggregate tree (0 = root, 1 = direct children, etc.) */
-  depth: number;
-  /** Name of the relation field in the parent entity (e.g., 'tags', 'comments') */
-  relationField?: string;
-}
-
-/**
- * Create operation.
- */
-export interface CreateOperation<T = any> extends BaseOperation {
-  type: "create";
-  /** Entity data to be created */
-  data: T;
-  /** Parent ID (for FK) */
-  parentId?: string;
-  /** Parent entity name */
-  parentEntity?: string;
-}
-
-/**
- * Update operation.
- */
-export interface UpdateOperation<T = any> extends BaseOperation {
-  type: "update";
-  /** Entity ID */
-  id: string;
-  /** Current entity instance */
-  data: T;
-  /** Only fields that have changed */
-  changedFields: Record<string, any>;
-}
-
-/**
- * Delete operation.
- */
-export interface DeleteOperation<T = any> extends BaseOperation {
-  type: "delete";
-  /** Entity ID to be deleted */
-  id: string;
-  /** Entity data (for reference) */
-  data: T;
-  /** Parent entity name */
-  parentEntity?: string;
-  /** Parent ID */
-  parentId?: string;
-}
-
-/**
- * Union of all possible operations.
- */
-export type Operation<T = any> =
-  | CreateOperation<T>
-  | UpdateOperation<T>
-  | DeleteOperation<T>;
-
-/**
- * Item for batch creation.
- */
-export interface BatchCreateItem<T = any> {
-  /** Entity data */
-  data: T;
-  /** Parent ID (for FK) */
-  parentId?: string;
-  /** Parent entity name */
-  parentEntity?: string;
-  /** Relation field name */
-  relationField?: string;
-}
-
-/**
- * Item for batch update.
- */
-export interface BatchUpdateItem {
-  /** Entity ID */
-  id: string;
-  /** Fields that have changed */
-  changedFields: Record<string, any>;
-}
-
-/**
- * Item for batch delete.
- */
-export interface BatchDeleteItem {
-  /** Entity ID */
-  id: string;
-  /** Relation field name */
-  relationField?: string;
-}
-
-/**
- * Grouped and ordered operations for batch execution.
- */
-export interface BatchOperations {
-  /**
-   * Deletes grouped by entity, ordered by depth descending (leaf → root).
-   */
-  deletes: Array<{
-    entity: string;
-    depth: number;
-    ids: string[];
-    parentId?: string;
-    /** Relation field name (for determining owned vs reference) */
-    relationField?: string;
-    /** Parent entity name */
-    parentEntity?: string;
-    /** Individual items with their relation fields (when mixed) */
-    items?: BatchDeleteItem[];
-  }>;
-
-  /**
-   * Creates grouped by entity, ordered by depth ascending (root → leaf).
-   */
-  creates: Array<{
-    entity: string;
-    depth: number;
-    items: BatchCreateItem[];
-    /** Relation field name (for determining owned vs reference) */
-    relationField?: string;
-    /** Parent entity name */
-    parentEntity?: string;
-  }>;
-
-  /**
-   * Updates grouped by entity.
-   */
-  updates: Array<{
-    entity: string;
-    items: BatchUpdateItem[];
-  }>;
-}
-
-/**
- * Changes detected in a collection (1:N).
- */
-export interface CollectionChanges<T = any> {
-  /** Created items */
-  created: T[];
-  /** Updated items with their changes */
-  updated: Array<{
-    entity: T;
-    changes: Record<string, { from: any; to: any }>;
-  }>;
-  /** Deleted items */
-  deleted: T[];
-}
-
-/**
- * Possible states for a 1:1 relationship.
- */
-export type EntityChangeState =
-  | "created" // null → Entity
-  | "updated" // Entity(id:1) → Entity(id:1) with changes
-  | "deleted" // Entity → null
-  | "replaced" // Entity(id:1) → Entity(id:2)
-  | "unchanged"; // No changes
-
-/**
- * Change in a 1:1 entity relationship.
- */
-export interface EntityChange<T = any> {
-  /** State of the change */
-  state: EntityChangeState;
-  /** Current entity (null if deleted) */
-  current: T | null;
-  /** Previous entity (null if created) */
-  previous: T | null;
-  /** Field changes (if state === 'updated') */
-  changes?: Record<string, { from: any; to: any }>;
-}
-
-/**
- * Change in a primitive field.
- */
-export interface FieldChange<T = any> {
-  from: T;
-  to: T;
-}
-
-/**
- * Extracts the props type from an Entity or ValueObject.
- */
-export type ExtractProps<T> = T extends Entity<infer P>
-  ? P
-  : T extends ValueObject<infer P>
-  ? P
-  : never;
-
-/**
- * Keys of primitive properties (not Entity, ValueObject or Array).
- */
-export type PrimitiveKeys<T> = {
-  [K in keyof T]: T[K] extends
-    | Entity<any>
-    | ValueObject<any>
-    | Array<any>
-    | undefined
-    ? never
-    : K;
-}[keyof T];
-
-/**
- * Keys of collections (arrays).
- */
-export type CollectionKeys<T> = {
-  [K in keyof T]: T[K] extends Array<any> ? K : never;
-}[keyof T];
-
-/**
- * Keys of single entities (1:1).
- */
-export type SingleEntityKeys<T> = {
-  [K in keyof T]: T[K] extends Entity<any> | ValueObject<any> | null | undefined
-    ? T[K] extends Array<any>
-      ? never
-      : K
-    : never;
-}[keyof T];
-
-/**
- * Change history entry.
- */
-export interface HistoryEntry {
-  path: string;
-  previousValue: any;
-  currentValue: any;
-  timestamp: number;
-}
-
-/**
- * Metadata from a tracked entity/VO.
- */
-export interface TrackedEntityMetadata {
-  /** Entity name */
-  entityName: string;
-  /** Depth in the tree */
-  depth: number;
-  /** Parent ID */
-  parentId?: string;
-  /** Parent entity name */
-  parentEntity?: string;
-  /** Path in the object (e.g., 'posts[0].comments[1]') */
-  path: string;
-}
-
-export interface TrackedItem {
-  entity: any;
-  metadata: TrackedEntityMetadata;
-  originalState: any;
-}
-
-export interface ArrayState {
-  cloned: any[];
-  original: any[];
-  metadata: TrackedEntityMetadata;
-}