@hotmeshio/hotmesh 0.7.0 → 0.8.0

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

@@ -1,202 +0,0 @@
-"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/providers/redis/_base.d.ts

@@ -1,137 +0,0 @@
-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, ScoutType } 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: ScoutType, delay?: number): Promise<boolean>;
-    releaseScoutRole(scoutType: ScoutType): 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 };