@woltz/rich-domain 1.2.1 → 1.2.4

package/src/entity-schema-registry.ts

@@ -8,17 +8,14 @@ import { Id } from "./id";
 export interface EntitySchema {
   /** Entity name in the domain (e.g., 'User', 'Post') */
   entity: string;
-
   /** Table name in the database (e.g., 'users', 'blog_posts') */
   table: string;
-
   /**
    * Field mapping: domain → database.
    * Only include fields with different names.
    * @example { email: 'user_email', createdAt: 'created_at' }
    */
   fields?: Record<string, string>;
-
   /**
    * FK configuration for parent relation.
    */
@@ -148,15 +145,11 @@ export class EntitySchemaRegistry {
   mapFields(entity: string, data: Record<string, any>): MappedEntityData {
     const fields = this.getFieldsMap(entity);
     const result: MappedEntityData = {};
-
     for (const [key, value] of Object.entries(data)) {
-      if (this.isEntityOrCollection(value)) {
-        continue;
-      }
+      if (this.isEntityOrCollection(value)) continue;
       const mappedKey = fields[key] ?? key;
       result[mappedKey] = this.normalizeValue(value);
     }
-
     return result;
   }
 
@@ -173,26 +166,18 @@ export class EntitySchemaRegistry {
   ): MappedEntityData {
     const fields = this.getFieldsMap(entity);
     const result: MappedEntityData = {};
-
-    // Map ID if it is an Entity or has entity-like structure
     const hasId = (domainEntity as any).id;
     if (hasId) {
-      // Extract id value
       const idValue = hasId.value ?? hasId;
       result["id"] = idValue;
     }
-
-    // Get props
     const props = (domainEntity as any).props || domainEntity;
-
     for (const [key, value] of Object.entries(props)) {
-      if (key === "id") continue; // ID already mapped
+      if (key === "id") continue;
       if (this.isEntityOrCollection(value)) continue;
-
       const mappedKey = fields[key] ?? key;
       result[mappedKey] = this.normalizeValue(value);
     }
-
     return result;
   }
 
@@ -206,7 +191,6 @@ export class EntitySchemaRegistry {
   getParentFk(entity: string, parentId: string): Record<string, string> | null {
     const schema = this.getSchema(entity);
     if (!schema.parentFk) return null;
-
     return { [schema.parentFk.field]: parentId };
   }
 
@@ -250,12 +234,9 @@ export class EntitySchemaRegistry {
     if (Array.isArray(value)) return true;
     if (value instanceof Entity) return true;
     if (value instanceof ValueObject) return true;
-
-    // Checks if it has the structure of an Entity (object with 'id' that has 'value')
     if (typeof value === 'object' && value.id && typeof value.id === 'object' && 'value' in value.id) {
       return true;
     }
-
     return false;
   }
 
@@ -267,7 +248,6 @@ export class EntitySchemaRegistry {
     if (value instanceof Id) return value.value;
     if (value instanceof Date) return value;
     if (typeof value === "object" && "value" in value) {
-      // Might be an ID or other wrapper
       return value.value;
     }
     return value;

package/src/entity.ts

@@ -1,16 +1,5 @@
-// ============================================================================
-// Entity & Aggregate Classes
-// ============================================================================
-
 import { BaseEntity } from "./base-entity";
 import { BaseProps } from "./types";
 
-/**
- * Entity - Has identity and lifecycle, but is not an aggregate root
- */
 export class Entity<T extends BaseProps> extends BaseEntity<T> {}
-
-/**
- * Aggregate - Aggregate root that manages a consistency boundary
- */
 export class Aggregate<T extends BaseProps> extends BaseEntity<T> {}

package/src/index.ts

@@ -1,29 +1,16 @@
-// ============================================================================
-// Rich Domain Library - Main Exports
-// ============================================================================
-
-// Core Classes
-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 * from "./validation-error";
-
-// Domain Events
 export * from "./domain-event";
 export * from "./domain-event-bus";
 export * from "./exceptions";
-
-// Criteria
 export * from "./criteria";
 export * from "./paginated-result";
-
-// Repository
 export * from "./repository";
-
-// Types
+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 {
   DomainEventHandler,
   EntityHooks,
@@ -41,7 +28,6 @@ export {
   Order,
   IUnitOfWork,
   IDomainEventHandler,
-  EntityId,
   FieldPath,
   FilterOperator,
   Search,
@@ -55,3 +41,12 @@ export {
   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/paginated-result.ts

@@ -2,10 +2,6 @@ import { Id } from "./id";
 import type { Criteria } from "./criteria";
 import type { Pagination, PaginationMeta, Filter } from "./types";
 
-// ============================================================================
-// Type Utilities
-// ============================================================================
-
 /**
  * Infers the JSON result type from T
  * - If T has toJson(), returns its return type
@@ -21,10 +17,6 @@ export type PaginatedJsonResult<T> = {
   meta: PaginationMeta;
 };
 
-// ============================================================================
-// PaginatedResult Class
-// ============================================================================
-
 export class PaginatedResult<T> {
   constructor(
     public readonly data: T[],
@@ -78,13 +70,11 @@ export class PaginatedResult<T> {
       total = result.length;
     }
 
-    // Apply filters
     for (const filter of criteria.getFilters()) {
       result = result.filter((item) => applyFilter(item, filter));
       total = result.length;
     }
 
-    // Apply ordering
     for (const order of criteria.getOrders().reverse()) {
       result.sort((a, b) => {
         const aVal = getNestedValue(a, order.field);
@@ -98,7 +88,6 @@ export class PaginatedResult<T> {
       });
     }
 
-    // Apply pagination
     const pagination = criteria.getPagination();
     if (pagination && !criteria.hasSearch()) {
       result = result.slice(
@@ -108,7 +97,6 @@ export class PaginatedResult<T> {
       return PaginatedResult.create(result, pagination, total);
     }
 
-    // No pagination - return all with default meta
     return PaginatedResult.create(
       result,
       { page: 1, limit: result.length, offset: 0 },
@@ -140,20 +128,16 @@ export class PaginatedResult<T> {
   private deepSerialize(obj: any): any {
     if (obj === null || obj === undefined) return obj;
 
-    // Id → string
     if (obj instanceof Id) return obj.value;
 
-    // Arrays → map recursively
     if (Array.isArray(obj)) {
       return obj.map((item) => this.deepSerialize(item));
     }
 
-    // Objects with toJson() method (Entity/Aggregate/ValueObject)
     if (obj && typeof obj.toJson === "function") {
       return obj.toJson();
     }
 
-    // Plain objects → serialize properties recursively
     if (typeof obj === "object") {
       const result: any = {};
       for (const key in obj) {
@@ -164,7 +148,6 @@ export class PaginatedResult<T> {
       return result;
     }
 
-    // Primitives
     return obj;
   }
 
@@ -190,10 +173,6 @@ export class PaginatedResult<T> {
   }
 }
 
-// ============================================================================
-// Helper Functions (moved from criteria.ts)
-// ============================================================================
-
 function applyFilter<T>(item: T, filter: Filter): boolean {
   const value = getNestedValue(item, filter.field);
 

package/src/repository/base-repository.ts

@@ -29,5 +29,5 @@ export abstract class Repository<
 > extends WriteAndRead<TDomain> {
   protected abstract readonly mapperToDomain: Mapper<unknown, TDomain>;
   protected abstract readonly mapperToPersistence: Mapper<TDomain, unknown>;
-  abstract get model(): any;
+  protected abstract get model(): any;
 }

package/src/repository/index.ts

@@ -1,12 +1,3 @@
-// ============================================================================
-// Repository Module - Clean exports
-// ============================================================================
-
-// Mapper
 export { Mapper } from "../mapper";
-
-// Base implementations
 export * from "./base-repository";
-
-// Unit of Work
 export { UnitOfWork, BaseTransactionContext } from "./unit-of-work";

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

@@ -1,7 +1,3 @@
-// ============================================================================
-// Unit of Work - Simple transaction management
-// ============================================================================
-
 import type { IUnitOfWork, TransactionContext } from "../types";
 
 /**

package/src/types/change-tracker.ts

@@ -126,10 +126,10 @@ export interface CollectionChanges<T = any> {
  * 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)
+  | "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
 
 /**
@@ -219,3 +219,15 @@ export interface TrackedEntityMetadata {
   /** 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;
+}

package/src/types/domain.ts

@@ -1,9 +1,6 @@
-import { ValidationConfig } from "..";
 import { Id } from "../id";
 import { StandardSchema } from "./standard-schema";
 
-export type EntityId = string | number;
-
 export interface BaseProps {
   id: Id;
 }
@@ -22,15 +19,14 @@ export interface VOHooks<T, E> {
   rules?: (entity: E) => void;
 }
 
-// Specialized hooks for entities (with BaseProps)
 export interface EntityHooks<T extends BaseProps, E> {
   onBeforeUpdate?: (entity: E, snapshot: T) => boolean;
   onCreate?: (entity: E) => void;
   rules?: (entity: E) => void;
 }
 
-export interface EntityConstructor<T extends BaseProps, E> {
-  new (props: T): E;
-  validation?: DomainValidation<T>;
-  hooks?: EntityHooks<T, E>;
+export interface ValidationConfig {
+  onCreate?: boolean;
+  onUpdate?: boolean;
+  throwOnError?: boolean;
 }

package/src/types/index.ts

@@ -1,7 +1,7 @@
 export * from "./criteria";
 export * from "./domain";
-export * from "./history-tracker";
 export * from "./standard-schema";
 export * from "./utils";
 export * from "./unit-of-work";
 export * from "./domain-event";
+export * from "./change-tracker";

package/src/utils/criteria-operator-validation.ts

@@ -8,28 +8,71 @@ import {
   StringOperators,
 } from "../types";
 
-export function isValidOperatorForType(
+const FORCE_STRING_OPERATORS = new Set(["contains", "startsWith", "endsWith"]);
+
+export function sanitizeFieldValue(
   value: unknown,
   operator: FilterOperator
-): boolean {
-  // Handle null/undefined
+): unknown {
   if (value === null || value === undefined) {
-    return ["isNull", "isNotNull", "equals", "notEquals"].includes(operator);
+    return value;
+  }
+
+  if (Array.isArray(value)) {
+    return value.map((item) => sanitizeFieldValue(item, operator));
+  }
+
+  if (value instanceof Date) {
+    return value;
+  }
+
+  const stringValue = String(value).trim();
+
+  if (stringValue === "") {
+    return "";
+  }
+
+  if (operator && FORCE_STRING_OPERATORS.has(operator)) {
+    return stringValue;
+  }
+
+  if (stringValue === "true" || stringValue === "false") {
+    return stringValue === "true";
+  }
+
+  const numberValue = Number(stringValue);
+  if (!Number.isNaN(numberValue)) {
+    return numberValue;
+  }
+
+  const dateObj = new Date(stringValue);
+  if (!Number.isNaN(dateObj.getTime())) {
+    return dateObj;
   }
 
-  // Special case: between operator with array [min, max]
-  if (operator === "between" && Array.isArray(value) && value.length === 2) {
-    // Validate based on the type of the first element
-    const elementType = typeof value[0];
-    if (elementType === "number" || value[0] instanceof Date) {
+  return stringValue;
+}
+
+export function isValidOperatorForType(
+  value: unknown,
+  operator: FilterOperator
+): boolean {
+  const sanitizedValue = sanitizeFieldValue(value, operator);
+
+  if (
+    operator === "between" &&
+    Array.isArray(sanitizedValue) &&
+    sanitizedValue.length === 2
+  ) {
+    const elementType = typeof sanitizedValue[0];
+    if (elementType === "number" || sanitizedValue[0] instanceof Date) {
       return true;
     }
     return false;
   }
 
-  const valueType = typeof value;
+  const valueType = typeof sanitizedValue;
 
-  // String operators
   if (valueType === "string") {
     const validOps: StringOperators[] = [
       "equals",
@@ -45,7 +88,6 @@ export function isValidOperatorForType(
     return validOps.includes(operator as StringOperators);
   }
 
-  // Number operators
   if (valueType === "number") {
     const validOps: NumberOperators[] = [
       "equals",
@@ -63,7 +105,6 @@ export function isValidOperatorForType(
     return validOps.includes(operator as NumberOperators);
   }
 
-  // Boolean operators
   if (valueType === "boolean") {
     const validOps: BooleanOperators[] = [
       "equals",
@@ -74,8 +115,7 @@ export function isValidOperatorForType(
     return validOps.includes(operator as BooleanOperators);
   }
 
-  // Date operators
-  if (value instanceof Date) {
+  if (sanitizedValue instanceof Date) {
     const validOps: DateOperators[] = [
       "equals",
       "notEquals",
@@ -92,13 +132,11 @@ export function isValidOperatorForType(
     return validOps.includes(operator as DateOperators);
   }
 
-  // Array operators
-  if (Array.isArray(value)) {
+  if (Array.isArray(sanitizedValue)) {
     const validOps: ArrayOperators[] = ["in", "notIn", "isNull", "isNotNull"];
     return validOps.includes(operator as ArrayOperators);
   }
 
-  // For unknown types, allow all operators
   return true;
 }
 
@@ -168,4 +206,4 @@ export function getValidOperatorsForType(value: unknown): FilterOperator[] {
 
 export function isOperator(value: string): value is FilterOperator {
   return FILTER_OPERATORS.includes(value as FilterOperator);
-}
+}

package/src/validation-error.ts

@@ -5,7 +5,7 @@ export interface ValidationIssue {
 
 export class ValidationError extends Error {
   public readonly issues: ValidationIssue[];
-  public readonly __isValidationError = true; // Brand for identification
+  public readonly __isValidationError = true;
 
   constructor(issues: ValidationIssue[], message?: string) {
     const errorMessage =
@@ -14,7 +14,6 @@ export class ValidationError extends Error {
     this.name = 'ValidationError';
     this.issues = issues;
 
-    // Maintain proper stack trace
     if (Error.captureStackTrace) {
       Error.captureStackTrace(this, ValidationError);
     }
@@ -27,7 +26,6 @@ export class ValidationError extends Error {
     if (error instanceof ValidationError) {
       return true;
     }
-    // Check by duck typing for cross-module compatibility
     return (
       error instanceof Error &&
       error.name === 'ValidationError' &&

package/src/value-object.ts

@@ -9,7 +9,6 @@ import {
 import { DEFAULT_VALIDATION_CONFIG } from "./constants";
 import { DomainError } from "./exceptions";
 
-// Helper to get static properties from constructor
 function getStaticProperty<T>(
   instance: any,
   propertyName: string
@@ -34,7 +33,7 @@ export abstract class ValueObject<T> {
 
   /**
    * Identity key for identification in collections.
-   * Used by HistoryTracker to track changes in arrays of Value Objects.
+   * Used by ChangeTracker to track changes in arrays of Value Objects.
    *
    * @example
    * ```typescript