@woltz/rich-domain 0.2.1

package/dist/id.js

@@ -0,0 +1,84 @@
+import { randomUUID } from 'crypto';
+// ============================================================================
+// Id Class - Smart Identity Management
+// ============================================================================
+export class Id {
+    /**
+     * 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();
+     * newId.isNew // true
+     *
+     * // Existing entity (uses provided ID)
+     * const existingId = new Id("550e8400-e29b-41d4-a716-446655440000");
+     * existingId.isNew // false
+     */
+    constructor(value) {
+        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() {
+        return this._value;
+    }
+    /**
+     * Check if this ID represents a new entity
+     */
+    get isNew() {
+        return this._isNew;
+    }
+    /**
+     * Convert to string (for JSON serialization and comparisons)
+     */
+    toString() {
+        return this._value;
+    }
+    /**
+     * Convert to JSON (returns the string value)
+     */
+    toJSON() {
+        return this._value;
+    }
+    /**
+     * Check equality with another Id or string
+     */
+    equals(other) {
+        if (other instanceof Id) {
+            return this._value === other._value;
+        }
+        return this._value === other;
+    }
+    /**
+     * Generate a UUID v4
+     */
+    generateUUID() {
+        // Simple UUID v4 implementation
+        return randomUUID();
+    }
+    /**
+     * Create a new Id (convenience static method)
+     */
+    static create() {
+        return new Id();
+    }
+    /**
+     * Create an Id from an existing value
+     */
+    static from(value) {
+        return new Id(value);
+    }
+}
+//# sourceMappingURL=id.js.map

package/dist/id.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"id.js","sourceRoot":"","sources":["../src/id.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AACpC,+EAA+E;AAC/E,uCAAuC;AACvC,+EAA+E;AAE/E,MAAM,OAAO,EAAE;IAIb;;;;;;;;;;;;OAYG;IACH,YAAY,KAAc;QACxB,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;YACxB,+CAA+C;YAC/C,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;YACpB,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;QACtB,CAAC;aAAM,CAAC;YACN,0DAA0D;YAC1D,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,YAAY,EAAE,CAAC;YAClC,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;QACrB,CAAC;IACH,CAAC;IAED;;OAEG;IACH,IAAI,KAAK;QACP,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IAED;;OAEG;IACH,IAAI,KAAK;QACP,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IAED;;OAEG;IACH,QAAQ;QACN,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IAED;;OAEG;IACH,MAAM;QACJ,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,KAAkB;QACvB,IAAI,KAAK,YAAY,EAAE,EAAE,CAAC;YACxB,OAAO,IAAI,CAAC,MAAM,KAAK,KAAK,CAAC,MAAM,CAAC;QACtC,CAAC;QACD,OAAO,IAAI,CAAC,MAAM,KAAK,KAAK,CAAC;IAC/B,CAAC;IAED;;OAEG;IACK,YAAY;QAClB,gCAAgC;QAChC,OAAO,UAAU,EAAE,CAAC;IACtB,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,MAAM;QACX,OAAO,IAAI,EAAE,EAAE,CAAC;IAClB,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,IAAI,CAAC,KAAa;QACvB,OAAO,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC;IACvB,CAAC;CACF"}

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+export { Id } from "./id";
+export { BaseEntity } from "./base-entity";
+export { Entity, Aggregate } from "./entity";
+export { ValueObject } from "./value-object";
+export * from "./validation-error";
+export * from "./domain-event";
+export * from "./domain-event-bus";
+export * from "./criteria";
+export * from "./paginated-result";
+export * from "./repository";
+export { InMemoryRepository } from "./repository";
+export * from "./types";
+export * from "./constants";
+export { DeepProxy } from "./deep-proxy";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,EAAE,EAAE,MAAM,MAAM,CAAC;AAC1B,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAC7C,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAE7C,cAAc,oBAAoB,CAAC;AAGnC,cAAc,gBAAgB,CAAC;AAE/B,cAAc,oBAAoB,CAAC;AAGnC,cAAc,YAAY,CAAC;AAC3B,cAAc,oBAAoB,CAAC;AAGnC,cAAc,cAAc,CAAC;AAE7B,OAAO,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAGlD,cAAc,SAAS,CAAC;AAExB,cAAc,aAAa,CAAC;AAG5B,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC"}

package/dist/index.js

@@ -0,0 +1,25 @@
+// ============================================================================
+// Rich Domain Library - Main Exports
+// ============================================================================
+// Core Classes
+export { Id } from "./id";
+export { BaseEntity } from "./base-entity";
+export { Entity, Aggregate } from "./entity";
+export { ValueObject } from "./value-object";
+export * from "./validation-error";
+// Domain Events
+export * from "./domain-event";
+export * from "./domain-event-bus";
+// Criteria & Repository
+export * from "./criteria";
+export * from "./paginated-result";
+// Repository
+export * from "./repository";
+// Backward compatibility - re-export InMemoryRepository at top level
+export { InMemoryRepository } from "./repository";
+// Types
+export * from "./types";
+export * from "./constants";
+// Internal (for advanced usage)
+export { DeepProxy } from "./deep-proxy";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,+EAA+E;AAC/E,qCAAqC;AACrC,+EAA+E;AAE/E,eAAe;AACf,OAAO,EAAE,EAAE,EAAE,MAAM,MAAM,CAAC;AAC1B,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAC7C,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAE7C,cAAc,oBAAoB,CAAC;AAEnC,gBAAgB;AAChB,cAAc,gBAAgB,CAAC;AAE/B,cAAc,oBAAoB,CAAC;AAEnC,wBAAwB;AACxB,cAAc,YAAY,CAAC;AAC3B,cAAc,oBAAoB,CAAC;AAEnC,aAAa;AACb,cAAc,cAAc,CAAC;AAC7B,qEAAqE;AACrE,OAAO,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAElD,QAAQ;AACR,cAAc,SAAS,CAAC;AAExB,cAAc,aAAa,CAAC;AAE5B,gCAAgC;AAChC,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC"}

package/dist/ordering.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Direction for ordering
+ */
+export type OrderDirection = "asc" | "desc";
+/**
+ * Configuration for a single field ordering
+ */
+export interface OrderByConfig<T> {
+    field: keyof T | string;
+    direction: OrderDirection;
+}
+/**
+ * Represents ordering configuration for a specific field
+ * Can be used for in-memory sorting or converted to database-specific queries
+ *
+ * @example
+ * ```typescript
+ * const orderBy = new OrderBy('name', 'asc');
+ * const items = users.sort(orderBy.compareFn());
+ * ```
+ */
+export declare class OrderBy<T> {
+    private readonly _field;
+    private readonly _direction;
+    constructor(field: keyof T | string, direction?: OrderDirection);
+    /**
+     * Gets the field to order by
+     */
+    get field(): keyof T | string;
+    /**
+     * Gets the order direction
+     */
+    get direction(): OrderDirection;
+    /**
+     * Returns configuration object for serialization
+     */
+    toConfig(): OrderByConfig<T>;
+    /**
+     * Creates a comparison function for in-memory sorting
+     * Handles nested properties using dot notation (e.g., "address.city")
+     *
+     * @example
+     * ```typescript
+     * const orderBy = new OrderBy<User>('name', 'asc');
+     * const sorted = users.sort(orderBy.compareFn());
+     * ```
+     */
+    compareFn(): (a: T, b: T) => number;
+    /**
+     * Gets nested property value using dot notation
+     * @private
+     */
+    private getNestedValue;
+    /**
+     * Creates a new OrderBy with reversed direction
+     */
+    reverse(): OrderBy<T>;
+}
+/**
+ * Represents multiple ordering configurations
+ * Allows sorting by multiple fields with different directions
+ *
+ * @example
+ * ```typescript
+ * const multiOrder = new MultiOrderBy<User>([
+ *   new OrderBy('status', 'asc'),
+ *   new OrderBy('name', 'asc')
+ * ]);
+ * const sorted = users.sort(multiOrder.compareFn());
+ * ```
+ */
+export declare class MultiOrderBy<T> {
+    private readonly _orderings;
+    constructor(orderings: OrderBy<T>[]);
+    /**
+     * Gets all ordering configurations
+     */
+    get orderings(): readonly OrderBy<T>[];
+    /**
+     * Returns array of configuration objects for serialization
+     */
+    toConfig(): OrderByConfig<T>[];
+    /**
+     * Creates a comparison function that applies all orderings in sequence
+     * If first ordering produces a tie, moves to next ordering, and so on
+     */
+    compareFn(): (a: T, b: T) => number;
+    /**
+     * Adds another ordering to the end of the list
+     */
+    thenBy(field: keyof T | string, direction?: OrderDirection): MultiOrderBy<T>;
+}
+//# sourceMappingURL=ordering.d.ts.map

package/dist/ordering.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ordering.d.ts","sourceRoot":"","sources":["../src/ordering.ts"],"names":[],"mappings":"AAMA;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,KAAK,GAAG,MAAM,CAAC;AAE5C;;GAEG;AACH,MAAM,WAAW,aAAa,CAAC,CAAC;IAC9B,KAAK,EAAE,MAAM,CAAC,GAAG,MAAM,CAAC;IACxB,SAAS,EAAE,cAAc,CAAC;CAC3B;AAMD;;;;;;;;;GASG;AACH,qBAAa,OAAO,CAAC,CAAC;IACpB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAmB;IAC1C,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAiB;gBAEhC,KAAK,EAAE,MAAM,CAAC,GAAG,MAAM,EAAE,SAAS,GAAE,cAAsB;IAKtE;;OAEG;IACH,IAAI,KAAK,IAAI,MAAM,CAAC,GAAG,MAAM,CAE5B;IAED;;OAEG;IACH,IAAI,SAAS,IAAI,cAAc,CAE9B;IAED;;OAEG;IACH,QAAQ,IAAI,aAAa,CAAC,CAAC,CAAC;IAO5B;;;;;;;;;OASG;IACH,SAAS,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,MAAM;IAsBnC;;;OAGG;IACH,OAAO,CAAC,cAAc;IAItB;;OAEG;IACH,OAAO,IAAI,OAAO,CAAC,CAAC,CAAC;CAItB;AAMD;;;;;;;;;;;;GAYG;AACH,qBAAa,YAAY,CAAC,CAAC;IACzB,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAe;gBAE9B,SAAS,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE;IAOnC;;OAEG;IACH,IAAI,SAAS,IAAI,SAAS,OAAO,CAAC,CAAC,CAAC,EAAE,CAErC;IAED;;OAEG;IACH,QAAQ,IAAI,aAAa,CAAC,CAAC,CAAC,EAAE;IAI9B;;;OAGG;IACH,SAAS,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,MAAM;IAYnC;;OAEG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,GAAG,MAAM,EAAE,SAAS,GAAE,cAAsB,GAAG,YAAY,CAAC,CAAC,CAAC;CAIpF"}

package/dist/ordering.js

@@ -0,0 +1,154 @@
+"use strict";
+// ============================================================================
+// Ordering System
+// ============================================================================
+// Provides ordering/sorting capabilities for queries and in-memory collections
+// Compatible with Entity, Aggregate, and ValueObject types
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MultiOrderBy = exports.OrderBy = void 0;
+// ============================================================================
+// OrderBy Class
+// ============================================================================
+/**
+ * Represents ordering configuration for a specific field
+ * Can be used for in-memory sorting or converted to database-specific queries
+ *
+ * @example
+ * ```typescript
+ * const orderBy = new OrderBy('name', 'asc');
+ * const items = users.sort(orderBy.compareFn());
+ * ```
+ */
+class OrderBy {
+    constructor(field, direction = "asc") {
+        this._field = field;
+        this._direction = direction;
+    }
+    /**
+     * Gets the field to order by
+     */
+    get field() {
+        return this._field;
+    }
+    /**
+     * Gets the order direction
+     */
+    get direction() {
+        return this._direction;
+    }
+    /**
+     * Returns configuration object for serialization
+     */
+    toConfig() {
+        return {
+            field: this._field,
+            direction: this._direction,
+        };
+    }
+    /**
+     * Creates a comparison function for in-memory sorting
+     * Handles nested properties using dot notation (e.g., "address.city")
+     *
+     * @example
+     * ```typescript
+     * const orderBy = new OrderBy<User>('name', 'asc');
+     * const sorted = users.sort(orderBy.compareFn());
+     * ```
+     */
+    compareFn() {
+        return (a, b) => {
+            const aValue = this.getNestedValue(a, this._field);
+            const bValue = this.getNestedValue(b, this._field);
+            // Handle null/undefined values
+            if (aValue === null || aValue === undefined)
+                return 1;
+            if (bValue === null || bValue === undefined)
+                return -1;
+            // Compare values
+            let comparison = 0;
+            if (aValue > bValue) {
+                comparison = 1;
+            }
+            else if (aValue < bValue) {
+                comparison = -1;
+            }
+            // Apply direction
+            return this._direction === "asc" ? comparison : -comparison;
+        };
+    }
+    /**
+     * Gets nested property value using dot notation
+     * @private
+     */
+    getNestedValue(obj, path) {
+        return path.split(".").reduce((current, prop) => current?.[prop], obj);
+    }
+    /**
+     * Creates a new OrderBy with reversed direction
+     */
+    reverse() {
+        const newDirection = this._direction === "asc" ? "desc" : "asc";
+        return new OrderBy(this._field, newDirection);
+    }
+}
+exports.OrderBy = OrderBy;
+// ============================================================================
+// MultiOrderBy Class
+// ============================================================================
+/**
+ * Represents multiple ordering configurations
+ * Allows sorting by multiple fields with different directions
+ *
+ * @example
+ * ```typescript
+ * const multiOrder = new MultiOrderBy<User>([
+ *   new OrderBy('status', 'asc'),
+ *   new OrderBy('name', 'asc')
+ * ]);
+ * const sorted = users.sort(multiOrder.compareFn());
+ * ```
+ */
+class MultiOrderBy {
+    constructor(orderings) {
+        if (orderings.length === 0) {
+            throw new Error("At least one OrderBy is required");
+        }
+        this._orderings = orderings;
+    }
+    /**
+     * Gets all ordering configurations
+     */
+    get orderings() {
+        return this._orderings;
+    }
+    /**
+     * Returns array of configuration objects for serialization
+     */
+    toConfig() {
+        return this._orderings.map((o) => o.toConfig());
+    }
+    /**
+     * Creates a comparison function that applies all orderings in sequence
+     * If first ordering produces a tie, moves to next ordering, and so on
+     */
+    compareFn() {
+        return (a, b) => {
+            for (const ordering of this._orderings) {
+                const comparison = ordering.compareFn()(a, b);
+                if (comparison !== 0) {
+                    return comparison;
+                }
+            }
+            return 0;
+        };
+    }
+    /**
+     * Adds another ordering to the end of the list
+     */
+    thenBy(field, direction = "asc") {
+        const newOrderBy = new OrderBy(field, direction);
+        return new MultiOrderBy([...this._orderings, newOrderBy]);
+    }
+}
+exports.MultiOrderBy = MultiOrderBy;
+//# sourceMappingURL=ordering.js.map

package/dist/ordering.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ordering.js","sourceRoot":"","sources":["../src/ordering.ts"],"names":[],"mappings":"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"}

package/dist/paginated-result.d.ts

@@ -0,0 +1,62 @@
+import type { Criteria } from "./criteria";
+import type { Pagination, PaginationMeta } 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 declare class PaginatedResult<T> {
+    readonly data: T[];
+    readonly meta: PaginationMeta;
+    constructor(data: T[], meta: PaginationMeta);
+    /**
+     * Creates a PaginatedResult with calculated metadata
+     */
+    static create<T>(data: T[], pagination: Pagination, total: number): PaginatedResult<T>;
+    /**
+     * Creates pagination metadata from total count
+     */
+    static createMeta(pagination: Pagination, total: number): PaginationMeta;
+    /**
+     * Applies criteria to an in-memory array (useful for testing)
+     */
+    static fromArray<T>(items: T[], criteria: Criteria<T>): PaginatedResult<T>;
+    /**
+     * 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>;
+    /**
+     * Deep serialization logic (similar to BaseEntity.deepToJson)
+     */
+    private deepSerialize;
+    /**
+     * Transform each item in the result using a mapper function
+     */
+    map<U>(fn: (item: T) => U): PaginatedResult<U>;
+    /**
+     * Check if result has no data
+     */
+    get isEmpty(): boolean;
+    /**
+     * Check if there are more pages available
+     */
+    get hasMore(): boolean;
+}
+export {};
+//# sourceMappingURL=paginated-result.d.ts.map

package/dist/paginated-result.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paginated-result.d.ts","sourceRoot":"","sources":["../src/paginated-result.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,KAAK,EAAE,UAAU,EAAE,cAAc,EAAU,MAAM,SAAS,CAAC;AAMlE;;;;GAIG;AACH,KAAK,eAAe,CAAC,CAAC,IAAI,CAAC,SAAS;IAAE,MAAM,IAAI,MAAM,CAAC,CAAA;CAAE,GAAG,CAAC,GAAG,CAAC,CAAC;AAElE;;GAEG;AACH,MAAM,MAAM,mBAAmB,CAAC,CAAC,IAAI;IACnC,IAAI,EAAE,eAAe,CAAC,CAAC,CAAC,EAAE,CAAC;IAC3B,IAAI,EAAE,cAAc,CAAC;CACtB,CAAC;AAMF,qBAAa,eAAe,CAAC,CAAC;aAEV,IAAI,EAAE,CAAC,EAAE;aACT,IAAI,EAAE,cAAc;gBADpB,IAAI,EAAE,CAAC,EAAE,EACT,IAAI,EAAE,cAAc;IAGtC;;OAEG;IACH,MAAM,CAAC,MAAM,CAAC,CAAC,EACb,IAAI,EAAE,CAAC,EAAE,EACT,UAAU,EAAE,UAAU,EACtB,KAAK,EAAE,MAAM,GACZ,eAAe,CAAC,CAAC,CAAC;IAKrB;;OAEG;IACH,MAAM,CAAC,UAAU,CAAC,UAAU,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,GAAG,cAAc;IAaxE;;OAEG;IACH,MAAM,CAAC,SAAS,CAAC,CAAC,EAChB,KAAK,EAAE,CAAC,EAAE,EACV,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,GACpB,eAAe,CAAC,CAAC,CAAC;IA0CrB;;;;;;;;OAQG;IACH,MAAM,IAAI,mBAAmB,CAAC,CAAC,CAAC;IAShC;;OAEG;IACH,OAAO,CAAC,aAAa;IA+BrB;;OAEG;IACH,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,GAAG,eAAe,CAAC,CAAC,CAAC;IAI9C;;OAEG;IACH,IAAI,OAAO,IAAI,OAAO,CAErB;IAED;;OAEG;IACH,IAAI,OAAO,IAAI,OAAO,CAErB;CACF"}

package/dist/paginated-result.js

@@ -0,0 +1,201 @@
+// ============================================================================
+// PaginatedResult - Container for paginated data with deep serialization
+// ============================================================================
+import { Id } from "./id";
+// ============================================================================
+// PaginatedResult Class
+// ============================================================================
+export class PaginatedResult {
+    constructor(data, meta) {
+        this.data = data;
+        this.meta = meta;
+    }
+    /**
+     * Creates a PaginatedResult with calculated metadata
+     */
+    static create(data, pagination, total) {
+        const meta = this.createMeta(pagination, total);
+        return new PaginatedResult(data, meta);
+    }
+    /**
+     * Creates pagination metadata from total count
+     */
+    static createMeta(pagination, total) {
+        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(items, criteria) {
+        let result = [...items];
+        // Apply filters
+        for (const filter of criteria.getFilters()) {
+            result = result.filter((item) => applyFilter(item, filter));
+        }
+        const total = result.length;
+        // Apply ordering
+        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;
+            });
+        }
+        // Apply pagination
+        const pagination = criteria.getPagination();
+        if (pagination) {
+            result = result.slice(pagination.offset, pagination.offset + pagination.limit);
+            return PaginatedResult.create(result, pagination, total);
+        }
+        // No pagination - return all with default meta
+        return PaginatedResult.create(result, { page: 1, limit: result.length, offset: 0 }, 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() {
+        return {
+            data: this.data.map((item) => this.deepSerialize(item)),
+            meta: this.meta,
+        };
+    }
+    /**
+     * Deep serialization logic (similar to BaseEntity.deepToJson)
+     */
+    deepSerialize(obj) {
+        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 = {};
+            for (const key in obj) {
+                if (obj.hasOwnProperty(key)) {
+                    result[key] = this.deepSerialize(obj[key]);
+                }
+            }
+            return result;
+        }
+        // Primitives
+        return obj;
+    }
+    /**
+     * Transform each item in the result using a mapper function
+     */
+    map(fn) {
+        return new PaginatedResult(this.data.map(fn), this.meta);
+    }
+    /**
+     * Check if result has no data
+     */
+    get isEmpty() {
+        return this.data.length === 0;
+    }
+    /**
+     * Check if there are more pages available
+     */
+    get hasMore() {
+        return this.meta.hasNext;
+    }
+}
+// ============================================================================
+// Helper Functions (moved from criteria.ts)
+// ============================================================================
+function applyFilter(item, filter) {
+    const value = getNestedValue(item, filter.field);
+    const isValueDate = value instanceof Date;
+    const parseValue = (v) => {
+        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;
+        }
+        case "greaterThanOrEqual": {
+            const compareTo = parseValue(filter.value);
+            return isValueDate ? value >= compareTo : value >= filter.value;
+        }
+        case "lessThan":
+            const lt = parseValue(filter.value);
+            return isValueDate ? value < lt : value < filter.value;
+        case "lessThanOrEqual":
+            const lte = parseValue(filter.value);
+            return isValueDate ? value <= lte : value <= filter.value;
+        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, path) {
+    return path.split(".").reduce((current, key) => {
+        if (current === null || current === undefined)
+            return undefined;
+        return current[key];
+    }, obj);
+}
+//# sourceMappingURL=paginated-result.js.map