@hotmeshio/hotmesh 0.3.8 → 0.3.9

package/types/stream.ts

@@ -1,3 +1,5 @@
+import { ProviderTransaction } from './provider';
+
 /** Represents a policy for retrying stream operations based on error codes */
 export interface StreamRetryPolicy {
   /**
@@ -121,7 +123,7 @@ export type ReclaimedMessageType = [
 ][];
 
 /** Configuration parameters for a stream */
-export type StreamConfig = {
+export type RouterConfig = {
   /** Namespace under which the stream operates */
   namespace: string;
   /** Application identifier */
@@ -141,3 +143,85 @@ export type StreamConfig = {
   /** if true, will not process stream messages; default true */
   readonly?: boolean;
 };
+
+export type StreamProviderType =
+  | 'redis'
+  | 'ioredis'
+  | 'postgres'
+  | 'nats'
+  | 'sqs';
+
+export interface StreamConfig {
+  // Common configuration
+  provider?: StreamProviderType;
+  namespace?: string;
+  appId?: string;
+  maxRetries?: number;
+  batchSize?: number;
+  timeout?: number;
+
+  // Provider-specific configurations
+  redis?: {
+    claimTimeout?: number;
+    blockingTimeout?: number;
+    minIdleTime?: number;
+  };
+  postgres?: {
+    pollInterval?: number;
+    vacuumInterval?: number;
+    partitionInterval?: 'daily' | 'weekly' | 'monthly';
+    cleanupInterval?: number;
+  };
+  nats?: {
+    jetstream?: boolean;
+    durableName?: string;
+    deliverPolicy?: 'all' | 'last' | 'new' | 'byStartSequence' | 'byStartTime';
+    ackWait?: number;
+  };
+  sqs?: {
+    deadLetterQueue?: string;
+    visibilityTimeout?: number;
+    waitTimeSeconds?: number;
+    messageRetentionPeriod?: number;
+    dlqArn?: string;
+  };
+}
+
+export interface StreamMessage {
+  id: string;
+  data: StreamData;
+  metadata?: StreamMessageMetadata;
+}
+
+export interface StreamMessageMetadata {
+  timestamp?: number;
+  stream?: string;
+  groupName?: string;
+  consumerName?: string;
+  retryCount?: number;
+  deliveryTime?: number;
+  originalMessageId?: string;
+  [key: string]: any; // For provider-specific metadata
+}
+
+export interface StreamStats {
+  messageCount: number;
+  consumerCount?: number;
+  bytesInMemory?: number;
+  oldestMessageTimestamp?: number;
+  pendingMessages?: number;
+  deadLetterQueueMessageCount?: number;
+  averageProcessingTime?: number;
+  lastErrorTimestamp?: number;
+  lastErrorMessage?: string;
+  [key: string]: any; // For provider-specific stats
+}
+
+/**
+ * When publishing a message to the stream, the configuration
+ * can include a transaction object to execute the operation
+ * atomically.
+ */
+export interface PublishMessageConfig {
+  transaction?: ProviderTransaction;
+}

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

@@ -1,13 +0,0 @@
-import { IORedisClientOptions as RedisClientOptions, IORedisClassType as RedisClassType, IORedisClientType as RedisClientType } from '../../../types/redis';
-declare class RedisConnection {
-    private connection;
-    private static instances;
-    private id;
-    private static clientOptions;
-    private createConnection;
-    getClient(): RedisClientType;
-    disconnect(): Promise<void>;
-    static connect(id: string, Redis: Partial<RedisClassType>, options?: RedisClientOptions): Promise<RedisConnection>;
-    static disconnectAll(): Promise<void>;
-}
-export { RedisConnection };

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

@@ -1,48 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RedisConnection = void 0;
-class RedisConnection {
-    constructor() {
-        this.connection = null;
-        this.id = null;
-    }
-    async createConnection(Redis, options) {
-        return new Redis(options);
-    }
-    getClient() {
-        if (!this.connection) {
-            throw new Error('Redis client is not connected');
-        }
-        return this.connection;
-    }
-    async disconnect() {
-        if (this.connection) {
-            await this.connection.quit();
-            this.connection = null;
-        }
-        if (this.id) {
-            RedisConnection.instances.delete(this.id);
-        }
-    }
-    static async connect(id, Redis, options) {
-        if (this.instances.has(id)) {
-            return this.instances.get(id);
-        }
-        const instance = new RedisConnection();
-        const opts = options ? { ...options } : { ...this.clientOptions };
-        instance.connection = await instance.createConnection(Redis, opts);
-        instance.id = id;
-        this.instances.set(id, instance);
-        return instance;
-    }
-    static async disconnectAll() {
-        await Promise.all(Array.from(this.instances.values()).map((instance) => instance.disconnect()));
-        this.instances.clear();
-    }
-}
-exports.RedisConnection = RedisConnection;
-RedisConnection.instances = new Map();
-RedisConnection.clientOptions = {
-    host: 'localhost',
-    port: 6379,
-};

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

@@ -1,13 +0,0 @@
-import { RedisRedisClassType, RedisRedisClientType, RedisRedisClientOptions } from '../../../types/redis';
-declare class RedisConnection {
-    private connection;
-    private static instances;
-    private id;
-    private static clientOptions;
-    private createConnection;
-    getClient(): RedisRedisClientType;
-    disconnect(): Promise<void>;
-    static connect(id: string, Redis: Partial<RedisRedisClassType>, options?: RedisRedisClientOptions): Promise<RedisConnection>;
-    static disconnectAll(): Promise<void>;
-}
-export { RedisConnection, RedisRedisClientType };

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

@@ -1,60 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RedisConnection = void 0;
-class RedisConnection {
-    constructor() {
-        this.connection = null;
-        this.id = null;
-    }
-    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 disconnect() {
-        if (this.connection) {
-            await this.connection.quit();
-            this.connection = null;
-        }
-        if (this.id) {
-            RedisConnection.instances.delete(this.id);
-        }
-    }
-    static async connect(id, Redis, options) {
-        if (this.instances.has(id)) {
-            return this.instances.get(id);
-        }
-        const instance = new RedisConnection();
-        const opts = options ? { ...options } : { ...this.clientOptions };
-        instance.connection = (await instance.createConnection(Redis, opts));
-        instance.id = id;
-        this.instances.set(id, instance);
-        return instance;
-    }
-    static async disconnectAll() {
-        await Promise.all(Array.from(this.instances.values()).map((instance) => instance.disconnect()));
-        this.instances.clear();
-    }
-}
-exports.RedisConnection = RedisConnection;
-RedisConnection.instances = new Map();
-RedisConnection.clientOptions = {
-    socket: {
-        host: 'localhost',
-        port: 6379,
-        tls: false,
-    },
-};