@hotmeshio/hotmesh 0.5.0 → 0.5.2

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

@@ -6,6 +6,7 @@ import { Entity } from './entity';
 import { WorkerService } from './worker';
 import { WorkflowService } from './workflow';
 import { WorkflowHandleService } from './handle';
+import { didInterrupt } from './workflow/interruption';
 /**
  * The MemFlow service is a collection of services that
  * emulate Temporal's capabilities, but instead are
@@ -106,6 +107,13 @@ declare class MemFlowClass {
      * including: `execChild`, `waitFor`, `sleep`, etc
      */
     static workflow: typeof WorkflowService;
+    /**
+     * Checks if an error is a HotMesh reserved error type that indicates
+     * a workflow interruption rather than a true error condition.
+     *
+     * @see {@link utils/interruption.didInterrupt} for detailed documentation
+     */
+    static didInterrupt: typeof didInterrupt;
     /**
      * Shutdown everything. All connections, workers, and clients will be closed.
      * Include in your signal handlers to ensure a clean shutdown.

package/build/services/memflow/index.js

@@ -9,6 +9,7 @@ const entity_1 = require("./entity");
 const worker_1 = require("./worker");
 const workflow_1 = require("./workflow");
 const handle_1 = require("./handle");
+const interruption_1 = require("./workflow/interruption");
 /**
  * The MemFlow service is a collection of services that
  * emulate Temporal's capabilities, but instead are
@@ -120,3 +121,10 @@ MemFlowClass.Worker = worker_1.WorkerService;
  * including: `execChild`, `waitFor`, `sleep`, etc
  */
 MemFlowClass.workflow = workflow_1.WorkflowService;
+/**
+ * Checks if an error is a HotMesh reserved error type that indicates
+ * a workflow interruption rather than a true error condition.
+ *
+ * @see {@link utils/interruption.didInterrupt} for detailed documentation
+ */
+MemFlowClass.didInterrupt = interruption_1.didInterrupt;

package/build/services/memflow/worker.js

@@ -322,6 +322,31 @@ class WorkerService {
                 const workflowResponse = await storage_1.asyncLocalStorage.run(context, async () => {
                     return await workflowFunction.apply(this, workflowInput.arguments);
                 });
+                //if the embedded function has a try/catch, it can interrup the throw
+                // throw here to interrupt the workflow if the embedded function caught and suppressed
+                if (interruptionRegistry.length > 0) {
+                    const payload = interruptionRegistry[0];
+                    switch (payload.type) {
+                        case 'MemFlowWaitForError':
+                            throw new errors_1.MemFlowWaitForError(payload);
+                        case 'MemFlowProxyError':
+                            throw new errors_1.MemFlowProxyError(payload);
+                        case 'MemFlowChildError':
+                            throw new errors_1.MemFlowChildError(payload);
+                        case 'MemFlowSleepError':
+                            throw new errors_1.MemFlowSleepError(payload);
+                        case 'MemFlowTimeoutError':
+                            throw new errors_1.MemFlowTimeoutError(payload.message, payload.stack);
+                        case 'MemFlowMaxedError':
+                            throw new errors_1.MemFlowMaxedError(payload.message, payload.stack);
+                        case 'MemFlowFatalError':
+                            throw new errors_1.MemFlowFatalError(payload.message, payload.stack);
+                        case 'MemFlowRetryError':
+                            throw new errors_1.MemFlowRetryError(payload.message, payload.stack);
+                        default:
+                            throw new errors_1.MemFlowRetryError(`Unknown interruption type: ${payload.type}`);
+                    }
+                }
                 return {
                     code: 200,
                     status: stream_1.StreamStatus.SUCCESS,

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

@@ -82,6 +82,7 @@ async function execChild(options) {
     const interruptionMessage = getChildInterruptPayload(context, options, execIndex);
     interruptionRegistry.push({
         code: common_1.HMSH_CODE_MEMFLOW_CHILD,
+        type: 'MemFlowChildError',
         ...interruptionMessage,
     });
     await (0, common_1.sleepImmediate)();

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

@@ -3,8 +3,8 @@ import { HookOptions } from './common';
  * Extended hook options that include signal configuration
  */
 export interface ExecHookOptions extends HookOptions {
-    /** Signal ID to send after hook execution */
-    signalId: string;
+    /** Signal ID to send after hook execution; if not provided, a random one will be generated */
+    signalId?: string;
 }
 /**
  * Executes a hook function and awaits the signal response.

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

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.execHook = void 0;
 const hook_1 = require("./hook");
 const waitFor_1 = require("./waitFor");
+const interruption_1 = require("./interruption");
 /**
  * Executes a hook function and awaits the signal response.
  * This is a convenience method that combines `hook()` and `waitFor()` operations.
@@ -60,14 +61,23 @@ const waitFor_1 = require("./waitFor");
  * ```
  */
 async function execHook(options) {
-    // Create hook options with signal field added to args
-    const hookOptions = {
-        ...options,
-        args: [...options.args, { signal: options.signalId }]
-    };
-    // Execute the hook with the signal information
-    await (0, hook_1.hook)(hookOptions);
-    // Wait for the signal response and return it
-    return await (0, waitFor_1.waitFor)(options.signalId);
+    try {
+        if (!options.signalId) {
+            options.signalId = 'memflow-hook-' + crypto.randomUUID();
+        }
+        const hookOptions = {
+            ...options,
+            args: [...options.args, { signal: options.signalId, $memflow: true }]
+        };
+        // Execute the hook with the signal information
+        await (0, hook_1.hook)(hookOptions);
+        // Wait for the signal response and return it
+        return await (0, waitFor_1.waitFor)(options.signalId);
+    }
+    catch (error) {
+        if ((0, interruption_1.didInterrupt)(error)) {
+            throw error;
+        }
+    }
 }
 exports.execHook = execHook;

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

@@ -12,6 +12,7 @@ import { random } from './random';
 import { signal } from './signal';
 import { hook } from './hook';
 import { interrupt } from './interrupt';
+import { didInterrupt } from './interruption';
 import { all } from './all';
 import { sleepFor } from './sleepFor';
 import { waitFor } from './waitFor';
@@ -22,10 +23,6 @@ import { entity } from './entityMethods';
  * These methods ensure deterministic replay, persistence of state, and error handling across
  * re-entrant workflow executions.
  *
- * By refactoring the original single-file implementation into submodules,
- * we maintain clear separation of concerns and improved maintainability,
- * while preserving type information and full functionality.
- *
  * @example
  * ```typescript
  * import { MemFlow } from '@hotmeshio/hotmesh';
@@ -62,6 +59,7 @@ export declare class WorkflowService {
     static random: typeof random;
     static signal: typeof signal;
     static hook: typeof hook;
+    static didInterrupt: typeof didInterrupt;
     static interrupt: typeof interrupt;
     static all: typeof all;
     static sleepFor: typeof sleepFor;

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

@@ -15,6 +15,7 @@ const random_1 = require("./random");
 const signal_1 = require("./signal");
 const hook_1 = require("./hook");
 const interrupt_1 = require("./interrupt");
+const interruption_1 = require("./interruption");
 const all_1 = require("./all");
 const sleepFor_1 = require("./sleepFor");
 const waitFor_1 = require("./waitFor");
@@ -25,10 +26,6 @@ const entityMethods_1 = require("./entityMethods");
  * These methods ensure deterministic replay, persistence of state, and error handling across
  * re-entrant workflow executions.
  *
- * By refactoring the original single-file implementation into submodules,
- * we maintain clear separation of concerns and improved maintainability,
- * while preserving type information and full functionality.
- *
  * @example
  * ```typescript
  * import { MemFlow } from '@hotmeshio/hotmesh';
@@ -80,6 +77,7 @@ WorkflowService.entity = entityMethods_1.entity;
 WorkflowService.random = random_1.random;
 WorkflowService.signal = signal_1.signal;
 WorkflowService.hook = hook_1.hook;
+WorkflowService.didInterrupt = interruption_1.didInterrupt;
 WorkflowService.interrupt = interrupt_1.interrupt;
 WorkflowService.all = all_1.all;
 WorkflowService.sleepFor = sleepFor_1.sleepFor;

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

@@ -0,0 +1,28 @@
+/**
+ * Checks if an error is a HotMesh reserved error type that indicates
+ * a HotMesh interruption rather than a true error condition.
+ *
+ * When this returns true, you can safely return rethrow the error.
+ * The workflow engine will handle the interruption automatically.
+ *
+ * @example
+ * ```typescript
+ * import { MemFlow } from '@hotmeshio/hotmesh';
+ *
+ * try {
+ *   await someWorkflowOperation();
+ * } catch (error) {
+ *   // Check if this is a HotMesh interruption
+ *   if (MemFlow.workflow.didInterrupt(error)) {
+ *     // Rethrow the error
+ *     throw error;
+ *   }
+ *   // Handle actual error
+ *   console.error('Workflow failed:', error);
+ * }
+ * ```
+ *
+ * @param error - The error to check
+ * @returns true if the error is a HotMesh interruption
+ */
+export declare function didInterrupt(error: Error): boolean;

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

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.didInterrupt = void 0;
+const errors_1 = require("../../../modules/errors");
+/**
+ * Checks if an error is a HotMesh reserved error type that indicates
+ * a HotMesh interruption rather than a true error condition.
+ *
+ * When this returns true, you can safely return rethrow the error.
+ * The workflow engine will handle the interruption automatically.
+ *
+ * @example
+ * ```typescript
+ * import { MemFlow } from '@hotmeshio/hotmesh';
+ *
+ * try {
+ *   await someWorkflowOperation();
+ * } catch (error) {
+ *   // Check if this is a HotMesh interruption
+ *   if (MemFlow.workflow.didInterrupt(error)) {
+ *     // Rethrow the error
+ *     throw error;
+ *   }
+ *   // Handle actual error
+ *   console.error('Workflow failed:', error);
+ * }
+ * ```
+ *
+ * @param error - The error to check
+ * @returns true if the error is a HotMesh interruption
+ */
+function didInterrupt(error) {
+    return (error instanceof errors_1.MemFlowChildError ||
+        error instanceof errors_1.MemFlowFatalError ||
+        error instanceof errors_1.MemFlowMaxedError ||
+        error instanceof errors_1.MemFlowProxyError ||
+        error instanceof errors_1.MemFlowRetryError ||
+        error instanceof errors_1.MemFlowSleepError ||
+        error instanceof errors_1.MemFlowTimeoutError ||
+        error instanceof errors_1.MemFlowWaitForError ||
+        error instanceof errors_1.MemFlowWaitForAllError);
+}
+exports.didInterrupt = didInterrupt;

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

@@ -67,6 +67,7 @@ function wrapActivity(activityName, options) {
         const interruptionMessage = getProxyInterruptPayload(context, activityName, execIndex, args, options);
         interruptionRegistry.push({
             code: common_1.HMSH_CODE_MEMFLOW_PROXY,
+            type: 'MemFlowProxyError',
             ...interruptionMessage,
         });
         await (0, common_1.sleepImmediate)();

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

@@ -43,6 +43,7 @@ async function sleepFor(duration) {
     };
     interruptionRegistry.push({
         code: common_1.HMSH_CODE_MEMFLOW_SLEEP,
+        type: 'MemFlowSleepError',
         ...interruptionMessage,
     });
     await (0, common_1.sleepImmediate)();

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

@@ -45,12 +45,12 @@ async function waitFor(signalId) {
         signalId,
         index: execIndex,
         workflowDimension,
-    };
-    interruptionRegistry.push({
+        type: 'MemFlowWaitForError',
         code: common_1.HMSH_CODE_MEMFLOW_WAIT,
-        ...interruptionMessage,
-    });
+    };
+    interruptionRegistry.push(interruptionMessage);
     await (0, common_1.sleepImmediate)();
+    //if you are seeing this error in the logs, you might have forgotten to `await waitFor(...)`
     throw new common_1.MemFlowWaitForError(interruptionMessage);
 }
 exports.waitFor = waitFor;

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

@@ -19,5 +19,15 @@ declare abstract class SearchService<ClientProvider extends ProviderClient> {
     abstract incrementFieldByFloat(key: string, field: string, increment: number): Promise<number>;
     abstract sendQuery(query: any): Promise<any>;
     abstract sendIndexedQuery(index: string, query: any[]): Promise<any>;
+    abstract findEntities(entity: string, conditions: Record<string, any>, options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<any[]>;
+    abstract findEntityById(entity: string, id: string): Promise<any>;
+    abstract findEntitiesByCondition(entity: string, field: string, value: any, operator?: '=' | '!=' | '>' | '<' | '>=' | '<=' | 'LIKE' | 'IN', options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<any[]>;
+    abstract createEntityIndex(entity: string, field: string, indexType?: 'btree' | 'gin' | 'gist'): Promise<void>;
 }
 export { SearchService };

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

@@ -21,5 +21,17 @@ declare class PostgresSearchService extends SearchService<PostgresClientType & P
      * assume aggregation type query
      */
     sendIndexedQuery(type: string, queryParams?: any[]): Promise<any[]>;
+    findEntities(entity: string, conditions: Record<string, any>, options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<any[]>;
+    findEntityById(entity: string, id: string): Promise<any>;
+    findEntitiesByCondition(entity: string, field: string, value: any, operator?: '=' | '!=' | '>' | '<' | '>=' | '<=' | 'LIKE' | 'IN', options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<any[]>;
+    createEntityIndex(entity: string, field: string, indexType?: 'btree' | 'gin' | 'gist'): Promise<void>;
+    private mongoToSqlOperator;
+    private inferType;
 }
 export { PostgresSearchService };

package/build/services/search/providers/postgres/postgres.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PostgresSearchService = void 0;
 const index_1 = require("../../index");
 const kvsql_1 = require("../../../store/providers/postgres/kvsql");
+const key_1 = require("../../../../modules/key");
 class PostgresSearchService extends index_1.SearchService {
     transact() {
         return this.storeClient.transact();
@@ -145,5 +146,213 @@ class PostgresSearchService extends index_1.SearchService {
             throw error;
         }
     }
+    // Entity querying methods for JSONB/SQL operations
+    async findEntities(entity, conditions, options) {
+        try {
+            const schemaName = this.searchClient.safeName(this.appId);
+            const tableName = `${schemaName}.${this.searchClient.safeName('jobs')}`;
+            // Build WHERE conditions from the conditions object
+            const whereConditions = [`entity = $1`];
+            const params = [entity];
+            let paramIndex = 2;
+            for (const [key, value] of Object.entries(conditions)) {
+                if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+                    // Handle MongoDB-style operators like { $gte: 18 }
+                    for (const [op, opValue] of Object.entries(value)) {
+                        const sqlOp = this.mongoToSqlOperator(op);
+                        whereConditions.push(`(context->>'${key}')::${this.inferType(opValue)} ${sqlOp} $${paramIndex}`);
+                        params.push(opValue);
+                        paramIndex++;
+                    }
+                }
+                else {
+                    // Simple equality
+                    whereConditions.push(`context->>'${key}' = $${paramIndex}`);
+                    params.push(String(value));
+                    paramIndex++;
+                }
+            }
+            let sql = `
+        SELECT key, context, status
+        FROM ${tableName}
+        WHERE ${whereConditions.join(' AND ')}
+        ORDER BY created_at DESC
+      `;
+            if (options?.limit) {
+                sql += ` LIMIT $${paramIndex}`;
+                params.push(options.limit);
+                paramIndex++;
+            }
+            if (options?.offset) {
+                sql += ` OFFSET $${paramIndex}`;
+                params.push(options.offset);
+            }
+            const result = await this.pgClient.query(sql, params);
+            return result.rows.map(row => ({
+                key: row.key,
+                context: typeof row.context === 'string' ? JSON.parse(row.context || '{}') : (row.context || {}),
+                status: row.status,
+            }));
+        }
+        catch (error) {
+            this.logger.error(`postgres-find-entities-error`, { entity, conditions, error });
+            throw error;
+        }
+    }
+    async findEntityById(entity, id) {
+        try {
+            const schemaName = this.searchClient.safeName(this.appId);
+            const tableName = `${schemaName}.${this.searchClient.safeName('jobs')}`;
+            // Use KeyService to mint the job state key
+            const fullKey = key_1.KeyService.mintKey(key_1.HMNS, key_1.KeyType.JOB_STATE, {
+                appId: this.appId,
+                jobId: id
+            });
+            const sql = `
+        SELECT key, context, status, entity
+        FROM ${tableName}
+        WHERE entity = $1 AND key = $2
+        LIMIT 1
+      `;
+            const result = await this.pgClient.query(sql, [entity, fullKey]);
+            if (result.rows.length === 0) {
+                return null;
+            }
+            const row = result.rows[0];
+            return {
+                key: row.key,
+                context: typeof row.context === 'string' ? JSON.parse(row.context || '{}') : (row.context || {}),
+                status: row.status,
+            };
+        }
+        catch (error) {
+            this.logger.error(`postgres-find-entity-by-id-error`, { entity, id, error });
+            throw error;
+        }
+    }
+    async findEntitiesByCondition(entity, field, value, operator = '=', options) {
+        try {
+            const schemaName = this.searchClient.safeName(this.appId);
+            const tableName = `${schemaName}.${this.searchClient.safeName('jobs')}`;
+            const params = [entity];
+            let whereCondition;
+            let paramIndex = 2;
+            if (operator === 'IN') {
+                // Handle IN operator with arrays
+                const placeholders = Array.isArray(value)
+                    ? value.map(() => `$${paramIndex++}`).join(',')
+                    : `$${paramIndex++}`;
+                whereCondition = `context->>'${field}' IN (${placeholders})`;
+                if (Array.isArray(value)) {
+                    params.push(...value);
+                }
+                else {
+                    params.push(value);
+                }
+            }
+            else if (operator === 'LIKE') {
+                whereCondition = `context->>'${field}' LIKE $${paramIndex}`;
+                params.push(value);
+                paramIndex++;
+            }
+            else {
+                // Handle numeric/comparison operators
+                const valueType = this.inferType(value);
+                whereCondition = `(context->>'${field}')::${valueType} ${operator} $${paramIndex}`;
+                params.push(value);
+                paramIndex++;
+            }
+            let sql = `
+        SELECT key, context, status
+        FROM ${tableName}
+        WHERE entity = $1 AND ${whereCondition}
+        ORDER BY created_at DESC
+      `;
+            if (options?.limit) {
+                sql += ` LIMIT $${paramIndex}`;
+                params.push(options.limit);
+                paramIndex++;
+            }
+            if (options?.offset) {
+                sql += ` OFFSET $${paramIndex}`;
+                params.push(options.offset);
+            }
+            const result = await this.pgClient.query(sql, params);
+            return result.rows.map(row => ({
+                key: row.key,
+                context: typeof row.context === 'string' ? JSON.parse(row.context || '{}') : (row.context || {}),
+                status: row.status,
+            }));
+        }
+        catch (error) {
+            this.logger.error(`postgres-find-entities-by-condition-error`, {
+                entity, field, value, operator, error
+            });
+            throw error;
+        }
+    }
+    async createEntityIndex(entity, field, indexType = 'btree') {
+        try {
+            const schemaName = this.searchClient.safeName(this.appId);
+            const tableName = `${schemaName}.${this.searchClient.safeName('jobs')}`;
+            const indexName = `idx_${this.appId}_${entity}_${field}`.replace(/[^a-zA-Z0-9_]/g, '_');
+            let sql;
+            if (indexType === 'gin') {
+                // GIN index for JSONB operations
+                sql = `
+          CREATE INDEX IF NOT EXISTS ${indexName}
+          ON ${tableName} USING gin (context jsonb_path_ops)
+          WHERE entity = '${entity}'
+        `;
+            }
+            else if (indexType === 'gist') {
+                // GiST index for specific field
+                sql = `
+          CREATE EXTENSION IF NOT EXISTS pg_trgm;
+          CREATE INDEX IF NOT EXISTS ${indexName}
+          ON ${tableName} USING gist ((context->>'${field}') gist_trgm_ops)
+          WHERE entity = '${entity}'
+        `;
+            }
+            else {
+                // B-tree index for specific field
+                sql = `
+          CREATE INDEX IF NOT EXISTS ${indexName}
+          ON ${tableName} USING btree ((context->>'${field}'))
+          WHERE entity = '${entity}'
+        `;
+            }
+            await this.pgClient.query(sql);
+            this.logger.info(`postgres-entity-index-created`, { entity, field, indexType, indexName });
+        }
+        catch (error) {
+            this.logger.error(`postgres-create-entity-index-error`, {
+                entity, field, indexType, error
+            });
+            throw error;
+        }
+    }
+    // Helper methods for entity operations
+    mongoToSqlOperator(mongoOp) {
+        const mapping = {
+            '$eq': '=',
+            '$ne': '!=',
+            '$gt': '>',
+            '$gte': '>=',
+            '$lt': '<',
+            '$lte': '<=',
+            '$in': 'IN',
+        };
+        return mapping[mongoOp] || '=';
+    }
+    inferType(value) {
+        if (typeof value === 'number') {
+            return Number.isInteger(value) ? 'integer' : 'numeric';
+        }
+        if (typeof value === 'boolean') {
+            return 'boolean';
+        }
+        return 'text';
+    }
 }
 exports.PostgresSearchService = PostgresSearchService;

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

@@ -15,5 +15,9 @@ declare class IORedisSearchService extends SearchService<IORedisClientType> {
     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

@@ -117,5 +117,18 @@ class IORedisSearchService extends index_1.SearchService {
             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

@@ -15,5 +15,9 @@ declare class RedisSearchService extends SearchService<RedisRedisClientType> {
     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 };

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

@@ -130,5 +130,18 @@ class RedisSearchService extends index_1.SearchService {
             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.RedisSearchService = RedisSearchService;