@hotmeshio/hotmesh 0.4.0 → 0.4.1

package/build/services/compiler/validator.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Validator = void 0;
+const pipe_1 = require("../pipe");
+class Validator {
+    constructor(manifest) {
+        this.manifest = null;
+        this.activityIds = [];
+        this.mappingStatements = {};
+        this.store = null;
+        this.manifest = manifest;
+    }
+    /**
+     * validate the manifest file
+     */
+    async validate(store) {
+        this.store = store;
+        this.getMappingStatements();
+        this.validateActivityIds();
+        this.validateReferencedActivityIds();
+        this.validateMappingStatements();
+        this.validateTransitions();
+        this.validateTransitionConditions();
+        this.validateStats();
+        this.validateSchemas();
+        this.validateUniqueHandledTopics();
+        this.validateGraphPublishSubscribe();
+        this.validateHooks();
+        this.validateConditionalStatements();
+    }
+    // 1.1) Validate the manifest file activity ids are unique (no duplicates)
+    validateActivityIds() {
+        const activityIdsSet = new Set();
+        this.manifest.app.graphs.forEach((graph) => {
+            const ids = Object.keys(graph.activities);
+            // Check for duplicates and add ids to the set
+            ids.forEach((id) => {
+                if (activityIdsSet.has(id)) {
+                    throw new Error(`Duplicate activity id found: ${id}`);
+                }
+                else {
+                    activityIdsSet.add(id);
+                }
+            });
+        });
+        this.activityIds = Array.from(activityIdsSet);
+    }
+    isMappingStatement(value) {
+        return (typeof value === 'string' && value.startsWith('{') && value.endsWith('}'));
+    }
+    extractMappingStatements(obj, result, currentActivityId) {
+        for (const key in obj) {
+            if (typeof obj[key] === 'object' && obj[key] !== null) {
+                this.extractMappingStatements(obj[key], result, currentActivityId);
+            }
+            else if (this.isMappingStatement(obj[key])) {
+                if (!result[currentActivityId]) {
+                    result[currentActivityId] = [];
+                }
+                result[currentActivityId].push(obj[key]);
+            }
+        }
+    }
+    getMappingStatements() {
+        const mappingStatements = {};
+        this.manifest.app.graphs.forEach((graph) => {
+            const activities = graph.activities;
+            for (const activityId in activities) {
+                const activity = activities[activityId];
+                this.extractMappingStatements(activity, mappingStatements, activityId);
+            }
+        });
+        this.mappingStatements = mappingStatements;
+    }
+    // 1.2) Validate no activity ids are referenced that don't exist
+    validateReferencedActivityIds() {
+        // get list of all mapping statements and validate
+        const mappingStatements = this.mappingStatements;
+        const activityIds = this.activityIds;
+        for (const activity in mappingStatements) {
+            const statements = mappingStatements[activity];
+            statements.forEach((statement) => {
+                if (statement.startsWith('{') && statement.endsWith('}')) {
+                    const statementParts = statement.slice(1, -1).split('.');
+                    const referencedActivityId = statementParts[0];
+                    if (!(Validator.SYS_VARS.includes(referencedActivityId) ||
+                        activityIds.includes(referencedActivityId) ||
+                        this.isFunction(statement) ||
+                        this.isContextVariable(statement))) {
+                        throw new Error(`Mapping statement references non-existent activity: ${statement}`);
+                    }
+                }
+            });
+        }
+    }
+    isFunction(value) {
+        return value.startsWith('{@') && pipe_1.Pipe.resolveFunction(value);
+    }
+    isContextVariable(value) {
+        return ['{$input}', '{$output}', '{$item}', '{$key}', '{$index}'].includes(value);
+    }
+    // 1.3) Validate the mapping/@pipe statements are valid
+    validateMappingStatements() {
+        // Implement the method content
+    }
+    // 1.4) Validate the transitions are valid
+    validateTransitions() {
+        // Implement the method content
+    }
+    // 1.5) Validate the transition conditions are valid
+    validateTransitionConditions() {
+        // Implement the method content
+    }
+    // 1.6) Validate the stats
+    validateStats() {
+        // Implement the method content
+    }
+    // 1.7) Validate the schemas
+    validateSchemas() {
+        // Implement the method content
+    }
+    // 1.8) Validate the topics are unique and handled
+    validateUniqueHandledTopics() {
+        // Implement the method content
+    }
+    // 1.9) Validate that every graph has publishes and subscribes
+    validateGraphPublishSubscribe() {
+        // Implement the method content
+    }
+    // 1.10) Validate hooks, including mapping statements
+    validateHooks() {
+        // Implement the method content
+    }
+    // 1.11) Validate conditional statements
+    validateConditionalStatements() {
+        // Implement the method content
+    }
+}
+exports.Validator = Validator;
+Validator.SYS_VARS = ['$app', '$self', '$graph', '$job'];
+Validator.CONTEXT_VARS = [
+    '{$input}',
+    '{$output}',
+    '{$item}',
+    '{$key}',
+    '{$index}',
+];

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

@@ -0,0 +1,22 @@
+import { HotMeshEngine, HotMeshWorker } from '../../types/hotmesh';
+import { ProviderConfig, ProviderNativeClient } from '../../types/provider';
+export declare class ConnectorService {
+    static disconnectAll(): Promise<void>;
+    /**
+     * 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 connectClient(ProviderConfig: ProviderConfig): Promise<ProviderNativeClient>;
+    /**
+     * Initialize `store`, `stream`, and `subscription` clients for any provider.
+     * @private
+     */
+    static initClients(target: HotMeshEngine | HotMeshWorker): Promise<void>;
+    /**
+     * Binds a provider client native instance to the target object.
+     * @private
+     */
+    static initClient(ProviderConfig: ProviderConfig, target: HotMeshEngine | HotMeshWorker, field: string): Promise<void>;
+}

package/build/services/connector/factory.js

@@ -0,0 +1,99 @@
+"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

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,54 @@
+"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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,26 @@
+"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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,34 @@
+"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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,102 @@
+"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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,38 @@
+"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;