@hotmeshio/hotmesh 0.0.7 → 0.0.9

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

@@ -1,410 +0,0 @@
-import { GetStateError } from '../../modules/errors';
-import { formatISODate, getValueByPath, restoreHierarchy } from '../../modules/utils';
-import { CollatorService } from '../collator';
-import { DimensionService } from '../dimension';
-import { MapperService } from '../mapper';
-import { Pipe } from '../pipe';
-import { MDATA_SYMBOLS } from '../serializer';
-import { StoreSignaler } from '../signaler/store';
-import { TelemetryService } from '../telemetry';
-import { StreamDataType, StreamStatus } from '../../types/stream';
-/**
- * The base class for all activities
- */
-class Activity {
-    constructor(config, data, metadata, hook, engine, context) {
-        this.status = StreamStatus.SUCCESS;
-        this.code = 200;
-        this.adjacentIndex = 0; //can be updated by leg2 using 'as' metadata hincrby output
-        this.config = config;
-        this.data = data;
-        this.metadata = metadata;
-        this.hook = hook;
-        this.engine = engine;
-        this.context = context || { data: {}, metadata: {} };
-        this.logger = engine.logger;
-        this.store = engine.store;
-    }
-    //********  INITIAL ENTRY POINT (A)  ********//
-    async process() {
-        this.logger.debug('activity-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);
-            let multiResponse;
-            const multi = this.store.getMulti();
-            if (this.doesHook()) {
-                //sleep and wait to awaken upon a signal
-                await this.registerHook(multi);
-                this.mapJobData();
-                await this.setState(multi);
-                await CollatorService.authorizeReentry(this, multi);
-                await this.setStatus(0, multi);
-                await multi.exec();
-                telemetry.mapActivityAttributes();
-            }
-            else {
-                //end the activity and transition to its children
-                this.adjacencyList = await this.filterAdjacent();
-                this.mapJobData();
-                await this.setState(multi);
-                await CollatorService.notarizeEarlyCompletion(this, multi);
-                await this.setStatus(this.adjacencyList.length - 1, multi);
-                multiResponse = await multi.exec();
-                telemetry.mapActivityAttributes();
-                const jobStatus = this.resolveStatus(multiResponse);
-                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.aid;
-        }
-        catch (error) {
-            if (error instanceof GetStateError) {
-                this.logger.error('activity-get-state-error', error);
-            }
-            else {
-                this.logger.error('activity-process-error', error);
-            }
-            telemetry.setActivityError(error.message);
-            throw error;
-        }
-        finally {
-            telemetry.endActivitySpan();
-            this.logger.debug('activity-process-end', { jid: this.context.metadata.jid, aid: this.metadata.aid });
-        }
-    }
-    setLeg(leg) {
-        this.leg = leg;
-    }
-    //********  SIGNALER RE-ENTRY POINT (B)  ********//
-    doesHook() {
-        return !!(this.config.hook?.topic || this.config.sleep);
-    }
-    async registerHook(multi) {
-        if (this.config.hook?.topic) {
-            const signaler = new StoreSignaler(this.store, this.logger);
-            return await signaler.registerWebHook(this.config.hook.topic, this.context, multi);
-        }
-        else if (this.config.sleep) {
-            const durationInSeconds = Pipe.resolve(this.config.sleep, this.context);
-            const jobId = this.context.metadata.jid;
-            const activityId = this.metadata.aid;
-            const dId = this.metadata.dad;
-            await this.engine.task.registerTimeHook(jobId, `${activityId}${dId || ''}`, 'sleep', durationInSeconds);
-            return jobId;
-        }
-    }
-    async processWebHookEvent() {
-        this.logger.debug('engine-process-web-hook-event', {
-            topic: this.config.hook.topic,
-            aid: this.metadata.aid
-        });
-        const signaler = new StoreSignaler(this.store, this.logger);
-        const data = { ...this.data };
-        const jobId = await signaler.processWebHookSignal(this.config.hook.topic, data);
-        if (jobId) {
-            await this.processHookEvent(jobId);
-            await signaler.deleteWebHookSignal(this.config.hook.topic, data);
-        } //else => already resolved
-    }
-    async processTimeHookEvent(jobId) {
-        this.logger.debug('engine-process-time-hook-event', {
-            jid: jobId,
-            aid: this.metadata.aid
-        });
-        return await this.processHookEvent(jobId);
-    }
-    //todo: hooks are currently singletons. but they can support
-    //      dimensional threads like `await` and `worker` do.
-    //      Copy code from those activities to support cyclical
-    //      timehook and eventhook inputs by adding a 'pending'
-    //      flag to hooks that allows for repeated signals
-    async processHookEvent(jobId) {
-        this.logger.debug('activity-process-hook-event', { jobId });
-        let telemetry;
-        try {
-            this.setLeg(2);
-            await this.getState(jobId);
-            const aState = await CollatorService.notarizeReentry(this);
-            this.adjacentIndex = CollatorService.getDimensionalIndex(aState);
-            telemetry = new TelemetryService(this.engine.appId, this.config, this.metadata, this.context);
-            telemetry.startActivitySpan(this.leg);
-            this.bindActivityData('hook');
-            this.mapJobData();
-            this.adjacencyList = await this.filterAdjacent();
-            const multi = this.engine.store.getMulti();
-            await this.setState(multi);
-            await CollatorService.notarizeCompletion(this, multi);
-            await this.setStatus(this.adjacencyList.length - 1, multi);
-            const multiResponse = await multi.exec();
-            telemetry.mapActivityAttributes();
-            const jobStatus = this.resolveStatus(multiResponse);
-            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 jobStatus;
-        }
-        catch (error) {
-            console.error('this error?', error);
-            this.logger.error('engine-process-hook-event-error', error);
-            telemetry.setActivityError(error.message);
-            throw error;
-        }
-        finally {
-            telemetry.endActivitySpan();
-        }
-    }
-    resolveStatus(multiResponse) {
-        const activityStatus = multiResponse[multiResponse.length - 1];
-        if (Array.isArray(activityStatus)) {
-            return Number(activityStatus[1]);
-        }
-        else {
-            return Number(activityStatus);
-        }
-    }
-    mapJobData() {
-        if (this.config.job?.maps) {
-            const mapper = new MapperService(this.config.job.maps, this.context);
-            this.context.data = mapper.mapRules();
-        }
-    }
-    mapInputData() {
-        if (this.config.input?.maps) {
-            const mapper = new MapperService(this.config.input.maps, this.context);
-            this.context.data = mapper.mapRules();
-        }
-    }
-    async registerTimeout() {
-        //set timeout in support of hook and/or duplex
-    }
-    bindActivityError(data) {
-        //todo: map activity error data into the job error (if defined)
-        //      map job status via: (500: [3**, 4**, 5**], 202: [$pending])
-        this.context.metadata.err = JSON.stringify(data);
-    }
-    async getTriggerConfig() {
-        return await this.store.getSchema(this.config.trigger, await this.engine.getVID());
-    }
-    getJobStatus() {
-        return null;
-    }
-    async setStatus(amount, multi) {
-        const { id: appId } = await this.engine.getVID();
-        await this.store.setStatus(amount, this.context.metadata.jid, appId, multi);
-    }
-    authorizeEntry(state) {
-        //pre-authorize activity state to allow entry for adjacent activities
-        return this.adjacencyList?.map((streamData) => {
-            const { metadata: { aid } } = streamData;
-            state[`${aid}/output/metadata/as`] = CollatorService.getSeed();
-            return aid;
-        }) ?? [];
-    }
-    bindDimensionalAddress(state) {
-        const dad = this.resolveDad();
-        state[`${this.metadata.aid}/output/metadata/dad`] = dad;
-    }
-    async setState(multi) {
-        const jobId = this.context.metadata.jid;
-        this.bindJobMetadata();
-        this.bindActivityMetadata();
-        let state = {};
-        await this.bindJobState(state);
-        const presets = this.authorizeEntry(state);
-        this.bindDimensionalAddress(state);
-        this.bindActivityState(state);
-        //symbolNames holds symkeys
-        const symbolNames = [
-            `$${this.config.subscribes}`,
-            this.metadata.aid,
-            ...presets
-        ];
-        const dIds = CollatorService.getDimensionsById([...this.config.ancestors, this.metadata.aid], this.resolveDad());
-        return await this.store.setState(state, this.getJobStatus(), jobId, symbolNames, dIds, multi);
-    }
-    bindJobMetadata() {
-        //both legs of the most recently run activity (1 and 2) modify ju (job_updated)
-        this.context.metadata.ju = formatISODate(new Date());
-    }
-    bindActivityMetadata() {
-        const self = this.context['$self'];
-        if (!self.output.metadata) {
-            self.output.metadata = {};
-        }
-        if (this.status === StreamStatus.ERROR) {
-            self.output.metadata.err = JSON.stringify(this.data);
-        }
-        //todo: verify leg2 never overwrites leg1 `ac`
-        self.output.metadata.ac =
-            self.output.metadata.au = formatISODate(new Date());
-        self.output.metadata.atp = this.config.type;
-        if (this.config.subtype) {
-            self.output.metadata.stp = this.config.subtype;
-        }
-        self.output.metadata.aid = this.metadata.aid;
-    }
-    async bindJobState(state) {
-        const triggerConfig = await this.getTriggerConfig();
-        const PRODUCES = [
-            ...(triggerConfig.PRODUCES || []),
-            ...this.bindJobMetadataPaths()
-        ];
-        for (const path of PRODUCES) {
-            const value = getValueByPath(this.context, path);
-            if (value !== undefined) {
-                state[path] = value;
-            }
-        }
-        TelemetryService.bindJobTelemetryToState(state, this.config, this.context);
-    }
-    bindActivityState(state) {
-        const produces = [
-            ...this.config.produces,
-            ...this.bindActivityMetadataPaths()
-        ];
-        for (const path of produces) {
-            const prefixedPath = `${this.metadata.aid}/${path}`;
-            const value = getValueByPath(this.context, prefixedPath);
-            if (value !== undefined) {
-                state[prefixedPath] = value;
-            }
-        }
-        TelemetryService.bindActivityTelemetryToState(state, this.config, this.metadata, this.context, this.leg);
-    }
-    bindJobMetadataPaths() {
-        return MDATA_SYMBOLS.JOB_UPDATE.KEYS.map((key) => `metadata/${key}`);
-    }
-    bindActivityMetadataPaths() {
-        const keys_to_save = this.leg === 1 ? 'ACTIVITY' : 'ACTIVITY_UPDATE';
-        return MDATA_SYMBOLS[keys_to_save].KEYS.map((key) => `output/metadata/${key}`);
-    }
-    async getState(jobId) {
-        //assemble list of paths necessary to create 'job state' from the 'symbol hash'
-        const jobSymbolHashName = `$${this.config.subscribes}`;
-        const consumes = {
-            [jobSymbolHashName]: MDATA_SYMBOLS.JOB.KEYS.map((key) => `metadata/${key}`)
-        };
-        for (let [activityId, paths] of Object.entries(this.config.consumes)) {
-            if (activityId === '$job') {
-                for (const path of paths) {
-                    consumes[jobSymbolHashName].push(path);
-                }
-            }
-            else {
-                if (activityId === '$self') {
-                    activityId = this.metadata.aid;
-                }
-                if (!consumes[activityId]) {
-                    consumes[activityId] = [];
-                }
-                for (const path of paths) {
-                    consumes[activityId].push(`${activityId}/${path}`);
-                }
-            }
-        }
-        TelemetryService.addTargetTelemetryPaths(consumes, this.config, this.metadata, this.leg);
-        let { dad, jid } = this.context.metadata;
-        jobId = jobId || jid;
-        const dIds = CollatorService.getDimensionsById([...this.config.ancestors, this.metadata.aid], dad);
-        //`state` is a flat hash; context is a tree
-        const [state, status] = await this.store.getState(jobId, consumes, dIds);
-        this.context = restoreHierarchy(state);
-        this.initDimensionalAddress(dad);
-        this.initSelf(this.context);
-        this.initPolicies(this.context);
-    }
-    initDimensionalAddress(dad) {
-        this.metadata.dad = dad;
-    }
-    initSelf(context) {
-        const activityId = this.metadata.aid;
-        if (!context[activityId]) {
-            context[activityId] = {};
-        }
-        const self = context[activityId];
-        if (!self.output) {
-            self.output = {};
-        }
-        if (!self.input) {
-            self.input = {};
-        }
-        if (!self.hook) {
-            self.hook = {};
-        }
-        context['$self'] = self;
-        context['$job'] = context; //NEVER call STRINGIFY! (circular)
-        return context;
-    }
-    initPolicies(context) {
-        context.metadata.expire = this.config.expire;
-    }
-    bindActivityData(type) {
-        this.context[this.metadata.aid][type].data = this.data;
-    }
-    resolveDad() {
-        let dad = this.metadata.dad;
-        if (this.adjacentIndex > 0) {
-            //if adjacent index > 0 the activity is cycling; replace last index with cycle index
-            dad = `${dad.substring(0, dad.lastIndexOf(','))},${this.adjacentIndex}`;
-        }
-        return dad;
-    }
-    resolveAdjacentDad() {
-        //concat self and child dimension (all children (leg 1) begin life at 0)
-        return `${this.resolveDad()}${DimensionService.getSeed(0)}`;
-    }
-    ;
-    async filterAdjacent() {
-        const adjacencyList = [];
-        const transitions = await this.store.getTransitions(await this.engine.getVID());
-        const transition = transitions[`.${this.metadata.aid}`];
-        //resolve the dimensional address for adjacent children
-        const adjacentDad = this.resolveAdjacentDad();
-        if (transition) {
-            for (const toActivityId in transition) {
-                const transitionRule = transition[toActivityId];
-                if (MapperService.evaluate(transitionRule, this.context, this.code)) {
-                    adjacencyList.push({
-                        metadata: {
-                            jid: this.context.metadata.jid,
-                            dad: adjacentDad,
-                            aid: toActivityId,
-                            spn: this.context['$self'].output.metadata?.l2s,
-                            trc: this.context.metadata.trc,
-                        },
-                        type: StreamDataType.TRANSITION,
-                        data: {}
-                    });
-                }
-            }
-        }
-        return adjacencyList;
-    }
-    async transition(adjacencyList, jobStatus) {
-        let mIds = [];
-        if (adjacencyList.length) {
-            const multi = this.store.getMulti();
-            for (const execSignal of adjacencyList) {
-                await this.engine.streamSignaler?.publishMessage(null, execSignal, multi);
-            }
-            mIds = (await multi.exec());
-        }
-        else if (jobStatus <= 0) {
-            await this.engine.runJobCompletionTasks(this.context);
-        }
-        return mIds;
-    }
-}
-export { Activity };

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

@@ -1,16 +0,0 @@
-import { Activity } from './activity';
-import { EngineService } from '../engine';
-import { ActivityData, ActivityMetadata, AwaitActivity, ActivityType } from '../../types/activity';
-import { JobState } from '../../types/job';
-import { MultiResponseFlags } from '../../types/redis';
-import { StreamCode, StreamData, StreamStatus } from '../../types/stream';
-declare class Await extends Activity {
-    config: AwaitActivity;
-    constructor(config: ActivityType, data: ActivityData, metadata: ActivityMetadata, hook: ActivityData | null, engine: EngineService, context?: JobState);
-    process(): Promise<string>;
-    execActivity(): Promise<string>;
-    processEvent(status?: StreamStatus, code?: StreamCode): Promise<void>;
-    processSuccess(adjacencyList: StreamData[]): Promise<MultiResponseFlags>;
-    processError(adjacencyList: StreamData[]): Promise<MultiResponseFlags>;
-}
-export { Await };

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

@@ -1,140 +0,0 @@
-import { GetStateError } from '../../modules/errors';
-import { Activity } from './activity';
-import { StreamDataType, StreamStatus } from '../../types/stream';
-import { TelemetryService } from '../telemetry';
-import { CollatorService } from '../collator';
-class Await 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('await-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();
-            //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) {
-            telemetry.setActivityError(error.message);
-            if (error instanceof GetStateError) {
-                this.logger.error('await-get-state-error', error);
-            }
-            else {
-                this.logger.error('await-process-error', error);
-            }
-            throw error;
-        }
-        finally {
-            telemetry.endActivitySpan();
-            this.logger.debug('await-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,
-            },
-            type: StreamDataType.AWAIT,
-            data: this.context.data
-        };
-        if (this.config.retry) {
-            streamData.policies = {
-                retry: this.config.retry
-            };
-        }
-        return (await this.engine.streamSignaler?.publishMessage(null, streamData));
-    }
-    //********  `RESOLVE` ENTRY POINT (B)  ********//
-    //this method is invoked when the job spawned by this job ends;
-    //`this.data` is the job data produced by the spawned job
-    async processEvent(status = StreamStatus.SUCCESS, code = 200) {
-        this.setLeg(2);
-        const jid = this.context.metadata.jid;
-        const aid = this.metadata.aid;
-        if (!jid) {
-            throw new Error('await-process-event-error');
-        }
-        this.logger.debug('await-resolve-await', { jid, aid, status, code });
-        this.status = status;
-        this.code = code;
-        let telemetry;
-        try {
-            await this.getState();
-            const aState = await CollatorService.notarizeReentry(this);
-            this.adjacentIndex = CollatorService.getDimensionalIndex(aState);
-            telemetry = new TelemetryService(this.engine.appId, this.config, this.metadata, this.context);
-            telemetry.startActivitySpan(this.leg);
-            let multiResponse = [];
-            if (status === StreamStatus.SUCCESS) {
-                this.bindActivityData('output');
-                this.adjacencyList = await this.filterAdjacent();
-                multiResponse = await this.processSuccess(this.adjacencyList);
-            }
-            else {
-                this.bindActivityError(this.data);
-                this.adjacencyList = await this.filterAdjacent();
-                multiResponse = await this.processError(this.adjacencyList);
-            }
-            telemetry.mapActivityAttributes();
-            const jobStatus = this.resolveStatus(multiResponse);
-            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);
-        }
-        catch (error) {
-            this.logger.error('await-resolve-await-error', error);
-            telemetry.setActivityError(error.message);
-            throw error;
-        }
-        finally {
-            telemetry.endActivitySpan();
-            this.logger.debug('await-resolve-await-end', { jid, aid, status, code });
-        }
-    }
-    async processSuccess(adjacencyList) {
-        this.mapJobData();
-        const multi = this.store.getMulti();
-        await this.setState(multi);
-        await CollatorService.notarizeCompletion(this, multi);
-        await this.setStatus(adjacencyList.length - 1, multi);
-        return await multi.exec();
-    }
-    async processError(adjacencyList) {
-        //todo: if adjacencyList.length == 0, then map to the job output
-        //      this method would be added to Base activity class 
-        //this.mapJobData();
-        const multi = this.store.getMulti();
-        await this.setState(multi);
-        await CollatorService.notarizeCompletion(this, multi);
-        await this.setStatus(adjacencyList.length - 1, multi);
-        return await multi.exec();
-    }
-}
-export { Await };

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.js

@@ -1,14 +0,0 @@
-import { Activity } from './activity';
-import { Await } from './await';
-import { Worker } from './worker';
-import { Iterate } from './iterate';
-import { Emit } from './emit';
-import { Trigger } from './trigger';
-export default {
-    activity: Activity,
-    await: Await,
-    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 };