@hotmeshio/hotmesh 0.0.4 → 0.0.5

package/build/esm/services/collator/index.js

@@ -0,0 +1,191 @@
+import { CollationError } from '../../modules/errors';
+import { CollationFaultType } from '../../types/collator';
+class CollatorService {
+    static getDimensionalAddress(activity) {
+        let dad = activity.context.metadata.dad || activity.metadata.dad;
+        //todo: unsure about this reset
+        // if (dad && activity.leg === 2) {
+        //   console.log('setting dad index back to 0=>', dad);
+        //   dad = `${dad.substring(0, dad.lastIndexOf(','))},0`;
+        // }
+        return CollatorService.getDimensionsById([...activity.config.ancestors, activity.metadata.aid], dad);
+    }
+    static async notarizeEntry(activity, multi) {
+        //decrement by -100_000_000_000_000
+        const amount = await activity.store.collate(activity.context.metadata.jid, activity.metadata.aid, -100000000000000, this.getDimensionalAddress(activity), multi);
+        this.verifyInteger(amount, 1, 'enter');
+        return amount;
+    }
+    ;
+    static async authorizeReentry(activity, multi) {
+        //set second digit to 8, allowing for re-entry
+        //decrement by -10_000_000_000_000
+        const amount = await activity.store.collate(activity.context.metadata.jid, activity.metadata.aid, -10000000000000, this.getDimensionalAddress(activity), multi);
+        //this.verifyInteger(amount, 1, 'exit');
+        return amount;
+    }
+    static async notarizeEarlyCompletion(activity, multi) {
+        //initialize both `possible` (1m) and `actualized` (1) zero dimension, while decrementing the 2nd and 3rd digits to deactivate the activity
+        return await activity.store.collate(activity.context.metadata.jid, activity.metadata.aid, 1000001 - 11000000000000, this.getDimensionalAddress(activity), multi);
+    }
+    ;
+    static async notarizeReentry(activity, multi) {
+        //increment by 1_000_000 (indicates re-entry and is used to drive the 'dimensional address' for adjacent activities (minus 1))
+        const amount = await activity.store.collate(activity.context.metadata.jid, activity.metadata.aid, 1000000, this.getDimensionalAddress(activity), multi);
+        this.verifyInteger(amount, 2, 'enter');
+        return amount;
+    }
+    ;
+    static async notarizeContinuation(activity, multi) {
+        //keep open; actualize the leg2 dimension (+1)
+        return await activity.store.collate(activity.context.metadata.jid, activity.metadata.aid, 1, this.getDimensionalAddress(activity), multi);
+    }
+    ;
+    static async notarizeCompletion(activity, multi) {
+        //close out; actualize leg2 dimension (+1) and decrement the 3rd digit (-1_000_000_000_000)
+        return await activity.store.collate(activity.context.metadata.jid, activity.metadata.aid, 1 - 1000000000000, this.getDimensionalAddress(activity), multi);
+    }
+    ;
+    static getDigitAtIndex(num, targetDigitIndex) {
+        const numStr = num.toString();
+        if (targetDigitIndex < 0 || targetDigitIndex >= numStr.length) {
+            return null;
+        }
+        const digit = parseInt(numStr[targetDigitIndex], 10);
+        return digit;
+    }
+    static getDimensionalIndex(num) {
+        const numStr = num.toString();
+        if (numStr.length < 9) {
+            return null;
+        }
+        const extractedStr = numStr.substring(3, 9);
+        const extractedInt = parseInt(extractedStr, 10);
+        return extractedInt - 1;
+    }
+    static isDuplicate(num, targetDigitIndex) {
+        return this.getDigitAtIndex(num, targetDigitIndex) < 8;
+    }
+    static isInactive(num) {
+        return this.getDigitAtIndex(num, 2) < 9;
+    }
+    static isPrimed(amount, leg) {
+        //activity entry is not allowed if paths not properly pre-set
+        if (leg == 1) {
+            return amount != -100000000000000;
+        }
+        else {
+            return this.getDigitAtIndex(amount, 0) < 9 &&
+                this.getDigitAtIndex(amount, 1) < 9;
+        }
+    }
+    static verifyInteger(amount, leg, stage) {
+        let faultType;
+        if (leg === 1 && stage === 'enter') {
+            if (!this.isPrimed(amount, 1)) {
+                faultType = CollationFaultType.MISSING;
+            }
+            else if (this.isDuplicate(amount, 0)) {
+                faultType = CollationFaultType.DUPLICATE;
+            }
+            else if (amount != 899000000000000) {
+                faultType = CollationFaultType.INVALID;
+            }
+        }
+        else if (leg === 1 && stage === 'exit') {
+            if (amount === -10000000000000) {
+                faultType = CollationFaultType.MISSING;
+            }
+            else if (this.isDuplicate(amount, 1)) {
+                faultType = CollationFaultType.DUPLICATE;
+            }
+        }
+        else if (leg === 2 && stage === 'enter') {
+            if (!this.isPrimed(amount, 2)) {
+                faultType = CollationFaultType.FORBIDDEN;
+            }
+            else if (this.isInactive(amount)) {
+                faultType = CollationFaultType.INACTIVE;
+            }
+        }
+        if (faultType) {
+            throw new CollationError(amount, leg, stage, faultType);
+        }
+    }
+    static getDimensionsById(ancestors, dad) {
+        //ancestors is an ordered list of all ancestors, starting with the trigger (['t1', 'a1', 'a2'])
+        //dad is the dimensional address of the ancestors list (',0,5,3')
+        //loop through the ancestors list and create a map of the ancestor to the dimensional address.
+        //return { 't1': ',0', 'a1': ',0,5', 'a1': ',0,5,3', $ADJACENT: ',0,5,3,0' };
+        // `adjacent` is a special key that is used to track the dimensional address of adjacent activities
+        const map = { '$ADJACENT': `${dad},0` };
+        let dadStr = dad;
+        ancestors.reverse().forEach((ancestor) => {
+            map[ancestor] = dadStr;
+            dadStr = dadStr.substring(0, dadStr.lastIndexOf(','));
+        });
+        return map;
+    }
+    /**
+     * All non-trigger activities are assigned a status seed by their parent
+     */
+    static getSeed() {
+        return '999000000000000';
+    }
+    /**
+     * All trigger activities are assigned a status seed in a completed state
+     */
+    static getTriggerSeed() {
+        return '888000001000001';
+    }
+    /**
+     * entry point for compiler-type activities. This is called by the compiler
+     * to bind the sorted activity IDs to the trigger activity. These are then used
+     * at runtime by the activities to track job/activity status.
+     * @param graphs
+     */
+    static compile(graphs) {
+        CollatorService.bindAncestorArray(graphs);
+    }
+    /**
+     * binds the ancestor array to each activity.
+     * Used in conjunction with the dimensional
+     *  address (dad). If dad is `,0,1,0,0` and the
+     * ancestor array is `['t1', 'a1', 'a2']` for
+     * activity 'a3', then the SAVED DAD
+     * will always have the trailing
+     * 0's removed. This ensures that the addressing
+     * remains consistent even if the graph changes.
+     *   id    DAD           SAVED DAD
+     * * t1 => ,0        =>  [empty]
+     * * a1 => ,0,1      =>  ,0,1
+     * * a2 => ,0,1,0    =>  ,0,1
+     * * a3 => ,0,1,0,0  =>  ,0,1
+     *
+     */
+    static bindAncestorArray(graphs) {
+        graphs.forEach((graph) => {
+            const ancestors = {};
+            const startingNode = Object.keys(graph.activities).find((activity) => graph.activities[activity].type === 'trigger');
+            if (!startingNode) {
+                throw new Error('collator-trigger-activity-not-found');
+            }
+            const dfs = (node, parentList) => {
+                ancestors[node] = parentList;
+                graph.activities[node]['ancestors'] = parentList;
+                const transitions = graph.transitions?.[node] || [];
+                transitions.forEach((transition) => {
+                    dfs(transition.to, [...parentList, node]);
+                });
+            };
+            // Start the DFS traversal
+            dfs(startingNode, []);
+        });
+    }
+    static isActivityComplete(status) {
+        return (status - 0) <= 0;
+    }
+}
+//max int digit count that supports `hincrby`
+CollatorService.targetLength = 15;
+export { CollatorService };

package/build/esm/services/compiler/deployer.d.ts

@@ -0,0 +1,36 @@
+import { StoreService } from '../store';
+import { HotMeshGraph, HotMeshManifest } from '../../types/hotmesh';
+import { RedisClient, RedisMulti } from '../../types/redis';
+import { Symbols } from '../../types/serializer';
+declare class Deployer {
+    manifest: HotMeshManifest | null;
+    store: StoreService<RedisClient, RedisMulti> | null;
+    constructor(manifest: HotMeshManifest);
+    deploy(store: StoreService<RedisClient, RedisMulti>): Promise<void>;
+    getVID(): {
+        id: string;
+        version: string;
+    };
+    generateSymKeys(): Promise<void>;
+    bindSelf(consumes: Record<string, string[]>, produces: string[], activityId: string): void;
+    bindSymbols(startIndex: number, maxIndex: number, existingSymbols: Symbols, prefix: string, produces: string[]): Symbols;
+    copyJobSchemas(): void;
+    bindBackRefs(): void;
+    convertTopicsToTypes(): void;
+    bindParents(): Promise<void>;
+    collectValues(schema: Record<string, any>, values: Set<string>): void;
+    traverse(obj: any, values: Set<string>): void;
+    generateSymVals(): Promise<void>;
+    resolveJobMapsPaths(): void;
+    resolveMappingDependencies(): void;
+    groupMappingRules(rules: string[]): Record<string, string[]>;
+    resolveMappableValue(mappable: string): [string, string];
+    deployActivitySchemas(): Promise<void>;
+    deploySubscriptions(): Promise<void>;
+    findTrigger(graph: HotMeshGraph): [string, Record<string, any>] | null;
+    deployTransitions(): Promise<void>;
+    deployHookPatterns(): Promise<void>;
+    deployConsumerGroups(): Promise<void>;
+    deployConsumerGroup(stream: string, group: string): Promise<void>;
+}
+export { Deployer };

package/build/esm/services/compiler/deployer.js

@@ -0,0 +1,423 @@
+import { KeyType } from '../../modules/key';
+import { getSymKey } from '../../modules/utils';
+import { CollatorService } from '../collator';
+import { SerializerService } from '../serializer';
+const DEFAULT_METADATA_RANGE_SIZE = 26; //metadata is 26 slots ([a-z] * 1)
+const DEFAULT_DATA_RANGE_SIZE = 260; //data is 260 slots ([a-zA-Z] * 5)
+const DEFAULT_RANGE_SIZE = DEFAULT_METADATA_RANGE_SIZE + DEFAULT_DATA_RANGE_SIZE;
+class Deployer {
+    constructor(manifest) {
+        this.manifest = null;
+        this.manifest = manifest;
+    }
+    async deploy(store) {
+        this.store = store;
+        CollatorService.compile(this.manifest.app.graphs);
+        this.convertTopicsToTypes();
+        this.copyJobSchemas();
+        this.bindBackRefs();
+        this.bindParents();
+        this.resolveMappingDependencies();
+        this.resolveJobMapsPaths();
+        await this.generateSymKeys();
+        await this.generateSymVals();
+        await this.deployHookPatterns();
+        await this.deployActivitySchemas();
+        await this.deploySubscriptions();
+        await this.deployTransitions();
+        await this.deployConsumerGroups();
+    }
+    getVID() {
+        return {
+            id: this.manifest.app.id,
+            version: this.manifest.app.version,
+        };
+    }
+    async generateSymKeys() {
+        //note: symbol ranges are additive (per version); path assignments are immutable
+        const appId = this.manifest.app.id;
+        for (const graph of this.manifest.app.graphs) {
+            //generate JOB symbols
+            const [, trigger] = this.findTrigger(graph);
+            const topic = trigger.subscribes;
+            const [lower, upper, symbols] = await this.store.reserveSymbolRange(`$${topic}`, DEFAULT_RANGE_SIZE, 'JOB');
+            const prefix = ''; //job meta/data is NOT namespaced
+            const newSymbols = this.bindSymbols(lower, upper, symbols, prefix, trigger.PRODUCES);
+            if (Object.keys(newSymbols).length) {
+                await this.store.addSymbols(`$${topic}`, newSymbols);
+            }
+            //generate ACTIVITY symbols
+            for (const [activityId, activity] of Object.entries(graph.activities)) {
+                const [lower, upper, symbols] = await this.store.reserveSymbolRange(activityId, DEFAULT_RANGE_SIZE, 'ACTIVITY');
+                const prefix = `${activityId}/`; //activity meta/data is namespaced
+                this.bindSelf(activity.consumes, activity.produces, activityId);
+                const newSymbols = this.bindSymbols(lower, upper, symbols, prefix, activity.produces);
+                if (Object.keys(newSymbols).length) {
+                    await this.store.addSymbols(activityId, newSymbols);
+                }
+            }
+        }
+    }
+    bindSelf(consumes, produces, activityId) {
+        //bind self-referential mappings
+        for (const selfId of [activityId, '$self']) {
+            const selfConsumes = consumes[selfId];
+            if (selfConsumes) {
+                for (const path of selfConsumes) {
+                    if (!produces.includes(path)) {
+                        produces.push(path);
+                    }
+                }
+            }
+        }
+    }
+    bindSymbols(startIndex, maxIndex, existingSymbols, prefix, produces) {
+        let newSymbols = {};
+        let currentSymbols = { ...existingSymbols };
+        for (let path of produces) {
+            const fullPath = `${prefix}${path}`;
+            if (!currentSymbols[fullPath]) {
+                if (startIndex > maxIndex) {
+                    throw new Error('Symbol index out of bounds');
+                }
+                const symbol = getSymKey(startIndex);
+                startIndex++;
+                newSymbols[fullPath] = symbol;
+                currentSymbols[fullPath] = symbol; // update the currentSymbols to include this new symbol
+            }
+        }
+        return newSymbols;
+    }
+    copyJobSchemas() {
+        const graphs = this.manifest.app.graphs;
+        for (const graph of graphs) {
+            const jobSchema = graph.output?.schema;
+            const outputSchema = graph.input?.schema;
+            if (!jobSchema && !outputSchema)
+                continue;
+            const activities = graph.activities;
+            // Find the trigger activity and bind the job schema to it
+            // at execution time, the trigger is a standin for the job
+            for (const activityKey in activities) {
+                if (activities[activityKey].type === 'trigger') {
+                    const trigger = activities[activityKey];
+                    if (jobSchema) {
+                        //possible for trigger to have job mappings
+                        if (!trigger.job) {
+                            trigger.job = {};
+                        }
+                        trigger.job.schema = jobSchema;
+                    }
+                    if (outputSchema) {
+                        //impossible for trigger to have output mappings.
+                        trigger.output = { schema: outputSchema };
+                    }
+                }
+            }
+        }
+    }
+    bindBackRefs() {
+        for (const graph of this.manifest.app.graphs) {
+            const activities = graph.activities;
+            const triggerId = this.findTrigger(graph)[0];
+            for (const activityKey in activities) {
+                activities[activityKey].trigger = triggerId;
+                activities[activityKey].subscribes = graph.subscribes;
+                if (graph.publishes) {
+                    activities[activityKey].publishes = graph.publishes;
+                }
+                if (graph.expire) {
+                    activities[activityKey].expire = graph.expire;
+                }
+            }
+        }
+    }
+    //more intuitive for SDK users to use 'topic',
+    //but the compiler is desiged to be generic and uses 'subtypes'
+    convertTopicsToTypes() {
+        for (const graph of this.manifest.app.graphs) {
+            const activities = graph.activities;
+            for (const activityKey in activities) {
+                const activity = activities[activityKey];
+                if (['worker', 'await'].includes(activity.type) && activity.topic && !activity.subtype) {
+                    activity.subtype = activity.topic;
+                }
+            }
+        }
+    }
+    async bindParents() {
+        const graphs = this.manifest.app.graphs;
+        for (const graph of graphs) {
+            if (graph.transitions) {
+                for (const fromActivity in graph.transitions) {
+                    const toTransitions = graph.transitions[fromActivity];
+                    for (const transition of toTransitions) {
+                        const to = transition.to;
+                        //DAGs have one parent; easy to optimize for
+                        graph.activities[to].parent = fromActivity;
+                    }
+                }
+            }
+        }
+    }
+    collectValues(schema, values) {
+        for (const [key, value] of Object.entries(schema)) {
+            if (key === 'enum' || key === 'examples' || key === 'default') {
+                if (Array.isArray(value)) {
+                    for (const v of value) {
+                        if (typeof v === 'string' && v.length > 5) {
+                            values.add(v);
+                        }
+                    }
+                }
+                else if (typeof value === 'string' && value.length > 5) {
+                    values.add(value);
+                }
+            }
+            else if (typeof value === 'object') {
+                this.collectValues(value, values);
+            }
+        }
+    }
+    traverse(obj, values) {
+        for (const value of Object.values(obj)) {
+            if (typeof value === 'object') {
+                if ('schema' in value) {
+                    this.collectValues(value.schema, values);
+                }
+                else {
+                    this.traverse(value, values);
+                }
+            }
+        }
+    }
+    async generateSymVals() {
+        const uniqueStrings = new Set();
+        for (const graph of this.manifest.app.graphs) {
+            this.traverse(graph, uniqueStrings);
+        }
+        const existingSymbols = await this.store.getSymbolValues();
+        const startIndex = Object.keys(existingSymbols).length;
+        const maxIndex = Math.pow(52, 2) - 1;
+        const newSymbols = SerializerService.filterSymVals(startIndex, maxIndex, existingSymbols, uniqueStrings);
+        await this.store.addSymbolValues(newSymbols);
+    }
+    resolveJobMapsPaths() {
+        function parsePaths(obj) {
+            let result = [];
+            function traverse(obj, path = []) {
+                for (let key in obj) {
+                    if (typeof obj[key] === 'object' && obj[key] !== null && !('@pipe' in obj[key])) {
+                        let newPath = [...path, key];
+                        traverse(obj[key], newPath);
+                    }
+                    else {
+                        const finalPath = `data/${[...path, key].join('/')}`;
+                        if (!result.includes(finalPath)) {
+                            result.push(finalPath);
+                        }
+                    }
+                }
+            }
+            if (obj) {
+                traverse(obj);
+            }
+            return result;
+        }
+        for (const graph of this.manifest.app.graphs) {
+            let results = [];
+            const [, trigger] = this.findTrigger(graph);
+            for (const activityKey in graph.activities) {
+                const activity = graph.activities[activityKey];
+                results = results.concat(parsePaths(activity.job?.maps));
+            }
+            trigger.PRODUCES = results;
+        }
+    }
+    resolveMappingDependencies() {
+        const dynamicMappingRules = [];
+        //recursive function to descend into the object and find all dynamic mapping rules
+        function traverse(obj, consumes) {
+            for (const key in obj) {
+                if (typeof obj[key] === 'string') {
+                    const stringValue = obj[key];
+                    const dynamicMappingRuleMatch = stringValue.match(/^\{[^@].*}$/);
+                    if (dynamicMappingRuleMatch) {
+                        if (stringValue.split('.')[1] !== 'input') {
+                            dynamicMappingRules.push(stringValue);
+                            consumes.push(stringValue);
+                        }
+                    }
+                }
+                else if (typeof obj[key] === 'object' && obj[key] !== null) {
+                    traverse(obj[key], consumes);
+                }
+            }
+        }
+        const graphs = this.manifest.app.graphs;
+        for (const graph of graphs) {
+            const activities = graph.activities;
+            for (const activityId in activities) {
+                const activity = activities[activityId];
+                activity.consumes = [];
+                traverse(activity, activity.consumes);
+                activity.consumes = this.groupMappingRules(activity.consumes);
+            }
+        }
+        const groupedRules = this.groupMappingRules(dynamicMappingRules);
+        // Iterate through the graph and add 'produces' field to each activity
+        for (const graph of graphs) {
+            const activities = graph.activities;
+            for (const activityId in activities) {
+                const activity = activities[activityId];
+                activity.produces = groupedRules[`${activityId}`] || [];
+            }
+        }
+    }
+    groupMappingRules(rules) {
+        rules = Array.from(new Set(rules)).sort();
+        // Group by the first symbol before the period (this is the activity name)
+        const groupedRules = {};
+        for (const rule of rules) {
+            const [group, resolved] = this.resolveMappableValue(rule);
+            if (!groupedRules[group]) {
+                groupedRules[group] = [];
+            }
+            groupedRules[group].push(resolved);
+        }
+        return groupedRules;
+    }
+    resolveMappableValue(mappable) {
+        mappable = mappable.substring(1, mappable.length - 1);
+        const parts = mappable.split('.');
+        if (parts[0] === '$job') {
+            const [group, ...path] = parts;
+            return [group, path.join('/')];
+        }
+        else {
+            //normalize paths to be relative to the activity
+            const [group, type, subtype, ...path] = parts;
+            const prefix = {
+                hook: 'hook/data',
+                input: 'input/data',
+                output: subtype === 'data' ? 'output/data' : 'output/metadata'
+            }[type];
+            return [group, `${prefix}/${path.join('/')}`];
+        }
+    }
+    async deployActivitySchemas() {
+        const graphs = this.manifest.app.graphs;
+        const activitySchemas = {};
+        for (const graph of graphs) {
+            const activities = graph.activities;
+            for (const activityKey in activities) {
+                activitySchemas[activityKey] = activities[activityKey];
+            }
+        }
+        await this.store.setSchemas(activitySchemas, this.getVID());
+    }
+    async deploySubscriptions() {
+        const graphs = this.manifest.app.graphs;
+        const publicSubscriptions = {};
+        for (const graph of graphs) {
+            const activities = graph.activities;
+            const subscribesTopic = graph.subscribes;
+            // Find the activity ID associated with the subscribes topic
+            for (const activityKey in activities) {
+                if (activities[activityKey].type === 'trigger') {
+                    publicSubscriptions[subscribesTopic] = activityKey;
+                    break;
+                }
+            }
+        }
+        await this.store.setSubscriptions(publicSubscriptions, this.getVID());
+    }
+    findTrigger(graph) {
+        for (const activityKey in graph.activities) {
+            const activity = graph.activities[activityKey];
+            if (activity.type === 'trigger') {
+                return [activityKey, activity];
+            }
+        }
+        return null;
+    }
+    async deployTransitions() {
+        const graphs = this.manifest.app.graphs;
+        const privateSubscriptions = {};
+        for (const graph of graphs) {
+            if (graph.subscribes && graph.subscribes.startsWith('.')) {
+                const [triggerId] = this.findTrigger(graph);
+                if (triggerId) {
+                    privateSubscriptions[graph.subscribes] = { [triggerId]: true };
+                }
+            }
+            if (graph.transitions) {
+                for (const fromActivity in graph.transitions) {
+                    const toTransitions = graph.transitions[fromActivity];
+                    const toValues = {};
+                    for (const transition of toTransitions) {
+                        const to = transition.to;
+                        if (transition.conditions) {
+                            toValues[to] = transition.conditions;
+                        }
+                        else {
+                            toValues[to] = true;
+                        }
+                    }
+                    if (Object.keys(toValues).length > 0) {
+                        privateSubscriptions['.' + fromActivity] = toValues;
+                    }
+                }
+            }
+        }
+        await this.store.setTransitions(privateSubscriptions, this.getVID());
+    }
+    async deployHookPatterns() {
+        const graphs = this.manifest.app.graphs;
+        const hookRules = {};
+        for (const graph of graphs) {
+            if (graph.hooks) {
+                for (const topic in graph.hooks) {
+                    hookRules[topic] = graph.hooks[topic];
+                    const activityId = graph.hooks[topic][0].to;
+                    const targetActivity = graph.activities[activityId];
+                    if (targetActivity) {
+                        if (!targetActivity.hook) {
+                            targetActivity.hook = {};
+                        }
+                        //create back-reference to the hook topic
+                        targetActivity.hook.topic = topic;
+                    }
+                }
+            }
+        }
+        await this.store.setHookRules(hookRules);
+    }
+    async deployConsumerGroups() {
+        //create one engine group
+        const params = { appId: this.manifest.app.id };
+        const key = this.store.mintKey(KeyType.STREAMS, params);
+        await this.deployConsumerGroup(key, 'ENGINE');
+        for (const graph of this.manifest.app.graphs) {
+            const activities = graph.activities;
+            for (const activityKey in activities) {
+                const activity = activities[activityKey];
+                if (activity.type === 'worker') {
+                    params.topic = activity.subtype;
+                    const key = this.store.mintKey(KeyType.STREAMS, params);
+                    //create one worker group per unique activity subtype (the topic)
+                    await this.deployConsumerGroup(key, 'WORKER');
+                }
+            }
+        }
+    }
+    async deployConsumerGroup(stream, group) {
+        try {
+            await this.store.xgroup('CREATE', stream, group, '$', 'MKSTREAM');
+        }
+        catch (err) {
+            this.store.logger.info('consumer-group-exists', { stream, group });
+        }
+    }
+}
+export { Deployer };

package/build/esm/services/compiler/index.d.ts

@@ -0,0 +1,30 @@
+import { ILogger } from '../logger';
+import { StoreService } from '../store';
+import { HotMeshManifest } from '../../types/hotmesh';
+import { RedisClient, RedisMulti } from '../../types/redis';
+/**
+ * The compiler service converts a graph into a executable program.
+ */
+declare class CompilerService {
+    store: StoreService<RedisClient, RedisMulti> | null;
+    logger: ILogger;
+    constructor(store: StoreService<RedisClient, RedisMulti>, logger: ILogger);
+    /**
+     * verifies and plans the deployment of an app to Redis; the app is not deployed yet
+     * @param path
+     */
+    plan(mySchemaOrPath: string): Promise<HotMeshManifest>;
+    isPath(input: string): boolean;
+    /**
+     * deploys an app to Redis but does NOT activate it.
+     */
+    deploy(mySchemaOrPath: string): Promise<HotMeshManifest>;
+    /**
+     * activates a deployed version of an app;
+     * @param appId
+     * @param appVersion
+     */
+    activate(appId: string, appVersion: string): Promise<boolean>;
+    saveAsJSON(originalPath: string, schema: HotMeshManifest): Promise<void>;
+}
+export { CompilerService };