@hotmeshio/hotmesh 0.5.6 → 0.5.7

package/build/services/store/providers/postgres/kvtypes/hash/udata.js

@@ -0,0 +1,384 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createUdataOperations = void 0;
+const utils_1 = require("./utils");
+function createUdataOperations(context) {
+    return {
+        handleUdataSet,
+        handleUdataGet,
+        handleUdataMget,
+        handleUdataDelete,
+        handleUdataIncrement,
+        handleUdataMultiply,
+        handleUdataAll,
+    };
+    function handleUdataSet(key, fields, options) {
+        const tableName = context.tableForKey(key, 'hash');
+        const replayId = Object.keys(fields).find((k) => k.includes('-') && k !== '@udata:set');
+        const udata = JSON.parse(fields['@udata:set']);
+        const params = [];
+        let sql = '';
+        // Extract the fields to set (can be object or key-value pairs)
+        const fieldsToSet = {};
+        if (typeof udata === 'object' && !Array.isArray(udata)) {
+            // Object format: { field1: 'value1', field2: 'value2' }
+            for (const [fieldName, value] of Object.entries(udata)) {
+                fieldsToSet[fieldName] = String(value);
+            }
+        }
+        else if (Array.isArray(udata)) {
+            // Array format: ['field1', 'value1', 'field2', 'value2']
+            for (let i = 0; i < udata.length; i += 2) {
+                const fieldName = udata[i];
+                const value = udata[i + 1];
+                fieldsToSet[fieldName] = String(value);
+            }
+        }
+        const fieldEntries = Object.entries(fieldsToSet);
+        if (fieldEntries.length === 0) {
+            // No fields to set, return a no-op
+            return { sql: 'SELECT 0 as count', params: [] };
+        }
+        const schemaName = context.safeName(context.appId);
+        if (replayId) {
+            // Version with replay storage
+            const placeholders = fieldEntries
+                .map(([fieldName, value], index) => {
+                const baseIndex = index * 3 + 3;
+                params.push(fieldName, value, 'udata');
+                return `($${baseIndex}, $${baseIndex + 1}, $${baseIndex + 2}::${schemaName}.type_enum)`;
+            })
+                .join(', ');
+            sql = `
+        WITH valid_job AS (
+          SELECT id FROM ${tableName} WHERE key = $1 AND is_live
+        ),
+        upsert_fields AS (
+          INSERT INTO ${tableName}_attributes (job_id, field, value, type)
+          SELECT 
+            job.id,
+            vals.field,
+            vals.value,
+            vals.type
+          FROM valid_job job
+          CROSS JOIN (
+            VALUES ${placeholders}
+          ) AS vals(field, value, type)
+          ON CONFLICT (job_id, field) DO UPDATE SET value = EXCLUDED.value
+          RETURNING 1 as field_count
+        ),
+        count_result AS (
+          SELECT COUNT(*) as new_fields_count FROM upsert_fields
+        ),
+        replay_insert AS (
+          INSERT INTO ${tableName}_attributes (job_id, field, value, type)
+          SELECT job.id, $2, new_fields_count::text, $${2 + fieldEntries.length * 3 + 1}::${schemaName}.type_enum
+          FROM valid_job job, count_result
+          ON CONFLICT (job_id, field) DO UPDATE
+          SET value = EXCLUDED.value
+          RETURNING 1
+        )
+        SELECT new_fields_count FROM count_result
+      `;
+            params.unshift(key, replayId);
+            params.push((0, utils_1.deriveType)(replayId));
+        }
+        else {
+            // Version without replay storage
+            const placeholders = fieldEntries
+                .map(([fieldName, value], index) => {
+                const baseIndex = index * 3 + 2;
+                params.push(fieldName, value, 'udata');
+                return `($${baseIndex}, $${baseIndex + 1}, $${baseIndex + 2}::${schemaName}.type_enum)`;
+            })
+                .join(', ');
+            sql = `
+        WITH valid_job AS (
+          SELECT id FROM ${tableName} WHERE key = $1 AND is_live
+        )
+        INSERT INTO ${tableName}_attributes (job_id, field, value, type)
+        SELECT 
+          job.id,
+          vals.field,
+          vals.value,
+          vals.type
+        FROM valid_job job
+        CROSS JOIN (
+          VALUES ${placeholders}
+        ) AS vals(field, value, type)
+        ON CONFLICT (job_id, field) DO UPDATE SET value = EXCLUDED.value
+        RETURNING 1 as count
+      `;
+            params.unshift(key);
+        }
+        return { sql, params };
+    }
+    function handleUdataGet(key, fields, options) {
+        const tableName = context.tableForKey(key, 'hash');
+        const fieldName = fields['@udata:get'];
+        const replayId = Object.keys(fields).find((k) => k.includes('-') && k !== '@udata:get');
+        const params = [];
+        let sql = '';
+        if (replayId) {
+            sql = `
+        WITH field_data AS (
+          SELECT COALESCE(a.value, '') as field_value
+          FROM ${tableName} j
+          LEFT JOIN ${tableName}_attributes a ON j.id = a.job_id AND a.field = $2
+          WHERE j.key = $1 AND j.is_live
+        ),
+        replay_insert AS (
+          INSERT INTO ${tableName}_attributes (job_id, field, value, type)
+          SELECT j.id, $3, field_value, $4
+          FROM ${tableName} j, field_data
+          WHERE j.key = $1 AND j.is_live
+          ON CONFLICT (job_id, field) DO UPDATE
+          SET value = EXCLUDED.value
+          RETURNING 1
+        )
+        SELECT field_value as new_value FROM field_data
+      `;
+            params.push(key, fieldName, replayId, (0, utils_1.deriveType)(replayId));
+        }
+        else {
+            sql = `
+        SELECT COALESCE(a.value, '') as new_value
+        FROM ${tableName} j
+        LEFT JOIN ${tableName}_attributes a ON j.id = a.job_id AND a.field = $2
+        WHERE j.key = $1 AND j.is_live
+      `;
+            params.push(key, fieldName);
+        }
+        return { sql, params };
+    }
+    function handleUdataMget(key, fields, options) {
+        const tableName = context.tableForKey(key, 'hash');
+        const fieldNames = JSON.parse(fields['@udata:mget']);
+        const replayId = Object.keys(fields).find((k) => k.includes('-') && k !== '@udata:mget');
+        const params = [];
+        let sql = '';
+        if (replayId) {
+            sql = `
+        WITH field_data AS (
+          SELECT array_agg(COALESCE(a.value, '') ORDER BY field_order.idx) as field_values
+          FROM ${tableName} j
+          CROSS JOIN (
+            SELECT unnest($2::text[]) as field_name, generate_subscripts($2::text[], 1) as idx
+          ) as field_order
+          LEFT JOIN ${tableName}_attributes a ON j.id = a.job_id AND a.field = field_order.field_name
+          WHERE j.key = $1 AND j.is_live
+        ),
+        replay_insert AS (
+          INSERT INTO ${tableName}_attributes (job_id, field, value, type)
+          SELECT j.id, $3, array_to_string(field_values, '|||'), $4
+          FROM ${tableName} j, field_data
+          WHERE j.key = $1 AND j.is_live
+          ON CONFLICT (job_id, field) DO UPDATE
+          SET value = EXCLUDED.value
+          RETURNING 1
+        )
+        SELECT field_values as new_value FROM field_data
+      `;
+            params.push(key, fieldNames, replayId, (0, utils_1.deriveType)(replayId));
+        }
+        else {
+            sql = `
+        SELECT array_agg(COALESCE(a.value, '') ORDER BY field_order.idx) as new_value
+        FROM ${tableName} j
+        CROSS JOIN (
+          SELECT unnest($2::text[]) as field_name, generate_subscripts($2::text[], 1) as idx
+        ) as field_order
+        LEFT JOIN ${tableName}_attributes a ON j.id = a.job_id AND a.field = field_order.field_name
+        WHERE j.key = $1 AND j.is_live
+      `;
+            params.push(key, fieldNames);
+        }
+        return { sql, params };
+    }
+    function handleUdataDelete(key, fields, options) {
+        const tableName = context.tableForKey(key, 'hash');
+        const fieldNames = JSON.parse(fields['@udata:delete']);
+        const replayId = Object.keys(fields).find((k) => k.includes('-') && k !== '@udata:delete');
+        const params = [];
+        let sql = '';
+        if (replayId) {
+            sql = `
+        WITH deleted_fields AS (
+          DELETE FROM ${tableName}_attributes
+          WHERE job_id = (
+            SELECT id FROM ${tableName} WHERE key = $1 AND is_live
+          )
+          AND field = ANY($2::text[])
+          RETURNING 1 as deleted_count
+        ),
+        count_result AS (
+          SELECT COUNT(*) as total_deleted FROM deleted_fields
+        ),
+        replay_insert AS (
+          INSERT INTO ${tableName}_attributes (job_id, field, value, type)
+          SELECT j.id, $3, total_deleted::text, $4
+          FROM ${tableName} j, count_result
+          WHERE j.key = $1 AND j.is_live
+          ON CONFLICT (job_id, field) DO UPDATE
+          SET value = EXCLUDED.value
+          RETURNING 1
+        )
+        SELECT total_deleted as new_value FROM count_result
+      `;
+            params.push(key, fieldNames, replayId, (0, utils_1.deriveType)(replayId));
+        }
+        else {
+            sql = `
+        WITH deleted_fields AS (
+          DELETE FROM ${tableName}_attributes
+          WHERE job_id = (
+            SELECT id FROM ${tableName} WHERE key = $1 AND is_live
+          )
+          AND field = ANY($2::text[])
+          RETURNING 1 as deleted_count
+        )
+        SELECT COUNT(*) as new_value FROM deleted_fields
+      `;
+            params.push(key, fieldNames);
+        }
+        return { sql, params };
+    }
+    function handleUdataIncrement(key, fields, options) {
+        const tableName = context.tableForKey(key, 'hash');
+        const { field, value } = JSON.parse(fields['@udata:increment']);
+        const replayId = Object.keys(fields).find((k) => k.includes('-') && k !== '@udata:increment');
+        const schemaName = context.safeName(context.appId);
+        const params = [];
+        let sql = '';
+        if (replayId) {
+            sql = `
+        WITH valid_job AS (
+          SELECT id FROM ${tableName} WHERE key = $1 AND is_live
+        ),
+        increment_result AS (
+          INSERT INTO ${tableName}_attributes (job_id, field, value, type)
+          SELECT id, $2, $3::text, $4::${schemaName}.type_enum
+          FROM valid_job
+          ON CONFLICT (job_id, field) DO UPDATE
+          SET value = ((COALESCE(${tableName}_attributes.value, '0')::double precision) + $3::double precision)::text
+          RETURNING value
+        ),
+        replay_insert AS (
+          INSERT INTO ${tableName}_attributes (job_id, field, value, type)
+          SELECT job.id, $5, inc.value, $6::${schemaName}.type_enum
+          FROM valid_job job, increment_result inc
+          ON CONFLICT (job_id, field) DO UPDATE
+          SET value = EXCLUDED.value
+          RETURNING 1
+        )
+        SELECT value as new_value FROM increment_result
+      `;
+            params.push(key, field, value, 'udata', replayId, (0, utils_1.deriveType)(replayId));
+        }
+        else {
+            sql = `
+        WITH valid_job AS (
+          SELECT id FROM ${tableName} WHERE key = $1 AND is_live
+        )
+        INSERT INTO ${tableName}_attributes (job_id, field, value, type)
+        SELECT id, $2, $3::text, $4::${schemaName}.type_enum
+        FROM valid_job
+        ON CONFLICT (job_id, field) DO UPDATE
+        SET value = ((COALESCE(${tableName}_attributes.value, '0')::double precision) + $3::double precision)::text
+        RETURNING value as new_value
+      `;
+            params.push(key, field, value, 'udata');
+        }
+        return { sql, params };
+    }
+    function handleUdataMultiply(key, fields, options) {
+        const tableName = context.tableForKey(key, 'hash');
+        const { field, value } = JSON.parse(fields['@udata:multiply']);
+        const replayId = Object.keys(fields).find((k) => k.includes('-') && k !== '@udata:multiply');
+        const schemaName = context.safeName(context.appId);
+        const params = [];
+        let sql = '';
+        // For multiplication, we work with logarithms to support exponential multiplication
+        // log(a * b) = log(a) + log(b), so exp(log(a) + log(b)) = a * b
+        if (replayId) {
+            sql = `
+        WITH valid_job AS (
+          SELECT id FROM ${tableName} WHERE key = $1 AND is_live
+        ),
+        multiply_result AS (
+          INSERT INTO ${tableName}_attributes (job_id, field, value, type)
+          SELECT id, $2, ln($3::double precision)::text, $4::${schemaName}.type_enum
+          FROM valid_job
+          ON CONFLICT (job_id, field) DO UPDATE
+          SET value = (COALESCE(${tableName}_attributes.value::double precision, 0) + ln($3::double precision))::text
+          RETURNING value
+        ),
+        replay_insert AS (
+          INSERT INTO ${tableName}_attributes (job_id, field, value, type)
+          SELECT job.id, $5, mult.value, $6::${schemaName}.type_enum
+          FROM valid_job job, multiply_result mult
+          ON CONFLICT (job_id, field) DO UPDATE
+          SET value = EXCLUDED.value
+          RETURNING 1
+        )
+        SELECT value as new_value FROM multiply_result
+      `;
+            params.push(key, field, value, 'udata', replayId, (0, utils_1.deriveType)(replayId));
+        }
+        else {
+            sql = `
+        WITH valid_job AS (
+          SELECT id FROM ${tableName} WHERE key = $1 AND is_live
+        )
+        INSERT INTO ${tableName}_attributes (job_id, field, value, type)
+        SELECT id, $2, ln($3::double precision)::text, $4::${schemaName}.type_enum
+        FROM valid_job
+        ON CONFLICT (job_id, field) DO UPDATE
+        SET value = (COALESCE(${tableName}_attributes.value::double precision, 0) + ln($3::double precision))::text
+        RETURNING value as new_value
+      `;
+            params.push(key, field, value, 'udata');
+        }
+        return { sql, params };
+    }
+    function handleUdataAll(key, fields, options) {
+        const tableName = context.tableForKey(key, 'hash');
+        const replayId = Object.keys(fields).find((k) => k.includes('-') && k !== '@udata:all');
+        const params = [];
+        let sql = '';
+        if (replayId) {
+            sql = `
+        WITH field_data AS (
+          SELECT jsonb_object_agg(a.field, a.value) as field_values
+          FROM ${tableName} j
+          LEFT JOIN ${tableName}_attributes a ON j.id = a.job_id 
+          WHERE j.key = $1 AND j.is_live
+          AND a.type = 'udata' AND a.field LIKE '\\_%'
+        ),
+        replay_insert AS (
+          INSERT INTO ${tableName}_attributes (job_id, field, value, type)
+          SELECT j.id, $2, field_values::text, $3
+          FROM ${tableName} j, field_data
+          WHERE j.key = $1 AND j.is_live
+          ON CONFLICT (job_id, field) DO UPDATE
+          SET value = EXCLUDED.value
+          RETURNING 1
+        )
+        SELECT field_values as new_value FROM field_data
+      `;
+            params.push(key, replayId, (0, utils_1.deriveType)(replayId));
+        }
+        else {
+            sql = `
+        SELECT jsonb_object_agg(a.field, a.value) as new_value
+        FROM ${tableName} j
+        LEFT JOIN ${tableName}_attributes a ON j.id = a.job_id 
+        WHERE j.key = $1 AND j.is_live
+        AND a.type = 'udata' AND a.field LIKE '\\_%'
+      `;
+            params.push(key);
+        }
+        return { sql, params };
+    }
+}
+exports.createUdataOperations = createUdataOperations;

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

@@ -42,10 +42,7 @@ class PostgresStoreService extends __1.StoreService {
         this.isScout = false;
         //Instead of directly referencing the 'pg' package and methods like 'query',
         //  the PostgresStore wraps the 'pg' client in a class that implements
-        //  the Redis client interface. This allows the same methods to be called
-        //  that were used when authoring the Redis client store provider.
-        //In general, this.storeClient will behave like Redis, but will
-        //  use the 'pg' package and will read/write to a Postgres database.
+        //  an entity/attribute interface.
         this.pgClient = storeClient;
         this.storeClient = new kvsql_1.KVSQL(storeClient, this.namespace, this.appId);
         //kvTables will provision tables and indexes in the Postgres db as necessary
@@ -75,7 +72,6 @@ class PostgresStoreService extends __1.StoreService {
         await this.kvsql().del(`${key}:${target}`);
     }
     async zAdd(key, score, value, transaction) {
-        //default call signature uses 'ioredis' NPM Package format
         return await this.kvsql(transaction).zadd(key, Number(score), value.toString());
     }
     async zRangeByScore(key, score, value) {
@@ -393,7 +389,7 @@ class PostgresStoreService extends __1.StoreService {
         }
     }
     hGetAllResult(result) {
-        //default response signature uses 'redis' NPM Package format
+        //default response signature
         return result;
     }
     async getJobStats(jobKeys) {

package/build/services/stream/factory.js

@@ -2,8 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StreamServiceFactory = void 0;
 const utils_1 = require("../../modules/utils");
-const ioredis_1 = require("./providers/redis/ioredis");
-const redis_1 = require("./providers/redis/redis");
 const nats_1 = require("./providers/nats/nats");
 const postgres_1 = require("./providers/postgres/postgres");
 class StreamServiceFactory {
@@ -11,24 +9,10 @@ class StreamServiceFactory {
         let service;
         const providerType = (0, utils_1.identifyProvider)(provider);
         if (providerType === 'nats') {
-            let storeProvider;
-            if ((0, utils_1.identifyProvider)(storeProvider) === 'redis') {
-                storeProvider = storeProvider;
-            }
-            else {
-                //ioredis
-                storeProvider = storeProvider;
-            }
             service = new nats_1.NatsStreamService(provider, storeProvider);
         }
         else if (providerType === 'postgres') {
             service = new postgres_1.PostgresStreamService(provider, storeProvider);
-        }
-        else if (providerType === 'redis') {
-            service = new redis_1.RedisStreamService(provider, storeProvider);
-        }
-        else if (providerType === 'ioredis') {
-            service = new ioredis_1.IORedisStreamService(provider, storeProvider);
         } //etc register other providers here
         await service.init(namespace, appId, logger);
         return service;

package/build/services/sub/factory.js

@@ -2,10 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SubServiceFactory = void 0;
 const utils_1 = require("../../modules/utils");
-const redis_1 = require("./providers/redis/redis");
 const postgres_1 = require("./providers/postgres/postgres");
 const nats_1 = require("./providers/nats/nats");
-const ioredis_1 = require("./providers/redis/ioredis");
 class SubServiceFactory {
     static async init(providerSubClient, providerPubClient, namespace, appId, engineId, logger) {
         let service;
@@ -13,15 +11,9 @@ class SubServiceFactory {
         if (providerType === 'nats') {
             service = new nats_1.NatsSubService(providerSubClient, providerPubClient);
         }
-        else if (providerType === 'redis') {
-            service = new redis_1.RedisSubService(providerSubClient, providerPubClient);
-        }
         else if (providerType === 'postgres') {
             service = new postgres_1.PostgresSubService(providerSubClient, providerPubClient);
         }
-        else {
-            service = new ioredis_1.IORedisSubService(providerSubClient, providerPubClient);
-        }
         await service.init(namespace, appId, engineId, logger);
         return service;
     }

package/build/services/sub/providers/nats/nats.js

@@ -15,7 +15,6 @@ class NatsSubService extends index_1.SubService {
         this.engineId = engineId;
     }
     transact() {
-        // NATS does not support transactions like Redis.
         // Return an empty object or throw an error if not supported.
         return {};
     }

package/build/services/task/index.js

@@ -113,7 +113,6 @@ class TaskService {
             }
             catch (err) {
                 //most common reasons: deleted job not found; container stopping; test stopping
-                //less common: redis/cluster down; retry with fallback (5s max main reassignment)
                 this.logger.warn('task-process-timehooks-error', err);
                 await (0, utils_1.sleepFor)(1000 * this.errorCount++);
                 if (this.errorCount < 5) {

package/build/types/activity.d.ts

@@ -58,11 +58,7 @@ interface TriggerActivityStats {
     } | string;
     /**
      * @deprecated
-     * return 'infinity' to disable; default behavior
-     * is to always segment keys by time to ensure
-     * indexes (Redis LIST) never grow unbounded
-     * as a default behavior; for now, 5m is default
-     * and infinity can be set to override
+     * return 'infinity' to disable
      */
     granularity?: string;
     /**

package/build/types/hotmesh.d.ts

@@ -140,11 +140,6 @@ type HotMeshWorker = {
      * @private
      */
     search?: ProviderClient;
-    /**
-     * redis connection options; replaced with 'connection'
-     * @deprecated
-     */
-    redis?: ProviderConfig;
     /**
      * short-form format for the connection options for the
      * store, stream, sub, and search clients

package/build/types/index.d.ts

@@ -17,7 +17,6 @@ export { MeshCallConnectParams, MeshCallExecParams, MeshCallCronParams, MeshCall
 export { PostgresClassType, PostgresClientOptions, PostgresClientType, PostgresConsumerGroup, PostgresPendingMessage, PostgresPoolClientType, PostgresQueryConfigType, PostgresQueryResultType, PostgresStreamMessage, PostgresStreamOptions, PostgresTransaction, } from './postgres';
 export { ActivateMessage, CronMessage, JobMessage, JobMessageCallback, PingMessage, PongMessage, QuorumMessage, QuorumMessageCallback, QuorumProfile, RollCallMessage, RollCallOptions, SubscriptionCallback, SubscriptionOptions, SystemHealth, ThrottleMessage, ThrottleOptions, WorkMessage, } from './quorum';
 export { NatsAckPolicy, NatsAckPolicyExplicitType, NatsClassType, NatsClientType, NatsClientOptions, NatsConsumerConfigType, NatsJetStreamManager, NatsConnection, NatsJetStreamType, NatsConnectionOptions, NatsConsumerConfig, NatsConsumerInfo, NatsConsumerManager, NatsDeliveryInfo, NatsJetStreamOptions, NatsError, NatsErrorType, NatsJetStreamClient, NatsJsMsg, NatsMessageType, NatsMsgExpect, NatsPubAck, NatsPubAckType, NatsPublishOptions, NatsRetentionPolicy, NatsRetentionPolicyWorkqueueType, NatsSequenceInfo, NatsStorageMemoryType, NatsStorageType, NatsStreamConfig, NatsStreamInfo, NatsStreamManager, NatsStreamConfigType, NatsStreamInfoType, NatsStreamOptions, NatsStreamState, NatsTransaction, } from './nats';
-export { RedisClass, RedisRedisClientType, RedisRedisClientOptions, RedisRedisClassType, IORedisClientType, RedisClient, RedisMulti, RedisRedisMultiType, IORedisClientOptions, IORedisClassType, IORedisMultiType, RedisOptions, isRedisClient, isIORedisClient, } from './redis';
 export { JSONSchema, StringAnyType, StringScalarType, StringStringType, SymbolMap, SymbolMaps, SymbolRanges, Symbols, SymbolSets, } from './serializer';
 export { AggregatedData, CountByFacet, GetStatsOptions, IdsData, Measure, MeasureIds, MetricTypes, StatType, StatsType, IdsResponse, JobStats, JobStatsInput, JobStatsRange, StatsResponse, Segment, TimeSegment, } from './stats';
 export { ReclaimedMessageType, RouterConfig, StreamCode, StreamConfig, StreamData, StreamDataType, StreamError, StreamDataResponse, StreamMessage, StreamMessageMetadata, StreamProviderType, StreamRetryPolicy, StreamRole, StreamStats, StreamStatus, } from './stream';

package/build/types/index.js

@@ -1,15 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValueType = exports.trace = exports.SpanKind = exports.SpanStatusCode = exports.propagation = exports.metrics = exports.context = exports.StreamStatus = exports.StreamRole = exports.StreamDataType = exports.isIORedisClient = exports.isRedisClient = exports.KeyType = exports.HookGate = exports.CollationFaultType = void 0;
+exports.ValueType = exports.trace = exports.SpanKind = exports.SpanStatusCode = exports.propagation = exports.metrics = exports.context = exports.StreamStatus = exports.StreamRole = exports.StreamDataType = exports.KeyType = exports.HookGate = exports.CollationFaultType = void 0;
 var collator_1 = require("./collator");
 Object.defineProperty(exports, "CollationFaultType", { enumerable: true, get: function () { return collator_1.CollationFaultType; } });
 var hook_1 = require("./hook");
 Object.defineProperty(exports, "HookGate", { enumerable: true, get: function () { return hook_1.HookGate; } });
 var hotmesh_1 = require("./hotmesh");
 Object.defineProperty(exports, "KeyType", { enumerable: true, get: function () { return hotmesh_1.KeyType; } });
-var redis_1 = require("./redis");
-Object.defineProperty(exports, "isRedisClient", { enumerable: true, get: function () { return redis_1.isRedisClient; } });
-Object.defineProperty(exports, "isIORedisClient", { enumerable: true, get: function () { return redis_1.isIORedisClient; } });
 var stream_1 = require("./stream");
 Object.defineProperty(exports, "StreamDataType", { enumerable: true, get: function () { return stream_1.StreamDataType; } });
 Object.defineProperty(exports, "StreamRole", { enumerable: true, get: function () { return stream_1.StreamRole; } });

package/build/types/job.d.ts

@@ -140,7 +140,7 @@ type JobInterruptOptions = {
      */
     suppress?: boolean;
     /**
-     * how long to wait in seconds before fully expiring/removing the hash from Redis;
+     * how long to wait in seconds before fully softdeleting the job;
      * the job is inactive, but can remain in the cache indefinitely;
      * @default 1 second.
      */

package/build/types/memflow.d.ts

@@ -91,7 +91,7 @@ type WorkflowContext = {
      */
     raw: StreamData;
     /**
-     * the HotMesh connection configuration (io/redis NPM package reference and login credentials)
+     * the HotMesh connection configuration
      */
     connection: Connection;
     /**
@@ -100,7 +100,8 @@ type WorkflowContext = {
     expire?: number;
 };
 /**
- * The schema for the full-text-search (RediSearch) index.
+ * The schema for the full-text-search
+ * @deprecated
  */
 export type WorkflowSearchSchema = Record<string, {
     /**
@@ -252,7 +253,7 @@ type WorkflowOptions = {
      */
     workflowSpan?: string;
     /**
-     * the full-text-search (RediSearch) options for the workflow
+     * the full-text-search
      */
     search?: WorkflowSearchOptions;
     /**
@@ -414,7 +415,7 @@ type FindWhereOptions = {
     };
 };
 type FindJobsOptions = {
-    /** The workflow name; include an asterisk for wilcard search; refer to Redis SCAN for the allowed format */
+    /** The workflow name; include an asterisk for wilcard search */
     match?: string;
     /**
      * application namespace

package/build/types/meshcall.d.ts

@@ -31,11 +31,6 @@ interface MeshCallConnectParams {
      * Unique topic for the worker function
      */
     topic: string;
-    /**
-     * Redis configuration; use 'connection' instead of 'redis'
-     * @deprecated
-     */
-    redis?: ProviderConfig;
     /**
      * Provider configuration
      */
@@ -58,11 +53,6 @@ interface MeshCallExecParams {
      * Arguments to pass to the worker function
      */
     args: any[];
-    /**
-     * Redis configuration; use 'connection' instead of 'redis'
-     * @deprecated
-     */
-    redis?: ProviderConfig;
     /**
      * Provider configuration
      */
@@ -91,11 +81,6 @@ interface MeshCallFlushParams {
      * topic assigned to the worker when it was connected
      */
     topic: string;
-    /**
-     * Redis configuration; use 'connection' instead of 'redis'
-     * @deprecated
-     */
-    redis?: ProviderConfig;
     /**
      * Provider configuration
      */
@@ -151,11 +136,6 @@ interface MeshCallCronParams {
      * Unique topic for the cron function to identify the worker
      */
     topic: string;
-    /**
-     * Redis configuration; use 'connection' instead of 'redis'
-     * @deprecated
-     */
-    redis?: ProviderConfig;
     /**
      * Provider configuration
      */
@@ -198,11 +178,6 @@ interface MeshCallInterruptParams {
      * topic assigned to the cron worker when it was connected
      */
     topic: string;
-    /**
-     * Redis configuration; use 'connection' instead of 'redis'
-     * @deprecated
-     */
-    redis?: ProviderConfig;
     /**
      * Provider configuration
      */

package/build/types/provider.d.ts

@@ -12,7 +12,7 @@ export interface ProviderClass {
 export interface ProviderOptions {
     [key: string]: any;
 }
-export type Providers = 'redis' | 'nats' | 'postgres' | 'ioredis';
+export type Providers = 'nats' | 'postgres';
 /**
  * A provider transaction is a set of operations that are executed
  * atomically by the provider. The transaction is created by calling