@hotmeshio/hotmesh 0.5.3 → 0.5.4

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

@@ -8,8 +8,8 @@ const kvtables_1 = require("./kvtables");
 class PostgresStreamService extends index_1.StreamService {
     constructor(streamClient, storeClient, config = {}) {
         super(streamClient, storeClient, config);
-        this.notificationConsumers = new Map();
-        this.fallbackIntervalId = null;
+        // Instance-level tracking for cleanup
+        this.instanceNotificationConsumers = new Set();
         this.notificationHandlerBound = this.handleNotification.bind(this);
     }
     async init(namespace, appId, logger) {
@@ -19,10 +19,34 @@ class PostgresStreamService extends index_1.StreamService {
         await (0, kvtables_1.deploySchema)(this.streamClient, this.appId, this.logger);
         // Set up notification handler if supported
         if (this.streamClient.on && this.isNotificationsEnabled()) {
-            this.streamClient.on('notification', this.notificationHandlerBound);
-            this.startFallbackPoller();
+            this.setupClientNotificationHandler();
+            this.startClientFallbackPoller();
         }
     }
+    setupClientNotificationHandler() {
+        // Check if notification handler is already set up for this client
+        if (PostgresStreamService.clientNotificationHandlers.get(this.streamClient)) {
+            return;
+        }
+        // Initialize notification consumer map for this client if it doesn't exist
+        if (!PostgresStreamService.clientNotificationConsumers.has(this.streamClient)) {
+            PostgresStreamService.clientNotificationConsumers.set(this.streamClient, new Map());
+        }
+        // Set up the notification handler for this client
+        this.streamClient.on('notification', this.handleNotification.bind(this));
+        // Mark this client as having a notification handler
+        PostgresStreamService.clientNotificationHandlers.set(this.streamClient, true);
+    }
+    startClientFallbackPoller() {
+        // Check if fallback poller already exists for this client
+        if (PostgresStreamService.clientFallbackPollers.has(this.streamClient)) {
+            return;
+        }
+        const fallbackIntervalId = setInterval(() => {
+            this.checkForMissedMessages();
+        }, this.getFallbackInterval());
+        PostgresStreamService.clientFallbackPollers.set(this.streamClient, fallbackIntervalId);
+    }
     isNotificationsEnabled() {
         return this.config?.postgres?.enableNotifications !== false; // Default: true
     }
@@ -32,42 +56,53 @@ class PostgresStreamService extends index_1.StreamService {
     getNotificationTimeout() {
         return this.config?.postgres?.notificationTimeout || 5000; // Default: 5 seconds
     }
-    startFallbackPoller() {
-        if (this.fallbackIntervalId) {
-            clearInterval(this.fallbackIntervalId);
-        }
-        this.fallbackIntervalId = setInterval(() => {
-            this.checkForMissedMessages();
-        }, this.getFallbackInterval());
-    }
     async checkForMissedMessages() {
         const now = Date.now();
-        for (const [key, consumer] of this.notificationConsumers.entries()) {
-            if (consumer.isListening && now - consumer.lastFallbackCheck > this.getFallbackInterval()) {
-                try {
-                    const messages = await this.fetchMessages(consumer.streamName, consumer.groupName, consumer.consumerName, { batchSize: 10, enableBackoff: false, maxRetries: 1 });
-                    if (messages.length > 0) {
-                        this.logger.debug('postgres-stream-fallback-messages', {
+        const clientNotificationConsumers = PostgresStreamService.clientNotificationConsumers.get(this.streamClient);
+        if (!clientNotificationConsumers) {
+            return;
+        }
+        for (const [consumerKey, instanceMap] of clientNotificationConsumers.entries()) {
+            for (const [instance, consumer] of instanceMap.entries()) {
+                if (consumer.isListening && now - consumer.lastFallbackCheck > this.getFallbackInterval()) {
+                    try {
+                        const messages = await instance.fetchMessages(consumer.streamName, consumer.groupName, consumer.consumerName, { batchSize: 10, enableBackoff: false, maxRetries: 1 });
+                        if (messages.length > 0) {
+                            instance.logger.debug('postgres-stream-fallback-messages', {
+                                streamName: consumer.streamName,
+                                groupName: consumer.groupName,
+                                messageCount: messages.length
+                            });
+                            consumer.callback(messages);
+                        }
+                        consumer.lastFallbackCheck = now;
+                    }
+                    catch (error) {
+                        instance.logger.error('postgres-stream-fallback-error', {
                             streamName: consumer.streamName,
                             groupName: consumer.groupName,
-                            messageCount: messages.length
+                            error
                         });
-                        consumer.callback(messages);
                     }
-                    consumer.lastFallbackCheck = now;
-                }
-                catch (error) {
-                    this.logger.error('postgres-stream-fallback-error', {
-                        streamName: consumer.streamName,
-                        groupName: consumer.groupName,
-                        error
-                    });
                 }
             }
         }
     }
     handleNotification(notification) {
         try {
+            // Only handle stream notifications (channels starting with "stream_")
+            // Ignore pub/sub notifications from sub provider which use different channel names
+            if (!notification.channel.startsWith('stream_')) {
+                // This is likely a pub/sub notification from the sub provider, ignore it
+                this.logger.debug('postgres-stream-ignoring-sub-notification', {
+                    channel: notification.channel,
+                    payloadPreview: notification.payload.substring(0, 100)
+                });
+                return;
+            }
+            this.logger.debug('postgres-stream-processing-notification', {
+                channel: notification.channel
+            });
             const payload = JSON.parse(notification.payload);
             const { stream_name, group_name } = payload;
             if (!stream_name || !group_name) {
@@ -75,10 +110,19 @@ class PostgresStreamService extends index_1.StreamService {
                 return;
             }
             const consumerKey = this.getConsumerKey(stream_name, group_name);
-            const consumer = this.notificationConsumers.get(consumerKey);
-            if (consumer && consumer.isListening) {
-                // Trigger immediate message fetch for this consumer
-                this.fetchAndDeliverMessages(consumer);
+            const clientNotificationConsumers = PostgresStreamService.clientNotificationConsumers.get(this.streamClient);
+            if (!clientNotificationConsumers) {
+                return;
+            }
+            const instanceMap = clientNotificationConsumers.get(consumerKey);
+            if (!instanceMap) {
+                return;
+            }
+            // Trigger immediate message fetch for all instances with this consumer
+            for (const [instance, consumer] of instanceMap.entries()) {
+                if (consumer.isListening) {
+                    instance.fetchAndDeliverMessages(consumer);
+                }
             }
         }
         catch (error) {
@@ -235,8 +279,18 @@ class PostgresStreamService extends index_1.StreamService {
         const startTime = Date.now();
         const consumerKey = this.getConsumerKey(streamName, groupName);
         const channelName = (0, kvtables_1.getNotificationChannelName)(streamName, groupName);
-        // Set up LISTEN if not already listening
-        if (!this.notificationConsumers.has(consumerKey)) {
+        // Get or create notification consumer map for this client
+        let clientNotificationConsumers = PostgresStreamService.clientNotificationConsumers.get(this.streamClient);
+        if (!clientNotificationConsumers) {
+            clientNotificationConsumers = new Map();
+            PostgresStreamService.clientNotificationConsumers.set(this.streamClient, clientNotificationConsumers);
+        }
+        // Get or create instance map for this consumer key
+        let instanceMap = clientNotificationConsumers.get(consumerKey);
+        if (!instanceMap) {
+            instanceMap = new Map();
+            clientNotificationConsumers.set(consumerKey, instanceMap);
+            // Set up LISTEN for this channel (only once per channel across all instances)
             try {
                 const listenStart = Date.now();
                 await this.streamClient.query(`LISTEN "${channelName}"`);
@@ -258,18 +312,22 @@ class PostgresStreamService extends index_1.StreamService {
                 return this.fetchMessages(streamName, groupName, consumerName, options);
             }
         }
-        // Register or update consumer
-        this.notificationConsumers.set(consumerKey, {
+        // Register or update consumer for this instance
+        const consumer = {
             streamName,
             groupName,
             consumerName,
             callback,
             isListening: true,
             lastFallbackCheck: Date.now()
-        });
+        };
+        instanceMap.set(this, consumer);
+        // Track this consumer for cleanup
+        this.instanceNotificationConsumers.add(consumerKey);
         this.logger.debug('postgres-stream-notification-setup-complete', {
             streamName,
             groupName,
+            instanceCount: instanceMap.size,
             setupDuration: Date.now() - startTime
         });
         // Do an initial fetch asynchronously to avoid blocking setup
@@ -306,14 +364,23 @@ class PostgresStreamService extends index_1.StreamService {
     }
     async stopNotificationConsumer(streamName, groupName) {
         const consumerKey = this.getConsumerKey(streamName, groupName);
-        const consumer = this.notificationConsumers.get(consumerKey);
+        const clientNotificationConsumers = PostgresStreamService.clientNotificationConsumers.get(this.streamClient);
+        if (!clientNotificationConsumers) {
+            return;
+        }
+        const instanceMap = clientNotificationConsumers.get(consumerKey);
+        if (!instanceMap) {
+            return;
+        }
+        const consumer = instanceMap.get(this);
         if (consumer) {
             consumer.isListening = false;
-            this.notificationConsumers.delete(consumerKey);
-            // If no more consumers for this channel, stop listening
-            const hasOtherConsumers = Array.from(this.notificationConsumers.values())
-                .some(c => c.streamName === streamName && c.groupName === groupName);
-            if (!hasOtherConsumers) {
+            instanceMap.delete(this);
+            // Remove from instance tracking
+            this.instanceNotificationConsumers.delete(consumerKey);
+            // If no more instances for this consumer key, stop listening and clean up
+            if (instanceMap.size === 0) {
+                clientNotificationConsumers.delete(consumerKey);
                 const channelName = (0, kvtables_1.getNotificationChannelName)(streamName, groupName);
                 try {
                     await this.streamClient.query(`UNLISTEN "${channelName}"`);
@@ -496,24 +563,67 @@ class PostgresStreamService extends index_1.StreamService {
     }
     // Cleanup method to be called when shutting down
     async cleanup() {
-        // Stop fallback poller
-        if (this.fallbackIntervalId) {
-            clearInterval(this.fallbackIntervalId);
-            this.fallbackIntervalId = null;
-        }
-        // Remove notification handler
-        if (this.streamClient.removeAllListeners) {
-            this.streamClient.removeAllListeners('notification');
-        }
-        else if (this.streamClient.off) {
-            this.streamClient.off('notification', this.notificationHandlerBound);
+        // Clean up this instance's notification consumers
+        const clientNotificationConsumers = PostgresStreamService.clientNotificationConsumers.get(this.streamClient);
+        if (clientNotificationConsumers) {
+            // Remove this instance from all consumer maps
+            for (const consumerKey of this.instanceNotificationConsumers) {
+                const instanceMap = clientNotificationConsumers.get(consumerKey);
+                if (instanceMap) {
+                    const consumer = instanceMap.get(this);
+                    if (consumer) {
+                        consumer.isListening = false;
+                        instanceMap.delete(this);
+                        // If no more instances for this consumer, stop listening
+                        if (instanceMap.size === 0) {
+                            clientNotificationConsumers.delete(consumerKey);
+                            const channelName = (0, kvtables_1.getNotificationChannelName)(consumer.streamName, consumer.groupName);
+                            try {
+                                await this.streamClient.query(`UNLISTEN "${channelName}"`);
+                                this.logger.debug('postgres-stream-cleanup-unlisten', {
+                                    streamName: consumer.streamName,
+                                    groupName: consumer.groupName,
+                                    channelName
+                                });
+                            }
+                            catch (error) {
+                                this.logger.error('postgres-stream-cleanup-unlisten-error', {
+                                    streamName: consumer.streamName,
+                                    groupName: consumer.groupName,
+                                    channelName,
+                                    error
+                                });
+                            }
+                        }
+                    }
+                }
+            }
         }
-        // Stop all consumers and unlisten from channels
-        const consumers = Array.from(this.notificationConsumers.entries());
-        for (const [key, consumer] of consumers) {
-            await this.stopNotificationConsumer(consumer.streamName, consumer.groupName);
+        // Clear instance tracking
+        this.instanceNotificationConsumers.clear();
+        // If no more consumers exist for this client, clean up static resources
+        if (clientNotificationConsumers && clientNotificationConsumers.size === 0) {
+            // Remove client from static maps
+            PostgresStreamService.clientNotificationConsumers.delete(this.streamClient);
+            PostgresStreamService.clientNotificationHandlers.delete(this.streamClient);
+            // Stop fallback poller for this client
+            const fallbackIntervalId = PostgresStreamService.clientFallbackPollers.get(this.streamClient);
+            if (fallbackIntervalId) {
+                clearInterval(fallbackIntervalId);
+                PostgresStreamService.clientFallbackPollers.delete(this.streamClient);
+            }
+            // Remove notification handler
+            if (this.streamClient.removeAllListeners) {
+                this.streamClient.removeAllListeners('notification');
+            }
+            else if (this.streamClient.off && this.notificationHandlerBound) {
+                this.streamClient.off('notification', this.notificationHandlerBound);
+            }
         }
-        this.notificationConsumers.clear();
     }
 }
 exports.PostgresStreamService = PostgresStreamService;
+// Static maps to manage notifications across all instances sharing the same client
+PostgresStreamService.clientNotificationConsumers = new Map();
+PostgresStreamService.clientNotificationHandlers = new Map();
+PostgresStreamService.clientFallbackPollers = new Map();

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

@@ -5,13 +5,22 @@ import { SubscriptionCallback } from '../../../../types/quorum';
 import { ProviderClient, ProviderTransaction } from '../../../../types/provider';
 import { PostgresClientType } from '../../../../types/postgres';
 declare class PostgresSubService extends SubService<PostgresClientType & ProviderClient> {
+    private static clientSubscriptions;
+    private static clientHandlers;
+    private instanceSubscriptions;
     constructor(eventClient: PostgresClientType & ProviderClient, storeClient?: PostgresClientType & ProviderClient);
     init(namespace: string, appId: string, engineId: string, logger: ILogger): Promise<void>;
+    private setupNotificationHandler;
     transact(): ProviderTransaction;
     mintKey(type: KeyType, params: KeyStoreParams): string;
     mintSafeKey(type: KeyType, params: KeyStoreParams): [string, string];
     subscribe(keyType: KeyType.QUORUM, callback: SubscriptionCallback, appId: string, topic?: string): Promise<void>;
     unsubscribe(keyType: KeyType.QUORUM, appId: string, topic?: string): Promise<void>;
+    /**
+     * Cleanup method to remove all subscriptions for this instance.
+     * Should be called when the SubService instance is being destroyed.
+     */
+    cleanup(): Promise<void>;
     publish(keyType: KeyType.QUORUM, message: Record<string, any>, appId: string, topic?: string): Promise<boolean>;
     psubscribe(): Promise<void>;
     punsubscribe(): Promise<void>;

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

@@ -10,12 +10,49 @@ const index_1 = require("../../index");
 class PostgresSubService extends index_1.SubService {
     constructor(eventClient, storeClient) {
         super(eventClient, storeClient);
+        // Instance-level subscriptions for cleanup
+        this.instanceSubscriptions = new Set();
     }
     async init(namespace = key_1.HMNS, appId, engineId, logger) {
         this.namespace = namespace;
         this.logger = logger;
         this.appId = appId;
         this.engineId = engineId;
+        this.setupNotificationHandler();
+    }
+    setupNotificationHandler() {
+        // Check if notification handler is already set up for this client
+        if (PostgresSubService.clientHandlers.get(this.eventClient)) {
+            return;
+        }
+        // Initialize subscription map for this client if it doesn't exist
+        if (!PostgresSubService.clientSubscriptions.has(this.eventClient)) {
+            PostgresSubService.clientSubscriptions.set(this.eventClient, new Map());
+        }
+        // Set up the notification handler for this client
+        this.eventClient.on('notification', (msg) => {
+            const clientSubscriptions = PostgresSubService.clientSubscriptions.get(this.eventClient);
+            const callbacks = clientSubscriptions?.get(msg.channel);
+            if (callbacks && callbacks.size > 0) {
+                try {
+                    const payload = JSON.parse(msg.payload || '{}');
+                    // Call all callbacks registered for this channel across all SubService instances
+                    callbacks.forEach(callback => {
+                        try {
+                            callback(msg.channel, payload);
+                        }
+                        catch (err) {
+                            this.logger?.error(`Error in subscription callback for ${msg.channel}:`, err);
+                        }
+                    });
+                }
+                catch (err) {
+                    this.logger?.error(`Error parsing message for topic ${msg.channel}:`, err);
+                }
+            }
+        });
+        // Mark this client as having a notification handler
+        PostgresSubService.clientHandlers.set(this.eventClient, true);
     }
     transact() {
         throw new Error('Transactions are not supported in lightweight pub/sub');
@@ -46,30 +83,81 @@ class PostgresSubService extends index_1.SubService {
             appId,
             engineId: topic,
         });
-        // Start listening to the safe topic
-        await this.eventClient.query(`LISTEN "${safeKey}"`);
-        this.logger.debug(`postgres-subscribe`, { originalKey, safeKey });
-        // Set up the notification handler
-        this.eventClient.on('notification', (msg) => {
-            if (msg.channel === safeKey) {
-                try {
-                    const payload = JSON.parse(msg.payload || '{}');
-                    callback(safeKey, payload);
-                }
-                catch (err) {
-                    this.logger.error(`Error parsing message for topic ${safeKey}:`, err);
-                }
-            }
-        });
+        // Get or create subscription map for this client
+        let clientSubscriptions = PostgresSubService.clientSubscriptions.get(this.eventClient);
+        if (!clientSubscriptions) {
+            clientSubscriptions = new Map();
+            PostgresSubService.clientSubscriptions.set(this.eventClient, clientSubscriptions);
+        }
+        // Get or create callback array for this channel
+        let callbacks = clientSubscriptions.get(safeKey);
+        if (!callbacks) {
+            callbacks = new Map();
+            clientSubscriptions.set(safeKey, callbacks);
+            // Start listening to the safe topic (only once per channel across all instances)
+            await this.eventClient.query(`LISTEN "${safeKey}"`);
+        }
+        // Add this callback to the list
+        callbacks.set(this, callback);
+        // Track this subscription for cleanup
+        this.instanceSubscriptions.add(safeKey);
+        this.logger.debug(`postgres-subscribe`, { originalKey, safeKey, totalCallbacks: callbacks.size });
     }
     async unsubscribe(keyType, appId, topic) {
         const [originalKey, safeKey] = this.mintSafeKey(keyType, {
             appId,
             engineId: topic,
         });
-        // Stop listening to the safe topic
-        await this.eventClient.query(`UNLISTEN "${safeKey}"`);
-        this.logger.debug(`postgres-subscribe`, { originalKey, safeKey });
+        const clientSubscriptions = PostgresSubService.clientSubscriptions.get(this.eventClient);
+        if (!clientSubscriptions) {
+            return;
+        }
+        const callbacks = clientSubscriptions.get(safeKey);
+        if (!callbacks || callbacks.size === 0) {
+            return;
+        }
+        // Remove callback from this specific instance
+        callbacks.delete(this);
+        // Remove from instance tracking
+        this.instanceSubscriptions.delete(safeKey);
+        // Stop listening to the safe topic if no more callbacks exist
+        if (callbacks.size === 0) {
+            clientSubscriptions.delete(safeKey);
+            await this.eventClient.query(`UNLISTEN "${safeKey}"`);
+        }
+        this.logger.debug(`postgres-unsubscribe`, { originalKey, safeKey, remainingCallbacks: callbacks.size });
+    }
+    /**
+     * Cleanup method to remove all subscriptions for this instance.
+     * Should be called when the SubService instance is being destroyed.
+     */
+    async cleanup() {
+        const clientSubscriptions = PostgresSubService.clientSubscriptions.get(this.eventClient);
+        if (!clientSubscriptions) {
+            return;
+        }
+        for (const safeKey of this.instanceSubscriptions) {
+            const callbacks = clientSubscriptions.get(safeKey);
+            if (callbacks) {
+                callbacks.delete(this);
+                // If no more callbacks exist for this channel, stop listening
+                if (callbacks.size === 0) {
+                    clientSubscriptions.delete(safeKey);
+                    try {
+                        await this.eventClient.query(`UNLISTEN "${safeKey}"`);
+                    }
+                    catch (err) {
+                        this.logger?.error(`Error unlistening from ${safeKey}:`, err);
+                    }
+                }
+            }
+        }
+        this.instanceSubscriptions.clear();
+        // If no more subscriptions exist for this client, remove it from static maps
+        if (clientSubscriptions.size === 0) {
+            PostgresSubService.clientSubscriptions.delete(this.eventClient);
+            PostgresSubService.clientHandlers.delete(this.eventClient);
+        }
     }
     async publish(keyType, message, appId, topic) {
         const [originalKey, safeKey] = this.mintSafeKey(keyType, {
@@ -90,3 +178,6 @@ class PostgresSubService extends index_1.SubService {
     }
 }
 exports.PostgresSubService = PostgresSubService;
+// Static maps to manage subscriptions across all instances sharing the same client
+PostgresSubService.clientSubscriptions = new Map();
+PostgresSubService.clientHandlers = new Map();

package/build/services/worker/index.js

@@ -24,6 +24,10 @@ class WorkerService {
         const services = [];
         if (Array.isArray(config.workers)) {
             for (const worker of config.workers) {
+                // Pass taskQueue from top-level config to worker for connection pooling
+                if (config.taskQueue) {
+                    worker.taskQueue = config.taskQueue;
+                }
                 await factory_1.ConnectorService.initClients(worker);
                 const service = new WorkerService();
                 service.verifyWorkerFields(worker);

package/build/types/hotmesh.d.ts

@@ -72,11 +72,6 @@ type HotMeshEngine = {
      * @private
      */
     search?: ProviderClient;
-    /**
-     * redis connection options; replaced with 'connection'
-     * @deprecated
-     */
-    redis?: ProviderConfig;
     /**
      * short-form format for the connection options for the
      * store, stream, sub, and search clients
@@ -107,6 +102,12 @@ type HotMeshEngine = {
      * @default false
      */
     readonly?: boolean;
+    /**
+     * Task queue identifier used for connection pooling optimization.
+     * When provided, connections will be reused across providers (store, sub, stream)
+     * that share the same task queue and database configuration.
+     */
+    taskQueue?: string;
 };
 type HotMeshWorker = {
     /**
@@ -173,6 +174,12 @@ type HotMeshWorker = {
      * from the target stream
      */
     callback: (payload: StreamData) => Promise<StreamDataResponse>;
+    /**
+     * Task queue identifier used for connection pooling optimization.
+     * When provided, connections will be reused across providers (store, sub, stream)
+     * that share the same task queue and database configuration.
+     */
+    taskQueue?: string;
 };
 type HotMeshConfig = {
     appId: string;
@@ -181,6 +188,13 @@ type HotMeshConfig = {
     guid?: string;
     logger?: ILogger;
     logLevel?: LogLevel;
+    /**
+     * Task queue identifier used for connection pooling optimization.
+     * When multiple engines/workers share the same task queue and database configuration,
+     * they will reuse the same connection instead of creating separate ones.
+     * This is particularly useful for PostgreSQL providers to reduce connection overhead.
+     */
+    taskQueue?: string;
     engine?: HotMeshEngine;
     workers?: HotMeshWorker[];
 };

package/build/types/index.d.ts

@@ -10,12 +10,10 @@ export { HookCondition, HookConditions, HookGate, HookInterface, HookRule, HookR
 export { HotMesh, HotMeshEngine, HotMeshWorker, HotMeshSettings, HotMeshApp, HotMeshApps, HotMeshConfig, HotMeshManifest, HotMeshGraph, KeyType, KeyStoreParams, } from './hotmesh';
 export { ILogger, LogLevel } from './logger';
 export { ExtensionType, JobCompletionOptions, JobData, JobsData, JobInterruptOptions, JobMetadata, JobOutput, JobState, JobStatus, PartialJobState, } from './job';
-export { DB, Profile, Namespaces, Entity, EntityInstanceTypes, SubClassInstance, AllSubclassInstances, SubclassType, Namespace, Instance, Instances, Profiles, } from './manifest';
 export { MappingStatements } from './map';
 export { Pipe, PipeContext, PipeItem, PipeItems, PipeObject, ReduceObject, } from './pipe';
 export { ProviderClass, ProviderClient, ProviderConfig, ProviderTransaction, Providers, TransactionResultList, ProviderNativeClient, ProviderOptions, } from './provider';
 export { MeshCallConnectParams, MeshCallExecParams, MeshCallCronParams, MeshCallExecOptions, MeshCallCronOptions, MeshCallInterruptOptions, MeshCallInterruptParams, MeshCallFlushParams, } from './meshcall';
-export { CallOptions, MeshDataWorkflowOptions, ConnectOptions, ConnectionInput, ExecInput, } from './meshdata';
 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';

package/env.example

@@ -0,0 +1,11 @@
+# Provide an openai api key to run the agent and pipeline tests
+# OPENAI_API_KEY=sk-proj-qqVSdKZ...Mvl3aw7gFuAEMA
+
+# Connnect as follows to run the tests against a remote postgres instance (supabase)
+# replace XXXXX and YYYYY with your supabase credentials
+# POSTGRES_IS_REMOTE=true
+# POSTGRES_HOST=aws-0-us-west-1.pooler.supabase.com
+# POSTGRES_PORT=5432
+# POSTGRES_DB=postgres
+# POSTGRES_USER=postgres.XXXXX
+# POSTGRES_PASSWORD=YYYYY

package/index.ts

@@ -10,8 +10,6 @@ import { WorkerService as Worker } from './services/memflow/worker';
 import { WorkflowService as workflow } from './services/memflow/workflow';
 import { WorkflowHandleService as WorkflowHandle } from './services/memflow/handle';
 import { proxyActivities } from './services/memflow/workflow/proxyActivities';
-import { MeshData } from './services/meshdata';
-import { MeshOS } from './services/meshos';
 import * as Errors from './modules/errors';
 import * as Utils from './modules/utils';
 import * as Enums from './modules/enums';
@@ -34,9 +32,7 @@ export {
   HotMesh,
   HotMeshConfig,
   MeshCall,
-  MeshData,
   MemFlow,
-  MeshOS,
 
   //MemFlow Submodules
   Client,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hotmeshio/hotmesh",
-  "version": "0.5.3",
+  "version": "0.5.4",
   "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"
   },