@hotmeshio/hotmesh 0.3.8 → 0.3.9

package/build/types/redis.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
+import { ProviderClient, ProviderConfig, ProviderTransaction } from './provider';
 import { StringStringType } from './serializer';
 import { ReclaimedMessageType } from './stream';
-type MultiResponseFlags = (string | number)[];
 interface ConnectionOptions {
     host?: string;
     port?: number;
@@ -56,13 +56,9 @@ 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;
@@ -78,7 +74,13 @@ 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, consumer: string, minIdleTime: number, id: string, ...args: string[]): this;
+    XLEN(key: string): this;
     XGROUP(command: 'CREATE' | string, key: string, groupName: string, id: string, mkStream?: 'MKSTREAM'): this;
     XPENDING(key: string, group: string, start?: string, end?: string, count?: number, consumer?: string): this;
     ZADD(key: string, values: {
@@ -91,7 +93,7 @@ interface RedisRedisMultiType {
     ZRANK(key: string, member: string): this;
     ZSCORE(key: string, value: string): this;
 }
-interface RedisRedisClientType {
+interface RedisRedisClientType extends ProviderClient {
     multi(): Partial<RedisRedisMultiType>;
     connect(): Promise<void>;
     sendCommand(args: any[]): Promise<any>;
@@ -109,10 +111,6 @@ interface RedisRedisClientType {
     punsubscribe(channel: string): void;
     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>;
@@ -125,6 +123,17 @@ 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;
@@ -161,7 +170,7 @@ interface IORedisClientOptions {
     keyPrefix?: string;
     reconnectOnError?: (err: Error) => boolean;
 }
-interface IORedisClient {
+interface IORedisClient extends ProviderClient {
     multi(): IORedisMultiType;
     exec(): Promise<unknown[]>;
     sendCommand(args: any[]): Promise<any>;
@@ -176,12 +185,15 @@ interface IORedisClient {
     punsubscribe(channel: string): void;
     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, group: string, start?: string, end?: string, count?: number, consumer?: string): Promise<[string, string, number, [string, number][]][] | [string, string, number, number] | unknown[]>;
     xclaim(key: string, group: string, consumer: string, minIdleTime: number, id: string, ...args: string[]): 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>;
@@ -200,13 +212,15 @@ interface IORedisClient {
     zrange(key: string, start: number, end: number, withScores?: 'WITHSCORES'): Promise<string[]>;
     zrank(key: string, member: string): Promise<number>;
     zscore(key: string, value: string): Promise<number>;
-    xgroup(command: 'CREATE' | string, key: string, groupName: string, id: string, mkStream?: 'MKSTREAM'): Promise<string>;
+    xgroup(command: 'CREATE' | 'DESTROY' | string, key: string, groupName: string, id?: string, mkStream?: 'MKSTREAM'): 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, group: string, start?: string, end?: string, count?: number, consumer?: string): this;
     xclaim(key: string, group: string, consumer: string, minIdleTime: number, id: string, ...args: string[]): this;
@@ -231,4 +245,8 @@ type RedisOptions = RedisRedisClientOptions | IORedisClientOptions;
 type RedisMulti = RedisRedisMultiType | IORedisMultiType;
 declare function isRedisClient(client: RedisClient): client is RedisRedisClientType;
 declare function isIORedisClient(client: RedisClient): client is IORedisClient;
-export { RedisClass, RedisRedisClientType, RedisRedisClientOptions, RedisRedisClassType, IORedisClient as IORedisClientType, RedisClient, RedisMulti, RedisRedisMultiType, IORedisClientOptions, IORedisClassType, IORedisMultiType, RedisOptions, MultiResponseFlags, isRedisClient, isIORedisClient, };
+interface RedisConfig extends ProviderConfig {
+    class: Partial<RedisClass>;
+    options: Partial<RedisOptions>;
+}
+export { RedisClass, RedisConfig, RedisRedisClientType, RedisRedisClientOptions, RedisRedisClassType, IORedisClient as IORedisClientType, RedisClient, RedisMulti, RedisRedisMultiType, IORedisClientOptions, IORedisClassType, IORedisMultiType, RedisOptions, isRedisClient, isIORedisClient, };

package/build/types/stream.d.ts

@@ -1,3 +1,4 @@
+import { ProviderTransaction } from './provider';
 export interface StreamRetryPolicy {
     [key: string]: [number, 'x'?];
 }
@@ -62,7 +63,7 @@ export type ReclaimedMessageType = [
         value: string
     ]
 ][];
-export type StreamConfig = {
+export type RouterConfig = {
     namespace: string;
     appId: string;
     guid: string;
@@ -73,3 +74,66 @@ export type StreamConfig = {
     reclaimCount?: number;
     readonly?: boolean;
 };
+export type StreamProviderType = 'redis' | 'ioredis' | 'postgres' | 'nats' | 'sqs';
+export interface StreamConfig {
+    provider?: StreamProviderType;
+    namespace?: string;
+    appId?: string;
+    maxRetries?: number;
+    batchSize?: number;
+    timeout?: number;
+    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;
+}
+export interface StreamStats {
+    messageCount: number;
+    consumerCount?: number;
+    bytesInMemory?: number;
+    oldestMessageTimestamp?: number;
+    pendingMessages?: number;
+    deadLetterQueueMessageCount?: number;
+    averageProcessingTime?: number;
+    lastErrorTimestamp?: number;
+    lastErrorMessage?: string;
+    [key: string]: any;
+}
+export interface PublishMessageConfig {
+    transaction?: ProviderTransaction;
+}

package/index.ts

@@ -2,26 +2,29 @@ import { HotMesh } from './services/hotmesh';
 import { HotMeshConfig } from './types/hotmesh';
 import { MeshCall } from './services/meshcall';
 import { MeshFlow } from './services/meshflow';
+import { WorkflowHandleService as WorkflowHandle } from './services/meshflow/handle';
 import { MeshData } from './services/meshdata';
 import { MeshOS } from './services/meshos';
+import * as Errors from './modules/errors';
 import * as Utils from './modules/utils';
 
-const { Client, Connection, Handle, Search, Worker, workflow } = MeshFlow;
+const { Client, Connection, Search, Worker, workflow } = MeshFlow;
 
 export {
+  Client,
+  Connection,
+  Errors,
   HotMesh,
   HotMeshConfig,
   MeshCall,
   MeshData,
-  MeshOS,
   MeshFlow,
-  Client,
-  Connection,
-  Handle,
+  MeshOS,
   Search,
   Utils,
   Worker,
   workflow,
+  WorkflowHandle,
 };
 
 export * as Types from './types';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hotmeshio/hotmesh",
-  "version": "0.3.8",
+  "version": "0.3.9",
   "description": "Unbreakable Workflows",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
@@ -25,8 +25,8 @@
     "test:await": "NODE_ENV=test jest ./tests/functional/awaiter/index.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/index.test.ts --detectOpenHandles --forceExit --verbose",
-    "test:connect:ioredis": "NODE_ENV=test jest ./tests/unit/services/connector/clients/ioredis.test.ts --detectOpenHandles --forceExit --verbose",
-    "test:connect:redis": "NODE_ENV=test jest ./tests/unit/services/connector/clients/redis.test.ts --detectOpenHandles --forceExit --verbose",
+    "test:connect:ioredis": "NODE_ENV=test jest ./tests/unit/services/connector/providers/ioredis.test.ts --detectOpenHandles --forceExit --verbose",
+    "test:connect:redis": "NODE_ENV=test jest ./tests/unit/services/connector/providers/redis.test.ts --detectOpenHandles --forceExit --verbose",
     "test:cycle": "NODE_ENV=test jest ./tests/functional/cycle/index.test.ts --detectOpenHandles --forceExit --verbose",
     "test:meshflow": "NODE_ENV=test jest ./tests/meshflow/*/index.test.ts --detectOpenHandles --forceExit --verbose",
     "test:meshflow:basic": "NODE_ENV=test jest ./tests/meshflow/basic/index.test.ts --detectOpenHandles --forceExit --verbose",
@@ -63,12 +63,14 @@
     "test:store:redis": "NODE_ENV=test jest ./tests/functional/store/providers/redis/redis.test.ts --detectOpenHandles --forceExit --verbose",
     "test:stream:ioredis": "NODE_ENV=test jest ./tests/functional/stream/providers/redis/ioredis.test.ts --detectOpenHandles --forceExit --verbose",
     "test:stream:redis": "NODE_ENV=test jest ./tests/functional/stream/providers/redis/redis.test.ts --detectOpenHandles --forceExit --verbose",
+    "test:stream:postgres": "NODE_ENV=test jest ./tests/functional/stream/providers/postgres.test.ts --detectOpenHandles --forceExit --verbose",
+    "test:stream:nats": "NODE_ENV=test jest ./tests/functional/stream/providers/nats/nats.test.ts --detectOpenHandles --forceExit --verbose",
     "test:sub:ioredis": "NODE_ENV=test jest ./tests/functional/sub/providers/redis/ioredis.test.ts --detectOpenHandles --forceExit --verbose",
     "test:sub:redis": "NODE_ENV=test jest ./tests/functional/sub/providers/redis/redis.test.ts --detectOpenHandles --forceExit --verbose",
     "test:trigger": "NODE_ENV=test jest ./tests/unit/services/activities/trigger.test.ts --detectOpenHandles --forceExit --verbose",
-    "test:meshdata": "NODE_ENV=test HMSH_IS_CLUSTER=true jest ./tests/meshdata/index.test.ts --forceExit --verbose --detectOpenHandles",
+    "test:meshdata": "NODE_ENV=test HMSH_IS_CLUSTER=true jest ./tests/meshdata/index.test.ts --forceExit --verbose",
     "test:meshos": "NODE_ENV=test HMSH_IS_CLUSTER=true jest ./tests/meshos/index.test.ts --forceExit --verbose --detectOpenHandles",
-    "test:meshcall": "NODE_ENV=test HMSH_LOGLEVEL=debug jest ./tests/meshcall/index.test.ts --forceExit --verbose --detectOpenHandles",
+    "test:meshcall": "NODE_ENV=test jest ./tests/meshcall/index.test.ts --forceExit --verbose --detectOpenHandles",
     "test:unit": "NODE_ENV=test jest ./tests/unit/*/*/index.test.ts --detectOpenHandles --forceExit --verbose"
   },
   "keywords": [
@@ -111,10 +113,15 @@
     "ts-node": "^10.9.1",
     "ts-node-dev": "^2.0.0",
     "typedoc": "^0.26.4",
-    "typescript": "^5.0.4"
+    "typescript": "^5.0.4",
+    "@types/pg": "^8.10.0",
+    "nats": "^2.28.0",
+    "pg": "^8.10.0"
   },
   "peerDependencies": {
     "ioredis": "^4.0.0 || ^5.0.0",
-    "redis": "^4.0.0"
+    "redis": "^4.0.0",
+    "nats": "^2.0.0",
+    "pg": "^8.0.0"
   }
 }

package/types/hotmesh.ts

@@ -2,9 +2,9 @@ import { ILogger } from '../services/logger';
 import { HotMesh as HotMeshService } from '../services/hotmesh';
 
 import { HookRules } from './hook';
-import { RedisClass, RedisClient, RedisOptions } from './redis';
 import { StreamData, StreamDataResponse } from './stream';
 import { LogLevel } from './logger';
+import { ProviderClient, ProviderConfig } from './provider';
 
 /**
  * the full set of entity types that are stored in the key/value store
@@ -50,29 +50,147 @@ type KeyStoreParams = {
 
 type HotMesh = typeof HotMeshService;
 
-type RedisConfig = {
-  class: Partial<RedisClass>;
-  options: Partial<RedisOptions>;
-};
-
 type HotMeshEngine = {
-  store?: RedisClient; //set by hotmesh using instanced `redis` class
-  stream?: RedisClient; //set by hotmesh using instanced `redis` class
-  sub?: RedisClient; //set by hotmesh using instanced `redis` class
-  redis?: RedisConfig;
-  reclaimDelay?: number; //milliseconds
+  /**
+   * set by hotmesh once the connnector service instances the provider
+   * @private
+   */
+  store?: ProviderClient;
+  /**
+   * set by hotmesh once the connnector service instances the provider
+   * @private
+   */
+  stream?: ProviderClient;
+  /**
+   * set by hotmesh once the connnector service instances the provider
+   * @private
+   */
+  sub?: ProviderClient;
+  /**
+   * set by hotmesh once the connnector service instances the provider
+   * @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
+   */
+  connection?: ProviderConfig;
+
+  /**
+   * long-form format for the connection options for the
+   * store, stream, sub, and search clients
+   */
+  connections?: {
+    store: ProviderConfig;
+    stream: ProviderConfig;
+    sub: ProviderConfig;
+    search?: ProviderConfig; //inherits from store if not set
+  };
+
+  /**
+   * the number of milliseconds to wait before reclaiming a stream;
+   * depending upon the provider this may be an explicit retry event,
+   * consuming a message from the stream and re-queueing it (dlq, etc),
+   * or it may be a configurable delay before the provider exposes the
+   * message to the consumer again. It is up to the provider, but expressed
+   * in milliseconds here.
+   */
+  reclaimDelay?: number;
+
+  /**
+   * the number of times to reclaim a stream before giving up
+   * and moving the message to a dead-letter queue or other
+   * error handling mechanism
+   */
   reclaimCount?: number;
-  readonly?: boolean; //if true, the engine will not route stream messages
+
+  /**
+   * if true, the engine will not route stream messages
+   * to the worker
+   * @default false
+   */
+  readonly?: boolean;
 };
 
 type HotMeshWorker = {
+  /**
+   * the topic that the worker subscribes to
+   */
   topic: string;
-  store?: RedisClient; //set by hotmesh using instanced `redis` class
-  stream?: RedisClient; //set by hotmesh using instanced `redis` class
-  sub?: RedisClient; //set by hotmesh using instanced `redis` class
-  redis?: RedisConfig;
-  reclaimDelay?: number; //milliseconds
-  reclaimCount?: number; //max number of times to reclaim a stream
+
+  /**
+   * set by hotmesh once the connnector service instances the provider
+   * @private
+   */
+  store?: ProviderClient;
+  /**
+   * set by hotmesh once the connnector service instances the provider
+   * @private
+   */
+  stream?: ProviderClient;
+  /**
+   * set by hotmesh once the connnector service instances the provider
+   * @private
+   */
+  sub?: ProviderClient;
+  /**
+   * set by hotmesh once the connnector service instances the provider
+   * @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
+   */
+  connection?: ProviderConfig;
+
+  /**
+   * long-form format for the connection options for the
+   * store, stream, sub, and search clients
+   */
+  connections?: {
+    store: ProviderConfig;
+    stream: ProviderConfig;
+    sub: ProviderConfig;
+    search?: ProviderConfig; //inherits from store if not set
+  };
+
+  /**
+   * the number of milliseconds to wait before reclaiming a stream;
+   * depending upon the provider this may be an explicit retry event,
+   * consuming a message from the stream and re-queueing it (dlq, etc),
+   * or it may be a configurable delay before the provider exposes the
+   * message to the consumer again. It is up to the provider, but expressed
+   * in milliseconds here.
+   */
+  reclaimDelay?: number;
+
+  /**
+   * the number of times to reclaim a stream before giving up
+   * and moving the message to a dead-letter queue or other
+   * error handling mechanism
+   */
+  reclaimCount?: number;
+
+  /**
+   * The callback function to execute when a message is dequeued
+   * from the target stream
+   */
   callback: (payload: StreamData) => Promise<StreamDataResponse>;
 };
 
@@ -169,12 +287,11 @@ type HotMeshApps = {
 export {
   HotMesh,
   HotMeshEngine,
-  RedisConfig,
   HotMeshWorker,
   HotMeshSettings,
-  HotMeshApp, //a single app in the db
-  HotMeshApps, //object array of all apps in the db
-  HotMeshConfig, //customer config
+  HotMeshApp,
+  HotMeshApps,
+  HotMeshConfig,
   HotMeshManifest,
   HotMeshGraph,
   KeyType,

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,13 @@ 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,
+} from './provider';
 export {
   MeshCallConnectParams,
   MeshCallExecParams,
@@ -178,10 +183,9 @@ export {
   IORedisClassType,
   IORedisMultiType,
   RedisOptions,
-  MultiResponseFlags,
   isRedisClient,
   isIORedisClient,
-} from './redis'; //common redis types
+} from './redis';
 export {
   JSONSchema,
   StringAnyType,
@@ -213,14 +217,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 (