@hotmeshio/hotmesh 0.5.3 → 0.5.5

package/build/modules/utils.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 import { StoreService } from '../services/store';
 import { AppSubscriptions, AppTransitions, AppVID } from '../types/app';
-import { ProviderClient, ProviderConfig, ProviderTransaction, Providers, ProvidersConfig } from '../types/provider';
+import { ProviderClient, ProviderTransaction, Providers } from '../types/provider';
 import { StringAnyType } from '../types/serializer';
 import { StreamCode, StreamData, StreamStatus } from '../types/stream';
 import { SystemHealth } from '../types/quorum';
@@ -34,14 +34,6 @@ export declare const polyfill: {
      * `redis` is deprecated; `connection` is the generic replacement
      */
     providerConfig(obj: any): any;
-    /**
-     * NOTE: `redisClass and redisOptions` input parameters are deprecated; use `connection` for all configuration inputs
-     */
-    meshDataConfig(obj: {
-        connection?: Partial<ProviderConfig | ProvidersConfig>;
-        redisClass?: any;
-        redisOptions?: StringAnyType;
-    }): Partial<ProviderConfig> | Partial<ProvidersConfig>;
 };
 /**
  * @private

package/build/modules/utils.js

@@ -127,12 +127,6 @@ exports.polyfill = {
     providerConfig(obj) {
         return obj?.connection ?? obj?.redis ?? obj?.connections;
     },
-    /**
-     * NOTE: `redisClass and redisOptions` input parameters are deprecated; use `connection` for all configuration inputs
-     */
-    meshDataConfig(obj) {
-        return { ...obj.connection };
-    },
 };
 /**
  * @private

package/build/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@hotmeshio/hotmesh",
-    "version": "0.5.3",
+    "version": "0.5.5",
     "description": "Permanent-Memory Workflows & AI Agents",
     "main": "./build/index.js",
     "types": "./build/index.d.ts",
@@ -20,7 +20,7 @@
         "lint:fix": "eslint . --fix --ext .ts",
         "start": "ts-node src/index.ts",
         "test": "NODE_ENV=test jest --detectOpenHandles --forceExit --verbose",
-        "test:await": "NODE_ENV=test jest ./tests/functional/awaiter/*.test.ts --detectOpenHandles --forceExit --verbose",
+        "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",
@@ -59,7 +59,7 @@
         "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:sequence": "NODE_ENV=test HMSH_LOGLEVEL=info jest ./tests/functional/sequence/*.test.ts --detectOpenHandles --forceExit --verbose",
+        "test:sequence": "NODE_ENV=test HMSH_LOGLEVEL=debug jest ./tests/functional/sequence/postgres.test.ts --detectOpenHandles --forceExit --verbose",
         "test:signal": "NODE_ENV=test jest ./tests/functional/signal/*.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",
@@ -75,7 +75,6 @@
         "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",
-        "test:meshos": "HMSH_LOGLEVEL=info NODE_ENV=test HMSH_IS_CLUSTER=true jest ./tests/meshos/*.test.ts --forceExit --verbose --detectOpenHandles",
         "test:meshcall": "NODE_ENV=test jest ./tests/meshcall/*.test.ts --forceExit --verbose --detectOpenHandles",
         "test:unit": "NODE_ENV=test jest ./tests/unit/*/*/index.test.ts --detectOpenHandles --forceExit --verbose"
     },

package/build/services/connector/factory.d.ts

@@ -8,7 +8,7 @@ export declare class ConnectorService {
      * initialization, but the factory method provided here is useful
      * for testing provider configurations.
      */
-    static connectClient(ProviderConfig: ProviderConfig): Promise<ProviderNativeClient>;
+    static connectClient(ProviderConfig: ProviderConfig, taskQueue?: string): Promise<ProviderNativeClient>;
     /**
      * Initialize `store`, `stream`, and `subscription` clients for any provider.
      * @private
@@ -18,5 +18,5 @@ export declare class ConnectorService {
      * Binds a provider client native instance to the target object.
      * @private
      */
-    static initClient(ProviderConfig: ProviderConfig, target: HotMeshEngine | HotMeshWorker, field: string): Promise<void>;
+    static initClient(ProviderConfig: ProviderConfig, target: HotMeshEngine | HotMeshWorker, field: string, taskQueue?: string): Promise<void>;
 }

package/build/services/connector/factory.js

@@ -19,9 +19,9 @@ class ConnectorService {
      * initialization, but the factory method provided here is useful
      * for testing provider configurations.
      */
-    static async connectClient(ProviderConfig) {
+    static async connectClient(ProviderConfig, taskQueue) {
         const target = {};
-        await ConnectorService.initClient(ProviderConfig, target, 'client');
+        await ConnectorService.initClient(ProviderConfig, target, 'client', taskQueue);
         return target.client;
     }
     /**
@@ -38,15 +38,17 @@ class ConnectorService {
                 sub: { ...connection },
             };
         }
+        // Extract taskQueue from target for connection pooling
+        const taskQueue = target.taskQueue;
         // Expanded form
         if (connection.store) {
-            await ConnectorService.initClient(connection.store, target, 'store');
+            await ConnectorService.initClient(connection.store, target, 'store', taskQueue);
         }
         if (connection.stream) {
-            await ConnectorService.initClient(connection.stream, target, 'stream');
+            await ConnectorService.initClient(connection.stream, target, 'stream', taskQueue);
         }
         if (connection.sub) {
-            await ConnectorService.initClient(connection.sub, target, 'sub');
+            await ConnectorService.initClient(connection.sub, target, 'sub', taskQueue);
             // use store for publishing events if same as subscription
             if (connection.sub.class !== connection.store.class) {
                 //initialize a separate client for publishing events, using
@@ -56,7 +58,7 @@ class ConnectorService {
                     options: { ...connection.sub.options },
                     provider: connection.sub.provider,
                 };
-                await ConnectorService.initClient(connection.pub, target, 'pub');
+                await ConnectorService.initClient(connection.pub, target, 'pub', taskQueue);
             }
         }
     }
@@ -64,7 +66,7 @@ class ConnectorService {
      * Binds a provider client native instance to the target object.
      * @private
      */
-    static async initClient(ProviderConfig, target, field) {
+    static async initClient(ProviderConfig, target, field, taskQueue) {
         if (target[field]) {
             return;
         }
@@ -87,7 +89,8 @@ class ConnectorService {
             case 'postgres':
                 //if connecting as a poolClient for subscription, auto connect the client
                 const bAutoConnect = field === 'sub';
-                clientInstance = await postgres_1.PostgresConnection.connect(id, providerClass, options, { connect: bAutoConnect, provider: providerName });
+                // Use taskQueue-based connection pooling for PostgreSQL
+                clientInstance = await postgres_1.PostgresConnection.getOrCreateTaskQueueConnection(id, taskQueue, providerClass, options, { connect: bAutoConnect, provider: providerName });
                 break;
             default:
                 throw new Error(`Unknown provider type: ${providerType}`);

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

@@ -4,17 +4,64 @@ declare class PostgresConnection extends AbstractConnection<PostgresClassType, P
     defaultOptions: PostgresClientOptions;
     protected static poolClientInstances: Set<PostgresPoolClientType>;
     protected static connectionInstances: Set<PostgresClientType>;
+    protected static taskQueueConnections: Map<string, PostgresConnection>;
+    /**
+     * Get comprehensive connection statistics for monitoring taskQueue pooling effectiveness
+     */
+    static getConnectionStats(): {
+        totalPoolClients: number;
+        totalConnections: number;
+        taskQueueConnections: number;
+        taskQueueDetails: Array<{
+            key: string;
+            connectionId: string;
+            reusedCount: number;
+        }>;
+    };
+    /**
+     * Log current connection statistics - useful for debugging connection pooling
+     */
+    static logConnectionStats(logger?: any): void;
+    /**
+     * Check taskQueue pooling effectiveness - returns metrics about connection reuse
+     */
+    static getPoolingEffectiveness(): {
+        totalConnections: number;
+        taskQueuePools: number;
+        totalReuses: number;
+        averageReusesPerPool: number;
+        poolingEfficiency: number;
+    };
     poolClientInstance: PostgresPoolClientType;
     createConnection(clientConstructor: any, options: PostgresClientOptions, config?: {
         connect?: boolean;
         provider?: string;
     }): Promise<PostgresClientType>;
     getClient(): PostgresClientType;
+    /**
+     * Get the connection ID for monitoring purposes
+     */
+    getConnectionId(): string | null;
     static disconnectAll(): Promise<void>;
     static disconnectPoolClients(): Promise<void>;
     static disconnectConnections(): Promise<void>;
     closeConnection(connection: PostgresClientType): Promise<void>;
     static isPoolClient(client: any): client is PostgresPoolClientType;
+    /**
+     * Creates a taskQueue-based connection key for connection pooling.
+     * This allows multiple providers (store, sub, stream) to reuse the same connection
+     * when they share the same taskQueue and database configuration.
+     */
+    private static createTaskQueueConnectionKey;
+    /**
+     * Gets or creates a PostgreSQL connection based on taskQueue and database configuration.
+     * If a connection already exists for the same taskQueue + config, it will be reused.
+     * This optimization reduces connection overhead for PostgreSQL providers.
+     */
+    static getOrCreateTaskQueueConnection(id: string, taskQueue: string | undefined, clientConstructor: PostgresClassType, options: PostgresClientOptions, config?: {
+        connect?: boolean;
+        provider?: string;
+    }): Promise<PostgresConnection>;
     static getTransactionClient(transactionClient: any): Promise<['client' | 'poolclient', PostgresClientType]>;
 }
 export { PostgresConnection };

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PostgresConnection = void 0;
 const __1 = require("..");
+const utils_1 = require("../../../modules/utils");
 class PostgresConnection extends __1.AbstractConnection {
     constructor() {
         super(...arguments);
@@ -15,6 +16,54 @@ class PostgresConnection extends __1.AbstractConnection {
             idleTimeoutMillis: 30000,
         };
     }
+    /**
+     * Get comprehensive connection statistics for monitoring taskQueue pooling effectiveness
+     */
+    static getConnectionStats() {
+        const taskQueueDetails = Array.from(this.taskQueueConnections.entries()).map(([key, connection]) => ({
+            key,
+            connectionId: connection.getConnectionId() || 'unknown',
+            reusedCount: connection.reusedCount || 0
+        }));
+        return {
+            totalPoolClients: this.poolClientInstances.size,
+            totalConnections: this.connectionInstances.size,
+            taskQueueConnections: this.taskQueueConnections.size,
+            taskQueueDetails
+        };
+    }
+    /**
+     * Log current connection statistics - useful for debugging connection pooling
+     */
+    static logConnectionStats(logger) {
+        const stats = this.getConnectionStats();
+        const message = `PostgreSQL Connection Stats: ${stats.totalConnections} total connections, ${stats.taskQueueConnections} taskQueue pools, ${stats.totalPoolClients} pool clients`;
+        if (logger) {
+            logger.info('postgres-connection-stats', {
+                ...stats,
+                message
+            });
+        }
+        else {
+            console.log(message, stats);
+        }
+    }
+    /**
+     * Check taskQueue pooling effectiveness - returns metrics about connection reuse
+     */
+    static getPoolingEffectiveness() {
+        const stats = this.getConnectionStats();
+        const totalReuses = stats.taskQueueDetails.reduce((sum, detail) => sum + detail.reusedCount, 0);
+        const averageReusesPerPool = stats.taskQueueConnections > 0 ? totalReuses / stats.taskQueueConnections : 0;
+        const poolingEfficiency = stats.totalConnections > 0 ? (stats.taskQueueConnections / stats.totalConnections) * 100 : 0;
+        return {
+            totalConnections: stats.totalConnections,
+            taskQueuePools: stats.taskQueueConnections,
+            totalReuses,
+            averageReusesPerPool: Math.round(averageReusesPerPool * 100) / 100,
+            poolingEfficiency: Math.round(poolingEfficiency * 100) / 100,
+        };
+    }
     async createConnection(clientConstructor, options, config = {}) {
         try {
             let connection;
@@ -55,11 +104,20 @@ class PostgresConnection extends __1.AbstractConnection {
         }
         return this.poolClientInstance || this.connection;
     }
+    /**
+     * Get the connection ID for monitoring purposes
+     */
+    getConnectionId() {
+        return this.id;
+    }
     static async disconnectAll() {
+        //log stats
+        //this.logConnectionStats();
         if (!this.disconnecting) {
             this.disconnecting = true;
             await this.disconnectPoolClients();
             await this.disconnectConnections();
+            this.taskQueueConnections.clear();
             this.disconnecting = false;
         }
     }
@@ -81,6 +139,53 @@ class PostgresConnection extends __1.AbstractConnection {
     static isPoolClient(client) {
         return !(isNaN(client?.totalCount) && isNaN(client?.idleCount));
     }
+    /**
+     * Creates a taskQueue-based connection key for connection pooling.
+     * This allows multiple providers (store, sub, stream) to reuse the same connection
+     * when they share the same taskQueue and database configuration.
+     */
+    static createTaskQueueConnectionKey(taskQueue, options, provider) {
+        const configHash = (0, utils_1.hashOptions)(options);
+        const providerType = provider?.split('.')[0] || 'postgres';
+        return `${providerType}:${taskQueue || 'default'}:${configHash}`;
+    }
+    /**
+     * Gets or creates a PostgreSQL connection based on taskQueue and database configuration.
+     * If a connection already exists for the same taskQueue + config, it will be reused.
+     * This optimization reduces connection overhead for PostgreSQL providers.
+     */
+    static async getOrCreateTaskQueueConnection(id, taskQueue, clientConstructor, options, config = {}) {
+        // Only use taskQueue pooling for PostgreSQL providers
+        if (!taskQueue || !config.provider?.startsWith('postgres')) {
+            return await this.connect(id, clientConstructor, options, config);
+        }
+        const connectionKey = this.createTaskQueueConnectionKey(taskQueue, options, config.provider);
+        // Check if we already have a connection for this taskQueue + config
+        if (this.taskQueueConnections.has(connectionKey)) {
+            const existingConnection = this.taskQueueConnections.get(connectionKey);
+            // Track reuse count for monitoring
+            existingConnection.reusedCount = (existingConnection.reusedCount || 0) + 1;
+            this.logger.debug('postgres-connection-reused', {
+                connectionKey,
+                taskQueue,
+                originalId: existingConnection.id,
+                newId: id,
+                reuseCount: existingConnection.reusedCount,
+            });
+            return existingConnection;
+        }
+        // Create new connection and cache it for the taskQueue
+        const newConnection = await this.connect(id, clientConstructor, options, config);
+        // Initialize reuse tracking
+        newConnection.reusedCount = 0;
+        this.taskQueueConnections.set(connectionKey, newConnection);
+        this.logger.debug('postgres-connection-created-for-taskqueue', {
+            connectionKey,
+            taskQueue,
+            connectionId: id,
+        });
+        return newConnection;
+    }
     static async getTransactionClient(transactionClient) {
         let client;
         let type;
@@ -100,3 +205,5 @@ exports.PostgresConnection = PostgresConnection;
 PostgresConnection.poolClientInstances = new Set();
 //statically track all connections (//call 'end')
 PostgresConnection.connectionInstances = new Set();
+//track connections by taskQueue + database config for reuse
+PostgresConnection.taskQueueConnections = new Map();

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

@@ -264,6 +264,14 @@ declare class HotMesh {
      * @private
      */
     doWork(config: HotMeshConfig, logger: ILogger): Promise<void>;
+    /**
+     * Initialize task queue with proper precedence:
+     * 1. Use component-specific queue if set (engine/worker)
+     * 2. Use global config queue if set
+     * 3. Use default queue as fallback
+     * @private
+     */
+    private initTaskQueue;
     /**
      * Starts a workflow
      * @example

package/build/services/hotmesh/index.js

@@ -275,6 +275,8 @@ class HotMesh {
             if (config.engine.connection.readonly) {
                 config.engine.readonly = true;
             }
+            // Initialize task queue for engine
+            config.engine.taskQueue = this.initTaskQueue(config.engine.taskQueue, config.taskQueue);
             await factory_1.ConnectorService.initClients(config.engine);
             this.engine = await engine_1.EngineService.init(this.namespace, this.appId, this.guid, config, logger);
         }
@@ -308,8 +310,33 @@ class HotMesh {
      * @private
      */
     async doWork(config, logger) {
+        // Initialize task queues for workers
+        if (config.workers) {
+            for (const worker of config.workers) {
+                worker.taskQueue = this.initTaskQueue(worker.taskQueue, config.taskQueue);
+            }
+        }
         this.workers = await worker_1.WorkerService.init(this.namespace, this.appId, this.guid, config, logger);
     }
+    /**
+     * Initialize task queue with proper precedence:
+     * 1. Use component-specific queue if set (engine/worker)
+     * 2. Use global config queue if set
+     * 3. Use default queue as fallback
+     * @private
+     */
+    initTaskQueue(componentQueue, globalQueue) {
+        // Component-specific queue takes precedence
+        if (componentQueue) {
+            return componentQueue;
+        }
+        // Global config queue is next
+        if (globalQueue) {
+            return globalQueue;
+        }
+        // Default queue as fallback
+        return enums_1.DEFAULT_TASK_QUEUE;
+    }
     // ************* PUB/SUB METHODS *************
     /**
      * Starts a workflow

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

@@ -60,7 +60,7 @@ export declare class ClientService {
     /**
      * @private
      */
-    getHotMeshClient: (workflowTopic: string | null, namespace?: string) => Promise<HotMesh>;
+    getHotMeshClient: (taskQueue: string | null, namespace?: string) => Promise<HotMesh>;
     /**
      * Creates a stream where messages can be published to ensure there is a
      * channel in place when the message arrives (a race condition for those

package/build/services/memflow/client.js

@@ -54,7 +54,7 @@ class ClientService {
         /**
          * @private
          */
-        this.getHotMeshClient = async (workflowTopic, namespace) => {
+        this.getHotMeshClient = async (taskQueue, namespace) => {
             //namespace isolation requires the connection options to be hashed
             //as multiple intersecting databases can be used by the same service
             //hashing options allows for reuse of the same connection without risk of
@@ -71,6 +71,7 @@ class ClientService {
             const readonly = this.connection.readonly ?? undefined;
             let hotMeshClient = hotmesh_1.HotMesh.init({
                 appId: targetNS,
+                taskQueue,
                 logLevel: enums_1.HMSH_LOGLEVEL,
                 engine: {
                     readonly,
@@ -130,7 +131,7 @@ class ClientService {
                 const spn = options.workflowSpan;
                 //hotmesh `topic` is equivalent to `queue+workflowname` pattern in other systems
                 const workflowTopic = `${taskQueueName}-${workflowName}`;
-                const hotMeshClient = await this.getHotMeshClient(workflowTopic, options.namespace);
+                const hotMeshClient = await this.getHotMeshClient(taskQueueName, options.namespace);
                 //verify that the stream channel exists before enqueueing
                 await this.verifyStream(hotMeshClient, workflowTopic, options.namespace);
                 const payload = {
@@ -182,7 +183,8 @@ class ClientService {
              * ```
              */
             hook: async (options) => {
-                const workflowTopic = `${options.taskQueue ?? options.entity}-${options.entity ?? options.workflowName}`;
+                const taskQueue = options.taskQueue ?? options.entity;
+                const workflowTopic = `${taskQueue}-${options.entity ?? options.workflowName}`;
                 const payload = {
                     arguments: [...options.args],
                     id: options.workflowId,
@@ -192,7 +194,7 @@ class ClientService {
                     maximumInterval: (0, utils_1.s)(options.config?.maximumInterval || enums_1.HMSH_MEMFLOW_MAX_INTERVAL),
                 };
                 //seed search data before entering
-                const hotMeshClient = await this.getHotMeshClient(workflowTopic, options.namespace);
+                const hotMeshClient = await this.getHotMeshClient(taskQueue, options.namespace);
                 const msgId = await hotMeshClient.hook(`${hotMeshClient.appId}.flow.signal`, payload, types_1.StreamStatus.PENDING, 202);
                 //todo: commit search data BEFORE enqueuing hook
                 if (options.search?.data) {
@@ -222,7 +224,7 @@ class ClientService {
              */
             getHandle: async (taskQueue, workflowName, workflowId, namespace) => {
                 const workflowTopic = `${taskQueue}-${workflowName}`;
-                const hotMeshClient = await this.getHotMeshClient(workflowTopic, namespace);
+                const hotMeshClient = await this.getHotMeshClient(taskQueue, namespace);
                 return new handle_1.WorkflowHandleService(hotMeshClient, workflowTopic, workflowId);
             },
             /**
@@ -249,7 +251,7 @@ class ClientService {
              */
             search: async (taskQueue, workflowName, namespace, index, ...query) => {
                 const workflowTopic = `${taskQueue}-${workflowName}`;
-                const hotMeshClient = await this.getHotMeshClient(workflowTopic, namespace);
+                const hotMeshClient = await this.getHotMeshClient(taskQueue, namespace);
                 try {
                     return await this.search(hotMeshClient, index, query);
                 }

package/build/services/memflow/worker.js

@@ -174,6 +174,7 @@ class WorkerService {
         const targetTopic = `${optionsHash}.${targetNamespace}.${activityTopic}`;
         const hotMeshWorker = await hotmesh_1.HotMesh.init({
             guid: config.guid ? `${config.guid}XA` : undefined,
+            taskQueue: config.taskQueue,
             logLevel: config.options?.logLevel ?? enums_1.HMSH_LOGLEVEL,
             appId: targetNamespace,
             engine: { connection: providerConfig },
@@ -258,6 +259,7 @@ class WorkerService {
         const targetTopic = `${optionsHash}.${targetNamespace}.${workflowTopic}`;
         const hotMeshWorker = await hotmesh_1.HotMesh.init({
             guid: config.guid,
+            taskQueue: config.taskQueue,
             logLevel: config.options?.logLevel ?? enums_1.HMSH_LOGLEVEL,
             appId: config.namespace ?? factory_1.APP_ID,
             engine: { connection: providerConfig },
@@ -518,6 +520,7 @@ WorkerService.getHotMesh = async (workflowTopic, config, options) => {
     const hotMeshClient = hotmesh_1.HotMesh.init({
         logLevel: options?.logLevel ?? enums_1.HMSH_LOGLEVEL,
         appId: targetNamespace,
+        taskQueue: config.taskQueue,
         engine: {
             connection: { ...config?.connection },
         },

package/build/services/pipe/functions/cron.js

@@ -37,4 +37,4 @@ class CronHandler {
     }
 }
 exports.CronHandler = CronHandler;
-CronHandler.logger = new logger_1.LoggerService('hotmesh', 'meshos');
+CronHandler.logger = new logger_1.LoggerService('hotmesh', 'cron');

package/build/services/store/providers/postgres/kvtables.js

@@ -23,15 +23,21 @@ const KVTables = (context) => ({
             client = transactionClient;
         }
         try {
-            // Acquire advisory lock
+            // First, check if tables already exist (no lock needed)
+            const tablesExist = await this.checkIfTablesExist(client, appName);
+            if (tablesExist) {
+                // Tables already exist, no need to acquire lock or create tables
+                return;
+            }
+            // Tables don't exist, need to acquire lock and create them
             const lockId = this.getAdvisoryLockId(appName);
             const lockResult = await client.query('SELECT pg_try_advisory_lock($1) AS locked', [lockId]);
             if (lockResult.rows[0].locked) {
                 // Begin transaction
                 await client.query('BEGIN');
-                // Check and create tables
-                const tablesExist = await this.checkIfTablesExist(client, appName);
-                if (!tablesExist) {
+                // Double-check tables don't exist (race condition safety)
+                const tablesStillMissing = !(await this.checkIfTablesExist(client, appName));
+                if (tablesStillMissing) {
                     await this.createTables(client, appName);
                 }
                 // Commit transaction
@@ -90,11 +96,18 @@ const KVTables = (context) => ({
                 client = transactionClient;
             }
             try {
+                // Check if tables exist directly (most efficient check)
+                const tablesExist = await this.checkIfTablesExist(client, appName);
+                if (tablesExist) {
+                    // Tables now exist, deployment is complete
+                    return;
+                }
+                // Fallback: check if the lock has been released (indicates completion)
                 const lockCheck = await client.query("SELECT NOT EXISTS (SELECT 1 FROM pg_locks WHERE locktype = 'advisory' AND objid = $1::bigint) AS unlocked", [lockId]);
                 if (lockCheck.rows[0].unlocked) {
                     // Lock has been released, tables should exist now
-                    const tablesExist = await this.checkIfTablesExist(client, appName);
-                    if (tablesExist) {
+                    const tablesExistAfterLock = await this.checkIfTablesExist(client, appName);
+                    if (tablesExistAfterLock) {
                         return;
                     }
                 }

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

@@ -1073,9 +1073,20 @@ class PostgresStoreService extends __1.StoreService {
         try {
             // Set up LISTEN for time notifications
             await this.pgClient.query(`LISTEN "${channelName}"`);
-            // Set up notification handler
+            // Set up notification handler with channel filtering
             this.pgClient.on('notification', (notification) => {
-                this.handleTimeNotification(notification, timeEventCallback);
+                // Only handle time notifications (channels starting with "time_hooks_")
+                // Ignore sub and stream notifications from other providers
+                if (notification.channel.startsWith('time_hooks_')) {
+                    this.handleTimeNotification(notification, timeEventCallback);
+                }
+                else {
+                    // This is likely a notification from sub or stream provider, ignore it
+                    this.logger.debug('postgres-store-ignoring-non-time-notification', {
+                        channel: notification.channel,
+                        payloadPreview: notification.payload.substring(0, 100)
+                    });
+                }
             });
             this.logger.debug('postgres-time-scout-notifications-started', {
                 appId: this.appId,

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

@@ -9,15 +9,18 @@ declare class PostgresStreamService extends StreamService<PostgresClientType & P
     namespace: string;
     appId: string;
     logger: ILogger;
-    private notificationConsumers;
+    private static clientNotificationConsumers;
+    private static clientNotificationHandlers;
+    private static clientFallbackPollers;
+    private instanceNotificationConsumers;
     private notificationHandlerBound;
-    private fallbackIntervalId;
     constructor(streamClient: PostgresClientType & ProviderClient, storeClient: ProviderClient, config?: StreamConfig);
     init(namespace: string, appId: string, logger: ILogger): Promise<void>;
+    private setupClientNotificationHandler;
+    private startClientFallbackPoller;
     private isNotificationsEnabled;
     private getFallbackInterval;
     private getNotificationTimeout;
-    private startFallbackPoller;
     private checkForMissedMessages;
     private handleNotification;
     private fetchAndDeliverMessages;