@hotmeshio/hotmesh 0.5.0 → 0.5.2

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

@@ -2,7 +2,7 @@ import { KeyStoreParams } from '../../../../types/hotmesh';
 import { PostgresClientType } from '../../../../types/postgres';
 import { ProviderTransaction } from '../../../../types/provider';
 import { stringModule } from './kvtypes/string';
-import { hashModule } from './kvtypes/hash';
+import { hashModule } from './kvtypes/hash/index';
 import { listModule } from './kvtypes/list';
 import { zsetModule } from './kvtypes/zset';
 /**
@@ -30,8 +30,8 @@ export declare class KVSQL {
      */
     tableForKey(key: string, stats_type?: 'hash' | 'sorted_set' | 'list'): string;
     safeName(input: string, prefix?: string): string;
-    set: (key: string, value: string, options?: import("../../../../types/provider").SetOptions, multi?: ProviderTransaction) => Promise<boolean>;
-    _set: (key: string, value: string, options?: import("../../../../types/provider").SetOptions) => {
+    set: (key: string, value: string, options?: import("./kvtypes/hash/index").SetOptions, multi?: ProviderTransaction) => Promise<boolean>;
+    _set: (key: string, value: string, options?: import("./kvtypes/hash/index").SetOptions) => {
         sql: string;
         params: any[];
     };
@@ -47,51 +47,27 @@ export declare class KVSQL {
     };
     setnx: (key: string, value: string, multi?: ProviderTransaction) => Promise<boolean>;
     setnxex: (key: string, value: string, delay: number, multi?: ProviderTransaction) => Promise<boolean>;
-    hset: (key: string, fields: Record<string, string>, options?: import("../../../../types/provider").HSetOptions, multi?: ProviderTransaction) => Promise<any>;
-    _hset: (key: string, fields: Record<string, string>, options?: import("../../../../types/provider").HSetOptions) => {
-        sql: string;
-        params: any[];
-    };
+    hset: (key: string, fields: Record<string, string>, options?: import("./kvtypes/hash/index").HSetOptions, multi?: any) => Promise<any>;
+    _hset: (key: string, fields: Record<string, string>, options?: import("./kvtypes/hash/index").HSetOptions) => import("./kvtypes/hash/types").SqlResult;
     hsetnx: (key: string, field: string, value: string, multi?: ProviderTransaction, entity?: string) => Promise<number>;
     hget: (key: string, field: string, multi?: ProviderTransaction) => Promise<string>;
-    _hget: (key: string, field: string) => {
-        sql: string;
-        params: any[];
-    };
+    _hget: (key: string, field: string) => import("./kvtypes/hash/types").SqlResult;
     hdel: (key: string, fields: string[], multi?: unknown) => Promise<number>;
-    _hdel: (key: string, fields: string[]) => {
-        sql: string;
-        params: any[];
-    };
+    _hdel: (key: string, fields: string[]) => import("./kvtypes/hash/types").SqlResult;
     hmget: (key: string, fields: string[], multi?: ProviderTransaction) => Promise<string[]>;
-    _hmget: (key: string, fields: string[]) => {
-        sql: string;
-        params: any[];
-    };
+    _hmget: (key: string, fields: string[]) => import("./kvtypes/hash/types").SqlResult;
     hgetall: (key: string, multi?: ProviderTransaction) => Promise<Record<string, string>>;
     hincrbyfloat: (key: string, field: string, increment: number, multi?: ProviderTransaction) => Promise<number>;
-    _hincrbyfloat: (key: string, field: string, increment: number) => {
-        sql: string;
-        params: any[];
-    };
-    hscan: (key: string, cursor: string, count?: number, pattern?: string, multi?: ProviderTransaction) => Promise<import("../../../../types/provider").HScanResult>;
-    _hscan: (key: string, cursor: string, count: number, pattern?: string) => {
-        sql: string;
-        params: any[];
-    };
+    _hincrbyfloat: (key: string, field: string, increment: number) => import("./kvtypes/hash/types").SqlResult;
+    hscan: (key: string, cursor: string, count?: number, pattern?: string, multi?: ProviderTransaction) => Promise<import("./kvtypes/hash/index").HScanResult>;
+    _hscan: (key: string, cursor: string, count: number, pattern?: string) => import("./kvtypes/hash/types").SqlResult;
     expire: (key: string, seconds: number, multi?: ProviderTransaction) => Promise<boolean>;
-    _expire: (key: string, seconds: number) => {
-        sql: string;
-        params: any[];
-    };
+    _expire: (key: string, seconds: number) => import("./kvtypes/hash/types").SqlResult;
     scan: (cursor: number, count?: number, pattern?: string, multi?: ProviderTransaction) => Promise<{
         cursor: number;
         keys: string[];
     }>;
-    _scan: (cursor: number, count: number, pattern?: string) => {
-        sql: string;
-        params: any[];
-    };
+    _scan: (cursor: number, count: number, pattern?: string) => import("./kvtypes/hash/types").SqlResult;
     lrange: (key: string, start: number, end: number, multi?: ProviderTransaction) => Promise<string[]>;
     _lrange: (key: string, start: number, end: number) => {
         sql: string;

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

@@ -4,7 +4,7 @@ exports.KVSQL = void 0;
 const key_1 = require("../../../../modules/key");
 const kvtransaction_1 = require("./kvtransaction");
 const string_1 = require("./kvtypes/string");
-const hash_1 = require("./kvtypes/hash");
+const index_1 = require("./kvtypes/hash/index");
 const list_1 = require("./kvtypes/list");
 const zset_1 = require("./kvtypes/zset");
 /**
@@ -72,7 +72,7 @@ class KVSQL {
         this.pgClient = pgClient;
         this.namespace = namespace;
         this.appId = appId;
-        this.hash = (0, hash_1.hashModule)(this);
+        this.hash = (0, index_1.hashModule)(this);
         this.list = (0, list_1.listModule)(this);
         this.zset = (0, zset_1.zsetModule)(this);
         this.string = (0, string_1.stringModule)(this);

package/build/services/store/providers/postgres/kvtypes/hash/basic.d.ts

@@ -0,0 +1,16 @@
+import { HashContext, SqlResult, HSetOptions, ProviderTransaction } from './types';
+export declare function createBasicOperations(context: HashContext['context']): {
+    hsetnx(key: string, field: string, value: string, multi?: ProviderTransaction, entity?: string): Promise<number>;
+    hset(key: string, fields: Record<string, string>, options?: HSetOptions, multi?: ProviderTransaction): Promise<number | any>;
+    hget(key: string, field: string, multi?: ProviderTransaction): Promise<string | null>;
+    hdel(key: string, fields: string[], multi?: unknown): Promise<number>;
+    hmget(key: string, fields: string[], multi?: ProviderTransaction): Promise<(string | null)[]>;
+    hgetall(key: string, multi?: ProviderTransaction): Promise<Record<string, string>>;
+    hincrbyfloat(key: string, field: string, increment: number, multi?: ProviderTransaction): Promise<number>;
+};
+export declare function _hset(context: HashContext['context'], key: string, fields: Record<string, string>, options?: HSetOptions): SqlResult;
+export declare function _hget(context: HashContext['context'], key: string, field: string): SqlResult;
+export declare function _hdel(context: HashContext['context'], key: string, fields: string[]): SqlResult;
+export declare function _hmget(context: HashContext['context'], key: string, fields: string[]): SqlResult;
+export declare function _hgetall(context: HashContext['context'], key: string): SqlResult;
+export declare function _hincrbyfloat(context: HashContext['context'], key: string, field: string, increment: number): SqlResult;

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

@@ -0,0 +1,480 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._hincrbyfloat = exports._hgetall = exports._hmget = exports._hdel = exports._hget = exports._hset = exports.createBasicOperations = void 0;
+const utils_1 = require("./utils");
+function createBasicOperations(context) {
+    return {
+        async hsetnx(key, field, value, multi, entity) {
+            const { sql, params } = _hset(context, key, { [field]: value }, { nx: true, entity });
+            if (multi) {
+                multi.addCommand(sql, params, 'number');
+                return Promise.resolve(0);
+            }
+            else {
+                try {
+                    const res = await context.pgClient.query(sql, params);
+                    return res.rowCount;
+                }
+                catch (err) {
+                    console.error('hsetnx error', err, sql, params);
+                    return 0;
+                }
+            }
+        },
+        async hset(key, fields, options, multi) {
+            const { sql, params } = _hset(context, key, fields, options);
+            if (multi) {
+                multi.addCommand(sql, params, 'number');
+                return Promise.resolve(0);
+            }
+            else {
+                try {
+                    const res = await context.pgClient.query(sql, params);
+                    // Check if this is a JSONB operation that returns a value
+                    const isJsonbOperation = Object.keys(fields).some(k => k.startsWith('@context:') && k !== '@context');
+                    if (isJsonbOperation && res.rows[0]?.new_value !== undefined) {
+                        let returnValue;
+                        try {
+                            // Try to parse as JSON, fallback to string if it fails
+                            returnValue = JSON.parse(res.rows[0].new_value);
+                        }
+                        catch {
+                            returnValue = res.rows[0].new_value;
+                        }
+                        return returnValue;
+                    }
+                    return res.rowCount;
+                }
+                catch (err) {
+                    console.error('hset error', err, sql, params);
+                    return 0;
+                }
+            }
+        },
+        async hget(key, field, multi) {
+            const { sql, params } = _hget(context, key, field);
+            if (multi) {
+                multi.addCommand(sql, params, 'string', (rows) => {
+                    return rows[0]?.value || null;
+                });
+                return Promise.resolve(null);
+            }
+            else {
+                const res = await context.pgClient.query(sql, params);
+                return res.rows[0]?.value || null;
+            }
+        },
+        async hdel(key, fields, multi) {
+            // Ensure fields is an array
+            if (!Array.isArray(fields)) {
+                fields = [fields];
+            }
+            const { sql, params } = _hdel(context, key, fields);
+            if (multi) {
+                multi.addCommand(sql, params, 'number');
+                return Promise.resolve(0);
+            }
+            else {
+                const res = await context.pgClient.query(sql, params);
+                return Number(res.rows[0]?.count || 0);
+            }
+        },
+        async hmget(key, fields, multi) {
+            const { sql, params } = _hmget(context, key, fields);
+            const processRows = (rows) => {
+                const tableName = context.tableForKey(key, 'hash');
+                const isJobsTableResult = (0, utils_1.isJobsTable)(tableName);
+                if (isJobsTableResult) {
+                    return (0, utils_1.processJobsRows)(rows, fields);
+                }
+                else {
+                    const fieldValueMap = new Map();
+                    for (const row of rows) {
+                        fieldValueMap.set(row.field, row.value);
+                    }
+                    return fields.map((field) => fieldValueMap.get(field) || null);
+                }
+            };
+            if (multi) {
+                multi.addCommand(sql, params, 'array', (rows) => {
+                    return processRows(rows);
+                });
+                return Promise.resolve([]);
+            }
+            else {
+                try {
+                    const res = await context.pgClient.query(sql, params);
+                    return processRows(res.rows);
+                }
+                catch (err) {
+                    console.error('hmget error', err, sql, params);
+                    throw err;
+                }
+            }
+        },
+        async hgetall(key, multi) {
+            const tableName = context.tableForKey(key, 'hash');
+            const isJobsTableResult = (0, utils_1.isJobsTable)(tableName);
+            const { sql, params } = _hgetall(context, key);
+            const processRows = (rows) => {
+                if (isJobsTableResult) {
+                    return (0, utils_1.processJobsRows)(rows);
+                }
+                else {
+                    return (0, utils_1.processRegularRows)(rows);
+                }
+            };
+            if (multi) {
+                multi.addCommand(sql, params, 'object', (rows) => {
+                    return processRows(rows);
+                });
+                return Promise.resolve({});
+            }
+            else {
+                try {
+                    const res = await context.pgClient.query(sql, params);
+                    return processRows(res.rows);
+                }
+                catch (err) {
+                    console.error('hgetall error', err, sql, params);
+                    throw err;
+                }
+            }
+        },
+        async hincrbyfloat(key, field, increment, multi) {
+            const { sql, params } = _hincrbyfloat(context, key, field, increment);
+            if (multi) {
+                multi.addCommand(sql, params, 'number', (rows) => {
+                    return parseFloat(rows[0].value);
+                });
+                return Promise.resolve(0);
+            }
+            else {
+                const res = await context.pgClient.query(sql, params);
+                return parseFloat(res.rows[0].value);
+            }
+        },
+    };
+}
+exports.createBasicOperations = createBasicOperations;
+// Internal helper functions
+function _hset(context, key, fields, options) {
+    const tableName = context.tableForKey(key, 'hash');
+    const isJobsTableResult = (0, utils_1.isJobsTable)(tableName);
+    const fieldEntries = Object.entries(fields);
+    const isStatusOnly = fieldEntries.length === 1 && fieldEntries[0][0] === ':';
+    let targetTable = tableName; // Default table name
+    if (isJobsTableResult) {
+        if (isStatusOnly) {
+            // Target the jobs table directly when setting only the status field
+            targetTable = tableName;
+        }
+        else {
+            // For other fields, target the attributes table
+            targetTable = `${tableName}_attributes`;
+        }
+    }
+    const params = [];
+    let sql = '';
+    if (isJobsTableResult && isStatusOnly) {
+        if (options?.nx) {
+            // Use WHERE NOT EXISTS to enforce nx
+            sql = `
+        INSERT INTO ${targetTable} (id, key, status, entity)
+        SELECT gen_random_uuid(), $1, $2, $3
+        WHERE NOT EXISTS (
+          SELECT 1 FROM ${targetTable}
+          WHERE key = $1 AND is_live
+        )
+        RETURNING 1 as count
+      `;
+            params.push(key, fields[':'], options?.entity ?? null);
+        }
+        else {
+            // Update existing job or insert new one
+            sql = `
+        INSERT INTO ${targetTable} (id, key, status, entity)
+        VALUES (gen_random_uuid(), $1, $2, $3)
+        ON CONFLICT (key) WHERE is_live DO UPDATE SET status = EXCLUDED.status
+        RETURNING 1 as count
+      `;
+            params.push(key, fields[':'], options?.entity ?? null);
+        }
+    }
+    else if (isJobsTableResult) {
+        const schemaName = context.safeName(context.appId);
+        const conflictAction = options?.nx
+            ? 'ON CONFLICT DO NOTHING'
+            : `ON CONFLICT (job_id, field) DO UPDATE SET value = EXCLUDED.value`;
+        const placeholders = fieldEntries
+            .map(([field, value], index) => {
+            const baseIndex = index * 3 + 2; // Adjusted baseIndex
+            params.push(field, value, (0, utils_1.deriveType)(field));
+            return `($${baseIndex}, $${baseIndex + 1}, $${baseIndex + 2}::${schemaName}.type_enum)`;
+        })
+            .join(', ');
+        sql = `
+      INSERT INTO ${targetTable} (job_id, field, value, type)
+      SELECT 
+        job.id,
+        vals.field,
+        vals.value,
+        vals.type
+      FROM (
+        SELECT id FROM ${tableName} WHERE key = $1 AND is_live
+      ) AS job
+      CROSS JOIN (
+        VALUES ${placeholders}
+      ) AS vals(field, value, type)
+      ${conflictAction}
+      RETURNING 1 as count
+    `;
+        params.unshift(key); // Add key as first parameter
+    }
+    else {
+        // For non-jobs tables
+        const conflictAction = options?.nx
+            ? 'ON CONFLICT DO NOTHING'
+            : `ON CONFLICT (key, field) DO UPDATE SET value = EXCLUDED.value`;
+        const placeholders = fieldEntries
+            .map(([field, value], index) => {
+            params.push(field, value);
+            return `($1, $${index * 2 + 2}, $${index * 2 + 3})`;
+        })
+            .join(', ');
+        sql = `
+      INSERT INTO ${targetTable} (key, field, value)
+      VALUES ${placeholders}
+      ${conflictAction}
+      RETURNING 1 as count
+    `;
+        params.unshift(key); // Add key as the first parameter
+    }
+    return { sql, params };
+}
+exports._hset = _hset;
+function _hget(context, key, field) {
+    const tableName = context.tableForKey(key, 'hash');
+    const isJobsTableResult = (0, utils_1.isJobsTable)(tableName);
+    const isStatusField = field === ':';
+    const isContextField = field === '@';
+    if (isJobsTableResult && isStatusField) {
+        // Fetch status from jobs table
+        const sql = `
+      SELECT status::text AS value
+      FROM ${tableName}
+      WHERE key = $1 AND is_live
+    `;
+        return { sql, params: [key] };
+    }
+    else if (isJobsTableResult && isContextField) {
+        // Fetch context from jobs table
+        const sql = `
+      SELECT context::text AS value
+      FROM ${tableName}
+      WHERE key = $1 AND is_live
+    `;
+        return { sql, params: [key] };
+    }
+    else if (isJobsTableResult) {
+        // Fetch a specific field from the attributes table for a job
+        const sql = `
+      SELECT value
+      FROM ${tableName}_attributes
+      WHERE job_id = (
+        SELECT id FROM ${tableName}
+        WHERE key = $1 AND is_live
+      )
+        AND field = $2
+    `;
+        return { sql, params: [key, field] };
+    }
+    else {
+        // Non-jobs tables
+        const baseQuery = `
+      SELECT value
+      FROM ${tableName}
+      WHERE key = $1 AND field = $2
+    `;
+        const sql = context.appendExpiryClause(baseQuery, tableName);
+        return { sql, params: [key, field] };
+    }
+}
+exports._hget = _hget;
+function _hdel(context, key, fields) {
+    const tableName = context.tableForKey(key, 'hash');
+    const isJobsTableResult = (0, utils_1.isJobsTable)(tableName);
+    const targetTable = isJobsTableResult ? `${tableName}_attributes` : tableName;
+    const fieldPlaceholders = fields.map((_, i) => `$${i + 2}`).join(', ');
+    const params = [key, ...fields];
+    if (isJobsTableResult) {
+        const sql = `
+      WITH valid_job AS (
+        SELECT id
+        FROM ${tableName}
+        WHERE key = $1 AND is_live
+      ),
+      deleted AS (
+        DELETE FROM ${targetTable}
+        WHERE job_id IN (SELECT id FROM valid_job) AND field IN (${fieldPlaceholders})
+        RETURNING 1
+      )
+      SELECT COUNT(*) as count FROM deleted
+    `;
+        return { sql, params };
+    }
+    else {
+        const sql = `
+      WITH deleted AS (
+        DELETE FROM ${targetTable}
+        WHERE key = $1 AND field IN (${fieldPlaceholders})
+        RETURNING 1
+      )
+      SELECT COUNT(*) as count FROM deleted
+    `;
+        return { sql, params };
+    }
+}
+exports._hdel = _hdel;
+function _hmget(context, key, fields) {
+    const tableName = context.tableForKey(key, 'hash');
+    const isJobsTableResult = (0, utils_1.isJobsTable)(tableName);
+    if (isJobsTableResult) {
+        const sql = `
+      WITH valid_job AS (
+        SELECT id, status, context
+        FROM ${tableName}
+        WHERE key = $1 
+        AND (expired_at IS NULL OR expired_at > NOW())
+        LIMIT 1
+      ),
+      job_fields AS (
+        -- Include both status and context fields from jobs table
+        SELECT 
+          'status' AS field,
+          status::text AS value
+        FROM valid_job
+        
+        UNION ALL
+        
+        SELECT 
+          'context' AS field,
+          context::text AS value
+        FROM valid_job
+        
+        UNION ALL
+        
+        -- Get attribute fields with proper type handling
+        SELECT 
+          a.field,
+          a.value
+        FROM ${tableName}_attributes a
+        JOIN valid_job j ON j.id = a.job_id
+        WHERE a.field = ANY($2::text[])
+      )
+      SELECT field, value
+      FROM job_fields
+      ORDER BY field
+    `;
+        return { sql, params: [key, fields] };
+    }
+    else {
+        // Non-job tables logic remains the same
+        const baseQuery = `
+      SELECT field, value
+      FROM ${tableName}
+      WHERE key = $1
+        AND field = ANY($2::text[])
+    `;
+        const sql = context.appendExpiryClause(baseQuery, tableName);
+        return { sql, params: [key, fields] };
+    }
+}
+exports._hmget = _hmget;
+function _hgetall(context, key) {
+    const tableName = context.tableForKey(key, 'hash');
+    const isJobsTableResult = (0, utils_1.isJobsTable)(tableName);
+    if (isJobsTableResult) {
+        const sql = `
+      WITH valid_job AS (
+        SELECT id, status, context
+        FROM ${tableName}
+        WHERE key = $1 AND is_live
+      ),
+      job_data AS (
+        SELECT 'status' AS field, status::text AS value
+        FROM ${tableName}
+        WHERE key = $1 AND is_live
+        
+        UNION ALL
+        
+        SELECT 'context' AS field, context::text AS value
+        FROM ${tableName}
+        WHERE key = $1 AND is_live
+      ),
+      attribute_data AS (
+        SELECT field, value
+        FROM ${tableName}_attributes
+        WHERE job_id IN (SELECT id FROM valid_job)
+      )
+      SELECT * FROM job_data
+      UNION ALL
+      SELECT * FROM attribute_data;
+    `;
+        return { sql, params: [key] };
+    }
+    else {
+        // Non-job tables
+        const sql = context.appendExpiryClause(`
+        SELECT field, value
+        FROM ${tableName}
+        WHERE key = $1
+      `, tableName);
+        return { sql, params: [key] };
+    }
+}
+exports._hgetall = _hgetall;
+function _hincrbyfloat(context, key, field, increment) {
+    const tableName = context.tableForKey(key, 'hash');
+    const isJobsTableResult = (0, utils_1.isJobsTable)(tableName);
+    const isStatusField = field === ':';
+    if (isJobsTableResult && isStatusField) {
+        const sql = `
+      UPDATE ${tableName}
+      SET status = status + $2
+      WHERE key = $1 AND is_live
+      RETURNING status::text AS value
+    `;
+        return { sql, params: [key, increment] };
+    }
+    else if (isJobsTableResult) {
+        // Update the condition here
+        const 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::double precision)::text, $4
+      FROM valid_job
+      ON CONFLICT (job_id, field) DO UPDATE
+      SET
+        value = ((COALESCE(${tableName}_attributes.value, '0')::double precision) + $3::double precision)::text,
+        type = EXCLUDED.type
+      RETURNING value;
+    `;
+        return { sql, params: [key, field, increment, (0, utils_1.deriveType)(field)] };
+    }
+    else {
+        const sql = `
+      INSERT INTO ${tableName} (key, field, value)
+      VALUES ($1, $2, ($3)::text)
+      ON CONFLICT (key, field) DO UPDATE
+      SET value = ((COALESCE(${tableName}.value, '0')::double precision + $3::double precision)::text)
+      RETURNING value
+    `;
+        return { sql, params: [key, field, increment] };
+    }
+}
+exports._hincrbyfloat = _hincrbyfloat;

package/build/services/store/providers/postgres/kvtypes/hash/expire.d.ts

@@ -0,0 +1,5 @@
+import { HashContext, SqlResult, ProviderTransaction } from './types';
+export declare function createExpireOperations(context: HashContext['context']): {
+    expire(key: string, seconds: number, multi?: ProviderTransaction): Promise<boolean>;
+};
+export declare function _expire(context: HashContext['context'], key: string, seconds: number): SqlResult;

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._expire = exports.createExpireOperations = void 0;
+function createExpireOperations(context) {
+    return {
+        async expire(key, seconds, multi) {
+            const { sql, params } = _expire(context, key, seconds);
+            if (multi) {
+                multi.addCommand(sql, params, 'boolean');
+                return Promise.resolve(true);
+            }
+            else {
+                const res = await context.pgClient.query(sql, params);
+                return res.rowCount > 0;
+            }
+        },
+    };
+}
+exports.createExpireOperations = createExpireOperations;
+function _expire(context, key, seconds) {
+    // Only job tables are ever expired
+    const tableName = context.tableForKey(key);
+    const expiryTime = new Date(Date.now() + seconds * 1000);
+    const sql = `
+    UPDATE ${tableName}
+    SET expired_at = $2
+    WHERE key = $1 AND is_live
+    RETURNING true as success
+  `;
+    const params = [key, expiryTime];
+    return { sql, params };
+}
+exports._expire = _expire;

package/build/services/store/providers/postgres/kvtypes/hash/index.d.ts

@@ -0,0 +1,29 @@
+import { KVSQL } from '../../kvsql';
+import { HSetOptions } from './types';
+import { isJobsTable } from './utils';
+export declare const hashModule: (context: KVSQL) => {
+    hset(key: string, fields: Record<string, string>, options?: HSetOptions, multi?: any): Promise<number | any>;
+    _hset: (key: string, fields: Record<string, string>, options?: HSetOptions) => import("./types").SqlResult;
+    _hget: (key: string, field: string) => import("./types").SqlResult;
+    _hdel: (key: string, fields: string[]) => import("./types").SqlResult;
+    _hmget: (key: string, fields: string[]) => import("./types").SqlResult;
+    _hincrbyfloat: (key: string, field: string, increment: number) => import("./types").SqlResult;
+    _hscan: (key: string, cursor: string, count: number, pattern?: string) => import("./types").SqlResult;
+    _expire: (key: string, seconds: number) => import("./types").SqlResult;
+    _scan: (cursor: number, count: number, pattern?: string) => import("./types").SqlResult;
+    isJobsTable: typeof isJobsTable;
+    expire(key: string, seconds: number, multi?: import("./types").ProviderTransaction): Promise<boolean>;
+    hscan(key: string, cursor: string, count?: number, pattern?: string, multi?: import("./types").ProviderTransaction): Promise<import("./types").HScanResult>;
+    scan(cursor: number, count?: number, pattern?: string, multi?: import("./types").ProviderTransaction): Promise<{
+        cursor: number;
+        keys: string[];
+    }>;
+    hsetnx(key: string, field: string, value: string, multi?: import("./types").ProviderTransaction, entity?: string): Promise<number>;
+    hget(key: string, field: string, multi?: import("./types").ProviderTransaction): Promise<string>;
+    hdel(key: string, fields: string[], multi?: unknown): Promise<number>;
+    hmget(key: string, fields: string[], multi?: import("./types").ProviderTransaction): Promise<string[]>;
+    hgetall(key: string, multi?: import("./types").ProviderTransaction): Promise<Record<string, string>>;
+    hincrbyfloat(key: string, field: string, increment: number, multi?: import("./types").ProviderTransaction): Promise<number>;
+};
+export { isJobsTable, deriveType } from './utils';
+export * from './types';