@hotmeshio/hotmesh 0.7.0 → 0.8.0

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

@@ -187,13 +187,7 @@ class PostgresSubService extends index_1.SubService {
             PostgresSubService.clientHandlers.delete(this.eventClient);
         }
     }
-    async publish(keyType, message, appId, topic) {
-        // Check if client is still connected before attempting to publish
-        // This prevents "Client was closed and is not queryable" errors during cleanup
-        if (this.storeClient._ending || this.storeClient._ended) {
-            this.logger?.debug('postgres-publish-skipped-closed-client', { appId, topic });
-            return false;
-        }
+    async publish(keyType, message, appId, topic, transaction) {
         const [originalKey, safeKey] = this.mintSafeKey(keyType, {
             appId,
             engineId: topic,
@@ -224,11 +218,32 @@ class PostgresSubService extends index_1.SubService {
                 jid,
             });
         }
-        // Publish the message using the safe topic
+        // Escape single quotes for SQL
+        payload = payload.replace(/'/g, "''");
+        // If transaction provided and has addCommand (KVSQL Multi pattern),
+        // add NOTIFY to transaction
+        if (transaction &&
+            typeof transaction.addCommand === 'function') {
+            // Add NOTIFY to transaction - will execute when transaction.exec() is called
+            transaction.addCommand(`NOTIFY "${safeKey}", '${payload}'`, [], 'void');
+            this.logger.debug(`postgres-publish-transactional`, {
+                originalKey,
+                safeKey
+            });
+            return true;
+        }
+        // Non-transactional publish - execute immediately
+        // Check if client is still connected before attempting to publish
+        if (this.storeClient._ending || this.storeClient._ended) {
+            this.logger?.debug('postgres-publish-skipped-closed-client', { appId, topic });
+            return false;
+        }
         try {
-            payload = payload.replace(/'/g, "''");
             await this.storeClient.query(`NOTIFY "${safeKey}", '${payload}'`);
-            this.logger.debug(`postgres-publish`, { originalKey, safeKey });
+            this.logger.debug(`postgres-publish`, {
+                originalKey,
+                safeKey
+            });
             return true;
         }
         catch (err) {

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

@@ -14,7 +14,7 @@ declare class TaskService {
     constructor(store: StoreService<ProviderClient, ProviderTransaction>, logger: ILogger);
     processWebHooks(hookEventCallback: HookInterface): Promise<void>;
     enqueueWorkItems(keys: string[]): Promise<void>;
-    registerJobForCleanup(jobId: string, inSeconds: number, options: JobCompletionOptions): Promise<void>;
+    registerJobForCleanup(jobId: string, inSeconds: number, options: JobCompletionOptions, transaction?: ProviderTransaction): Promise<void>;
     registerTimeHook(jobId: string, gId: string, activityId: string, type: WorkListTaskType, inSeconds: number, dad: string, transaction?: ProviderTransaction): Promise<void>;
     /**
      * Should this engine instance play the role of 'scout' on behalf

package/build/services/task/index.js

@@ -34,13 +34,9 @@ class TaskService {
     async enqueueWorkItems(keys) {
         await this.store.addTaskQueues(keys);
     }
-    async registerJobForCleanup(jobId, inSeconds = enums_1.HMSH_EXPIRE_DURATION, options) {
+    async registerJobForCleanup(jobId, inSeconds = enums_1.HMSH_EXPIRE_DURATION, options, transaction) {
         if (inSeconds > 0) {
-            await this.store.expireJob(jobId, inSeconds);
-            // const fromNow = Date.now() + inSeconds * 1000;
-            // const fidelityMS = HMSH_FIDELITY_SECONDS * 1000;
-            // const timeSlot = Math.floor(fromNow / fidelityMS) * fidelityMS;
-            // await this.store.registerDependenciesForCleanup(jobId, timeSlot, options);
+            await this.store.expireJob(jobId, inSeconds, transaction);
         }
     }
     async registerTimeHook(jobId, gId, activityId, type, inSeconds = enums_1.HMSH_FIDELITY_SECONDS, dad, transaction) {

package/build/types/index.d.ts

@@ -17,7 +17,6 @@ export { MeshCallConnectParams, MeshCallExecParams, MeshCallCronParams, MeshCall
 export { PostgresClassType, PostgresClientOptions, PostgresClientType, PostgresConsumerGroup, PostgresPendingMessage, PostgresPoolClientType, PostgresQueryConfigType, PostgresQueryResultType, PostgresStreamMessage, PostgresStreamOptions, PostgresTransaction, } from './postgres';
 export { ActivateMessage, CronMessage, JobMessage, JobMessageCallback, PingMessage, PongMessage, QuorumMessage, QuorumMessageCallback, QuorumProfile, RollCallMessage, RollCallOptions, SubscriptionCallback, SubscriptionOptions, SystemHealth, ThrottleMessage, ThrottleOptions, WorkMessage, } from './quorum';
 export { NatsAckPolicy, NatsAckPolicyExplicitType, NatsClassType, NatsClientType, NatsClientOptions, NatsConsumerConfigType, NatsJetStreamManager, NatsConnection, NatsJetStreamType, NatsConnectionOptions, NatsConsumerConfig, NatsConsumerInfo, NatsConsumerManager, NatsDeliveryInfo, NatsJetStreamOptions, NatsError, NatsErrorType, NatsJetStreamClient, NatsJsMsg, NatsMessageType, NatsMsgExpect, NatsPubAck, NatsPubAckType, NatsPublishOptions, NatsRetentionPolicy, NatsRetentionPolicyWorkqueueType, NatsSequenceInfo, NatsStorageMemoryType, NatsStorageType, NatsStreamConfig, NatsStreamInfo, NatsStreamManager, NatsStreamConfigType, NatsStreamInfoType, NatsStreamOptions, NatsStreamState, NatsTransaction, } from './nats';
-export { RedisClass, RedisRedisClientType, RedisRedisClientOptions, RedisRedisClassType, IORedisClientType, RedisClient, RedisMulti, RedisRedisMultiType, IORedisClientOptions, IORedisClassType, IORedisMultiType, RedisOptions, isRedisClient, isIORedisClient, } from './redis';
 export { JSONSchema, StringAnyType, StringScalarType, StringStringType, SymbolMap, SymbolMaps, SymbolRanges, Symbols, SymbolSets, } from './serializer';
 export { AggregatedData, CountByFacet, GetStatsOptions, IdsData, Measure, MeasureIds, MetricTypes, StatType, StatsType, IdsResponse, JobStats, JobStatsInput, JobStatsRange, StatsResponse, Segment, TimeSegment, } from './stats';
 export { ReclaimedMessageType, RetryPolicy, RouterConfig, StreamCode, StreamConfig, StreamData, StreamDataType, StreamError, StreamDataResponse, StreamMessage, StreamMessageMetadata, StreamProviderType, StreamRetryPolicy, StreamRole, StreamStats, StreamStatus, PublishMessageConfig, } from './stream';

package/build/types/index.js

@@ -1,15 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValueType = exports.trace = exports.SpanKind = exports.SpanStatusCode = exports.propagation = exports.metrics = exports.context = exports.StreamStatus = exports.StreamRole = exports.StreamDataType = exports.isIORedisClient = exports.isRedisClient = exports.KeyType = exports.HookGate = exports.CollationFaultType = void 0;
+exports.ValueType = exports.trace = exports.SpanKind = exports.SpanStatusCode = exports.propagation = exports.metrics = exports.context = exports.StreamStatus = exports.StreamRole = exports.StreamDataType = exports.KeyType = exports.HookGate = exports.CollationFaultType = void 0;
 var collator_1 = require("./collator");
 Object.defineProperty(exports, "CollationFaultType", { enumerable: true, get: function () { return collator_1.CollationFaultType; } });
 var hook_1 = require("./hook");
 Object.defineProperty(exports, "HookGate", { enumerable: true, get: function () { return hook_1.HookGate; } });
 var hotmesh_1 = require("./hotmesh");
 Object.defineProperty(exports, "KeyType", { enumerable: true, get: function () { return hotmesh_1.KeyType; } });
-var redis_1 = require("./redis");
-Object.defineProperty(exports, "isRedisClient", { enumerable: true, get: function () { return redis_1.isRedisClient; } });
-Object.defineProperty(exports, "isIORedisClient", { enumerable: true, get: function () { return redis_1.isIORedisClient; } });
 var stream_1 = require("./stream");
 Object.defineProperty(exports, "StreamDataType", { enumerable: true, get: function () { return stream_1.StreamDataType; } });
 Object.defineProperty(exports, "StreamRole", { enumerable: true, get: function () { return stream_1.StreamRole; } });

package/build/types/provider.d.ts

@@ -12,7 +12,7 @@ export interface ProviderClass {
 export interface ProviderOptions {
     [key: string]: any;
 }
-export type Providers = 'nats' | 'postgres' | 'redis' | 'ioredis';
+export type Providers = 'nats' | 'postgres';
 /**
  * A provider transaction is a set of operations that are executed
  * atomically by the provider. The transaction is created by calling

package/index.ts

@@ -16,17 +16,13 @@ import * as Enums from './modules/enums';
 import * as KeyStore from './modules/key';
 import { ConnectorService as Connector } from './services/connector/factory';
 import { PostgresConnection as ConnectorPostgres } from './services/connector/providers/postgres';
-import { RedisConnection as ConnectorIORedis } from './services/connector/providers/ioredis';
-import { RedisConnection as ConnectorRedis } from './services/connector/providers/redis';
 import { NatsConnection as ConnectorNATS } from './services/connector/providers/nats';
 
 export {
   //Provider Connectors
   Connector, //factory
-  ConnectorIORedis,
   ConnectorNATS,
   ConnectorPostgres,
-  ConnectorRedis,
 
   //Top-level Modules
   HotMesh,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hotmeshio/hotmesh",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Permanent-Memory Workflows & AI Agents",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
@@ -23,58 +23,51 @@
     "test:await": "NODE_ENV=test jest ./tests/functional/awaiter/postgres.test.ts --detectOpenHandles --forceExit --verbose",
     "test:compile": "NODE_ENV=test jest ./tests/functional/compile/index.test.ts --detectOpenHandles --forceExit --verbose",
     "test:connect": "NODE_ENV=test jest ./tests/unit/services/connector/* --detectOpenHandles --forceExit --verbose",
-    "test:connect:ioredis": "NODE_ENV=test jest ./tests/unit/services/connector/providers/ioredis.test.ts --detectOpenHandles --forceExit --verbose",
     "test:connect:postgres": "NODE_ENV=test jest ./tests/unit/services/connector/providers/postgres.test.ts --detectOpenHandles --forceExit --verbose",
-    "test:connect:redis": "NODE_ENV=test jest ./tests/unit/services/connector/providers/ioredis.test.ts --detectOpenHandles --forceExit --verbose",
     "test:connect:nats": "NODE_ENV=test jest ./tests/unit/services/connector/providers/nats.test.ts --detectOpenHandles --forceExit --verbose",
     "test:memflow": "NODE_ENV=test jest ./tests/memflow/*/*.test.ts --detectOpenHandles --forceExit --verbose",
+    "test:memflow:postgres": "HMSH_LOGLEVEL=info NODE_ENV=test jest ./tests/memflow/*/postgres.test.ts --detectOpenHandles --forceExit --verbose",
     "test:memflow:basic": "HMSH_LOGLEVEL=info NODE_ENV=test jest ./tests/memflow/basic/postgres.test.ts --detectOpenHandles --forceExit --verbose",
     "test:memflow:collision": "NODE_ENV=test jest ./tests/memflow/collision/postgres.test.ts --detectOpenHandles --forceExit --verbose",
     "test:memflow:fatal": "NODE_ENV=test jest ./tests/memflow/fatal/*.test.ts --detectOpenHandles --forceExit --verbose",
     "test:memflow:goodbye": "NODE_ENV=test HMSH_LOGLEVEL=debug jest ./tests/memflow/goodbye/postgres.test.ts --detectOpenHandles --forceExit --verbose",
-    "test:memflow:interceptor": "NODE_ENV=test HMSH_LOGLEVEL=debug jest ./tests/memflow/interceptor/postgres.test.ts --detectOpenHandles --forceExit --verbose",
+    "test:memflow:interceptor": "NODE_ENV=test HMSH_LOGLEVEL=info jest ./tests/memflow/interceptor/postgres.test.ts --detectOpenHandles --forceExit --verbose",
     "test:memflow:entity": "NODE_ENV=test HMSH_LOGLEVEL=debug jest ./tests/memflow/entity/postgres.test.ts --detectOpenHandles --forceExit --verbose",
     "test:memflow:agent": "NODE_ENV=test HMSH_LOGLEVEL=debug jest ./tests/memflow/agent/postgres.test.ts --detectOpenHandles --forceExit --verbose",
     "test:memflow:hello": "HMSH_TELEMETRY=debug HMSH_LOGLEVEL=debug NODE_ENV=test jest ./tests/memflow/helloworld/postgres.test.ts --detectOpenHandles --forceExit --verbose",
     "test:memflow:hook": "NODE_ENV=test jest ./tests/memflow/hook/postgres.test.ts --detectOpenHandles --forceExit --verbose",
-    "test:memflow:interrupt": "NODE_ENV=test jest ./tests/memflow/interrupt/*.test.ts --detectOpenHandles --forceExit --verbose",
-    "test:memflow:loopactivity": "NODE_ENV=test jest ./tests/memflow/loopactivity/*.test.ts --detectOpenHandles --forceExit --verbose",
+    "test:memflow:interrupt": "NODE_ENV=test jest ./tests/memflow/interrupt/postgres.test.ts --detectOpenHandles --forceExit --verbose",
+    "test:memflow:loopactivity": "NODE_ENV=test jest ./tests/memflow/loopactivity/postgres.test.ts --detectOpenHandles --forceExit --verbose",
     "test:memflow:nested": "NODE_ENV=test jest ./tests/memflow/nested/postgres.test.ts --detectOpenHandles --forceExit --verbose",
     "test:memflow:pipeline": "NODE_ENV=test jest ./tests/memflow/pipeline/postgres.test.ts --detectOpenHandles --forceExit --verbose",
     "test:memflow:retry": "NODE_ENV=test jest ./tests/memflow/retry/postgres.test.ts --detectOpenHandles --forceExit --verbose",
     "test:memflow:retrypolicy": "NODE_ENV=test jest ./tests/memflow/retry-policy/*.test.ts --detectOpenHandles --forceExit --verbose",
     "test:memflow:sleep": "NODE_ENV=test jest ./tests/memflow/sleep/postgres.test.ts --detectOpenHandles --forceExit --verbose",
     "test:memflow:signal": "NODE_ENV=test jest ./tests/memflow/signal/postgres.test.ts --detectOpenHandles --forceExit --verbose",
-    "test:memflow:unknown": "NODE_ENV=test jest ./tests/memflow/unknown/*.test.ts --detectOpenHandles --forceExit --verbose",
+    "test:memflow:unknown": "NODE_ENV=test jest ./tests/memflow/unknown/postgres.test.ts --detectOpenHandles --forceExit --verbose",
     "test:cycle": "NODE_ENV=test jest ./tests/functional/cycle/*.test.ts --detectOpenHandles --forceExit --verbose",
-    "test:functional": "NODE_ENV=test jest ./tests/functional/* --detectOpenHandles --forceExit --verbose",
+    "test:functional": "NODE_ENV=test jest ./tests/functional/**/postgres.test.ts --detectOpenHandles --forceExit --verbose",
     "test:emit": "NODE_ENV=test jest ./tests/functional/emit/*.test.ts --detectOpenHandles --forceExit --verbose",
     "test:pending": "NODE_ENV=test jest ./tests/functional/pending/index.test.ts --detectOpenHandles --forceExit --verbose",
-    "test:hmsh": "NODE_ENV=test jest ./tests/functional/*.test.ts --detectOpenHandles --verbose --forceExit",
+    "test:hmsh": "NODE_ENV=test jest ./tests/functional/postgres.test.ts --detectOpenHandles --verbose --forceExit",
     "test:hook": "NODE_ENV=test jest ./tests/functional/hook/postgres.test.ts --detectOpenHandles --forceExit --verbose",
-    "test:interrupt": "NODE_ENV=test jest ./tests/functional/interrupt/*.test.ts --detectOpenHandles --forceExit --verbose",
+    "test:interrupt": "NODE_ENV=test jest ./tests/functional/interrupt/postgres.test.ts --detectOpenHandles --forceExit --verbose",
     "test:parallel": "NODE_ENV=test jest ./tests/functional/parallel/index.test.ts --detectOpenHandles --forceExit --verbose",
     "test:pipe": "NODE_ENV=test jest ./tests/unit/services/pipe/index.test.ts --detectOpenHandles --forceExit --verbose",
     "test:quorum": "NODE_ENV=test jest ./tests/functional/quorum/postgres.test.ts --detectOpenHandles --forceExit --verbose",
-    "test:reclaim": "NODE_ENV=test jest ./tests/functional/reclaim/*.test.ts --detectOpenHandles --forceExit --verbose",
-    "test:redeploy": "NODE_ENV=test jest ./tests/functional/redeploy/*.test.ts --detectOpenHandles --forceExit --verbose",
+    "test:reclaim": "NODE_ENV=test jest ./tests/functional/reclaim/postgres.test.ts --detectOpenHandles --forceExit --verbose",
+    "test:redeploy": "NODE_ENV=test jest ./tests/functional/redeploy/postgres.test.ts --detectOpenHandles --forceExit --verbose",
     "test:reporter": "NODE_ENV=test jest ./tests/unit/services/reporter/index.test.ts --detectOpenHandles --forceExit --verbose",
-    "test:reentrant": "NODE_ENV=test jest ./tests/functional/reentrant/*.test.ts --detectOpenHandles --forceExit --verbose",
-    "test:retry": "NODE_ENV=test jest ./tests/functional/retry/*.test.ts --detectOpenHandles --forceExit --verbose",
+    "test:reentrant": "NODE_ENV=test jest ./tests/functional/reentrant/postgres.test.ts --detectOpenHandles --forceExit --verbose",
+    "test:retry": "NODE_ENV=test jest ./tests/functional/retry/postgres.test.ts --detectOpenHandles --forceExit --verbose",
     "test:retrypolicy": "NODE_ENV=test jest ./tests/functional/retry-policy/*.test.ts --detectOpenHandles --forceExit --verbose",
-    "test:sequence": "NODE_ENV=test HMSH_LOGLEVEL=debug jest ./tests/functional/sequence/*.test.ts --detectOpenHandles --forceExit --verbose",
-    "test:signal": "NODE_ENV=test jest ./tests/functional/signal/*.test.ts --detectOpenHandles --forceExit --verbose",
+    "test:sequence": "NODE_ENV=test HMSH_LOGLEVEL=info jest ./tests/functional/sequence/postgres.test.ts --detectOpenHandles --forceExit --verbose",
+    "test:signal": "NODE_ENV=test jest ./tests/functional/signal/postgres.test.ts --detectOpenHandles --forceExit --verbose",
     "test:status": "NODE_ENV=test jest ./tests/functional/status/index.test.ts --detectOpenHandles --forceExit --verbose",
     "test:providers": "NODE_ENV=test jest ./tests/functional/*/providers/*/*.test.ts --detectOpenHandles --forceExit --verbose",
-    "test:store:ioredis": "NODE_ENV=test jest ./tests/functional/store/providers/redis/ioredis.test.ts --detectOpenHandles --forceExit --verbose",
-    "test:store:redis": "NODE_ENV=test jest ./tests/functional/store/providers/redis/redis.test.ts --detectOpenHandles --forceExit --verbose",
     "test:store:postgres": "NODE_ENV=test jest ./tests/functional/store/providers/postgres/postgres.test.ts --detectOpenHandles --forceExit --verbose",
-    "test:stream:ioredis": "NODE_ENV=test jest ./tests/functional/stream/providers/redis/ioredis.test.ts --detectOpenHandles --forceExit --verbose",
-    "test:stream:redis": "NODE_ENV=test jest ./tests/functional/stream/providers/redis/redis.test.ts --detectOpenHandles --forceExit --verbose",
     "test:stream:postgres": "NODE_ENV=test jest ./tests/functional/stream/providers/postgres/postgres.test.ts --detectOpenHandles --forceExit --verbose",
     "test:stream:nats": "NODE_ENV=test jest ./tests/functional/stream/providers/nats/nats.test.ts --detectOpenHandles --forceExit --verbose",
-    "test:sub:ioredis": "NODE_ENV=test jest ./tests/functional/sub/providers/redis/ioredis.test.ts --detectOpenHandles --forceExit --verbose",
-    "test:sub:redis": "NODE_ENV=test jest ./tests/functional/sub/providers/redis/redis.test.ts --detectOpenHandles --forceExit --verbose",
     "test:sub:postgres": "NODE_ENV=test jest ./tests/functional/sub/providers/postgres/postgres.test.ts --detectOpenHandles --forceExit --verbose",
     "test:sub:nats": "NODE_ENV=test jest ./tests/functional/sub/providers/nats/nats.test.ts --detectOpenHandles --forceExit --verbose",
     "test:trigger": "NODE_ENV=test jest ./tests/unit/services/activities/trigger.test.ts --detectOpenHandles --forceExit --verbose",
@@ -116,13 +109,11 @@
     "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-import": "^2.29.1",
     "eslint-plugin-prettier": "^5.1.3",
-    "ioredis": "^5.3.2",
     "javascript-obfuscator": "^0.6.2",
     "jest": "^29.5.0",
     "nats": "^2.28.0",
     "openai": "^5.9.0",
     "pg": "^8.10.0",
-    "redis": "^4.6.13",
     "rimraf": "^4.4.1",
     "terser": "^5.37.0",
     "ts-jest": "^29.0.5",
@@ -132,9 +123,7 @@
     "typescript": "^5.0.4"
   },
   "peerDependencies": {
-    "ioredis": "^4.0.0 || ^5.0.0",
     "nats": "^2.0.0",
-    "pg": "^8.0.0",
-    "redis": "^4.0.0"
+    "pg": "^8.0.0"
   }
 }

package/build/services/connector/providers/ioredis.d.ts

@@ -1,9 +0,0 @@
-import { AbstractConnection } from '..';
-import { IORedisClientOptions as RedisClientOptions, IORedisClassType as RedisClassType, IORedisClientType as RedisClientType } from '../../../types/redis';
-declare class RedisConnection extends AbstractConnection<RedisClassType, RedisClientOptions> {
-    defaultOptions: RedisClientOptions;
-    createConnection(Redis: RedisClassType, options: RedisClientOptions): Promise<RedisClientType>;
-    getClient(): RedisClientType;
-    closeConnection(connection: RedisClientType): Promise<void>;
-}
-export { RedisConnection };

package/build/services/connector/providers/ioredis.js

@@ -1,26 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RedisConnection = void 0;
-const __1 = require("..");
-class RedisConnection extends __1.AbstractConnection {
-    constructor() {
-        super(...arguments);
-        this.defaultOptions = {
-            host: 'localhost',
-            port: 6379,
-        };
-    }
-    async createConnection(Redis, options) {
-        return new Redis(options);
-    }
-    getClient() {
-        if (!this.connection) {
-            throw new Error('Redis client is not connected');
-        }
-        return this.connection;
-    }
-    async closeConnection(connection) {
-        await connection.quit();
-    }
-}
-exports.RedisConnection = RedisConnection;

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

@@ -1,9 +0,0 @@
-import { AbstractConnection } from '..';
-import { RedisRedisClassType as RedisClassType, RedisRedisClientType as RedisClientType, RedisRedisClientOptions as RedisClientOptions } from '../../../types/redis';
-declare class RedisConnection extends AbstractConnection<RedisClassType, RedisClientOptions> {
-    defaultOptions: RedisClientOptions;
-    createConnection(Redis: Partial<RedisClassType>, options: RedisClientOptions): Promise<Partial<RedisClientType>>;
-    getClient(): RedisClientType;
-    closeConnection(connection: any): Promise<void>;
-}
-export { RedisConnection, RedisClientType };

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

@@ -1,38 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RedisConnection = void 0;
-const __1 = require("..");
-class RedisConnection extends __1.AbstractConnection {
-    constructor() {
-        super(...arguments);
-        this.defaultOptions = {
-            socket: {
-                host: 'localhost',
-                port: 6379,
-                tls: false,
-            },
-        };
-    }
-    async createConnection(Redis, options) {
-        return new Promise((resolve, reject) => {
-            const client = Redis.createClient(options);
-            client.on('error', (error) => {
-                reject(error);
-            });
-            client.on('ready', () => {
-                resolve(client);
-            });
-            client.connect();
-        });
-    }
-    getClient() {
-        if (!this.connection) {
-            throw new Error('Redis client is not connected');
-        }
-        return this.connection;
-    }
-    async closeConnection(connection) {
-        await connection.quit();
-    }
-}
-exports.RedisConnection = RedisConnection;

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

@@ -1,23 +0,0 @@
-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

@@ -1,189 +0,0 @@
-"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

@@ -1,23 +0,0 @@
-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 };