@decaf-ts/integrations 0.10.5 → 0.11.0

package/lib/cjs/redis/RedisDispatch.cjs

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisDispatch = void 0;
+const core_1 = require("@decaf-ts/core");
+const db_decorators_1 = require("@decaf-ts/db-decorators");
+const decorator_validation_1 = require("@decaf-ts/decorator-validation");
+const crypto_1 = require("crypto");
+const constants_js_1 = require("./constants.cjs");
+/**
+ * @description Dispatcher for Redis change events
+ * @summary Extends the core `Dispatch` to broadcast record changes over Redis
+ * pub/sub so that every process sharing the same database refreshes its observers.
+ * Local observer updates are still performed synchronously through the base class;
+ * the published message carries an `origin` id so a process ignores the echo of its
+ * own events and never notifies its observers twice.
+ * @class RedisDispatch
+ * @category Redis
+ */
+class RedisDispatch extends core_1.Dispatch {
+    constructor() {
+        super(...arguments);
+        this.origin = (0, crypto_1.randomUUID)();
+        /**
+         * @description Whether the pub/sub subscription is currently active
+         */
+        this.active = false;
+    }
+    /**
+     * @description Initializes the dispatcher and opens the pub/sub subscription
+     * @summary Proxies the adapter's CRUD methods through the base implementation,
+     * then opens a dedicated subscriber connection listening for change events.
+     * @param {...ContextualArgs} args - Contextual arguments
+     * @return {Promise<void>} A promise that resolves once initialization is complete
+     */
+    async initialize(...args) {
+        await super.initialize(...args);
+        if (!this.adapter)
+            return;
+        try {
+            const subscriber = this.adapter.client.duplicate();
+            await subscriber.connect();
+            await subscriber.subscribe(constants_js_1.RedisEventsChannel, (message) => void this.changeHandler(message));
+            this.subscriber = subscriber;
+            this.active = true;
+        }
+        catch (e) {
+            this.log
+                .for(this.initialize)
+                .error(`Failed to subscribe to Redis change events: ${e}`);
+        }
+    }
+    /**
+     * @description Closes the dispatcher and releases the pub/sub subscription
+     * @param {...ContextualArgs} args - Contextual arguments
+     * @return {Promise<void>} A promise that resolves once the dispatcher is closed
+     */
+    async close(...args) {
+        this.active = false;
+        const subscriber = this.subscriber;
+        this.subscriber = undefined;
+        if (subscriber) {
+            try {
+                await subscriber.unsubscribe(constants_js_1.RedisEventsChannel);
+            }
+            catch (e) {
+                this.log
+                    .for(this.close)
+                    .error(`Failed to unsubscribe from Redis change events: ${e}`);
+            }
+            try {
+                await subscriber.quit();
+            }
+            catch (e) {
+                this.log
+                    .for(this.close)
+                    .error(`Failed to close Redis change subscriber: ${e}`);
+            }
+        }
+        return super.close(...args);
+    }
+    /**
+     * @description Notifies local observers and broadcasts the event to other processes
+     * @summary Performs the base local refresh, then publishes the change to the
+     * Redis pub/sub channel. Remote processes receive the event and refresh their own
+     * observers; the originating process ignores its own message.
+     * @param {Constructor<any> | string} model - The model (or table name) that changed
+     * @param {OperationKeys | BulkCrudOperationKeys | string} event - The operation that occurred
+     * @param {any} id - The identifier(s) of the affected record(s)
+     * @param {...ContextualArgs} args - Contextual arguments
+     * @return {Promise<void>} A promise that resolves once observers are notified
+     */
+    async updateObservers(model, event, id, ...args) {
+        await super.updateObservers(model, event, id, ...args);
+        if (!this.adapter)
+            return;
+        const table = model && typeof model === "string" ? model : decorator_validation_1.Model.tableName(model);
+        try {
+            await this.adapter.client.publish(constants_js_1.RedisEventsChannel, JSON.stringify({ origin: this.origin, table, event: String(event), id }));
+        }
+        catch (e) {
+            this.log
+                .for(this.updateObservers)
+                .error(`Failed to publish Redis change event: ${e}`);
+        }
+    }
+    /**
+     * @description Handles an incoming Redis change event
+     * @summary Ignores the echo of locally published events and refreshes the
+     * observers of this process for events published elsewhere.
+     * @param {string} message - The raw JSON pub/sub payload
+     * @return {Promise<void>} A promise that resolves once observers are notified
+     */
+    async changeHandler(message) {
+        try {
+            const parsed = JSON.parse(message);
+            if (parsed.origin === this.origin)
+                return;
+            if (!this.adapter)
+                return;
+            const ctx = await this.adapter.context(db_decorators_1.OperationKeys.UPDATE, {}, decorator_validation_1.Model);
+            await super.updateObservers(parsed.table, parsed.event, parsed.id, ctx);
+        }
+        catch (e) {
+            this.log
+                .for(this.changeHandler)
+                .error(`Failed to process Redis change event: ${e}`);
+        }
+    }
+}
+exports.RedisDispatch = RedisDispatch;
+//# sourceMappingURL=RedisDispatch.js.map
+//# sourceMappingURL=RedisDispatch.cjs.map

package/lib/cjs/redis/RedisDispatch.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis/RedisDispatch.cjs","sourceRoot":"","sources":["redis/RedisDispatch.js"],"names":[],"mappings":";;;AAAA,yCAA0C;AAC1C,2DAAwD;AACxD,yEAAuD;AACvD,mCAAoC;AACpC,iDAAoD;AACpD;;;;;;;;;GASG;AACH,MAAa,aAAc,SAAQ,eAAQ;IACvC;QACI,KAAK,CAAC,GAAG,SAAS,CAAC,CAAC;QACpB,IAAI,CAAC,MAAM,GAAG,IAAA,mBAAU,GAAE,CAAC;QAC3B;;WAEG;QACH,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;IACxB,CAAC;IACD;;;;;;OAMG;IACH,KAAK,CAAC,UAAU,CAAC,GAAG,IAAI;QACpB,MAAM,KAAK,CAAC,UAAU,CAAC,GAAG,IAAI,CAAC,CAAC;QAChC,IAAI,CAAC,IAAI,CAAC,OAAO;YACb,OAAO;QACX,IAAI,CAAC;YACD,MAAM,UAAU,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC;YACnD,MAAM,UAAU,CAAC,OAAO,EAAE,CAAC;YAC3B,MAAM,UAAU,CAAC,SAAS,CAAC,iCAAkB,EAAE,CAAC,OAAO,EAAE,EAAE,CAAC,KAAK,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,CAAC;YAC9F,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;YAC7B,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;QACvB,CAAC;QACD,OAAO,CAAC,EAAE,CAAC;YACP,IAAI,CAAC,GAAG;iBACH,GAAG,CAAC,IAAI,CAAC,UAAU,CAAC;iBACpB,KAAK,CAAC,+CAA+C,CAAC,EAAE,CAAC,CAAC;QACnE,CAAC;IACL,CAAC;IACD;;;;OAIG;IACH,KAAK,CAAC,KAAK,CAAC,GAAG,IAAI;QACf,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;QACpB,MAAM,UAAU,GAAG,IAAI,CAAC,UAAU,CAAC;QACnC,IAAI,CAAC,UAAU,GAAG,SAAS,CAAC;QAC5B,IAAI,UAAU,EAAE,CAAC;YACb,IAAI,CAAC;gBACD,MAAM,UAAU,CAAC,WAAW,CAAC,iCAAkB,CAAC,CAAC;YACrD,CAAC;YACD,OAAO,CAAC,EAAE,CAAC;gBACP,IAAI,CAAC,GAAG;qBACH,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC;qBACf,KAAK,CAAC,mDAAmD,CAAC,EAAE,CAAC,CAAC;YACvE,CAAC;YACD,IAAI,CAAC;gBACD,MAAM,UAAU,CAAC,IAAI,EAAE,CAAC;YAC5B,CAAC;YACD,OAAO,CAAC,EAAE,CAAC;gBACP,IAAI,CAAC,GAAG;qBACH,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC;qBACf,KAAK,CAAC,4CAA4C,CAAC,EAAE,CAAC,CAAC;YAChE,CAAC;QACL,CAAC;QACD,OAAO,KAAK,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,CAAC;IAChC,CAAC;IACD;;;;;;;;;;OAUG;IACH,KAAK,CAAC,eAAe,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE,EAAE,GAAG,IAAI;QAC3C,MAAM,KAAK,CAAC,eAAe,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE,EAAE,GAAG,IAAI,CAAC,CAAC;QACvD,IAAI,CAAC,IAAI,CAAC,OAAO;YACb,OAAO;QACX,MAAM,KAAK,GAAG,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,4BAAK,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;QAClF,IAAI,CAAC;YACD,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,iCAAkB,EAAE,IAAI,CAAC,SAAS,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,CAAC,KAAK,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC;QACpI,CAAC;QACD,OAAO,CAAC,EAAE,CAAC;YACP,IAAI,CAAC,GAAG;iBACH,GAAG,CAAC,IAAI,CAAC,eAAe,CAAC;iBACzB,KAAK,CAAC,yCAAyC,CAAC,EAAE,CAAC,CAAC;QAC7D,CAAC;IACL,CAAC;IACD;;;;;;OAMG;IACH,KAAK,CAAC,aAAa,CAAC,OAAO;QACvB,IAAI,CAAC;YACD,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;YACnC,IAAI,MAAM,CAAC,MAAM,KAAK,IAAI,CAAC,MAAM;gBAC7B,OAAO;YACX,IAAI,CAAC,IAAI,CAAC,OAAO;gBACb,OAAO;YACX,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,6BAAa,CAAC,MAAM,EAAE,EAAE,EAAE,4BAAK,CAAC,CAAC;YACxE,MAAM,KAAK,CAAC,eAAe,CAAC,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,EAAE,EAAE,GAAG,CAAC,CAAC;QAC5E,CAAC;QACD,OAAO,CAAC,EAAE,CAAC;YACP,IAAI,CAAC,GAAG;iBACH,GAAG,CAAC,IAAI,CAAC,aAAa,CAAC;iBACvB,KAAK,CAAC,yCAAyC,CAAC,EAAE,CAAC,CAAC;QAC7D,CAAC;IACL,CAAC;CACJ;AA9GD,sCA8GC;AACD,yCAAyC"}

package/lib/cjs/redis/RedisPaginator.cjs

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisPaginator = void 0;
+const core_1 = require("@decaf-ts/core");
+const decorator_validation_1 = require("@decaf-ts/decorator-validation");
+/**
+ * @description Redis-specific paginator implementation
+ * @summary Extends the base Paginator class to provide pagination functionality for
+ * Redis adapter queries. This class handles the pagination of query results loaded
+ * from Redis, allowing for efficient retrieval of large result sets in smaller chunks.
+ * @template M - The model type being paginated
+ * @class RedisPaginator
+ * @category Redis
+ * @example
+ * ```typescript
+ * // Create a query for User model
+ * const query: RawRedisQuery<User> = {
+ *   select: undefined, // Select all fields
+ *   from: User,
+ *   where: (user) => user.active === true
+ * };
+ *
+ * // Create a paginator with page size of 10
+ * const paginator = new RedisPaginator<User>(adapter, query, 10, User);
+ *
+ * // Get the first page of results
+ * const firstPage = await paginator.page(1);
+ *
+ * // Get the next page
+ * const secondPage = await paginator.page(2);
+ * ```
+ */
+class RedisPaginator extends core_1.Paginator {
+    /**
+     * @description Creates a paginator bound to the Redis adapter
+     * @param {Adapter<any, any, RawRedisQuery<M>, any>} adapter - The Redis adapter instance
+     * @param {RawRedisQuery<M>} query - The raw query to paginate
+     * @param {number} size - The number of records per page
+     * @param {Constructor<M>} clazz - The model constructor being paginated
+     */
+    constructor(adapter, query, size, clazz) {
+        super(adapter, query, size, clazz);
+    }
+    /**
+     * @description Prepares a Redis query for pagination
+     * @summary Modifies the raw query statement to include pagination parameters.
+     * This protected method sets the limit parameter on the query to match the page size.
+     * @param {RawRedisQuery<M>} rawStatement - The original query statement
+     * @return {RawRedisQuery<M>} The modified query with pagination parameters
+     */
+    prepare(rawStatement) {
+        const query = Object.assign({}, rawStatement);
+        query.limit = this.size;
+        return query;
+    }
+    /**
+     * @description Retrieves a specific page of results
+     * @summary Executes the query with pagination parameters to retrieve a specific page of results.
+     * This method calculates the appropriate skip value based on the page number and page size,
+     * executes the query, and updates the current page tracking.
+     * @param {number} [page=1] - The page number to retrieve (1-based)
+     * @return {Promise<R[]>} A promise that resolves to an array of results for the requested page
+     */
+    async page(page = 1, ...args) {
+        const { ctx, ctxArgs } = this.adapter["logCtx"](args, this.page);
+        if (this.isPreparedStatement()) {
+            return this.pagePrepared(page, ...ctxArgs);
+        }
+        const statement = this.prepare(this.statement);
+        let results;
+        if (!this._recordCount || !this._totalPages) {
+            this._totalPages = this._recordCount = 0;
+            results = await this.adapter.raw({ ...statement, limit: Number.MAX_SAFE_INTEGER }, false, ctx);
+            this._recordCount = results.count || results.data.length;
+            if (this._recordCount > 0) {
+                const size = statement?.limit || this.size;
+                this._totalPages = Math.ceil(this._recordCount / size);
+                return await this.page(page, ...ctxArgs);
+            }
+        }
+        else {
+            page = this.validatePage(page);
+            statement.skip = (page - 1) * this.size;
+            results = await this.adapter.raw(statement, true, ...ctxArgs);
+        }
+        this._currentPage = page;
+        this._bookmark = results.length
+            ? results[results.length - 1][decorator_validation_1.Model.pk(this.clazz)]
+            : undefined;
+        return results.data || results;
+    }
+}
+exports.RedisPaginator = RedisPaginator;
+//# sourceMappingURL=RedisPaginator.js.map
+//# sourceMappingURL=RedisPaginator.cjs.map

package/lib/cjs/redis/RedisPaginator.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis/RedisPaginator.cjs","sourceRoot":"","sources":["redis/RedisPaginator.js"],"names":[],"mappings":";;;AAAA,yCAA4C;AAC5C,yEAAuD;AACvD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAa,cAAe,SAAQ,gBAAS;IACzC;;;;;;OAMG;IACH,YAAY,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK;QACnC,KAAK,CAAC,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;IACvC,CAAC;IACD;;;;;;OAMG;IACH,OAAO,CAAC,YAAY;QAChB,MAAM,KAAK,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,YAAY,CAAC,CAAC;QAC9C,KAAK,CAAC,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC;QACxB,OAAO,KAAK,CAAC;IACjB,CAAC;IACD;;;;;;;OAOG;IACH,KAAK,CAAC,IAAI,CAAC,IAAI,GAAG,CAAC,EAAE,GAAG,IAAI;QACxB,MAAM,EAAE,GAAG,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;QACjE,IAAI,IAAI,CAAC,mBAAmB,EAAE,EAAE,CAAC;YAC7B,OAAO,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,GAAG,OAAO,CAAC,CAAC;QAC/C,CAAC;QACD,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QAC/C,IAAI,OAAO,CAAC;QACZ,IAAI,CAAC,IAAI,CAAC,YAAY,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC;YAC1C,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,YAAY,GAAG,CAAC,CAAC;YACzC,OAAO,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,GAAG,SAAS,EAAE,KAAK,EAAE,MAAM,CAAC,gBAAgB,EAAE,EAAE,KAAK,EAAE,GAAG,CAAC,CAAC;YAC/F,IAAI,CAAC,YAAY,GAAG,OAAO,CAAC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC;YACzD,IAAI,IAAI,CAAC,YAAY,GAAG,CAAC,EAAE,CAAC;gBACxB,MAAM,IAAI,GAAG,SAAS,EAAE,KAAK,IAAI,IAAI,CAAC,IAAI,CAAC;gBAC3C,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,CAAC;gBACvD,OAAO,MAAM,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,GAAG,OAAO,CAAC,CAAC;YAC7C,CAAC;QACL,CAAC;aACI,CAAC;YACF,IAAI,GAAG,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;YAC/B,SAAS,CAAC,IAAI,GAAG,CAAC,IAAI,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC;YACxC,OAAO,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,SAAS,EAAE,IAAI,EAAE,GAAG,OAAO,CAAC,CAAC;QAClE,CAAC;QACD,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;QACzB,IAAI,CAAC,SAAS,GAAG,OAAO,CAAC,MAAM;YAC3B,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,4BAAK,CAAC,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACnD,CAAC,CAAC,SAAS,CAAC;QAChB,OAAO,OAAO,CAAC,IAAI,IAAI,OAAO,CAAC;IACnC,CAAC;CACJ;AA3DD,wCA2DC;AACD,0CAA0C"}

package/lib/cjs/redis/RedisStatement.cjs

@@ -0,0 +1,433 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisStatement = void 0;
+const core_1 = require("@decaf-ts/core");
+const db_decorators_1 = require("@decaf-ts/db-decorators");
+const decoration_1 = require("@decaf-ts/decoration");
+/**
+ * @description Redis-specific query statement builder
+ * @summary Extends the base Statement class to provide query building functionality for the Redis adapter.
+ * This class translates high-level query operations into predicates that can filter and sort
+ * in-memory data structures (records reverted from the table hash).
+ * @template M - The model type being queried
+ * @template R - The result type returned by the query
+ * @class RedisStatement
+ * @category Redis
+ * @example
+ * ```typescript
+ * // Create a statement for querying User models
+ * const statement = redisAdapter.Statement<User>();
+ *
+ * // Build a query to find active users with age > 18
+ * const results = await statement
+ *   .from(User)
+ *   .where(Condition.and(
+ *     Condition.eq('active', true),
+ *     Condition.gt('age', 18)
+ *   ))
+ *   .orderBy('lastName', 'asc')
+ *   .limit(10)
+ *   .execute();
+ * ```
+ */
+class RedisStatement extends core_1.Statement {
+    /**
+     * @description Creates a statement bound to the Redis adapter
+     * @param {A} adapter - The Redis adapter instance to use for executing queries
+     * @param {Partial<AdapterFlags>} [overrides] - Optional adapter flag overrides
+     */
+    constructor(adapter, overrides) {
+        super(adapter, overrides);
+    }
+    /**
+     * @description Creates a sort comparator function
+     * @summary Generates a function that compares two model instances based on the orderBy criteria.
+     * This method handles different data types (string, number, date) and sort directions (asc, desc).
+     * @return {function(Model, Model): number} A comparator function for sorting model instances
+     */
+    getSort() {
+        const selectors = this.orderBySelectors;
+        return (el1, el2) => {
+            if (!selectors || !selectors.length)
+                throw new db_decorators_1.InternalError("orderBySelectors not set. Should be impossible");
+            for (const [key, direction] of selectors) {
+                const normalizedDirection = String(direction).toLowerCase();
+                const directionFactor = normalizedDirection === core_1.OrderDirection.ASC ? 1 : -1;
+                const comparison = this.compareByKey(el1, el2, key);
+                if (comparison !== 0)
+                    return directionFactor * comparison;
+            }
+            return 0;
+        };
+    }
+    /**
+     * @description Compares two models by a single attribute
+     * @summary Resolves the attribute's design type and delegates to the matching
+     * type-specific comparator.
+     * @param {Model} el1 - The first model instance
+     * @param {Model} el2 - The second model instance
+     * @param {keyof Model} key - The attribute to compare
+     * @return {number} A negative number, zero or a positive number as per the comparison
+     */
+    compareByKey(el1, el2, key) {
+        const value1 = el1[key];
+        const value2 = el2[key];
+        if (value1 === value2)
+            return 0;
+        if (value1 == null || value2 == null)
+            return value1 == null ? 1 : -1;
+        const { designType: type } = decoration_1.Metadata.getPropDesignTypes(el1.constructor, key);
+        const resolvedType = (type && type.name && type.name.toLowerCase()) || typeof value1;
+        switch (resolvedType) {
+            case "string":
+                return this.compareStrings(value1, value2);
+            case "number":
+                return this.compareNumbers(value1, value2);
+            case "bigint":
+                return this.compareBigInts(value1, value2);
+            case "boolean":
+                return this.compareBooleans(value1, value2);
+            case "date":
+            case "object":
+                if (value1 instanceof Date && value2 instanceof Date) {
+                    return this.compareDates(value1, value2);
+                }
+                break;
+            default:
+                break;
+        }
+        throw new core_1.QueryError(`sorting not supported for type ${resolvedType}`);
+    }
+    /**
+     * @description Compares two boolean values
+     * @return {number} 0 when equal, 1 when `a` is true, -1 otherwise
+     */
+    compareBooleans(a, b) {
+        return a === b ? 0 : a ? 1 : -1;
+    }
+    /**
+     * @description Compares two numeric values
+     * @return {number} The numeric difference between the values
+     */
+    compareNumbers(a, b) {
+        return a - b;
+    }
+    /**
+     * @description Compares two bigint values
+     * @return {number} 0 when equal, 1 when `a` is greater, -1 otherwise
+     */
+    compareBigInts(a, b) {
+        if (a === b)
+            return 0;
+        return a > b ? 1 : -1;
+    }
+    /**
+     * @description Compares two strings using locale-aware ordering
+     * @return {number} The locale compare result between the values
+     */
+    compareStrings(a, b) {
+        return a.localeCompare(b);
+    }
+    /**
+     * @description Compares two dates by their epoch timestamps
+     * @return {number} The difference between the timestamps
+     */
+    compareDates(a, b) {
+        return a.valueOf() - b.valueOf();
+    }
+    /**
+     * @description Builds a Redis query from the statement
+     * @summary Converts the statement's selectors and conditions into a RawRedisQuery object
+     * that can be executed by the Redis adapter. This method assembles all query components
+     * (select, from, where, limit, offset, sort) into the final query structure.
+     * @return {RawRedisQuery<M>} The constructed Redis query object
+     */
+    build() {
+        if (this.minSelector)
+            this.ensureNumberOrDateSelector(this.minSelector, "MIN operation");
+        if (this.maxSelector)
+            this.ensureNumberOrDateSelector(this.maxSelector, "MAX operation");
+        if (this.sumSelector)
+            this.ensureNumericSelector(this.sumSelector, "SUM operation");
+        if (this.avgSelector)
+            this.ensureNumberOrDateSelector(this.avgSelector, "AVG operation");
+        const result = {
+            select: this.selectSelector,
+            from: this.fromSelector,
+            where: this.whereCondition
+                ? this.parseCondition(this.whereCondition).where
+                : // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                    (el) => {
+                        return true;
+                    },
+            limit: this.limitSelector,
+            skip: this.offsetSelector,
+            groupBy: this.groupBySelectors,
+        };
+        if (typeof this.countSelector !== "undefined")
+            result.count = this.countSelector;
+        if (this.countDistinctSelector)
+            result.countDistinct = this.countDistinctSelector;
+        if (this.minSelector)
+            result.min = this.minSelector;
+        if (this.maxSelector)
+            result.max = this.maxSelector;
+        if (this.sumSelector)
+            result.sum = this.sumSelector;
+        if (this.avgSelector)
+            result.avg = this.avgSelector;
+        if (this.distinctSelector)
+            result.distinct = this.distinctSelector;
+        if (this.orderBySelectors?.length)
+            result.sort = this.getSort();
+        return result;
+    }
+    /**
+     * @description Parses a condition into a Redis query predicate
+     * @summary Converts a Condition object into a predicate function that can be used
+     * to filter model instances in memory. This method handles both simple conditions
+     * (equals, greater than, etc.) and complex conditions with logical operators (AND, OR).
+     * @template M - The model type for the condition
+     * @param {Condition<M>} condition - The condition to parse
+     * @return {RawRedisQuery<M>} A Redis query object with a where predicate function
+     * @mermaid
+     * sequenceDiagram
+     *   participant Caller
+     *   participant RedisStatement
+     *   participant SimpleCondition
+     *   participant ComplexCondition
+     *
+     *   Caller->>RedisStatement: parseCondition(condition)
+     *   alt Simple condition (eq, gt, lt, etc.)
+     *     RedisStatement->>SimpleCondition: Extract attr1, operator, comparison
+     *     SimpleCondition-->>RedisStatement: Return predicate function
+     *   else Logical operator (AND, OR)
+     *     RedisStatement->>ComplexCondition: Extract nested conditions
+     *     RedisStatement->>RedisStatement: parseCondition(leftCondition)
+     *     RedisStatement->>RedisStatement: parseCondition(rightCondition)
+     *     ComplexCondition-->>RedisStatement: Combine predicates with logical operator
+     *   end
+     *   RedisStatement-->>Caller: Return query with where predicate
+     */
+    parseCondition(condition) {
+        return {
+            where: (m) => {
+                const { attr1, operator, comparison } = condition;
+                if ([core_1.GroupOperator.AND, core_1.GroupOperator.OR, core_1.Operator.NOT].indexOf(operator) === -1) {
+                    switch (operator) {
+                        case core_1.Operator.BIGGER:
+                            return m[attr1] > comparison;
+                        case core_1.Operator.BIGGER_EQ:
+                            return m[attr1] >= comparison;
+                        case core_1.Operator.DIFFERENT:
+                            return m[attr1] !== comparison;
+                        case core_1.Operator.EQUAL:
+                            return m[attr1] === comparison;
+                        case core_1.Operator.REGEXP:
+                            if (typeof m[attr1] !== "string")
+                                throw new core_1.QueryError(`Invalid regexp comparison on a non string attribute: ${m[attr1]}`);
+                            return !!m[attr1].match(new RegExp(comparison, "g"));
+                        case core_1.Operator.STARTS_WITH: {
+                            const attr = attr1;
+                            const attrName = attr;
+                            const attrValue = m[attr];
+                            if (typeof attrValue !== "string") {
+                                throw new core_1.QueryError(`Invalid startsWith comparison on a non string attribute "${attrName}"`);
+                            }
+                            if (typeof comparison !== "string") {
+                                throw new core_1.QueryError(`STARTS_WITH operator requires a string comparison, got ${typeof comparison}`);
+                            }
+                            return attrValue.startsWith(comparison);
+                        }
+                        case core_1.Operator.ENDS_WITH: {
+                            const attr = attr1;
+                            const attrName = attr;
+                            const attrValue = m[attr];
+                            if (typeof attrValue !== "string") {
+                                throw new core_1.QueryError(`Invalid endsWith comparison on a non string attribute "${attrName}"`);
+                            }
+                            if (typeof comparison !== "string") {
+                                throw new core_1.QueryError(`ENDS_WITH operator requires a string comparison, got ${typeof comparison}`);
+                            }
+                            return attrValue.endsWith(comparison);
+                        }
+                        case core_1.Operator.SMALLER:
+                            return m[attr1] < comparison;
+                        case core_1.Operator.SMALLER_EQ:
+                            return m[attr1] <= comparison;
+                        case core_1.Operator.IN:
+                            if (!Array.isArray(comparison))
+                                throw new core_1.QueryError(`IN operator requires an array, got: ${typeof comparison}`);
+                            return comparison.includes(m[attr1]);
+                        case core_1.Operator.BETWEEN: {
+                            if (!Array.isArray(comparison) || comparison.length !== 2)
+                                throw new core_1.QueryError(`BETWEEN operator requires an array with 2 values [min, max], got: ${JSON.stringify(comparison)}`);
+                            const attr = attr1;
+                            const attrName = attr;
+                            const attrType = this.determineAttributeType(m.constructor, attrName, "BETWEEN");
+                            if (!this.isNumericType(attrType) && attrType !== "date") {
+                                throw new core_1.QueryError(`BETWEEN operator requires numeric or date attributes, but "${attrName}" is ${attrType ||
+                                    "unknown"}`);
+                            }
+                            const [min, max] = comparison;
+                            const value = m[attr];
+                            const comparableValue = this.toComparableValue(value, attrType, attrName, "BETWEEN", { allowNull: true });
+                            if (comparableValue === null)
+                                return false;
+                            const minComparable = this.toComparableValue(min, attrType, attrName, "BETWEEN min");
+                            const maxComparable = this.toComparableValue(max, attrType, attrName, "BETWEEN max");
+                            return (comparableValue >= minComparable && comparableValue <= maxComparable);
+                        }
+                        case core_1.Operator.EXISTS: {
+                            const present = m[attr1] !== undefined &&
+                                m[attr1] !== null;
+                            return comparison === false ? !present : present;
+                        }
+                        default:
+                            throw new db_decorators_1.InternalError(`Invalid operator for standard comparisons: ${operator}`);
+                    }
+                }
+                else if (operator === core_1.Operator.NOT) {
+                    if (!(attr1 instanceof core_1.Condition)) {
+                        throw new db_decorators_1.InternalError("NOT operator requires a nested condition to negate");
+                    }
+                    const nested = this.parseCondition(attr1);
+                    return !nested.where(m);
+                }
+                else {
+                    const op1 = this.parseCondition(attr1);
+                    const op2 = this.parseCondition(comparison);
+                    switch (operator) {
+                        case core_1.GroupOperator.AND:
+                            return op1.where(m) && op2.where(m);
+                        case core_1.GroupOperator.OR:
+                            return op1.where(m) || op2.where(m);
+                        default:
+                            throw new db_decorators_1.InternalError(`Invalid operator for And/Or comparisons: ${operator}`);
+                    }
+                }
+            },
+        };
+    }
+    /**
+     * @description Validates that an aggregation selector targets a numeric attribute
+     * @param {SelectSelector<M>} selector - The attribute selector to validate
+     * @param {string} context - The aggregation context used in error messages
+     * @return {void}
+     */
+    ensureNumericSelector(selector, context) {
+        this.ensureSelectorType(selector, context, (type) => this.isNumericType(type), "numeric");
+    }
+    /**
+     * @description Validates that an aggregation selector targets a numeric or date attribute
+     * @param {SelectSelector<M>} selector - The attribute selector to validate
+     * @param {string} context - The aggregation context used in error messages
+     * @return {void}
+     */
+    ensureNumberOrDateSelector(selector, context) {
+        this.ensureSelectorType(selector, context, (type) => this.isNumericType(type) || type === "date", "numeric or date");
+    }
+    /**
+     * @description Validates that a selector's attribute type satisfies a predicate
+     * @summary Resolves the attribute type from the model metadata and raises a
+     * `QueryError` when the type does not match the expected kind.
+     * @param {SelectSelector<M>} selector - The attribute selector to validate
+     * @param {string} context - The aggregation context used in error messages
+     * @param {function(string): boolean} predicate - Type acceptance predicate
+     * @param {string} description - Human readable description of the accepted types
+     * @return {void}
+     */
+    ensureSelectorType(selector, context, predicate, description) {
+        if (!this.fromSelector) {
+            throw new db_decorators_1.InternalError(`${context} requires a target model. Call from() before aggregating.`);
+        }
+        const attr = selector;
+        const type = this.determineAttributeType(this.fromSelector, attr, context);
+        if (!predicate(type)) {
+            throw new core_1.QueryError(`${context} requires a ${description} attribute, but "${attr}" is ${type || "unknown"}`);
+        }
+    }
+    /**
+     * @description Resolves the attribute type from the model metadata
+     * @summary Reads the metadata or design type of the attribute and normalizes it
+     * to a lowercase type name.
+     * @param {Constructor<Model>} clazz - The model constructor
+     * @param {string} attr - The attribute name
+     * @param {string} context - The context used in error messages
+     * @return {string} The normalized attribute type
+     */
+    determineAttributeType(clazz, attr, context) {
+        const propKey = attr;
+        const metaType = decoration_1.Metadata.type(clazz, propKey) ??
+            decoration_1.Metadata.getPropDesignTypes(clazz, propKey)?.designType;
+        const resolved = this.normalizeMetaType(metaType);
+        if (!resolved) {
+            throw new core_1.QueryError(`${context} could not resolve property type for "${attr}"`);
+        }
+        return resolved;
+    }
+    /**
+     * @description Normalizes a raw metadata type to a lowercase type name
+     * @param {any} metaType - The raw metadata type value
+     * @return {string | undefined} The normalized type name, when resolvable
+     */
+    normalizeMetaType(metaType) {
+        if (!metaType)
+            return undefined;
+        if (typeof metaType === "string")
+            return metaType.toLowerCase();
+        if (typeof metaType === "function" && metaType.name)
+            return metaType.name.toLowerCase();
+        return undefined;
+    }
+    /**
+     * @description Whether the given type name is a numeric type
+     * @param {string} [type] - The normalized type name
+     * @return {boolean} True for "number" and "bigint"
+     */
+    isNumericType(type) {
+        return type === "number" || type === "bigint";
+    }
+    /**
+     * @description Converts a value to a numeric comparable value
+     * @summary Maps date, number and bigint values to numbers for comparison and
+     * raises a `QueryError` for missing or incompatible values.
+     * @param {any} value - The value to convert
+     * @param {string} attrType - The normalized attribute type
+     * @param {string} attrName - The attribute name used in error messages
+     * @param {string} context - The context used in error messages
+     * @param {object} [options] - Conversion options
+     * @param {boolean} [options.allowNull] - Whether null/undefined values return null instead of raising
+     * @return {number | null} The numeric comparable value
+     */
+    toComparableValue(value, attrType, attrName, context, options) {
+        if (value == null) {
+            if (options?.allowNull)
+                return null;
+            throw new core_1.QueryError(`${context} requires a value for "${attrName}"`);
+        }
+        switch (attrType) {
+            case "date":
+                if (!(value instanceof Date)) {
+                    throw new core_1.QueryError(`${context} on date attribute "${attrName}" requires Date values`);
+                }
+                return value.getTime();
+            case "number":
+                if (typeof value !== "number") {
+                    throw new core_1.QueryError(`${context} on numeric attribute "${attrName}" requires number values`);
+                }
+                return value;
+            case "bigint":
+                if (typeof value === "number")
+                    return value;
+                if (typeof value === "bigint")
+                    return Number(value);
+                throw new core_1.QueryError(`${context} on bigint attribute "${attrName}" requires numeric values`);
+            default:
+                throw new core_1.QueryError(`${context} unsupported type "${attrType}" for attribute "${attrName}"`);
+        }
+    }
+}
+exports.RedisStatement = RedisStatement;
+//# sourceMappingURL=RedisStatement.js.map
+//# sourceMappingURL=RedisStatement.cjs.map