@hotmeshio/hotmesh 0.6.0 → 0.7.0

package/build/services/memflow/workflow/proxyActivities.d.ts

@@ -11,10 +11,81 @@ declare function getProxyInterruptPayload(context: ReturnType<typeof getContext>
  */
 declare function wrapActivity<T>(activityName: string, options?: ActivityConfig): T;
 /**
- * Provides a proxy for defined activities, ensuring deterministic replay and retry.
+ * Create proxies for activity functions with automatic retry and deterministic replay.
+ * Activities execute via message queue, so they can run on different servers.
+ *
+ * Without `taskQueue`, activities use the workflow's task queue (e.g., `my-workflow-activity`).
+ * With `taskQueue`, activities use the specified queue (e.g., `payment-activity`).
+ *
+ * The `activities` parameter is optional. If activities are already registered via
+ * `registerActivityWorker()`, you can reference them by providing just the `taskQueue`
+ * and a TypeScript interface.
+ *
  * @template ACT
- * @param {ActivityConfig} [options] - Optional activity config (includes retryPolicy).
- * @returns {ProxyType<ACT>} A proxy to call activities as if local, but durably managed by the workflow.
+ * @param {ActivityConfig} [options] - Activity configuration
+ * @param {any} [options.activities] - (Optional) Activity functions to register inline
+ * @param {string} [options.taskQueue] - (Optional) Task queue name (without `-activity` suffix)
+ * @param {object} [options.retryPolicy] - Retry configuration
+ * @returns {ProxyType<ACT>} Proxy for calling activities with durability and retry
+ *
+ * @example
+ * ```typescript
+ * // Inline registration (activities in same codebase)
+ * const activities = MemFlow.workflow.proxyActivities<typeof activities>({
+ *   activities: { processData, validateData },
+ *   retryPolicy: { maximumAttempts: 3 }
+ * });
+ *
+ * await activities.processData('input');
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Reference pre-registered activities (can be on different server)
+ * interface PaymentActivities {
+ *   processPayment: (amount: number) => Promise<string>;
+ *   sendEmail: (to: string, subject: string) => Promise<void>;
+ * }
+ *
+ * const { processPayment, sendEmail } =
+ *   MemFlow.workflow.proxyActivities<PaymentActivities>({
+ *     taskQueue: 'payment',
+ *     retryPolicy: { maximumAttempts: 3 }
+ *   });
+ *
+ * const result = await processPayment(100.00);
+ * await sendEmail('user@example.com', 'Payment processed');
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Shared activities in interceptor
+ * const interceptor: WorkflowInterceptor = {
+ *   async execute(ctx, next) {
+ *     const { auditLog } = MemFlow.workflow.proxyActivities<{
+ *       auditLog: (id: string, action: string) => Promise<void>;
+ *     }>({
+ *       taskQueue: 'shared',
+ *       retryPolicy: { maximumAttempts: 3 }
+ *     });
+ *
+ *     await auditLog(ctx.get('workflowId'), 'started');
+ *     const result = await next();
+ *     await auditLog(ctx.get('workflowId'), 'completed');
+ *     return result;
+ *   }
+ * };
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Custom task queue for specific activities
+ * const highPriority = MemFlow.workflow.proxyActivities<typeof activities>({
+ *   activities: { criticalProcess },
+ *   taskQueue: 'high-priority',
+ *   retryPolicy: { maximumAttempts: 5 }
+ * });
+ * ```
  */
 export declare function proxyActivities<ACT>(options?: ActivityConfig): ProxyType<ACT>;
 export { wrapActivity, getProxyInterruptPayload };

package/build/services/memflow/workflow/proxyActivities.js

@@ -10,7 +10,11 @@ const didRun_1 = require("./didRun");
  */
 function getProxyInterruptPayload(context, activityName, execIndex, args, options) {
     const { workflowDimension, workflowId, originJobId, workflowTopic, expire } = context;
-    const activityTopic = `${workflowTopic}-activity`;
+    // Use explicitly provided taskQueue, otherwise derive from workflow (original behavior)
+    // This keeps backward compatibility while allowing explicit global/custom queues
+    const activityTopic = options?.taskQueue
+        ? `${options.taskQueue}-activity`
+        : `${workflowTopic}-activity`;
     const activityJobId = `-${workflowId}-$${activityName}${workflowDimension}-${execIndex}`;
     let maximumInterval;
     if (options?.retryPolicy?.maximumInterval) {
@@ -77,15 +81,88 @@ function wrapActivity(activityName, options) {
 }
 exports.wrapActivity = wrapActivity;
 /**
- * Provides a proxy for defined activities, ensuring deterministic replay and retry.
+ * Create proxies for activity functions with automatic retry and deterministic replay.
+ * Activities execute via message queue, so they can run on different servers.
+ *
+ * Without `taskQueue`, activities use the workflow's task queue (e.g., `my-workflow-activity`).
+ * With `taskQueue`, activities use the specified queue (e.g., `payment-activity`).
+ *
+ * The `activities` parameter is optional. If activities are already registered via
+ * `registerActivityWorker()`, you can reference them by providing just the `taskQueue`
+ * and a TypeScript interface.
+ *
  * @template ACT
- * @param {ActivityConfig} [options] - Optional activity config (includes retryPolicy).
- * @returns {ProxyType<ACT>} A proxy to call activities as if local, but durably managed by the workflow.
+ * @param {ActivityConfig} [options] - Activity configuration
+ * @param {any} [options.activities] - (Optional) Activity functions to register inline
+ * @param {string} [options.taskQueue] - (Optional) Task queue name (without `-activity` suffix)
+ * @param {object} [options.retryPolicy] - Retry configuration
+ * @returns {ProxyType<ACT>} Proxy for calling activities with durability and retry
+ *
+ * @example
+ * ```typescript
+ * // Inline registration (activities in same codebase)
+ * const activities = MemFlow.workflow.proxyActivities<typeof activities>({
+ *   activities: { processData, validateData },
+ *   retryPolicy: { maximumAttempts: 3 }
+ * });
+ *
+ * await activities.processData('input');
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Reference pre-registered activities (can be on different server)
+ * interface PaymentActivities {
+ *   processPayment: (amount: number) => Promise<string>;
+ *   sendEmail: (to: string, subject: string) => Promise<void>;
+ * }
+ *
+ * const { processPayment, sendEmail } =
+ *   MemFlow.workflow.proxyActivities<PaymentActivities>({
+ *     taskQueue: 'payment',
+ *     retryPolicy: { maximumAttempts: 3 }
+ *   });
+ *
+ * const result = await processPayment(100.00);
+ * await sendEmail('user@example.com', 'Payment processed');
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Shared activities in interceptor
+ * const interceptor: WorkflowInterceptor = {
+ *   async execute(ctx, next) {
+ *     const { auditLog } = MemFlow.workflow.proxyActivities<{
+ *       auditLog: (id: string, action: string) => Promise<void>;
+ *     }>({
+ *       taskQueue: 'shared',
+ *       retryPolicy: { maximumAttempts: 3 }
+ *     });
+ *
+ *     await auditLog(ctx.get('workflowId'), 'started');
+ *     const result = await next();
+ *     await auditLog(ctx.get('workflowId'), 'completed');
+ *     return result;
+ *   }
+ * };
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Custom task queue for specific activities
+ * const highPriority = MemFlow.workflow.proxyActivities<typeof activities>({
+ *   activities: { criticalProcess },
+ *   taskQueue: 'high-priority',
+ *   retryPolicy: { maximumAttempts: 5 }
+ * });
+ * ```
  */
 function proxyActivities(options) {
+    // Register activities if provided (optional - may already be registered remotely)
     if (options?.activities) {
         common_1.WorkerService.registerActivities(options.activities);
     }
+    // Create proxy for all registered activities
     const proxy = {};
     const keys = Object.keys(common_1.WorkerService.activityRegistry);
     if (keys.length) {

package/build/services/router/consumption/index.d.ts

@@ -19,7 +19,8 @@ export declare class ConsumptionManager<S extends StreamService<ProviderClient,
     private counts;
     private hasReachedMaxBackoff;
     private router;
-    constructor(stream: S, logger: ILogger, throttleManager: ThrottleManager, errorHandler: ErrorHandler, lifecycleManager: LifecycleManager<S>, reclaimDelay: number, reclaimCount: number, appId: string, role: any, router: any);
+    private retryPolicy;
+    constructor(stream: S, logger: ILogger, throttleManager: ThrottleManager, errorHandler: ErrorHandler, lifecycleManager: LifecycleManager<S>, reclaimDelay: number, reclaimCount: number, appId: string, role: any, router: any, retryPolicy?: import('../../../types/stream').RetryPolicy);
     createGroup(stream: string, group: string): Promise<void>;
     publishMessage(topic: string, streamData: StreamData | StreamDataResponse, transaction?: ProviderTransaction): Promise<string | ProviderTransaction>;
     consumeMessages(stream: string, group: string, consumer: string, callback: (streamData: StreamData) => Promise<StreamDataResponse | void>): Promise<void>;

package/build/services/router/consumption/index.js

@@ -7,7 +7,7 @@ const config_1 = require("../config");
 const stream_1 = require("../../../types/stream");
 const key_1 = require("../../../modules/key");
 class ConsumptionManager {
-    constructor(stream, logger, throttleManager, errorHandler, lifecycleManager, reclaimDelay, reclaimCount, appId, role, router) {
+    constructor(stream, logger, throttleManager, errorHandler, lifecycleManager, reclaimDelay, reclaimCount, appId, role, router, retryPolicy) {
         this.errorCount = 0;
         this.counts = {};
         this.stream = stream;
@@ -20,6 +20,7 @@ class ConsumptionManager {
         this.appId = appId;
         this.role = role;
         this.router = router;
+        this.retryPolicy = retryPolicy;
     }
     async createGroup(stream, group) {
         try {
@@ -32,6 +33,31 @@ class ConsumptionManager {
     async publishMessage(topic, streamData, transaction) {
         const code = streamData?.code || '200';
         this.counts[code] = (this.counts[code] || 0) + 1;
+        // Extract retry policy from child workflow (590) and activity (591) message data
+        // ONLY if values differ from YAML defaults (10, 3/5, 120)
+        // If they're defaults, let old retry mechanism (policies.retry) handle it
+        const codeNum = typeof code === 'number' ? code : parseInt(code, 10);
+        if ((codeNum === 590 || codeNum === 591) && streamData.data) {
+            const data = streamData.data;
+            const backoff = data.backoffCoefficient;
+            const attempts = data.maximumAttempts;
+            const maxInterval = typeof data.maximumInterval === 'string'
+                ? parseInt(data.maximumInterval)
+                : data.maximumInterval;
+            // Only extract if values are NOT the YAML defaults
+            // YAML defaults: backoffCoefficient=10, maximumAttempts=3 or 5, maximumInterval=120
+            const hasNonDefaultBackoff = backoff != null && backoff !== 10;
+            const hasNonDefaultAttempts = attempts != null && attempts !== 3 && attempts !== 5;
+            const hasNonDefaultInterval = maxInterval != null && maxInterval !== 120;
+            if (hasNonDefaultBackoff || hasNonDefaultAttempts || hasNonDefaultInterval) {
+                // Has custom values from config - add _streamRetryConfig
+                streamData._streamRetryConfig = {
+                    max_retry_attempts: attempts,
+                    backoff_coefficient: backoff,
+                    maximum_interval_seconds: maxInterval,
+                };
+            }
+        }
         const stream = this.stream.mintKey(key_1.KeyType.STREAMS, { topic });
         const responses = await this.stream.publishMessages(stream, [JSON.stringify(streamData)], { transaction });
         return responses[0];
@@ -390,7 +416,17 @@ class ConsumptionManager {
     async publishResponse(input, output) {
         if (output && typeof output === 'object') {
             if (output.status === 'error') {
-                return await this.errorHandler.handleRetry(input, output, this.publishMessage.bind(this));
+                // Extract retry policy with priority:
+                // 1. Use message-level _streamRetryConfig (from database columns or previous retry)
+                // 2. Fall back to router-level retryPolicy (from worker config)
+                const retryPolicy = input._streamRetryConfig
+                    ? {
+                        maximumAttempts: input._streamRetryConfig.max_retry_attempts,
+                        backoffCoefficient: input._streamRetryConfig.backoff_coefficient,
+                        maximumInterval: input._streamRetryConfig.maximum_interval_seconds,
+                    }
+                    : this.retryPolicy;
+                return await this.errorHandler.handleRetry(input, output, this.publishMessage.bind(this), retryPolicy);
             }
             else if (typeof output.metadata !== 'object') {
                 output.metadata = { ...input.metadata, guid: (0, utils_1.guid)() };

package/build/services/router/error-handling/index.d.ts

@@ -1,8 +1,8 @@
-import { StreamData, StreamDataResponse } from '../../../types/stream';
+import { StreamData, StreamDataResponse, RetryPolicy } from '../../../types/stream';
 export declare class ErrorHandler {
-    shouldRetry(input: StreamData, output: StreamDataResponse): [boolean, number];
+    shouldRetry(input: StreamData, output: StreamDataResponse, retryPolicy?: RetryPolicy): [boolean, number];
     structureUnhandledError(input: StreamData, err: Error): StreamDataResponse;
     structureUnacknowledgedError(input: StreamData): StreamDataResponse;
     structureError(input: StreamData, output: StreamDataResponse): StreamDataResponse;
-    handleRetry(input: StreamData, output: StreamDataResponse, publishMessage: (topic: string, streamData: StreamData | StreamDataResponse) => Promise<string>): Promise<string>;
+    handleRetry(input: StreamData, output: StreamDataResponse, publishMessage: (topic: string, streamData: StreamData | StreamDataResponse) => Promise<string>, retryPolicy?: RetryPolicy): Promise<string>;
 }

package/build/services/router/error-handling/index.js

@@ -5,18 +5,37 @@ const utils_1 = require("../../../modules/utils");
 const config_1 = require("../config");
 const stream_1 = require("../../../types/stream");
 class ErrorHandler {
-    shouldRetry(input, output) {
-        //const isUnhandledEngineError = output.code === 500;
+    shouldRetry(input, output, retryPolicy) {
+        const tryCount = input.metadata.try || 0;
+        // Priority 1: Use structured retry policy (from stream columns or config)
+        if (retryPolicy) {
+            const maxAttempts = retryPolicy.maximumAttempts || 3;
+            const backoffCoeff = retryPolicy.backoffCoefficient || 10;
+            const maxInterval = typeof retryPolicy.maximumInterval === 'string'
+                ? parseInt(retryPolicy.maximumInterval)
+                : (retryPolicy.maximumInterval || 120);
+            // Check if we can retry (next attempt would be attempt #tryCount+2, must be <= maxAttempts)
+            // tryCount=0 is 1st attempt, tryCount=1 is 2nd attempt, etc.
+            // So after tryCount, we've made (tryCount + 1) attempts
+            // We can retry if (tryCount + 1) < maxAttempts
+            if ((tryCount + 1) < maxAttempts) {
+                // Exponential backoff: min(coefficient^(try+1), maxInterval)
+                // First retry (after try=0): coefficient^1
+                // Second retry (after try=1): coefficient^2, etc.
+                const backoffSeconds = Math.min(Math.pow(backoffCoeff, tryCount + 1), maxInterval);
+                return [true, backoffSeconds * 1000]; // Convert to milliseconds
+            }
+            return [false, 0];
+        }
+        // Priority 2: Use message-level policies (existing behavior)
         const policies = input.policies?.retry;
         const errorCode = output.code.toString();
         const policy = policies?.[errorCode];
         const maxRetries = policy?.[0];
-        const tryCount = Math.min(input.metadata.try || 0, config_1.HMSH_MAX_RETRIES);
-        //only possible values for maxRetries are 1, 2, 3
-        //only possible values for tryCount are 0, 1, 2
-        if (maxRetries > tryCount) {
+        const cappedTryCount = Math.min(tryCount, config_1.HMSH_MAX_RETRIES);
+        if (maxRetries > cappedTryCount) {
             // 10ms, 100ms, or 1000ms delays between system retries
-            return [true, Math.pow(10, tryCount + 1)];
+            return [true, Math.pow(10, cappedTryCount + 1)];
         }
         return [false, 0];
     }
@@ -78,16 +97,32 @@ class ErrorHandler {
             data,
         };
     }
-    async handleRetry(input, output, publishMessage) {
-        const [shouldRetry, timeout] = this.shouldRetry(input, output);
+    async handleRetry(input, output, publishMessage, retryPolicy) {
+        const [shouldRetry, timeout] = this.shouldRetry(input, output, retryPolicy);
         if (shouldRetry) {
-            await (0, utils_1.sleepFor)(timeout);
-            return (await publishMessage(input.metadata.topic, {
+            // Only sleep if no retryPolicy (legacy behavior for backward compatibility)
+            // With retryPolicy, use visibility timeout instead of in-memory sleep
+            if (!retryPolicy) {
+                await (0, utils_1.sleepFor)(timeout);
+            }
+            // Create new message with incremented try count
+            const newMessage = {
                 data: input.data,
-                //note: retain guid (this is a retry attempt)
                 metadata: { ...input.metadata, try: (input.metadata.try || 0) + 1 },
                 policies: input.policies,
-            }));
+            };
+            // Propagate retry config to new message (for immutable pattern)
+            if (input._streamRetryConfig) {
+                newMessage._streamRetryConfig = input._streamRetryConfig;
+            }
+            // Add visibility delay for production-ready retry with retryPolicy
+            if (retryPolicy && timeout > 0) {
+                newMessage._visibilityDelayMs = timeout;
+            }
+            // Track retry attempt count in database
+            const currentAttempt = input._retryAttempt || 0;
+            newMessage._retryAttempt = currentAttempt + 1;
+            return (await publishMessage(input.metadata.topic, newMessage));
         }
         else {
             const structuredError = this.structureError(input, output);

package/build/services/router/index.d.ts

@@ -13,6 +13,7 @@ declare class Router<S extends StreamService<ProviderClient, ProviderTransaction
     reclaimCount: number;
     logger: ILogger;
     readonly: boolean;
+    retryPolicy: import('../../types/stream').RetryPolicy | undefined;
     errorCount: number;
     counts: {
         [key: string]: number;

package/build/services/router/index.js

@@ -29,11 +29,12 @@ class Router {
         this.reclaimCount = enhancedConfig.reclaimCount;
         this.logger = logger;
         this.readonly = enhancedConfig.readonly;
+        this.retryPolicy = enhancedConfig.retryPolicy;
         // Initialize submodule managers
         this.throttleManager = new throttling_1.ThrottleManager(enhancedConfig.throttle);
         this.errorHandler = new error_handling_1.ErrorHandler();
         this.lifecycleManager = new lifecycle_1.LifecycleManager(this.readonly, this.topic, this.logger, this.stream);
-        this.consumptionManager = new consumption_1.ConsumptionManager(this.stream, this.logger, this.throttleManager, this.errorHandler, this.lifecycleManager, this.reclaimDelay, this.reclaimCount, this.appId, this.role, this);
+        this.consumptionManager = new consumption_1.ConsumptionManager(this.stream, this.logger, this.throttleManager, this.errorHandler, this.lifecycleManager, this.reclaimDelay, this.reclaimCount, this.appId, this.role, this, this.retryPolicy);
         this.resetThrottleState();
     }
     // Legacy compatibility methods

package/build/services/search/factory.js

@@ -3,12 +3,20 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SearchServiceFactory = void 0;
 const utils_1 = require("../../modules/utils");
 const postgres_1 = require("./providers/postgres/postgres");
+const ioredis_1 = require("./providers/redis/ioredis");
+const redis_1 = require("./providers/redis/redis");
 class SearchServiceFactory {
     static async init(providerClient, storeProviderClient, namespace, appId, logger) {
         let service;
         if ((0, utils_1.identifyProvider)(providerClient) === 'postgres') {
             service = new postgres_1.PostgresSearchService(providerClient, storeProviderClient);
         }
+        else if ((0, utils_1.identifyProvider)(providerClient) === 'redis') {
+            service = new redis_1.RedisSearchService(providerClient, storeProviderClient);
+        }
+        else {
+            service = new ioredis_1.IORedisSearchService(providerClient, storeProviderClient);
+        }
         await service.init(namespace, appId, logger);
         return service;
     }

package/build/services/search/providers/redis/ioredis.d.ts

@@ -0,0 +1,23 @@
+import { SearchService } from '../../index';
+import { ILogger } from '../../../logger';
+import { IORedisClientType } from '../../../../types/redis';
+declare class IORedisSearchService extends SearchService<IORedisClientType> {
+    constructor(searchClient: IORedisClientType, storeClient?: IORedisClientType);
+    init(namespace: string, appId: string, logger: ILogger): Promise<void>;
+    createSearchIndex(indexName: string, prefixes: string[], schema: string[]): Promise<void>;
+    listSearchIndexes(): Promise<string[]>;
+    updateContext(key: string, fields: Record<string, string>): Promise<any>;
+    setFields(key: string, fields: Record<string, string>): Promise<number>;
+    getField(key: string, field: string): Promise<string>;
+    getFields(key: string, fields: string[]): Promise<string[]>;
+    getAllFields(key: string): Promise<Record<string, string>>;
+    deleteFields(key: string, fields: string[]): Promise<number>;
+    incrementFieldByFloat(key: string, field: string, increment: number): Promise<number>;
+    sendQuery(...query: [string, ...string[]]): Promise<any>;
+    sendIndexedQuery(index: string, query: string[]): Promise<string[]>;
+    findEntities(): Promise<any[]>;
+    findEntityById(): Promise<any>;
+    findEntitiesByCondition(): Promise<any[]>;
+    createEntityIndex(): Promise<void>;
+}
+export { IORedisSearchService };

package/build/services/search/providers/redis/ioredis.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IORedisSearchService = void 0;
+const index_1 = require("../../index");
+class IORedisSearchService extends index_1.SearchService {
+    constructor(searchClient, storeClient) {
+        super(searchClient, storeClient);
+    }
+    async init(namespace, appId, logger) {
+        this.namespace = namespace;
+        this.appId = appId;
+        this.logger = logger;
+    }
+    async createSearchIndex(indexName, prefixes, schema) {
+        try {
+            await this.searchClient.call('FT.CREATE', indexName, 'ON', 'HASH', 'PREFIX', prefixes.length.toString(), ...prefixes, 'SCHEMA', ...schema);
+        }
+        catch (error) {
+            this.logger.info('Error creating search index', { error });
+            throw error;
+        }
+    }
+    async listSearchIndexes() {
+        try {
+            const indexes = await this.searchClient.call('FT._LIST');
+            return indexes;
+        }
+        catch (error) {
+            this.logger.info('Error listing search indexes', { error });
+            throw error;
+        }
+    }
+    async updateContext(key, fields) {
+        // Find replay ID if present (field with hyphen, not the @udata field)
+        const replayId = Object.keys(fields).find((k) => k.includes('-') && !k.startsWith('@'));
+        // Route based on @udata operation
+        if ('@udata:set' in fields) {
+            const udata = JSON.parse(fields['@udata:set']);
+            const fieldsToSet = Array.isArray(udata)
+                ? Object.fromEntries(Array.from({ length: udata.length / 2 }, (_, i) => [
+                    udata[i * 2],
+                    udata[i * 2 + 1],
+                ]))
+                : udata;
+            const result = await this.setFields(key, fieldsToSet);
+            if (replayId)
+                await this.searchClient.hset(key, { [replayId]: String(result) });
+            return result;
+        }
+        if ('@udata:get' in fields) {
+            const result = await this.getField(key, fields['@udata:get']);
+            if (replayId)
+                await this.searchClient.hset(key, { [replayId]: result });
+            return result;
+        }
+        if ('@udata:mget' in fields) {
+            const result = await this.getFields(key, JSON.parse(fields['@udata:mget']));
+            if (replayId)
+                await this.searchClient.hset(key, { [replayId]: result.join('|||') });
+            return result;
+        }
+        if ('@udata:delete' in fields) {
+            const result = await this.deleteFields(key, JSON.parse(fields['@udata:delete']));
+            if (replayId)
+                await this.searchClient.hset(key, { [replayId]: String(result) });
+            return result;
+        }
+        if ('@udata:increment' in fields) {
+            const { field, value } = JSON.parse(fields['@udata:increment']);
+            const result = await this.incrementFieldByFloat(key, field, value);
+            if (replayId)
+                await this.searchClient.hset(key, { [replayId]: String(result) });
+            return result;
+        }
+        if ('@udata:multiply' in fields) {
+            const { field, value } = JSON.parse(fields['@udata:multiply']);
+            const result = await this.incrementFieldByFloat(key, field, Math.log(value));
+            if (replayId)
+                await this.searchClient.hset(key, { [replayId]: String(result) });
+            return result;
+        }
+        if ('@udata:all' in fields) {
+            const all = await this.getAllFields(key);
+            const result = Object.fromEntries(Object.entries(all).filter(([k]) => k.startsWith('_')));
+            if (replayId)
+                await this.searchClient.hset(key, { [replayId]: JSON.stringify(result) });
+            return result;
+        }
+        // Default: call setFields
+        return await this.setFields(key, fields);
+    }
+    async setFields(key, fields) {
+        try {
+            const result = await this.searchClient.hset(key, fields);
+            return Number(result);
+        }
+        catch (error) {
+            this.logger.error(`Error setting fields for key: ${key}`, { error });
+            throw error;
+        }
+    }
+    async getField(key, field) {
+        try {
+            return await this.searchClient.hget(key, field);
+        }
+        catch (error) {
+            this.logger.error(`Error getting field ${field} for key: ${key}`, {
+                error,
+            });
+            throw error;
+        }
+    }
+    async getFields(key, fields) {
+        try {
+            return await this.searchClient.hmget(key, [...fields]);
+        }
+        catch (error) {
+            this.logger.error(`Error getting fields for key: ${key}`, { error });
+            throw error;
+        }
+    }
+    async getAllFields(key) {
+        try {
+            return await this.searchClient.hgetall(key);
+        }
+        catch (error) {
+            this.logger.error(`Error getting fields for key: ${key}`, { error });
+            throw error;
+        }
+    }
+    async deleteFields(key, fields) {
+        try {
+            const result = await this.searchClient.hdel(key, ...fields);
+            return Number(result);
+        }
+        catch (error) {
+            this.logger.error(`Error deleting fields for key: ${key}`, { error });
+            throw error;
+        }
+    }
+    async incrementFieldByFloat(key, field, increment) {
+        try {
+            const result = await this.searchClient.hincrbyfloat(key, field, increment);
+            return Number(result);
+        }
+        catch (error) {
+            this.logger.error(`Error incrementing field ${field} for key: ${key}`, {
+                error,
+            });
+            throw error;
+        }
+    }
+    async sendQuery(...query) {
+        try {
+            return await this.searchClient.call(...query);
+        }
+        catch (error) {
+            this.logger.error('Error executing query', { error });
+            throw error;
+        }
+    }
+    async sendIndexedQuery(index, query) {
+        try {
+            if (query[0]?.startsWith('FT.')) {
+                const [cmd, ...rest] = query;
+                return (await this.searchClient.call(cmd, ...rest));
+            }
+            return (await this.searchClient.call('FT.SEARCH', index, ...query));
+        }
+        catch (error) {
+            this.logger.error('Error executing query', { error });
+            throw error;
+        }
+    }
+    // Entity methods - not implemented for Redis (postgres-specific JSONB operations)
+    async findEntities() {
+        throw new Error('Entity findEntities not supported in Redis - use PostgreSQL');
+    }
+    async findEntityById() {
+        throw new Error('Entity findEntityById not supported in Redis - use PostgreSQL');
+    }
+    async findEntitiesByCondition() {
+        throw new Error('Entity findEntitiesByCondition not supported in Redis - use PostgreSQL');
+    }
+    async createEntityIndex() {
+        throw new Error('Entity createEntityIndex not supported in Redis - use PostgreSQL');
+    }
+}
+exports.IORedisSearchService = IORedisSearchService;

package/build/services/search/providers/redis/redis.d.ts

@@ -0,0 +1,23 @@
+import { SearchService } from '../../index';
+import { ILogger } from '../../../logger';
+import { RedisRedisClientType } from '../../../../types/redis';
+declare class RedisSearchService extends SearchService<RedisRedisClientType> {
+    constructor(searchClient: RedisRedisClientType, storeClient?: RedisRedisClientType);
+    init(namespace: string, appId: string, logger: ILogger): Promise<void>;
+    createSearchIndex(indexName: string, prefixes: string[], schema: string[]): Promise<void>;
+    listSearchIndexes(): Promise<string[]>;
+    updateContext(key: string, fields: Record<string, string>): Promise<any>;
+    setFields(key: string, fields: Record<string, string>): Promise<number>;
+    getField(key: string, field: string): Promise<string>;
+    getFields(key: string, fields: string[]): Promise<string[]>;
+    getAllFields(key: string): Promise<Record<string, string>>;
+    deleteFields(key: string, fields: string[]): Promise<number>;
+    incrementFieldByFloat(key: string, field: string, increment: number): Promise<number>;
+    sendQuery(...query: any[]): Promise<any>;
+    sendIndexedQuery(index: string, query: string[]): Promise<string[]>;
+    findEntities(): Promise<any[]>;
+    findEntityById(): Promise<any>;
+    findEntitiesByCondition(): Promise<any[]>;
+    createEntityIndex(): Promise<void>;
+}
+export { RedisSearchService };