@hotmeshio/hotmesh 0.6.0 → 0.7.0

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

@@ -9,8 +9,18 @@ const zsetModule = (context) => ({
             return Promise.resolve(0);
         }
         else {
-            const res = await context.pgClient.query(sql, params);
-            return Number(res.rows[0]?.count || 0);
+            try {
+                const res = await context.pgClient.query(sql, params);
+                return Number(res.rows[0]?.count || 0);
+            }
+            catch (error) {
+                // Connection closed during test cleanup - return 0
+                if (error?.message?.includes('closed') || error?.message?.includes('queryable')) {
+                    return 0;
+                }
+                // Re-throw unexpected errors
+                throw error;
+            }
         }
     },
     _zadd(key, score, member, options) {
@@ -50,13 +60,23 @@ const zsetModule = (context) => ({
             return Promise.resolve([]);
         }
         else {
-            const res = await context.pgClient.query(sql, params);
-            if (facet === 'WITHSCORES') {
-                // Include scores in the result
-                return res.rows.flatMap((row) => [row.member, row.score.toString()]);
+            try {
+                const res = await context.pgClient.query(sql, params);
+                if (facet === 'WITHSCORES') {
+                    // Include scores in the result
+                    return res.rows.flatMap((row) => [row.member, row.score.toString()]);
+                }
+                else {
+                    return res.rows.map((row) => row.member);
+                }
             }
-            else {
-                return res.rows.map((row) => row.member);
+            catch (error) {
+                // Connection closed during test cleanup - return empty array
+                if (error?.message?.includes('closed') || error?.message?.includes('queryable')) {
+                    return [];
+                }
+                // Re-throw unexpected errors
+                throw error;
             }
         }
     },
@@ -99,8 +119,18 @@ const zsetModule = (context) => ({
             return Promise.resolve(null);
         }
         else {
-            const res = await context.pgClient.query(sql, params);
-            return res.rows.length ? parseFloat(res.rows[0].score) : null;
+            try {
+                const res = await context.pgClient.query(sql, params);
+                return res.rows.length ? parseFloat(res.rows[0].score) : null;
+            }
+            catch (error) {
+                // Connection closed during test cleanup - return null
+                if (error?.message?.includes('closed') || error?.message?.includes('queryable')) {
+                    return null;
+                }
+                // Re-throw unexpected errors
+                throw error;
+            }
         }
     },
     _zscore(key, member) {
@@ -122,8 +152,18 @@ const zsetModule = (context) => ({
             return Promise.resolve([]);
         }
         else {
-            const res = await context.pgClient.query(sql, params);
-            return res.rows.map((row) => row.member);
+            try {
+                const res = await context.pgClient.query(sql, params);
+                return res.rows.map((row) => row.member);
+            }
+            catch (error) {
+                // Connection closed during test cleanup - return empty array
+                if (error?.message?.includes('closed') || error?.message?.includes('queryable')) {
+                    return [];
+                }
+                // Re-throw unexpected errors
+                throw error;
+            }
         }
     },
     _zrangebyscore(key, min, max) {
@@ -143,8 +183,18 @@ const zsetModule = (context) => ({
             return Promise.resolve([]);
         }
         else {
-            const res = await context.pgClient.query(sql, params);
-            return res.rows.map((row) => ({ member: row.member, score: row.score }));
+            try {
+                const res = await context.pgClient.query(sql, params);
+                return res.rows.map((row) => ({ member: row.member, score: row.score }));
+            }
+            catch (error) {
+                // Connection closed during test cleanup - return empty array
+                if (error?.message?.includes('closed') || error?.message?.includes('queryable')) {
+                    return [];
+                }
+                // Re-throw unexpected errors
+                throw error;
+            }
         }
     },
     _zrangebyscore_withscores(key, min, max) {
@@ -164,8 +214,18 @@ const zsetModule = (context) => ({
             return Promise.resolve(0);
         }
         else {
-            const res = await context.pgClient.query(sql, params);
-            return Number(res.rows[0]?.count || 0);
+            try {
+                const res = await context.pgClient.query(sql, params);
+                return Number(res.rows[0]?.count || 0);
+            }
+            catch (error) {
+                // Connection closed during test cleanup - return 0
+                if (error?.message?.includes('closed') || error?.message?.includes('queryable')) {
+                    return 0;
+                }
+                // Re-throw unexpected errors
+                throw error;
+            }
         }
     },
     _zrem(key, member) {
@@ -188,12 +248,22 @@ const zsetModule = (context) => ({
             return Promise.resolve(null);
         }
         else {
-            const res = await context.pgClient.query(sql, params);
-            return res.rows[0]?.rank
-                ? parseInt(res.rows[0].rank, 10) > 0
-                    ? parseInt(res.rows[0].rank, 10) - 1
-                    : null
-                : null;
+            try {
+                const res = await context.pgClient.query(sql, params);
+                return res.rows[0]?.rank
+                    ? parseInt(res.rows[0].rank, 10) > 0
+                        ? parseInt(res.rows[0].rank, 10) - 1
+                        : null
+                    : null;
+            }
+            catch (error) {
+                // Connection closed during test cleanup - return null
+                if (error?.message?.includes('closed') || error?.message?.includes('queryable')) {
+                    return null;
+                }
+                // Re-throw unexpected errors
+                throw error;
+            }
         }
     },
     _zrank(key, member) {

package/build/services/store/providers/postgres/postgres.d.ts

@@ -3,7 +3,7 @@ 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 { 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';
@@ -38,8 +38,8 @@ declare class PostgresStoreService extends StoreService<ProviderClient, Provider
      * 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>;
+    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]>;

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, 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 };