@woltz/rich-domain 1.3.0 → 1.3.1

package/src/change-tracker.ts

@@ -9,11 +9,7 @@ import { AggregateChanges } from "./aggregate-changes";
  * Callback for validation on property change.
  * Return false to reject the change, or throw an error.
  */
-export type OnChangeValidator = (
-  path: string,
-  oldValue: any,
-  newValue: any
-) => boolean | void;
+export type OnChangeValidator = (path: string, newValue: any) => boolean | void;
 
 /**
  * Tracks changes in Aggregates using Proxy.
@@ -39,7 +35,9 @@ export class ChangeTracker {
     private rootEntityName: string,
     private path: string = "",
     private depth: number = 0,
+    // @ts-expect-error - This is a private property
     private parentId?: string,
+    // @ts-expect-error - This is a private property
     private parentEntity?: string,
     private rootTracker?: ChangeTracker
   ) {
@@ -195,11 +193,7 @@ export class ChangeTracker {
         const rootTracker = this.getRootTracker();
         if (rootTracker.onChangeValidator) {
           try {
-            const result = rootTracker.onChangeValidator(
-              currentPath,
-              oldValue,
-              newValue
-            );
+            const result = rootTracker.onChangeValidator(currentPath, newValue);
             if (result === false) {
               return true;
             }
@@ -272,7 +266,7 @@ export class ChangeTracker {
 
               if (rootTracker.onChangeValidator) {
                 try {
-                  const result = rootTracker.onChangeValidator(path, oldArray, [
+                  const result = rootTracker.onChangeValidator(path, [
                     ...oldArray,
                     ...args,
                   ]);
@@ -322,11 +316,7 @@ export class ChangeTracker {
 
           if (rootTracker.onChangeValidator) {
             try {
-              const result = rootTracker.onChangeValidator(
-                path,
-                oldArray,
-                newValue
-              );
+              const result = rootTracker.onChangeValidator(path, newValue);
               if (result === false) {
                 return true;
               }

package/src/entity-schema-registry.ts

@@ -160,6 +160,13 @@ export class EntitySchemaRegistry {
     return schema;
   }
 
+  /**
+   * Gets all registered schemas.
+   */
+  getAllSchemas(): EntitySchema[] {
+    return Array.from(this.schemas.values());
+  }
+
   /**
    * Tries to get the schema of an entity, returns null if not found.
    * @param entity - Entity name.
@@ -459,11 +466,7 @@ export class EntitySchemaRegistry {
     const availableCollections = Object.keys(collections);
 
     if (availableCollections.length === 0) {
-      throw new ConfigurationError(
-        `EntitySchemaRegistry: Entity '${entity}' has no collections configured, ` +
-          `but received operation for relation '${relationField}'. ` +
-          `Did you forget to configure collections in the schema?`
-      );
+      return;
     }
 
     if (!collections[relationField]) {

package/src/index.ts

@@ -11,7 +11,7 @@ export { ValueObject } from "./value-object";
 export { Mapper } from "./mapper";
 export { EntitySchemaRegistry } from "./entity-schema-registry";
 export { AggregateChanges } from "./aggregate-changes";
-export {
+export type {
   DomainEventHandler,
   EntityHooks,
   Filter,

package/src/paginated-result.ts

@@ -81,6 +81,18 @@ export class PaginatedResult<T> {
       pagination.offset,
       pagination.offset + pagination.limit
     );
+
+    const search = criteria.getSearch();
+
+    if (search) {
+      result = result.filter((item) => {
+        const values = Object.values(item as Record<string, unknown>);
+        return values.some((val) =>
+          String(val).toLowerCase().includes(search.toLowerCase())
+        );
+      });
+    }
+
     return PaginatedResult.create(result, pagination, total);
   }
 

package/src/types/domain.ts

@@ -15,7 +15,6 @@ export type VOValidation<T> = DomainValidation<T>;
 
 export interface VOHooks<T, E> {
   onBeforeCreate?: (props: T) => void;
-  onBeforeUpdate?: (entity: E, snapshot: T) => boolean;
   onCreate?: (entity: E) => void;
   rules?: (entity: E) => void;
 }

package/src/validation-error.ts

@@ -6,19 +6,41 @@ export interface ValidationIssue {
 export class ValidationError extends Error {
   public readonly issues: ValidationIssue[];
   public readonly __isValidationError = true;
+  public readonly entityName?: string;
 
-  constructor(issues: ValidationIssue[], message?: string) {
-    const errorMessage =
-      message || `Validation failed: ${issues.map(i => i.message).join(', ')}`;
+  constructor(issues: ValidationIssue[], options?: { message?: string; entityName?: string }) {
+    const errorMessage = options?.message || ValidationError.formatMessage(issues, options?.entityName);
     super(errorMessage);
     this.name = 'ValidationError';
     this.issues = issues;
+    this.entityName = options?.entityName;
 
     if (Error.captureStackTrace) {
       Error.captureStackTrace(this, ValidationError);
     }
   }
 
+  private static formatMessage(issues: ValidationIssue[], entityName?: string): string {
+    const entityPrefix = entityName ? `[${entityName}] ` : '';
+
+    if (issues.length === 0) {
+      return `${entityPrefix}Validation failed`;
+    }
+
+    if (issues.length === 1) {
+      const issue = issues[0];
+      const pathStr = issue.path.length > 0 ? ` at "${issue.path.join('.')}"` : '';
+      return `${entityPrefix}Validation failed${pathStr}: ${issue.message}`;
+    }
+
+    const errorLines = issues.map((issue, index) => {
+      const pathStr = issue.path.length > 0 ? ` at "${issue.path.join('.')}"` : '';
+      return `  ${index + 1}. ${issue.message}${pathStr}`;
+    }).join('\n');
+
+    return `${entityPrefix}Validation failed with ${issues.length} error(s):\n${errorLines}`;
+  }
+
   /**
    * Check if an error is a ValidationError (works across module boundaries)
    */
@@ -58,13 +80,41 @@ export class ValidationError extends Error {
   /**
    * Convert to a plain object for serialization
    */
-  toJSON(): { name: string; message: string; issues: ValidationIssue[] } {
+  toJSON(): { name: string; message: string; issues: ValidationIssue[]; entityName?: string } {
     return {
       name: this.name,
       message: this.message,
       issues: this.issues,
+      entityName: this.entityName,
     };
   }
+
+  /**
+   * Get a formatted string with all validation errors
+   */
+  getFormattedErrors(): string {
+    return this.issues.map((issue) => {
+      const pathStr = issue.path.length > 0 ? ` [${issue.path.join('.')}]` : '';
+      return `${pathStr} ${issue.message}`;
+    }).join('\n');
+  }
+
+  /**
+   * Get a summary of the error for logging
+   */
+  getSummary(): string {
+    const entityPrefix = this.entityName ? `[${this.entityName}] ` : '';
+    const paths = this.issues
+      .filter(i => i.path.length > 0)
+      .map(i => i.path.join('.'));
+
+    if (paths.length === 0) {
+      return `${entityPrefix}Validation failed with ${this.issues.length} error(s)`;
+    }
+
+    const uniquePaths = Array.from(new Set(paths));
+    return `${entityPrefix}Validation failed on: ${uniquePaths.join(', ')} (${this.issues.length} error(s))`;
+  }
 }
 
 /**

package/src/value-object.ts

@@ -24,6 +24,7 @@ export type IdentityKeyDefinition<T> = (keyof T)[] | keyof T;
 export abstract class ValueObject<T> {
   protected readonly props!: T;
   private validationConfig: Required<ValidationConfig>;
+  // @ts-expect-error - This is a private property
   private domainHooks?: VOHooks<T, any>;
   private domainSchema?: StandardSchema<T>;
   private domainEvents: IDomainEvent[] = [];
@@ -57,6 +58,10 @@ export abstract class ValueObject<T> {
     );
     const hooks = getStaticProperty<VOHooks<T, any>>(this, "hooks");
 
+    if (hooks?.onBeforeCreate) {
+      hooks.onBeforeCreate(props as T);
+    }
+
     this.domainHooks = hooks;
 
     if (validation?.schema) {