@hotmeshio/hotmesh 0.3.31 → 0.4.0

package/build/services/connector/factory.js

@@ -1,99 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConnectorService = void 0;
-const utils_1 = require("../../modules/utils");
-const ioredis_1 = require("./providers/ioredis");
-const nats_1 = require("./providers/nats");
-const postgres_1 = require("./providers/postgres");
-const redis_1 = require("./providers/redis");
-class ConnectorService {
-    static async disconnectAll() {
-        await redis_1.RedisConnection.disconnectAll();
-        await ioredis_1.RedisConnection.disconnectAll();
-        await postgres_1.PostgresConnection.disconnectAll();
-        await nats_1.NatsConnection.disconnectAll();
-    }
-    /**
-     * Connect to a provider (redis, nats, postgres) and return the native
-     * client. Connections are handled by the engine and worker routers at
-     * initialization, but the factory method provided here is useful
-     * for testing provider configurations.
-     */
-    static async connectClient(ProviderConfig) {
-        const target = {};
-        await ConnectorService.initClient(ProviderConfig, target, 'client');
-        return target.client;
-    }
-    /**
-     * Initialize `store`, `stream`, and `subscription` clients for any provider.
-     * @private
-     */
-    static async initClients(target) {
-        let connection = utils_1.polyfill.providerConfig(target);
-        if (!('store' in connection)) {
-            connection = target.connection = {
-                ...connection,
-                store: { ...connection },
-                stream: { ...connection },
-                sub: { ...connection },
-            };
-        }
-        // Expanded form
-        if (connection.store) {
-            await ConnectorService.initClient(connection.store, target, 'store');
-        }
-        if (connection.stream) {
-            await ConnectorService.initClient(connection.stream, target, 'stream');
-        }
-        if (connection.sub) {
-            await ConnectorService.initClient(connection.sub, target, 'sub');
-            // use store for publishing events if same as subscription
-            if (connection.sub.class !== connection.store.class) {
-                //initialize a separate client for publishing events, using
-                //the same provider as the subscription client
-                connection.pub = {
-                    class: connection.sub.class,
-                    options: { ...connection.sub.options },
-                    provider: connection.sub.provider,
-                };
-                await ConnectorService.initClient(connection.pub, target, 'pub');
-            }
-        }
-    }
-    /**
-     * Binds a provider client native instance to the target object.
-     * @private
-     */
-    static async initClient(ProviderConfig, target, field) {
-        if (target[field]) {
-            return;
-        }
-        const providerClass = ProviderConfig.class;
-        const options = ProviderConfig.options;
-        const providerName = ProviderConfig.provider || (0, utils_1.identifyProvider)(providerClass); //e.g. 'postgres.poolclient'
-        const providerType = providerName.split('.')[0]; //e.g. 'postgres'
-        let clientInstance;
-        const id = (0, utils_1.guid)();
-        switch (providerType) {
-            case 'redis':
-                clientInstance = await redis_1.RedisConnection.connect(id, providerClass, options, { provider: providerName });
-                break;
-            case 'ioredis':
-                clientInstance = await ioredis_1.RedisConnection.connect(id, providerClass, options, { provider: providerName });
-                break;
-            case 'nats':
-                clientInstance = await nats_1.NatsConnection.connect(id, providerClass, options, { provider: providerName });
-                break;
-            case 'postgres':
-                //if connecting as a poolClient for subscription, auto connect the client
-                const bAutoConnect = field === 'sub';
-                clientInstance = await postgres_1.PostgresConnection.connect(id, providerClass, options, { connect: bAutoConnect, provider: providerName });
-                break;
-            default:
-                throw new Error(`Unknown provider type: ${providerType}`);
-        }
-        // Bind the resolved client instance to the target object
-        target[field] = clientInstance.getClient();
-    }
-}
-exports.ConnectorService = ConnectorService;

package/build/services/connector/index.d.ts

@@ -1,30 +0,0 @@
-import { StringAnyType } from '../../types';
-import { ProviderClass, ProviderNativeClient, ProviderOptions } from '../../types/provider';
-import { ILogger } from '../logger';
-/**
- * Abstract class for creating connections to different backend providers.
- * All implementations should extend this class and implement
- * the following steps:
- *
- * 1) Add the provider to ./providers/<name>.ts
- * 2) Update ./factory.ts to reference the provider
- * 3) Register the tag with the `Provider` type in ./types/provider.ts.
- * 4) Create the specific provider type file at ./types/<name>.ts
- * 5) Update ./modules/utils.ts (identifyProvider) with logic to resolve the provider by inspecting the class/import
- */
-declare abstract class AbstractConnection<PClass, POptions> {
-    static logger: ILogger;
-    static disconnecting: boolean;
-    protected connection: any | null;
-    protected static instances: Map<string, AbstractConnection<ProviderClass, ProviderOptions>>;
-    protected id: string | null;
-    protected abstract defaultOptions: any;
-    protected abstract createConnection(client: PClass, options: POptions, config?: StringAnyType): Promise<any>;
-    abstract getClient(): ProviderNativeClient;
-    disconnect(): Promise<void>;
-    protected abstract closeConnection(connection: any): Promise<void>;
-    static connect<T extends AbstractConnection<ProviderClass, ProviderOptions>>(this: new () => T, id: string, client: ProviderClass, options?: ProviderOptions, //user
-    config?: StringAnyType): Promise<T>;
-    static disconnectAll(): Promise<void>;
-}
-export { AbstractConnection };

package/build/services/connector/index.js

@@ -1,54 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AbstractConnection = void 0;
-const logger_1 = require("../logger");
-/**
- * Abstract class for creating connections to different backend providers.
- * All implementations should extend this class and implement
- * the following steps:
- *
- * 1) Add the provider to ./providers/<name>.ts
- * 2) Update ./factory.ts to reference the provider
- * 3) Register the tag with the `Provider` type in ./types/provider.ts.
- * 4) Create the specific provider type file at ./types/<name>.ts
- * 5) Update ./modules/utils.ts (identifyProvider) with logic to resolve the provider by inspecting the class/import
- */
-class AbstractConnection {
-    constructor() {
-        this.connection = null;
-        this.id = null;
-    }
-    async disconnect() {
-        if (this.connection) {
-            await this.closeConnection(this.connection);
-            this.connection = null;
-        }
-        if (this.id) {
-            AbstractConnection.instances.delete(this.id);
-        }
-    }
-    static async connect(id, client, options, //user
-    config) {
-        if (AbstractConnection.instances.has(id)) {
-            return AbstractConnection.instances.get(id);
-        }
-        const instance = new this();
-        const opts = options ? { ...options } : { ...instance.defaultOptions };
-        instance.connection = await instance.createConnection(client, opts, config);
-        instance.id = id;
-        AbstractConnection.instances.set(id, instance);
-        return instance;
-    }
-    static async disconnectAll() {
-        if (!this.disconnecting) {
-            this.disconnecting = true;
-            await Promise.all(Array.from(this.instances.values()).map((instance) => instance.disconnect()));
-            this.instances.clear();
-            this.disconnecting = false;
-        }
-    }
-}
-exports.AbstractConnection = AbstractConnection;
-AbstractConnection.logger = new logger_1.LoggerService('hotmesh', 'system');
-AbstractConnection.disconnecting = false;
-AbstractConnection.instances = new Map();

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

@@ -1,9 +0,0 @@
-import { AbstractConnection } from '..';
-import { IORedisClientOptions as RedisClientOptions, IORedisClassType as RedisClassType, IORedisClientType as RedisClientType } from '../../../types/redis';
-declare class RedisConnection extends AbstractConnection<RedisClassType, RedisClientOptions> {
-    defaultOptions: RedisClientOptions;
-    createConnection(Redis: RedisClassType, options: RedisClientOptions): Promise<RedisClientType>;
-    getClient(): RedisClientType;
-    closeConnection(connection: RedisClientType): Promise<void>;
-}
-export { RedisConnection };

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

@@ -1,26 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RedisConnection = void 0;
-const __1 = require("..");
-class RedisConnection extends __1.AbstractConnection {
-    constructor() {
-        super(...arguments);
-        this.defaultOptions = {
-            host: 'localhost',
-            port: 6379,
-        };
-    }
-    async createConnection(Redis, options) {
-        return new Redis(options);
-    }
-    getClient() {
-        if (!this.connection) {
-            throw new Error('Redis client is not connected');
-        }
-        return this.connection;
-    }
-    async closeConnection(connection) {
-        await connection.quit();
-    }
-}
-exports.RedisConnection = RedisConnection;

package/build/services/connector/providers/nats.d.ts

@@ -1,9 +0,0 @@
-import { AbstractConnection } from '..';
-import { NatsClientOptions, NatsClientType, NatsClassType } from '../../../types/nats';
-declare class NatsConnection extends AbstractConnection<NatsClassType, NatsClientOptions> {
-    defaultOptions: NatsClientOptions;
-    createConnection(Connect: NatsClassType, options: NatsClientOptions): Promise<NatsClientType>;
-    getClient(): NatsClientType;
-    closeConnection(connection: NatsClientType): Promise<void>;
-}
-export { NatsConnection, NatsClientOptions };

package/build/services/connector/providers/nats.js

@@ -1,34 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NatsConnection = void 0;
-const __1 = require("..");
-class NatsConnection extends __1.AbstractConnection {
-    constructor() {
-        super(...arguments);
-        this.defaultOptions = {
-            servers: ['nats:4222'],
-            timeout: 5000,
-        };
-    }
-    async createConnection(Connect, options) {
-        try {
-            return (await Connect(options));
-        }
-        catch (error) {
-            NatsConnection.logger.error(`nats-provider-connection-failed`, {
-                error,
-            });
-            throw new Error(`nats-provider-connection-failed: ${error.message}`);
-        }
-    }
-    getClient() {
-        if (!this.connection) {
-            throw new Error('nats-provider-connection-failed');
-        }
-        return this.connection;
-    }
-    async closeConnection(connection) {
-        await connection.close();
-    }
-}
-exports.NatsConnection = NatsConnection;

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

@@ -1,20 +0,0 @@
-import { AbstractConnection } from '..';
-import { PostgresClientOptions, PostgresClientType, PostgresClassType, PostgresPoolClientType } from '../../../types/postgres';
-declare class PostgresConnection extends AbstractConnection<PostgresClassType, PostgresClientOptions> {
-    defaultOptions: PostgresClientOptions;
-    protected static poolClientInstances: Set<PostgresPoolClientType>;
-    protected static connectionInstances: Set<PostgresClientType>;
-    poolClientInstance: PostgresPoolClientType;
-    createConnection(clientConstructor: any, options: PostgresClientOptions, config?: {
-        connect?: boolean;
-        provider?: string;
-    }): Promise<PostgresClientType>;
-    getClient(): PostgresClientType;
-    static disconnectAll(): Promise<void>;
-    static disconnectPoolClients(): Promise<void>;
-    static disconnectConnections(): Promise<void>;
-    closeConnection(connection: PostgresClientType): Promise<void>;
-    static isPoolClient(client: any): client is PostgresPoolClientType;
-    static getTransactionClient(transactionClient: any): Promise<['client' | 'poolclient', PostgresClientType]>;
-}
-export { PostgresConnection };

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

@@ -1,102 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PostgresConnection = void 0;
-const __1 = require("..");
-class PostgresConnection extends __1.AbstractConnection {
-    constructor() {
-        super(...arguments);
-        this.defaultOptions = {
-            host: 'postgres',
-            port: 5432,
-            user: 'postgres',
-            password: 'password',
-            database: 'hotmesh',
-            max: 20,
-            idleTimeoutMillis: 30000,
-        };
-    }
-    async createConnection(clientConstructor, options, config = {}) {
-        try {
-            let connection;
-            if (config.provider === 'postgres.poolclient' ||
-                PostgresConnection.isPoolClient(clientConstructor)) {
-                // It's a PoolClient
-                connection = clientConstructor;
-                if (config.connect) {
-                    const client = await clientConstructor.connect();
-                    //register the connection singularly to be 'released' later
-                    PostgresConnection.poolClientInstances.add(client);
-                    this.poolClientInstance = client;
-                }
-            }
-            else {
-                // It's a Client
-                connection = new clientConstructor(options);
-                await connection.connect();
-                await connection.query('SELECT 1');
-            }
-            //register the connection statically to be 'ended' later
-            PostgresConnection.connectionInstances.add(connection);
-            return connection;
-        }
-        catch (error) {
-            PostgresConnection.logger.error(`postgres-provider-connection-failed`, {
-                host: options.host ?? 'unknown',
-                database: options.database ?? 'unknown',
-                port: options.port ?? 'unknown',
-                error,
-            });
-            throw new Error(`postgres-provider-connection-failed: ${error.message}`);
-        }
-    }
-    getClient() {
-        if (!this.connection) {
-            throw new Error('Postgres client is not connected');
-        }
-        return this.poolClientInstance || this.connection;
-    }
-    static async disconnectAll() {
-        if (!this.disconnecting) {
-            this.disconnecting = true;
-            await this.disconnectPoolClients();
-            await this.disconnectConnections();
-            this.disconnecting = false;
-        }
-    }
-    static async disconnectPoolClients() {
-        Array.from(this.poolClientInstances.values()).map((instance) => {
-            instance.release();
-        });
-        this.poolClientInstances.clear();
-    }
-    static async disconnectConnections() {
-        Array.from(this.connectionInstances.values()).map((instance) => {
-            instance.end();
-        });
-        this.connectionInstances.clear();
-    }
-    async closeConnection(connection) {
-        //no-op (handled by disconnectAll)
-    }
-    static isPoolClient(client) {
-        return !(isNaN(client?.totalCount) && isNaN(client?.idleCount));
-    }
-    static async getTransactionClient(transactionClient) {
-        let client;
-        let type;
-        if (PostgresConnection.isPoolClient(transactionClient)) {
-            type = 'poolclient';
-            client = await transactionClient.connect();
-        }
-        else {
-            type = 'client';
-            client = transactionClient;
-        }
-        return [type, client];
-    }
-}
-exports.PostgresConnection = PostgresConnection;
-//statically track all clients (//call 'release')
-PostgresConnection.poolClientInstances = new Set();
-//statically track all connections (//call 'end')
-PostgresConnection.connectionInstances = new Set();

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

@@ -1,9 +0,0 @@
-import { AbstractConnection } from '..';
-import { RedisRedisClassType as RedisClassType, RedisRedisClientType as RedisClientType, RedisRedisClientOptions as RedisClientOptions } from '../../../types/redis';
-declare class RedisConnection extends AbstractConnection<RedisClassType, RedisClientOptions> {
-    defaultOptions: RedisClientOptions;
-    createConnection(Redis: Partial<RedisClassType>, options: RedisClientOptions): Promise<Partial<RedisClientType>>;
-    getClient(): RedisClientType;
-    closeConnection(connection: any): Promise<void>;
-}
-export { RedisConnection, RedisClientType };

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

@@ -1,38 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RedisConnection = void 0;
-const __1 = require("..");
-class RedisConnection extends __1.AbstractConnection {
-    constructor() {
-        super(...arguments);
-        this.defaultOptions = {
-            socket: {
-                host: 'localhost',
-                port: 6379,
-                tls: false,
-            },
-        };
-    }
-    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 closeConnection(connection) {
-        await connection.quit();
-    }
-}
-exports.RedisConnection = RedisConnection;