@hotmeshio/hotmesh 0.3.8 → 0.3.9

package/types/meshcall.ts

@@ -1,4 +1,4 @@
-import { RedisConfig } from './hotmesh';
+import { ProviderConfig } from './provider';
 import { LogLevel } from './logger';
 
 interface MeshCallExecOptions {
@@ -33,13 +33,18 @@ interface MeshCallConnectParams {
    */
   topic: string;
   /**
-   * Redis configuration for the worker
+   * Redis configuration; use 'connection' instead of 'redis'
+   * @deprecated
    */
-  redis: RedisConfig;
+  redis?: ProviderConfig;
   /**
-   * The linked worker function that will be called
+   * Provider configuration
    */
-  callback: (...args: any[]) => any;
+  connection?: ProviderConfig;
+  /**
+   * The linked worker function that will be called; optional if read only
+   */
+  callback?: (...args: any[]) => any;
 }
 
 interface MeshCallExecParams {
@@ -56,9 +61,14 @@ interface MeshCallExecParams {
    */
   args: any[];
   /**
-   * Redis configuration
+   * Redis configuration; use 'connection' instead of 'redis'
+   * @deprecated
    */
-  redis: RedisConfig;
+  redis?: ProviderConfig;
+  /**
+   * Provider configuration
+   */
+  connection?: ProviderConfig;
   /**
    * Execution options like caching ttl
    */
@@ -86,9 +96,14 @@ interface MeshCallFlushParams {
    */
   topic: string;
   /**
-   * Redis configuration
+   * Redis configuration; use 'connection' instead of 'redis'
+   * @deprecated
    */
-  redis: RedisConfig;
+  redis?: ProviderConfig;
+  /**
+   * Provider configuration
+   */
+  connection?: ProviderConfig;
   /**
    * Options for the flush
    */
@@ -144,9 +159,14 @@ interface MeshCallCronParams {
    */
   topic: string;
   /**
-   * Redis configuration for the cron job
+   * Redis configuration; use 'connection' instead of 'redis'
+   * @deprecated
+   */
+  redis?: ProviderConfig;
+  /**
+   * Provider configuration
    */
-  redis: RedisConfig;
+  connection?: ProviderConfig;
   /**
    * Arguments to pass to the cron job; arguments will be passed to the callback
    * each time it runs
@@ -188,9 +208,14 @@ interface MeshCallInterruptParams {
    */
   topic: string;
   /**
-   * Redis configuration
+   * Redis configuration; use 'connection' instead of 'redis'
+   * @deprecated
+   */
+  redis?: ProviderConfig;
+  /**
+   * Provider configuration
    */
-  redis: RedisConfig;
+  connection?: ProviderConfig;
   /**
    * Options for interrupting the cron
    */

package/types/meshflow.ts

@@ -1,7 +1,7 @@
 import { WorkflowHandleService } from '../services/meshflow/handle';
 
 import { LogLevel } from './logger';
-import { RedisClass, RedisOptions } from './redis';
+import { ProviderConfig } from './provider';
 import { StringAnyType, StringStringType } from './serializer';
 import { StreamData, StreamError } from './stream';
 
@@ -435,11 +435,7 @@ type WorkflowDataType = {
   expire?: number;
 };
 
-type ConnectionConfig = {
-  class: Partial<RedisClass>;
-  options: Partial<RedisOptions>;
-};
-type Connection = ConnectionConfig;
+type Connection = ProviderConfig;
 
 type ClientConfig = {
   connection: Connection;
@@ -628,7 +624,6 @@ export {
   ClientConfig,
   ClientWorkflow,
   ContextType,
-  ConnectionConfig,
   Connection,
   ProxyResponseType,
   ProxyType,

package/types/nats.ts

@@ -0,0 +1,231 @@
+import { ProviderClient, ProviderTransaction } from './provider';
+
+// NOTE: Manually defines NATS types to avoid importing 'nats' package
+// TODO: Generate file using 'nats' package/interface definitions
+
+/** Connection Options for NATS */
+export interface NatsConnectionOptions {
+  servers?: string | string[];
+  timeout?: number;
+  name?: string;
+  user?: string;
+  pass?: string;
+  token?: string;
+  // Add other connection options as needed
+}
+
+/** Additional JetStream Options */
+export interface NatsJetStreamOptions {
+  domain?: string;
+  prefix?: string;
+  timeout?: number;
+}
+
+/** Combined Stream Options */
+export interface NatsStreamOptions extends NatsConnectionOptions {
+  jetstream?: NatsJetStreamOptions;
+}
+
+/** Type for NATS Client Options */
+export type NatsClientOptions = NatsStreamOptions;
+
+/** Interface representing a NATS Connection */
+export interface NatsConnection extends ProviderClient {
+  jetstream(options?: NatsJetStreamOptions): NatsJetStreamClient;
+  jetstreamManager(options?: NatsJetStreamOptions): Promise<NatsJetStreamManager>;
+  close(): Promise<void>;
+}
+
+/** Type representing the NATS Connection */
+export type NatsClientType = NatsConnection;
+
+/** Type representing the NATS Connection Function */
+export type NatsClassType = (options: NatsClientOptions) => Promise<NatsConnection>;
+
+/** Interface for JetStream Client */
+export interface NatsJetStreamClient {
+  publish(subject: string, data: Uint8Array, options?: NatsPublishOptions): Promise<NatsPubAck>;
+  consumers: any; // Simplify as needed
+  jetstreamManager(): Promise<NatsJetStreamManager>;
+  // Additional methods as needed
+}
+
+/** **NatsJetStreamType** */
+export type NatsJetStreamType = NatsJetStreamClient;
+
+/** Interface for JetStream Manager */
+export interface NatsJetStreamManager {
+  streams: NatsStreamManager;
+  consumers: NatsConsumerManager;
+}
+
+/** Interface for Stream Manager */
+export interface NatsStreamManager {
+  add(config: Partial<NatsStreamConfig>): Promise<void>;
+  delete(stream: string): Promise<boolean>;
+  info(stream: string): Promise<NatsStreamInfo>;
+  list(): AsyncIterable<NatsStreamInfo>;
+  deleteMessage(stream: string, seq: number): Promise<boolean>;
+  update(stream: string, config: NatsStreamConfig ): Promise<void>;
+}
+
+/** Interface for Consumer Manager */
+export interface NatsConsumerManager {
+  add(stream: string, config: NatsConsumerConfig): Promise<void>;
+  delete(stream: string, consumer: string): Promise<boolean>;
+  info(stream: string, consumer: string): Promise<NatsConsumerInfo>;
+  list(stream: string): AsyncIterable<NatsConsumerInfo>;
+  // Additional methods as needed
+}
+
+/** Stream Configuration */
+export interface NatsStreamConfig {
+  name: string;
+  subjects?: string[];
+  retention?: NatsRetentionPolicy;
+  storage?: NatsStorageType;
+  num_replicas?: number;
+  max_msgs?: number;
+  max_age?: number; // In nanoseconds
+  // Add other stream configurations as needed
+}
+
+/** Consumer Configuration */
+export interface NatsConsumerConfig {
+  durable_name?: string;
+  deliver_subject?: string;
+  deliver_group?: string;
+  ack_policy?: NatsAckPolicy;
+  ack_wait?: number; // In nanoseconds
+  max_deliver?: number;
+  // Add other consumer configurations as needed
+}
+
+/** Interface for JetStream Message */
+export interface NatsJsMsg {
+  seq: number;
+  ack(): void;
+  nak(): void;
+  term(): void;
+  inProgress(): void;
+  working(): void;
+  data: Uint8Array;
+  subject: string;
+  headers?: { [key: string]: string };
+  info: NatsDeliveryInfo;
+  // Additional properties and methods as needed
+}
+
+/** Delivery Info for a Message */
+export interface NatsDeliveryInfo {
+  stream: string;
+  consumer: string;
+  redeliveryCount: number;
+  timestampNanos: number;
+  pending: number;
+  // Additional properties as needed
+}
+
+/** Interface for Publish Acknowledgment */
+export interface NatsPubAck extends ProviderTransaction {
+  stream: string;
+  seq: number;
+  duplicate: boolean;
+}
+
+/** Interface for Stream Information */
+export interface NatsStreamInfo {
+  config: NatsStreamConfig;
+  state: NatsStreamState;
+}
+
+/** Stream State Information */
+export interface NatsStreamState {
+  messages: number;
+  bytes: number;
+  first_seq: number;
+  last_seq: number;
+  // Additional state properties as needed
+}
+
+/** Interface for Consumer Information */
+export interface NatsConsumerInfo {
+  name: string;
+  stream_name: string;
+  config: NatsConsumerConfig;
+  delivered: NatsSequenceInfo;
+  ack_floor: NatsSequenceInfo;
+  num_ack_pending: number;
+  num_redelivered: number;
+  num_waiting: number;
+  num_pending: number;
+  // Additional properties as needed
+}
+
+/** Sequence Information */
+export interface NatsSequenceInfo {
+  consumer_seq: number;
+  stream_seq: number;
+}
+
+/** Publish Options */
+export interface NatsPublishOptions {
+  msgID?: string;
+  expect?: NatsMsgExpect;
+  headers?: { [key: string]: string };
+  // Additional options as needed
+}
+
+/** Message Expectation */
+export interface NatsMsgExpect {
+  lastMsgID?: string;
+  streamName?: string;
+  lastSequence?: number;
+  // Additional expectations as needed
+}
+
+/** NATS Error */
+export interface NatsError extends Error {
+  code?: string;
+  // Additional properties as needed
+}
+
+/** Retention Policies */
+export type NatsRetentionPolicy = 'limits' | 'interest' | 'workqueue';
+
+/** Storage Types */
+export type NatsStorageType = 'file' | 'memory';
+
+/** Acknowledgment Policies */
+export type NatsAckPolicy = 'none' | 'all' | 'explicit';
+
+/** Types for Specific Policies */
+export type NatsRetentionPolicyWorkqueueType = 'workqueue';
+export type NatsStorageMemoryType = 'memory';
+export type NatsAckPolicyExplicitType = 'explicit';
+
+/** NATS Message Type */
+export type NatsMessageType = NatsJsMsg;
+
+/** NATS Transaction Interface */
+export interface NatsTransaction {
+  msgs: NatsMessageType[];
+  pubAcks: NatsPubAck[];
+  execute(): Promise<void>;
+  rollback(): Promise<void>;
+}
+
+/** NATS Client Error Type */
+export type NatsErrorType = NatsError;
+
+/** NATS Stream Info Type */
+export type NatsStreamInfoType = NatsStreamInfo;
+
+/** NATS Stream Config Type */
+export type NatsStreamConfigType = Partial<NatsStreamConfig>;
+
+/** NATS Consumer Config Type */
+export type NatsConsumerConfigType = Partial<NatsConsumerConfig>;
+
+/** NATS Publish Ack Type */
+export type NatsPubAckType = NatsPubAck;

package/types/postgres.ts

@@ -0,0 +1,54 @@
+import { Pool, PoolConfig, PoolClient, QueryResult, QueryConfig } from 'pg';
+
+export interface PostgresStreamOptions extends PoolConfig {
+  schema?: string;
+  maxRetries?: number;
+  retryDelay?: number;
+  streamTablePrefix?: string;
+  consumerTablePrefix?: string;
+}
+
+export type PostgresClientOptions = PoolConfig;
+export type PostgresClientType = Pool;
+export type PostgresClassType = typeof Pool;
+export type PostgresPoolClientType = PoolClient;
+export type PostgresQueryResultType = QueryResult;
+export type PostgresQueryConfigType = QueryConfig;
+
+export interface PostgresStreamMessage {
+  id: string;
+  stream: string;
+  message: any;
+  created_at: Date;
+  sequence?: number;
+}
+
+export interface PostgresConsumerGroup {
+  stream: string;
+  group_name: string;
+  last_message_id: string;
+  created_at: Date;
+  updated_at: Date;
+}
+
+export interface PostgresPendingMessage {
+  stream: string;
+  group_name: string;
+  consumer_name: string;
+  message_id: string;
+  delivered_at: Date;
+  delivery_count: number;
+}
+
+export interface PostgresTransaction {
+  client: PoolClient;
+  queryBuffer: {
+    text: string;
+    values: any[];
+  }[];
+  begin(): Promise<void>;
+  query(text: string, values?: any[]): Promise<PostgresQueryResultType>;
+  commit(): Promise<void>;
+  rollback(): Promise<void>;
+  release(): void;
+}

package/types/provider.ts

@@ -0,0 +1,71 @@
+import { KeyStoreParams } from '../modules/key';
+
+import { StringAnyType } from './serializer';
+
+/**
+ * Generic type for provider class
+ */
+export interface ProviderClass {
+  [key: string]: any;
+}
+
+/**
+ * Generic type for provider options
+ */
+export interface ProviderOptions {
+  [key: string]: any;
+}
+
+export type Providers = 'redis' | 'nats' | 'postgres' | 'ioredis';
+
+/**
+ * A provider transaction is a set of operations that are executed
+ * atomically by the provider. The transaction is created by calling
+ * the `transact` method on the provider. The transaction object
+ * contains methods specific to the provider allowing it to optionally
+ * choose to execute a single command or collect all commands and
+ * execute as a single transaction.
+ */
+export interface ProviderTransaction {
+  //outside callers can execute the transaction, regardless of provider by calling this method
+  exec(): Promise<any>;
+
+  // All other transaction methods are provider specific
+  [key: string]: any;
+}
+
+/**
+ * A provider native client is the raw client object provided by the
+ * connecter service. This object is passed to the ProviderClient
+ * (which wraps it), providing a standardized interface for all
+ * providers.
+ */
+export interface ProviderNativeClient {
+  [key: string]: any;
+}
+
+/**
+ * Wrapped provider native client object that standardizes the
+ * interface for all providers.
+ */
+export interface ProviderClient {
+  /** The provider-specific transaction object */
+  transact(): ProviderTransaction;
+
+  /** Mint a provider-specific key */
+  mintKey(type: KeyType, params: KeyStoreParams): string;
+
+  /** The provider-specific client object */
+  [key: string]: any;
+}
+
+/**
+ * an array of outputs generic to all providers
+ * e.g., [3, 2, '0']
+ */
+export type TransactionResultList = (string | number)[]; // e.g., [3, 2, '0']
+
+export type ProviderConfig = {
+  class: any;
+  options: StringAnyType;
+};

package/types/redis.ts

@@ -1,8 +1,11 @@
+import {
+  ProviderClient,
+  ProviderConfig,
+  ProviderTransaction,
+} from './provider';
 import { StringStringType } from './serializer';
 import { ReclaimedMessageType } from './stream';
 
-type MultiResponseFlags = (string | number)[]; // e.g., [3, 2, '0']
-
 /**
  * Redis types
  */
@@ -64,14 +67,10 @@ interface RedisRedisClientOptions {
   stringNumbers?: boolean;
 }
 
-interface RedisRedisMultiType {
+interface RedisRedisMultiType extends ProviderTransaction {
   sendCommand(command: string, ...args: string[]): Promise<any>;
   exec: () => Promise<unknown[]>;
 
-  XADD(key: string, id: string, fields: any): this;
-  XACK(key: string, group: string, id: string): this;
-  XDEL(key: string, id: string): this;
-  XLEN(key: string): this;
   DEL(key: string): this;
   EXISTS(key: string): this;
   EXPIRE(key: string, seconds: number): this;
@@ -87,6 +86,11 @@ interface RedisRedisMultiType {
   LRANGE(key: string, start: number, end: number): this;
   RPUSH(key: string, items: string[]): this;
   SET(key: string, value: string): this;
+  XADD(key: string, id: string, fields: any): this;
+  XACK(key: string, group: string, id: string): this;
+  XACK(key: string, group: string, ...ids: string[]): this;
+  XDEL(key: string, id: string): this;
+  XDEL(key: string, ...ids: string[]): this;
   XCLAIM(
     key: string,
     group: string,
@@ -95,6 +99,7 @@ interface RedisRedisMultiType {
     id: string,
     ...args: string[]
   ): this;
+  XLEN(key: string): this;
   XGROUP(
     command: 'CREATE' | string,
     key: string,
@@ -120,7 +125,7 @@ interface RedisRedisMultiType {
   ZSCORE(key: string, value: string): this;
 }
 
-interface RedisRedisClientType {
+interface RedisRedisClientType extends ProviderClient {
   multi(): Partial<RedisRedisMultiType>;
   connect(): Promise<void>;
   sendCommand(args: any[]): Promise<any>;
@@ -145,10 +150,6 @@ interface RedisRedisClientType {
   get(key: string): Promise<string | null>;
   set(key: string, value: string): Promise<string>;
 
-  XADD(key: string, id: string, fields: any): Promise<string>;
-  XACK(key: string, group: string, id: string): Promise<number>;
-  XDEL(key: string, id: string): Promise<number>;
-  XLEN(key: string): Promise<number>;
   DEL(key: string): Promise<number>;
   EXISTS(key: string): Promise<number>;
   HDEL(key: string, fields: string[] | string): Promise<number>;
@@ -161,6 +162,31 @@ interface RedisRedisClientType {
   LRANGE(key: string, start: number, end: number): Promise<string[]>;
   RPUSH(key: string, items: string[]): Promise<number>;
   SET(key: string, value: string): Promise<string>;
+  XADD(key: string, id: string, fields: any): Promise<string>;
+  XACK(key: string, group: string, ...ids: string[]): Promise<number>;
+  XACK(key: string, group: string, id: string): Promise<number>;
+  XCLAIM(
+    key: string,
+    group: string,
+    consumer: string,
+    minIdleTime: number,
+    id: string,
+    ...args: string[]
+  ): Promise<ReclaimedMessageType>;
+  XDEL(key: string, id: string): Promise<number>;
+  XDEL(key: string, ...ids: string[]): Promise<number>;
+  xGroupDestroy(key: string, groupName: string): Promise<boolean>;
+  XINFO(command: 'GROUPS' | string, key: string): Promise<unknown>;
+  XINFO_GROUPS(key: string): Promise<unknown>;
+  XLEN(key: string): Promise<number>;
+  XPENDING(
+    key: string,
+    group: string,
+    start?: string,
+    end?: string,
+    count?: number,
+    consumer?: string,
+  ): this;
   ZADD(
     key: string,
     values: { score: string; value: string },
@@ -200,7 +226,7 @@ interface IORedisClientOptions {
   reconnectOnError?: (err: Error) => boolean;
 }
 
-interface IORedisClient {
+interface IORedisClient extends ProviderClient {
   multi(): IORedisMultiType;
   exec(): Promise<unknown[]>;
   sendCommand(args: any[]): Promise<any>;
@@ -223,7 +249,9 @@ interface IORedisClient {
 
   xadd(key: string, id: string, fields: any, message?: string): Promise<string>;
   xack(key: string, group: string, id: string): Promise<number>;
+  xack(key: string, group: string, ...ids: string[]): Promise<number>;
   xdel(key: string, id: string): Promise<number>;
+  xdel(key: string, ...ids: string[]): Promise<number>;
   xlen(key: string): Promise<number>;
   xpending(
     key: string,
@@ -247,6 +275,16 @@ interface IORedisClient {
   ): Promise<ReclaimedMessageType>;
   xinfo(command: 'GROUPS' | string, key: string): Promise<unknown>;
   xrange(key: string, start: string, end: string): Promise<string[][]>;
+  xreadgroup(
+    command: 'GROUP',
+    groupName: string,
+    consumerName: string,
+    blockOption: string,
+    blockTime: number,
+    streamsOption: string,
+    streamName: string,
+    key: string,
+  ): Promise<string[][]>;
   del(key: string): Promise<number>;
   exists(key: string): Promise<number>;
   get(key: string): Promise<string | null>;
@@ -271,22 +309,24 @@ interface IORedisClient {
   zrank(key: string, member: string): Promise<number>;
   zscore(key: string, value: string): Promise<number>;
   xgroup(
-    command: 'CREATE' | string,
+    command: 'CREATE' | 'DESTROY' | string,
     key: string,
     groupName: string,
-    id: string,
+    id?: string,
     mkStream?: 'MKSTREAM',
-  ): Promise<string>;
+  ): Promise<string | number>;
 }
 
 type IORedisClassType = new (
   options: IORedisClientOptions,
   ...args: any[]
 ) => IORedisClient;
-interface IORedisMultiType {
+interface IORedisMultiType extends ProviderTransaction {
   xadd(key: string, id: string, fields: any, message?: string): this;
   xack(key: string, group: string, id: string): this;
+  xack(key: string, group: string, ...ids: string[]): this;
   xdel(key: string, id: string): this;
+  xdel(key: string, ...ids: string[]): this;
   xlen(key: string): this;
   xpending(
     key: string,
@@ -340,8 +380,14 @@ function isIORedisClient(client: RedisClient): client is IORedisClient {
   return 'pipeline' in client;
 }
 
+interface RedisConfig extends ProviderConfig {
+  class: Partial<RedisClass>;
+  options: Partial<RedisOptions>;
+}
+
 export {
   RedisClass,
+  RedisConfig,
   RedisRedisClientType,
   RedisRedisClientOptions,
   RedisRedisClassType,
@@ -353,7 +399,6 @@ export {
   IORedisClassType,
   IORedisMultiType,
   RedisOptions,
-  MultiResponseFlags,
   isRedisClient,
   isIORedisClient,
 };