@hotmeshio/hotmesh 0.5.8 → 0.6.1

package/build/services/search/providers/redis/redis.d.ts

@@ -0,0 +1,23 @@
+import { SearchService } from '../../index';
+import { ILogger } from '../../../logger';
+import { RedisRedisClientType } from '../../../../types/redis';
+declare class RedisSearchService extends SearchService<RedisRedisClientType> {
+    constructor(searchClient: RedisRedisClientType, storeClient?: RedisRedisClientType);
+    init(namespace: string, appId: string, logger: ILogger): Promise<void>;
+    createSearchIndex(indexName: string, prefixes: string[], schema: string[]): Promise<void>;
+    listSearchIndexes(): Promise<string[]>;
+    updateContext(key: string, fields: Record<string, string>): Promise<any>;
+    setFields(key: string, fields: Record<string, string>): Promise<number>;
+    getField(key: string, field: string): Promise<string>;
+    getFields(key: string, fields: string[]): Promise<string[]>;
+    getAllFields(key: string): Promise<Record<string, string>>;
+    deleteFields(key: string, fields: string[]): Promise<number>;
+    incrementFieldByFloat(key: string, field: string, increment: number): Promise<number>;
+    sendQuery(...query: any[]): Promise<any>;
+    sendIndexedQuery(index: string, query: string[]): Promise<string[]>;
+    findEntities(): Promise<any[]>;
+    findEntityById(): Promise<any>;
+    findEntitiesByCondition(): Promise<any[]>;
+    createEntityIndex(): Promise<void>;
+}
+export { RedisSearchService };

package/build/services/search/providers/redis/redis.js

@@ -0,0 +1,202 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisSearchService = void 0;
+const index_1 = require("../../index");
+class RedisSearchService extends index_1.SearchService {
+    constructor(searchClient, storeClient) {
+        super(searchClient, storeClient);
+    }
+    async init(namespace, appId, logger) {
+        this.namespace = namespace;
+        this.appId = appId;
+        this.logger = logger;
+    }
+    async createSearchIndex(indexName, prefixes, schema) {
+        try {
+            await this.searchClient.sendCommand([
+                'FT.CREATE',
+                indexName,
+                'ON',
+                'HASH',
+                'PREFIX',
+                prefixes.length.toString(),
+                ...prefixes,
+                'SCHEMA',
+                ...schema,
+            ]);
+        }
+        catch (error) {
+            this.logger.info('Error creating search index', { error });
+            throw error;
+        }
+    }
+    async listSearchIndexes() {
+        try {
+            const indexes = await this.searchClient.sendCommand(['FT._LIST']);
+            return indexes;
+        }
+        catch (error) {
+            this.logger.info('Error listing search indexes', { error });
+            throw error;
+        }
+    }
+    async updateContext(key, fields) {
+        // Find replay ID if present (field with hyphen, not the @udata field)
+        const replayId = Object.keys(fields).find((k) => k.includes('-') && !k.startsWith('@'));
+        // Route based on @udata operation
+        if ('@udata:set' in fields) {
+            const udata = JSON.parse(fields['@udata:set']);
+            const fieldsToSet = Array.isArray(udata)
+                ? Object.fromEntries(Array.from({ length: udata.length / 2 }, (_, i) => [
+                    udata[i * 2],
+                    udata[i * 2 + 1],
+                ]))
+                : udata;
+            const result = await this.setFields(key, fieldsToSet);
+            if (replayId)
+                await this.searchClient.HSET(key, { [replayId]: String(result) });
+            return result;
+        }
+        if ('@udata:get' in fields) {
+            const result = await this.getField(key, fields['@udata:get']);
+            if (replayId)
+                await this.searchClient.HSET(key, { [replayId]: result });
+            return result;
+        }
+        if ('@udata:mget' in fields) {
+            const result = await this.getFields(key, JSON.parse(fields['@udata:mget']));
+            if (replayId)
+                await this.searchClient.HSET(key, { [replayId]: result.join('|||') });
+            return result;
+        }
+        if ('@udata:delete' in fields) {
+            const result = await this.deleteFields(key, JSON.parse(fields['@udata:delete']));
+            if (replayId)
+                await this.searchClient.HSET(key, { [replayId]: String(result) });
+            return result;
+        }
+        if ('@udata:increment' in fields) {
+            const { field, value } = JSON.parse(fields['@udata:increment']);
+            const result = await this.incrementFieldByFloat(key, field, value);
+            if (replayId)
+                await this.searchClient.HSET(key, { [replayId]: String(result) });
+            return result;
+        }
+        if ('@udata:multiply' in fields) {
+            const { field, value } = JSON.parse(fields['@udata:multiply']);
+            const result = await this.incrementFieldByFloat(key, field, Math.log(value));
+            if (replayId)
+                await this.searchClient.HSET(key, { [replayId]: String(result) });
+            return result;
+        }
+        if ('@udata:all' in fields) {
+            const all = await this.getAllFields(key);
+            const result = Object.fromEntries(Object.entries(all).filter(([k]) => k.startsWith('_')));
+            if (replayId)
+                await this.searchClient.HSET(key, { [replayId]: JSON.stringify(result) });
+            return result;
+        }
+        // Default: call setFields
+        return await this.setFields(key, fields);
+    }
+    async setFields(key, fields) {
+        try {
+            const result = await this.searchClient.HSET(key, fields);
+            return Number(result);
+        }
+        catch (error) {
+            this.logger.error(`Error setting fields for key: ${key}`, { error });
+            throw error;
+        }
+    }
+    async getField(key, field) {
+        try {
+            return await this.searchClient.HGET(key, field);
+        }
+        catch (error) {
+            this.logger.error(`Error getting field ${field} for key: ${key}`, {
+                error,
+            });
+            throw error;
+        }
+    }
+    async getFields(key, fields) {
+        try {
+            return await this.searchClient.HMGET(key, [...fields]);
+        }
+        catch (error) {
+            this.logger.error(`Error getting fields for key: ${key}`, { error });
+            throw error;
+        }
+    }
+    async getAllFields(key) {
+        try {
+            return await this.searchClient.HGETALL(key);
+        }
+        catch (error) {
+            this.logger.error(`Error getting fields for key: ${key}`, { error });
+            throw error;
+        }
+    }
+    async deleteFields(key, fields) {
+        try {
+            const result = await this.searchClient.HDEL(key, fields);
+            return Number(result);
+        }
+        catch (error) {
+            this.logger.error(`Error deleting fields for key: ${key}`, { error });
+            throw error;
+        }
+    }
+    async incrementFieldByFloat(key, field, increment) {
+        try {
+            const result = await this.searchClient.HINCRBYFLOAT(key, field, increment);
+            return Number(result);
+        }
+        catch (error) {
+            this.logger.error(`Error incrementing field ${field} for key: ${key}`, {
+                error,
+            });
+            throw error;
+        }
+    }
+    async sendQuery(...query) {
+        try {
+            return await this.searchClient.sendCommand(query);
+        }
+        catch (error) {
+            this.logger.error('Error executing query', { error });
+            throw error;
+        }
+    }
+    async sendIndexedQuery(index, query) {
+        try {
+            if (query[0]?.startsWith('FT.')) {
+                return (await this.searchClient.sendCommand(query));
+            }
+            return (await this.searchClient.sendCommand([
+                'FT.SEARCH',
+                index,
+                ...query,
+            ]));
+        }
+        catch (error) {
+            this.logger.error('Error executing query', { error });
+            throw error;
+        }
+    }
+    // Entity methods - not implemented for Redis (postgres-specific JSONB operations)
+    async findEntities() {
+        throw new Error('Entity findEntities not supported in Redis - use PostgreSQL');
+    }
+    async findEntityById() {
+        throw new Error('Entity findEntityById not supported in Redis - use PostgreSQL');
+    }
+    async findEntitiesByCondition() {
+        throw new Error('Entity findEntitiesByCondition not supported in Redis - use PostgreSQL');
+    }
+    async createEntityIndex() {
+        throw new Error('Entity createEntityIndex not supported in Redis - use PostgreSQL');
+    }
+}
+exports.RedisSearchService = RedisSearchService;

package/build/services/store/factory.js

@@ -2,11 +2,19 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StoreServiceFactory = void 0;
 const utils_1 = require("../../modules/utils");
+const ioredis_1 = require("./providers/redis/ioredis");
+const redis_1 = require("./providers/redis/redis");
 const postgres_1 = require("./providers/postgres/postgres");
 class StoreServiceFactory {
     static async init(providerClient, namespace, appId, logger) {
         let service;
-        if ((0, utils_1.identifyProvider)(providerClient) === 'postgres') {
+        if ((0, utils_1.identifyProvider)(providerClient) === 'redis') {
+            service = new redis_1.RedisStoreService(providerClient);
+        }
+        else if ((0, utils_1.identifyProvider)(providerClient) === 'ioredis') {
+            service = new ioredis_1.IORedisStoreService(providerClient);
+        }
+        else if ((0, utils_1.identifyProvider)(providerClient) === 'postgres') {
             service = new postgres_1.PostgresStoreService(providerClient);
         } //etc
         await service.init(namespace, appId, logger);

package/build/services/store/providers/postgres/postgres.js

@@ -33,6 +33,7 @@ const cache_1 = require("../../cache");
 const __1 = require("../..");
 const kvsql_1 = require("./kvsql");
 const kvtables_1 = require("./kvtables");
+const time_notify_1 = require("./time-notify");
 class PostgresStoreService extends __1.StoreService {
     transact() {
         return this.storeClient.transact();
@@ -1039,11 +1040,8 @@ class PostgresStoreService extends __1.StoreService {
         const schemaName = this.kvsql().safeName(appId);
         const client = this.pgClient;
         try {
-            // Read the SQL template and replace schema placeholder
-            const fs = await Promise.resolve().then(() => __importStar(require('fs')));
-            const path = await Promise.resolve().then(() => __importStar(require('path')));
-            const sqlTemplate = fs.readFileSync(path.join(__dirname, 'time-notify.sql'), 'utf8');
-            const sql = sqlTemplate.replace(/{schema}/g, schemaName);
+            // Get the SQL with schema placeholder replaced
+            const sql = (0, time_notify_1.getTimeNotifySql)(schemaName);
             // Execute the entire SQL as one statement (functions contain $$ blocks with semicolons)
             await client.query(sql);
             this.logger.info('postgres-time-notifications-deployed', {

package/build/services/store/providers/postgres/time-notify.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Time-aware notification system for PostgreSQL
+ * This system minimizes polling by using LISTEN/NOTIFY for time-based task awakening
+ *
+ * Exported as a function that returns the SQL with schema placeholder replaced.
+ */
+export declare function getTimeNotifySql(schema: string): string;

package/build/services/store/providers/postgres/time-notify.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTimeNotifySql = void 0;
+/**
+ * Time-aware notification system for PostgreSQL
+ * This system minimizes polling by using LISTEN/NOTIFY for time-based task awakening
+ *
+ * Exported as a function that returns the SQL with schema placeholder replaced.
+ */
+function getTimeNotifySql(schema) {
+    return `
+-- Time-aware notification system for PostgreSQL
+-- This system minimizes polling by using LISTEN/NOTIFY for time-based task awakening
+
+-- Function to calculate the next awakening time from the sorted set
+CREATE OR REPLACE FUNCTION ${schema}.get_next_awakening_time(app_key TEXT)
+RETURNS TIMESTAMP WITH TIME ZONE AS $$
+DECLARE
+    next_score DOUBLE PRECISION;
+    next_time TIMESTAMP WITH TIME ZONE;
+BEGIN
+    -- Get the earliest (lowest score) entry from the time range ZSET
+    SELECT score INTO next_score
+    FROM ${schema}.task_schedules
+    WHERE key = app_key
+    AND (expiry IS NULL OR expiry > NOW())
+    ORDER BY score ASC
+    LIMIT 1;
+    
+    IF next_score IS NULL THEN
+        RETURN NULL;
+    END IF;
+    
+    -- Convert epoch milliseconds to timestamp
+    next_time := to_timestamp(next_score / 1000.0);
+    
+    -- Only return if it's in the future
+    IF next_time > NOW() THEN
+        RETURN next_time;
+    END IF;
+    
+    RETURN NULL;
+END;
+$$ LANGUAGE plpgsql;
+
+-- Function to schedule a notification for the next awakening time
+CREATE OR REPLACE FUNCTION ${schema}.schedule_time_notification(
+    app_id TEXT,
+    new_awakening_time TIMESTAMP WITH TIME ZONE DEFAULT NULL
+)
+RETURNS VOID AS $$
+DECLARE
+    channel_name TEXT;
+    current_next_time TIMESTAMP WITH TIME ZONE;
+    app_key TEXT;
+BEGIN
+    -- Build the time range key for this app
+    app_key := app_id || ':time_range';
+    channel_name := 'time_hooks_' || app_id;
+    
+    -- Get the current next awakening time
+    current_next_time := ${schema}.get_next_awakening_time(app_key);
+    
+    -- If we have a specific new awakening time, check if it's earlier
+    IF new_awakening_time IS NOT NULL THEN
+        IF current_next_time IS NULL OR new_awakening_time < current_next_time THEN
+            current_next_time := new_awakening_time;
+        END IF;
+    END IF;
+    
+    -- If there's a next awakening time, schedule immediate notification
+    -- The application will handle the timing logic
+    IF current_next_time IS NOT NULL THEN
+        PERFORM pg_notify(channel_name, json_build_object(
+            'type', 'time_schedule_updated',
+            'app_id', app_id,
+            'next_awakening', extract(epoch from current_next_time) * 1000,
+            'updated_at', extract(epoch from NOW()) * 1000
+        )::text);
+    END IF;
+END;
+$$ LANGUAGE plpgsql;
+
+-- Function to notify when time hooks are ready
+CREATE OR REPLACE FUNCTION ${schema}.notify_time_hooks_ready(app_id TEXT)
+RETURNS VOID AS $$
+DECLARE
+    channel_name TEXT;
+BEGIN
+    channel_name := 'time_hooks_' || app_id;
+    
+    PERFORM pg_notify(channel_name, json_build_object(
+        'type', 'time_hooks_ready',
+        'app_id', app_id,
+        'ready_at', extract(epoch from NOW()) * 1000
+    )::text);
+END;
+$$ LANGUAGE plpgsql;
+
+-- Trigger function for when time hooks are added/updated
+CREATE OR REPLACE FUNCTION ${schema}.on_time_hook_change()
+RETURNS TRIGGER AS $$
+DECLARE
+    app_id_extracted TEXT;
+    awakening_time TIMESTAMP WITH TIME ZONE;
+BEGIN
+    -- Extract app_id from the key (assumes format: app_id:time_range)
+    app_id_extracted := split_part(NEW.key, ':time_range', 1);
+    
+    -- Convert the score (epoch milliseconds) to timestamp
+    awakening_time := to_timestamp(NEW.score / 1000.0);
+    
+    -- Schedule notification for this new awakening time
+    PERFORM ${schema}.schedule_time_notification(app_id_extracted, awakening_time);
+    
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+-- Trigger function for when time hooks are removed
+CREATE OR REPLACE FUNCTION ${schema}.on_time_hook_remove()
+RETURNS TRIGGER AS $$
+DECLARE
+    app_id_extracted TEXT;
+BEGIN
+    -- Extract app_id from the key
+    app_id_extracted := split_part(OLD.key, ':time_range', 1);
+    
+    -- Recalculate and notify about the schedule update
+    PERFORM ${schema}.schedule_time_notification(app_id_extracted);
+    
+    RETURN OLD;
+END;
+$$ LANGUAGE plpgsql;
+
+-- Create triggers on the sorted_set table for time hooks
+-- Note: These will be created per app schema
+-- Drop existing triggers first to avoid conflicts
+DROP TRIGGER IF EXISTS trg_time_hook_insert ON ${schema}.task_schedules;
+DROP TRIGGER IF EXISTS trg_time_hook_update ON ${schema}.task_schedules;
+DROP TRIGGER IF EXISTS trg_time_hook_delete ON ${schema}.task_schedules;
+
+-- Create new triggers
+CREATE TRIGGER trg_time_hook_insert
+    AFTER INSERT ON ${schema}.task_schedules
+    FOR EACH ROW
+    WHEN (NEW.key LIKE '%:time_range')
+    EXECUTE FUNCTION ${schema}.on_time_hook_change();
+
+CREATE TRIGGER trg_time_hook_update
+    AFTER UPDATE ON ${schema}.task_schedules
+    FOR EACH ROW
+    WHEN (NEW.key LIKE '%:time_range')
+    EXECUTE FUNCTION ${schema}.on_time_hook_change();
+
+CREATE TRIGGER trg_time_hook_delete
+    AFTER DELETE ON ${schema}.task_schedules
+    FOR EACH ROW
+    WHEN (OLD.key LIKE '%:time_range')
+    EXECUTE FUNCTION ${schema}.on_time_hook_remove();
+`;
+}
+exports.getTimeNotifySql = getTimeNotifySql;

package/build/services/store/providers/redis/_base.d.ts

@@ -0,0 +1,137 @@
+import { KeyStoreParams, KeyType } from '../../../../modules/key';
+import { ILogger } from '../../../logger';
+import { ActivityType, Consumes } from '../../../../types/activity';
+import { AppVID } from '../../../../types/app';
+import { HookRule, HookSignal } from '../../../../types/hook';
+import { HotMeshApp, HotMeshApps, HotMeshSettings } from '../../../../types/hotmesh';
+import { ProviderClient, ProviderTransaction } from '../../../../types/provider';
+import { SymbolSets, StringStringType, StringAnyType, Symbols } from '../../../../types/serializer';
+import { IdsData, JobStatsRange, StatsType } from '../../../../types/stats';
+import { Transitions } from '../../../../types/transition';
+import { JobInterruptOptions } from '../../../../types/job';
+import { WorkListTaskType } from '../../../../types/task';
+import { ThrottleOptions } from '../../../../types/quorum';
+import { StoreService } from '../..';
+declare abstract class RedisStoreBase<ClientProvider extends ProviderClient, TransactionProvider extends ProviderTransaction> extends StoreService<ClientProvider, TransactionProvider> {
+    commands: Record<string, string>;
+    abstract transact(): TransactionProvider;
+    abstract exec(...args: any[]): Promise<any>;
+    abstract setnxex(key: string, value: string, expireSeconds: number): Promise<boolean>;
+    constructor(storeClient: ClientProvider);
+    init(namespace: string, appId: string, logger: ILogger): Promise<HotMeshApps>;
+    isSuccessful(result: any): boolean;
+    delistSignalKey(key: string, target: string): Promise<void>;
+    zAdd(key: string, score: number | string, value: string | number, redisMulti?: TransactionProvider): Promise<any>;
+    zRangeByScore(key: string, score: number | string, value: string | number): Promise<string | null>;
+    mintKey(type: KeyType, params: KeyStoreParams): string;
+    invalidateCache(): void;
+    /**
+     * At any given time only a single engine will
+     * check for and process work items in the
+     * time and signal task queues.
+     */
+    reserveScoutRole(scoutType: 'time' | 'signal' | 'activate', delay?: number): Promise<boolean>;
+    releaseScoutRole(scoutType: 'time' | 'signal' | 'activate'): Promise<boolean>;
+    getSettings(bCreate?: boolean): Promise<HotMeshSettings>;
+    setSettings(manifest: HotMeshSettings): Promise<any>;
+    reserveSymbolRange(target: string, size: number, type: 'JOB' | 'ACTIVITY', tryCount?: number): Promise<[number, number, Symbols]>;
+    getAllSymbols(): Promise<Symbols>;
+    getSymbols(activityId: string): Promise<Symbols>;
+    addSymbols(activityId: string, symbols: Symbols): Promise<boolean>;
+    seedSymbols(target: string, type: 'JOB' | 'ACTIVITY', startIndex: number): StringStringType;
+    seedJobSymbols(startIndex: number): StringStringType;
+    seedActivitySymbols(startIndex: number, activityId: string): StringStringType;
+    getSymbolValues(): Promise<Symbols>;
+    addSymbolValues(symvals: Symbols): Promise<boolean>;
+    getSymbolKeys(symbolNames: string[]): Promise<SymbolSets>;
+    getApp(id: string, refresh?: boolean): Promise<HotMeshApp>;
+    setApp(id: string, version: string): Promise<HotMeshApp>;
+    activateAppVersion(id: string, version: string): Promise<boolean>;
+    registerAppVersion(appId: string, version: string): Promise<any>;
+    setStats(jobKey: string, jobId: string, dateTime: string, stats: StatsType, appVersion: AppVID, transaction?: TransactionProvider): Promise<any>;
+    hGetAllResult(result: any): any;
+    getJobStats(jobKeys: string[]): Promise<JobStatsRange>;
+    getJobIds(indexKeys: string[], idRange: [number, number]): Promise<IdsData>;
+    setStatus(collationKeyStatus: number, jobId: string, appId: string, transaction?: TransactionProvider): Promise<any>;
+    getStatus(jobId: string, appId: string): Promise<number>;
+    setState({ ...state }: StringAnyType, status: number | null, jobId: string, symbolNames: string[], dIds: StringStringType, transaction?: TransactionProvider): Promise<string>;
+    /**
+     * Returns custom search fields and values.
+     * NOTE: The `fields` param should NOT prefix items with an underscore.
+     * NOTE: Literals are allowed if quoted.
+     */
+    getQueryState(jobId: string, fields: string[]): Promise<StringAnyType>;
+    getState(jobId: string, consumes: Consumes, dIds: StringStringType): Promise<[StringAnyType, number] | undefined>;
+    getRaw(jobId: string): Promise<StringStringType>;
+    /**
+     * collate is a generic method for incrementing a value in a hash
+     * in order to track their progress during processing.
+     */
+    collate(jobId: string, activityId: string, amount: number, dIds: StringStringType, transaction?: TransactionProvider): Promise<number>;
+    /**
+     * Synthentic collation affects those activities in the graph
+     * that represent the synthetic DAG that was materialized during compilation;
+     * Synthetic collation distinguishes `re-entry due to failure` from
+     * `purposeful re-entry`.
+     */
+    collateSynthetic(jobId: string, guid: string, amount: number, transaction?: TransactionProvider): Promise<number>;
+    setStateNX(jobId: string, appId: string, status?: number, entity?: string): Promise<boolean>;
+    getSchema(activityId: string, appVersion: AppVID): Promise<ActivityType>;
+    getSchemas(appVersion: AppVID): Promise<Record<string, ActivityType>>;
+    setSchemas(schemas: Record<string, ActivityType>, appVersion: AppVID): Promise<any>;
+    setSubscriptions(subscriptions: Record<string, any>, appVersion: AppVID): Promise<boolean>;
+    getSubscriptions(appVersion: AppVID): Promise<Record<string, string>>;
+    getSubscription(topic: string, appVersion: AppVID): Promise<string | undefined>;
+    setTransitions(transitions: Record<string, any>, appVersion: AppVID): Promise<any>;
+    getTransitions(appVersion: AppVID): Promise<Transitions>;
+    setHookRules(hookRules: Record<string, HookRule[]>): Promise<any>;
+    getHookRules(): Promise<Record<string, HookRule[]>>;
+    setHookSignal(hook: HookSignal, transaction?: TransactionProvider): Promise<any>;
+    getHookSignal(topic: string, resolved: string): Promise<string | undefined>;
+    deleteHookSignal(topic: string, resolved: string): Promise<number | undefined>;
+    addTaskQueues(keys: string[]): Promise<void>;
+    getActiveTaskQueue(): Promise<string | null>;
+    deleteProcessedTaskQueue(workItemKey: string, key: string, processedKey: string, scrub?: boolean): Promise<void>;
+    processTaskQueue(sourceKey: string, destinationKey: string): Promise<any>;
+    expireJob(jobId: string, inSeconds: number, redisMulti?: TransactionProvider): Promise<void>;
+    getDependencies(jobId: string): Promise<string[]>;
+    /**
+     * registers a hook activity to be awakened (uses ZSET to
+     * store the 'sleep group' and LIST to store the events
+     * for the given sleep group. Sleep groups are
+     * organized into 'n'-second blocks (LISTS))
+     */
+    registerTimeHook(jobId: string, gId: string, activityId: string, type: WorkListTaskType, deletionTime: number, dad: string, transaction?: TransactionProvider): Promise<void>;
+    getNextTask(listKey?: string): Promise<[
+        listKey: string,
+        jobId: string,
+        gId: string,
+        activityId: string,
+        type: WorkListTaskType
+    ] | boolean>;
+    /**
+     * when processing time jobs, the target LIST ID returned
+     * from the ZSET query can be prefixed to denote what to
+     * do with the work list. (not everything is known in advance,
+     * so the ZSET key defines HOW to approach the work in the
+     * generic LIST (lists typically contain target job ids)
+     * @param {string} listKey - composite key
+     */
+    resolveTaskKeyContext(listKey: string): [WorkListTaskType, string];
+    /**
+     * Interrupts a job and sets sets a job error (410), if 'throw'!=false.
+     * This method is called by the engine and not by an activity and is
+     * followed by a call to execute job completion/cleanup tasks
+     * associated with a job completion event.
+     *
+     * Todo: move most of this logic to the engine (too much logic for the store)
+     */
+    interrupt(topic: string, jobId: string, options?: JobInterruptOptions): Promise<void>;
+    scrub(jobId: string): Promise<void>;
+    findJobs(queryString?: string, limit?: number, batchSize?: number, cursor?: string): Promise<[string, string[]]>;
+    findJobFields(jobId: string, fieldMatchPattern?: string, limit?: number, batchSize?: number, cursor?: string): Promise<[string, StringStringType]>;
+    setThrottleRate(options: ThrottleOptions): Promise<void>;
+    getThrottleRates(): Promise<StringStringType>;
+    getThrottleRate(topic: string): Promise<number>;
+}
+export { RedisStoreBase };