@woltz/rich-domain 0.2.2 → 1.1.0

package/src/base-entity.ts

@@ -5,7 +5,7 @@
 import { Id } from "./id";
 import { DeepProxy } from "./deep-proxy";
 import { ValidationError } from "./validation-error";
-import { IDomainEvent } from "./domain-event";
+import { IDomainEvent } from ".";
 import {
   BaseProps,
   SubscriptionConfig,
@@ -18,6 +18,7 @@ import {
 } from "./types";
 import { DomainEventBus } from "./domain-event-bus";
 import { DEFAULT_VALIDATION_CONFIG } from "./constants";
+import { DomainError } from "./exceptions";
 
 // Helper to get static properties from constructor
 function getStaticProperty<T>(
@@ -60,7 +61,6 @@ export abstract class BaseEntity<T extends BaseProps> {
       ...validation?.config,
     };
 
-    // Apply defaultValues
     let finalProps = { ...props } as T;
 
     // Generate ID if not provided
@@ -102,7 +102,7 @@ export abstract class BaseEntity<T extends BaseProps> {
     const result = this.entitySchema["~standard"].validate(props);
 
     if (result instanceof Promise) {
-      throw new Error(
+      throw new DomainError(
         "Async validation not supported in constructor. Use sync validation schema."
       );
     }
@@ -278,8 +278,8 @@ export abstract class BaseEntity<T extends BaseProps> {
     return this._props.id;
   }
 
-  get isNew(): boolean {
-    return this._props.id.isNew;
+  public isNew(): boolean {
+    return this._props.id.isNew();
   }
 
   /**
@@ -386,6 +386,7 @@ export abstract class BaseEntity<T extends BaseProps> {
   private deepToJson(obj: any): any {
     if (obj === null || obj === undefined) return obj;
     if (obj instanceof Id) return obj.value;
+    if (obj instanceof Date) return obj.toISOString();
     if (Array.isArray(obj)) return obj.map((item) => this.deepToJson(item));
     if (obj instanceof BaseEntity) return obj.toJson();
     if (obj && typeof obj.toJson === "function") return obj.toJson();

package/src/criteria.ts

@@ -1,12 +1,15 @@
+import { InvalidCriteriaError } from "./exceptions";
 import {
   FieldPath,
   Filter,
+  FILTER_OPERATORS,
   FilterOperator,
   FilterValueFor,
   Order,
   OrderDirection,
   Pagination,
   PathValue,
+  Search,
   TypedFilter,
 } from "./types";
 
@@ -14,21 +17,18 @@ import {
 // Filter Types
 // ============================================================================
 
-export class Criteria<T = unknown> {
+export class Criteria<T = any> {
   private _filters: Filter<FieldPath<T>, any>[] = [];
   private _orders: Order[] = [];
   private _pagination: Pagination = { page: 1, limit: 20, offset: 0 };
-  private _search?: {
-    fields: FieldPath<T>[];
-    value: string;
-  };
+  private _search?: Search<T>
 
   private constructor() {}
 
   /**
    * Create a new Criteria instance
    */
-  static create<T = unknown>(): Criteria<T> {
+  static create<T = any>(): Criteria<T> {
     return new Criteria<T>();
   }
 
@@ -221,9 +221,9 @@ export class Criteria<T = unknown> {
       const [field, operatorRaw] = key.split(":");
 
       if (!operatorRaw || !field) continue;
-
       const operator = isOperator(operatorRaw) ? operatorRaw : null;
-      if (!operator) throw new Error(`Invalid filter operator: ${operatorRaw}`);
+      if (!operator)
+        throw new InvalidCriteriaError(`Invalid filter operator`, operatorRaw);
 
       let parsedValue: any = value;
 
@@ -243,7 +243,7 @@ export class Criteria<T = unknown> {
         continue;
       }
 
-      criteria.where(field as any, operator, parseQueryValue(value));
+      criteria.where(field as FieldPath<T>, operator, parseQueryValue(value));
     }
 
     // Pagination
@@ -259,7 +259,7 @@ export class Criteria<T = unknown> {
       const sortParts = query.orderBy.split(",");
       sortParts.forEach((part: string) => {
         const [field, direction] = part.split(":");
-        criteria.orderBy(field as any, (direction as OrderDirection) || "asc");
+        criteria.orderBy(field as FieldPath<T>, (direction as OrderDirection) || "asc");
       });
     }
 
@@ -287,5 +287,5 @@ function parseQueryValue(value: string): any {
 }
 
 function isOperator(value: string): value is FilterOperator {
-  return FilterOperator.includes(value as FilterOperator);
+  return FILTER_OPERATORS.includes(value as FilterOperator);
 }