@hotmeshio/hotmesh 0.0.8 → 0.0.9

package/build/esm/services/activities/cycle.js

@@ -1,74 +0,0 @@
-import { GetStateError } from '../../modules/errors';
-import { CollatorService } from '../collator';
-import { Activity } from './activity';
-import { TelemetryService } from '../telemetry';
-class Cycle extends Activity {
-    constructor(config, data, metadata, hook, engine, context) {
-        super(config, data, metadata, hook, engine, context);
-    }
-    //********  LEG 1 ENTRY  ********//
-    async process() {
-        this.logger.debug('cycle-process', { jid: this.context.metadata.jid, aid: this.metadata.aid });
-        let telemetry;
-        try {
-            //verify entry is allowed
-            this.setLeg(1);
-            await CollatorService.notarizeEntry(this);
-            await this.getState();
-            telemetry = new TelemetryService(this.engine.appId, this.config, this.metadata, this.context);
-            telemetry.startActivitySpan(this.leg);
-            this.mapInputData();
-            //set state/status
-            let multi = this.store.getMulti();
-            await this.setState(multi);
-            await this.setStatus(0, multi); //leg 1 never changes job status
-            const multiResponse = await multi.exec();
-            telemetry.mapActivityAttributes();
-            const jobStatus = this.resolveStatus(multiResponse);
-            //cycle the target ancestor
-            multi = this.store.getMulti();
-            const messageId = await this.cycleAncestorActivity(multi);
-            telemetry.setActivityAttributes({
-                'app.activity.mid': messageId,
-                'app.job.jss': jobStatus
-            });
-            //exit early (`Cycle` activities only execute Leg 1)
-            await CollatorService.notarizeEarlyExit(this, multi);
-            await multi.exec();
-            return this.context.metadata.aid;
-        }
-        catch (error) {
-            if (error instanceof GetStateError) {
-                this.logger.error('cycle-get-state-error', error);
-            }
-            else {
-                this.logger.error('cycle-process-error', error);
-            }
-            telemetry.setActivityError(error.message);
-            throw error;
-        }
-        finally {
-            telemetry.endActivitySpan();
-            this.logger.debug('cycle-process-end', { jid: this.context.metadata.jid, aid: this.metadata.aid });
-        }
-    }
-    /**
-     * Trigger the target ancestor to execute in a cycle,
-     * without violating the constraints of the DAG. Immutable
-     * `individual activity state` will execute in a new dimensional
-     * thread while `shared job state` can change. This
-     * pattern allows for retries without violating the DAG.
-     */
-    async cycleAncestorActivity(multi) {
-        const streamData = {
-            metadata: {
-                dad: CollatorService.resolveReentryDimension(this),
-                jid: this.context.metadata.jid,
-                aid: this.config.ancestor,
-            },
-            data: {} //todo: verify immutability, before enabling: `this.context.data`
-        };
-        return (await this.engine.streamSignaler?.publishMessage(null, streamData, multi));
-    }
-}
-export { Cycle };

package/build/esm/services/activities/emit.d.ts

@@ -1,9 +0,0 @@
-import { EngineService } from '../engine';
-import { Activity, ActivityType } from './activity';
-import { ActivityData, ActivityMetadata, EmitActivity } from '../../types/activity';
-declare class Emit extends Activity {
-    config: EmitActivity;
-    constructor(config: ActivityType, data: ActivityData, metadata: ActivityMetadata, hook: ActivityData | null, engine: EngineService);
-    mapInputData(): Promise<void>;
-}
-export { Emit };

package/build/esm/services/activities/emit.js

@@ -1,10 +0,0 @@
-import { Activity } from './activity';
-class Emit extends Activity {
-    constructor(config, data, metadata, hook, engine) {
-        super(config, data, metadata, hook, engine);
-    }
-    async mapInputData() {
-        this.logger.info('emit-map-input-data');
-    }
-}
-export { Emit };

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

@@ -1,17 +0,0 @@
-import { Activity } from './activity';
-import { Await } from './await';
-import { Cycle } from './cycle';
-import { Emit } from './emit';
-import { Iterate } from './iterate';
-import { Trigger } from './trigger';
-import { Worker } from './worker';
-declare const _default: {
-    activity: typeof Activity;
-    await: typeof Await;
-    cycle: typeof Cycle;
-    iterate: typeof Iterate;
-    emit: typeof Emit;
-    trigger: typeof Trigger;
-    worker: typeof Worker;
-};
-export default _default;

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

@@ -1,16 +0,0 @@
-import { Activity } from './activity';
-import { Await } from './await';
-import { Cycle } from './cycle';
-import { Emit } from './emit';
-import { Iterate } from './iterate';
-import { Trigger } from './trigger';
-import { Worker } from './worker';
-export default {
-    activity: Activity,
-    await: Await,
-    cycle: Cycle,
-    iterate: Iterate,
-    emit: Emit,
-    trigger: Trigger,
-    worker: Worker,
-};

package/build/esm/services/activities/iterate.d.ts

@@ -1,9 +0,0 @@
-import { EngineService } from '../engine';
-import { Activity, ActivityType } from './activity';
-import { ActivityData, ActivityMetadata, IterateActivity } from '../../types/activity';
-declare class Iterate extends Activity {
-    config: IterateActivity;
-    constructor(config: ActivityType, data: ActivityData, metadata: ActivityMetadata, hook: ActivityData | null, engine: EngineService);
-    mapInputData(): Promise<void>;
-}
-export { Iterate };

package/build/esm/services/activities/iterate.js

@@ -1,10 +0,0 @@
-import { Activity } from './activity';
-class Iterate extends Activity {
-    constructor(config, data, metadata, hook, engine) {
-        super(config, data, metadata, hook, engine);
-    }
-    async mapInputData() {
-        this.logger.info('iterate-map-input-data');
-    }
-}
-export { Iterate };

package/build/esm/services/activities/trigger.d.ts

@@ -1,22 +0,0 @@
-import { Activity } from './activity';
-import { EngineService } from '../engine';
-import { ActivityData, ActivityMetadata, ActivityType, TriggerActivity } from '../../types/activity';
-import { JobState } from '../../types/job';
-import { RedisMulti } from '../../types/redis';
-declare class Trigger extends Activity {
-    config: TriggerActivity;
-    constructor(config: ActivityType, data: ActivityData, metadata: ActivityMetadata, hook: ActivityData | null, engine: EngineService, context?: JobState);
-    process(): Promise<string>;
-    setStatus(amount: number): Promise<void>;
-    createInputContext(): Partial<JobState>;
-    getState(): Promise<void>;
-    bindJobMetadataPaths(): string[];
-    bindActivityMetadataPaths(): string[];
-    resolveGranularity(): string;
-    getJobStatus(): number;
-    resolveJobId(context: Partial<JobState>): string;
-    resolveJobKey(context: Partial<JobState>): string;
-    setStateNX(): Promise<void>;
-    setStats(multi?: RedisMulti): Promise<void>;
-}
-export { Trigger };

package/build/esm/services/activities/trigger.js

@@ -1,158 +0,0 @@
-import { v4 as uuidv4 } from 'uuid';
-import { DuplicateJobError } from '../../modules/errors';
-import { formatISODate, getTimeSeries } from '../../modules/utils';
-import { Activity } from './activity';
-import { CollatorService } from '../collator';
-import { DimensionService } from '../dimension';
-import { Pipe } from '../pipe';
-import { ReporterService } from '../reporter';
-import { MDATA_SYMBOLS } from '../serializer';
-import { TelemetryService } from '../telemetry';
-class Trigger extends Activity {
-    constructor(config, data, metadata, hook, engine, context) {
-        super(config, data, metadata, hook, engine, context);
-    }
-    async process() {
-        this.logger.debug('trigger-process', { subscribes: this.config.subscribes });
-        let telemetry;
-        try {
-            this.setLeg(2);
-            await this.getState();
-            telemetry = new TelemetryService(this.engine.appId, this.config, this.metadata, this.context);
-            telemetry.startJobSpan();
-            telemetry.startActivitySpan(this.leg);
-            this.mapJobData();
-            await this.setStateNX();
-            this.adjacencyList = await this.filterAdjacent();
-            await this.setStatus(this.adjacencyList.length);
-            const multi = this.store.getMulti();
-            await this.setState(multi);
-            await this.setStats(multi);
-            await multi.exec();
-            telemetry.mapActivityAttributes();
-            const jobStatus = Number(this.context.metadata.js);
-            telemetry.setJobAttributes({ 'app.job.jss': jobStatus });
-            const attrs = { 'app.job.jss': jobStatus };
-            const messageIds = await this.transition(this.adjacencyList, jobStatus);
-            if (messageIds.length) {
-                attrs['app.activity.mids'] = messageIds.join(',');
-            }
-            telemetry.setActivityAttributes(attrs);
-            return this.context.metadata.jid;
-        }
-        catch (error) {
-            if (error instanceof DuplicateJobError) {
-                this.logger.error('duplicate-job-error', error);
-            }
-            else {
-                this.logger.error('trigger-process-error', error);
-            }
-            telemetry.setActivityError(error.message);
-            throw error;
-        }
-        finally {
-            telemetry.endJobSpan();
-            telemetry.endActivitySpan();
-            this.logger.debug('trigger-process-end', { subscribes: this.config.subscribes, jid: this.context.metadata.jid });
-        }
-    }
-    async setStatus(amount) {
-        this.context.metadata.js = amount;
-    }
-    createInputContext() {
-        const input = {
-            [this.metadata.aid]: {
-                input: { data: this.data }
-            },
-            '$self': {
-                input: { data: this.data },
-                output: { data: this.data }
-            },
-        };
-        return input;
-    }
-    async getState() {
-        const inputContext = this.createInputContext();
-        const jobId = this.resolveJobId(inputContext);
-        const jobKey = this.resolveJobKey(inputContext);
-        const utc = formatISODate(new Date());
-        const { id, version } = await this.engine.getVID();
-        this.initDimensionalAddress(DimensionService.getSeed());
-        const activityMetadata = {
-            ...this.metadata,
-            jid: jobId,
-            key: jobKey,
-            as: CollatorService.getTriggerSeed(),
-        };
-        this.context = {
-            metadata: {
-                ...this.metadata,
-                ngn: this.context.metadata.ngn,
-                pj: this.context.metadata.pj,
-                pd: this.context.metadata.pd,
-                pa: this.context.metadata.pa,
-                app: id,
-                vrs: version,
-                tpc: this.config.subscribes,
-                trc: this.context.metadata.trc,
-                spn: this.context.metadata.spn,
-                jid: jobId,
-                dad: DimensionService.getSeed(),
-                key: jobKey,
-                jc: utc,
-                ju: utc,
-                ts: getTimeSeries(this.resolveGranularity()),
-                js: 0,
-            },
-            data: {},
-            [this.metadata.aid]: {
-                input: {
-                    data: this.data,
-                    metadata: activityMetadata
-                },
-                output: {
-                    data: this.data,
-                    metadata: activityMetadata
-                },
-                settings: { data: {} },
-                errors: { data: {} },
-            },
-        };
-        this.context['$self'] = this.context[this.metadata.aid];
-    }
-    bindJobMetadataPaths() {
-        return MDATA_SYMBOLS.JOB.KEYS.map((key) => `metadata/${key}`);
-    }
-    bindActivityMetadataPaths() {
-        return MDATA_SYMBOLS.ACTIVITY.KEYS.map((key) => `output/metadata/${key}`);
-    }
-    resolveGranularity() {
-        return ReporterService.DEFAULT_GRANULARITY;
-    }
-    getJobStatus() {
-        return this.context.metadata.js;
-    }
-    resolveJobId(context) {
-        const jobId = this.config.stats?.id;
-        return jobId ? Pipe.resolve(jobId, context) : uuidv4();
-    }
-    resolveJobKey(context) {
-        const jobKey = this.config.stats?.key;
-        return jobKey ? Pipe.resolve(jobKey, context) : '';
-    }
-    async setStateNX() {
-        const jobId = this.context.metadata.jid;
-        if (!await this.store.setStateNX(jobId, this.engine.appId)) {
-            throw new DuplicateJobError(jobId);
-        }
-    }
-    async setStats(multi) {
-        const md = this.context.metadata;
-        if (this.config.stats?.measures) {
-            const config = await this.engine.getVID();
-            const reporter = new ReporterService(config, this.store, this.logger);
-            await this.store.setStats(md.key, md.jid, md.ts, reporter.resolveTriggerStatistics(this.config, this.context), config, multi);
-        }
-    }
-}
-export { Trigger };

package/build/esm/services/activities/worker.d.ts

@@ -1,11 +0,0 @@
-import { Activity } from './activity';
-import { EngineService } from '../engine';
-import { ActivityData, ActivityMetadata, ActivityType, WorkerActivity } from '../../types/activity';
-import { JobState } from '../../types/job';
-declare class Worker extends Activity {
-    config: WorkerActivity;
-    constructor(config: ActivityType, data: ActivityData, metadata: ActivityMetadata, hook: ActivityData | null, engine: EngineService, context?: JobState);
-    process(): Promise<string>;
-    execActivity(): Promise<string>;
-}
-export { Worker };

package/build/esm/services/activities/worker.js

@@ -1,70 +0,0 @@
-import { GetStateError } from '../../modules/errors';
-import { Activity } from './activity';
-import { CollatorService } from '../collator';
-import { TelemetryService } from '../telemetry';
-class Worker extends Activity {
-    constructor(config, data, metadata, hook, engine, context) {
-        super(config, data, metadata, hook, engine, context);
-    }
-    //********  INITIAL ENTRY POINT (A)  ********//
-    async process() {
-        this.logger.debug('worker-process', { jid: this.context.metadata.jid, aid: this.metadata.aid });
-        let telemetry;
-        try {
-            this.setLeg(1);
-            await CollatorService.notarizeEntry(this);
-            await this.getState();
-            telemetry = new TelemetryService(this.engine.appId, this.config, this.metadata, this.context);
-            telemetry.startActivitySpan(this.leg);
-            this.mapInputData();
-            const multi = this.store.getMulti();
-            //todo: await this.registerTimeout();
-            await CollatorService.authorizeReentry(this, multi);
-            await this.setState(multi);
-            await this.setStatus(0, multi);
-            const multiResponse = await multi.exec();
-            telemetry.mapActivityAttributes();
-            const jobStatus = this.resolveStatus(multiResponse);
-            const messageId = await this.execActivity();
-            telemetry.setActivityAttributes({
-                'app.activity.mid': messageId,
-                'app.job.jss': jobStatus
-            });
-            return this.context.metadata.aid;
-        }
-        catch (error) {
-            if (error instanceof GetStateError) {
-                this.logger.error('worker-get-state-error', error);
-            }
-            else {
-                this.logger.error('worker-process-error', error);
-            }
-            telemetry.setActivityError(error.message);
-            throw error;
-        }
-        finally {
-            telemetry.endActivitySpan();
-            this.logger.debug('worker-process-end', { jid: this.context.metadata.jid, aid: this.metadata.aid });
-        }
-    }
-    async execActivity() {
-        const streamData = {
-            metadata: {
-                jid: this.context.metadata.jid,
-                dad: this.metadata.dad,
-                aid: this.metadata.aid,
-                topic: this.config.subtype,
-                spn: this.context['$self'].output.metadata.l1s,
-                trc: this.context.metadata.trc,
-            },
-            data: this.context.data
-        };
-        if (this.config.retry) {
-            streamData.policies = {
-                retry: this.config.retry
-            };
-        }
-        return (await this.engine.streamSignaler?.publishMessage(this.config.subtype, streamData));
-    }
-}
-export { Worker };

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

@@ -1,73 +0,0 @@
-import { RedisMulti } from '../../types/redis';
-import { CollationStage } from '../../types/collator';
-import { ActivityDuplex } from '../../types/activity';
-import { HotMeshGraph } from '../../types/hotmesh';
-import { Activity } from '../activities/activity';
-import { Cycle } from '../activities/cycle';
-declare class CollatorService {
-    static targetLength: number;
-    /**
-     * 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: Activity, isEntry?: boolean): Record<string, string>;
-    /**
-     * 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: Cycle): string;
-    static notarizeEntry(activity: Activity, multi?: RedisMulti): Promise<number>;
-    static authorizeReentry(activity: Activity, multi?: RedisMulti): Promise<number>;
-    static notarizeEarlyExit(activity: Activity, multi?: RedisMulti): Promise<number>;
-    static notarizeEarlyCompletion(activity: Activity, multi?: RedisMulti): Promise<number>;
-    static notarizeReentry(activity: Activity, multi?: RedisMulti): Promise<number>;
-    static notarizeContinuation(activity: Activity, multi?: RedisMulti): Promise<number>;
-    static notarizeCompletion(activity: Activity, multi?: RedisMulti): Promise<number>;
-    static getDigitAtIndex(num: number, targetDigitIndex: number): number | null;
-    static getDimensionalIndex(num: number): number | null;
-    static isDuplicate(num: number, targetDigitIndex: number): boolean;
-    static isInactive(num: number): boolean;
-    static isPrimed(amount: number, leg: ActivityDuplex): boolean;
-    static verifyInteger(amount: number, leg: ActivityDuplex, stage: CollationStage): void;
-    static getDimensionsById(ancestors: string[], dad: string): Record<string, string>;
-    /**
-     * All non-trigger activities are assigned a status seed by their parent
-     */
-    static getSeed(): string;
-    /**
-     * All trigger activities are assigned a status seed in a completed state
-     */
-    static getTriggerSeed(): string;
-    /**
-     * 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: HotMeshGraph[]): void;
-    /**
-     * 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: HotMeshGraph[]): void;
-    static isActivityComplete(status: number): boolean;
-}
-export { CollatorService };