@hotmeshio/hotmesh 0.3.8 → 0.3.10

package/types/index.ts

@@ -28,7 +28,6 @@ export {
   ClientConfig,
   ClientWorkflow,
   ContextType,
-  ConnectionConfig,
   Connection,
   ProxyResponseType,
   ProxyType,
@@ -78,6 +77,19 @@ export {
   HookRules,
   HookSignal,
 } from './hook';
+export {
+  HotMesh,
+  HotMeshEngine,
+  HotMeshWorker,
+  HotMeshSettings,
+  HotMeshApp,
+  HotMeshApps,
+  HotMeshConfig,
+  HotMeshManifest,
+  HotMeshGraph,
+  KeyType,
+  KeyStoreParams,
+} from './hotmesh';
 export { ILogger, LogLevel } from './logger';
 export {
   ExtensionType,
@@ -93,7 +105,6 @@ export {
 } from './job';
 export {
   DB,
-  DBConfig,
   Profile,
   Namespaces,
   Entity,
@@ -116,19 +127,15 @@ export {
   ReduceObject,
 } from './pipe';
 export {
-  HotMesh,
-  HotMeshApp,
-  HotMeshApps,
-  HotMeshConfig,
-  HotMeshEngine,
-  RedisConfig,
-  HotMeshGraph,
-  HotMeshManifest,
-  HotMeshSettings,
-  HotMeshWorker,
-  KeyStoreParams,
-  KeyType,
-} from './hotmesh';
+  ProviderClass,
+  ProviderClient,
+  ProviderConfig,
+  ProviderTransaction,
+  Providers,
+  TransactionResultList,
+  ProviderNativeClient,
+  ProviderOptions,
+} from './provider';
 export {
   MeshCallConnectParams,
   MeshCallExecParams,
@@ -146,6 +153,19 @@ export {
   ConnectionInput,
   ExecInput,
 } from './meshdata';
+export  {
+  PostgresClassType,
+  PostgresClientOptions,
+  PostgresClientType,
+  PostgresConsumerGroup,
+  PostgresPendingMessage,
+  PostgresPoolClientType,
+  PostgresQueryConfigType,
+  PostgresQueryResultType,
+  PostgresStreamMessage,
+  PostgresStreamOptions,
+  PostgresTransaction,
+} from './postgres'
 export {
   ActivateMessage,
   CronMessage,
@@ -165,6 +185,45 @@ export {
   ThrottleOptions,
   WorkMessage,
 } from './quorum';
+export {
+  NatsAckPolicy,
+  NatsAckPolicyExplicitType,
+  NatsClassType,
+  NatsClientType,
+  NatsClientOptions,
+  NatsConsumerConfigType,
+  NatsJetStreamManager,
+  NatsConnection,
+  NatsJetStreamType,
+  NatsConnectionOptions,
+  NatsConsumerConfig,
+  NatsConsumerInfo,
+  NatsConsumerManager,
+  NatsDeliveryInfo,
+  NatsJetStreamOptions,
+  NatsError,
+  NatsErrorType,
+  NatsJetStreamClient,
+  NatsJsMsg,
+  NatsMessageType,
+  NatsMsgExpect,
+  NatsPubAck,
+  NatsPubAckType,
+  NatsPublishOptions,
+  NatsRetentionPolicy,
+  NatsRetentionPolicyWorkqueueType,
+  NatsSequenceInfo,
+  NatsStorageMemoryType,
+  NatsStorageType,
+  NatsStreamConfig,
+  NatsStreamInfo,
+  NatsStreamManager,
+  NatsStreamConfigType,
+  NatsStreamInfoType,
+  NatsStreamOptions,
+  NatsStreamState,
+  NatsTransaction,
+} from './nats'
 export {
   RedisClass,
   RedisRedisClientType,
@@ -178,10 +237,9 @@ export {
   IORedisClassType,
   IORedisMultiType,
   RedisOptions,
-  MultiResponseFlags,
   isRedisClient,
   isIORedisClient,
-} from './redis'; //common redis types
+} from './redis';
 export {
   JSONSchema,
   StringAnyType,
@@ -213,14 +271,19 @@ export {
 } from './stats';
 export {
   ReclaimedMessageType,
+  RouterConfig,
   StreamCode,
   StreamConfig,
   StreamData,
   StreamDataType,
   StreamError,
   StreamDataResponse,
+  StreamMessage,
+  StreamMessageMetadata,
+  StreamProviderType,
   StreamRetryPolicy,
   StreamRole,
+  StreamStats,
   StreamStatus,
 } from './stream';
 export {

package/types/manifest.ts

@@ -2,20 +2,11 @@ import { MeshOS } from '../services/meshos';
 
 import * as Types from './index';
 
-export type DBConfig = {
-  REDIS_DATABASE: number;
-  REDIS_HOST: string | undefined;
-  REDIS_PORT: number;
-  REDIS_USERNAME: string;
-  REDIS_PASSWORD: string;
-  REDIS_USE_TLS: boolean;
-};
-
 export type DB = {
   name: string;
   label: string;
   search: boolean;
-  config: DBConfig;
+  connection: Types.ProviderConfig;
 };
 
 export type SubClassInstance<T extends typeof MeshOS> = T extends abstract new (

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,236 @@
+import { ProviderClient, ProviderTransaction } from './provider';
+
+/** 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,85 @@
+// /app/types/postgres.ts
+export interface PostgresClientOptions {
+  host?: string;
+  port?: number;
+  user?: string;
+  password?: string;
+  database?: string;
+  max?: number;
+  idleTimeoutMillis?: number;
+  // Add any other options you might need
+}
+
+export type PostgresClassType = {
+  new (options: PostgresClientOptions): PostgresClientType;
+  connect: (options: PostgresClientOptions) => Promise<PostgresClientType>;
+};
+
+export interface PostgresClientType {
+  query: (text: string, values?: any[]) => Promise<PostgresQueryResultType>;
+  end: () => Promise<void>;
+  // Include other methods if necessary
+}
+
+export interface PostgresPoolClientType {
+  query: (text: string, values?: any[]) => Promise<PostgresQueryResultType>;
+  release: () => void;
+  // Include other methods if necessary
+}
+
+export interface PostgresQueryResultType {
+  rows: any[];
+  rowCount: number;
+  // Include other properties if necessary
+}
+
+export interface PostgresQueryConfigType {
+  text: string;
+  values?: any[];
+}
+
+export interface PostgresStreamOptions extends PostgresClientOptions {
+  schema?: string;
+  maxRetries?: number;
+  retryDelay?: number;
+  streamTablePrefix?: string;
+  consumerTablePrefix?: string;
+}
+
+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: PostgresPoolClientType;
+  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;
+};