@hotmeshio/hotmesh 0.0.8 → 0.0.9

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

@@ -1,221 +0,0 @@
-import { CollationError } from '../../modules/errors';
-import { CollationFaultType } from '../../types/collator';
-class CollatorService {
-    /**
-     * returns the dimensional address (dad) for the target; due
-     * to the nature of the notary system, the dad for leg 2 entry
-     * must target the `0` index while leg 2 exit must target the
-     * current index (0)
-     */
-    static getDimensionalAddress(activity, isEntry = false) {
-        let dad = activity.context.metadata.dad || activity.metadata.dad;
-        if (isEntry && dad && activity.leg === 2) {
-            dad = `${dad.substring(0, dad.lastIndexOf(','))},0`;
-        }
-        return CollatorService.getDimensionsById([...activity.config.ancestors, activity.metadata.aid], dad);
-    }
-    /**
-     * resolves the dimensional address for the
-     * ancestor in the graph to go back to. this address
-     * is determined by trimming the last digits from
-     * the `dad` (including the target).
-     * the target activity index is then set to `0`, so that
-     * the origin node can be queried for approval/entry.
-     */
-    static resolveReentryDimension(activity) {
-        const targetActivityId = activity.config.ancestor;
-        const ancestors = activity.config.ancestors;
-        const ancestorIndex = ancestors.indexOf(targetActivityId);
-        const dimensions = activity.metadata.dad.split(','); //e.g., `,0,0,1,0`
-        dimensions.length = ancestorIndex + 1;
-        dimensions.push('0');
-        return dimensions.join(',');
-    }
-    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 notarizeEarlyExit(activity, multi) {
-        //decrement the 2nd and 3rd digits to fully deactivate (`cycle` activities use this command to fully exit after leg 1) (should result in `888000000000000`)
-        return await activity.store.collate(activity.context.metadata.jid, activity.metadata.aid, -11000000000000, this.getDimensionalAddress(activity), multi);
-    }
-    ;
-    static async notarizeEarlyCompletion(activity, multi) {
-        //initialize both `possible` (1m) and `actualized` (1) zero dimension, while decrementing the 2nd
-        //3rd digit is optionally kept open if the activity might be used in a cycle
-        const decrement = activity.config.cycle ? 10000000000000 : 11000000000000;
-        return await activity.store.collate(activity.context.metadata.jid, activity.metadata.aid, 1000001 - decrement, 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, true), 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) {
-        //1) ALWAYS actualize leg2 dimension (+1)
-        //2) IF the activity is used in a cycle, don't close leg 2!
-        const decrement = activity.config.cycle ? 0 : -1000000000000;
-        return await activity.store.collate(activity.context.metadata.jid, activity.metadata.aid, 1 - decrement, 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

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

@@ -1,423 +0,0 @@
-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 };