@hotmeshio/hotmesh 0.5.1 → 0.5.2

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

@@ -0,0 +1,190 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveType = exports.isJobsTable = exports.hashModule = void 0;
+const basic_1 = require("./basic");
+const jsonb_1 = require("./jsonb");
+const scan_1 = require("./scan");
+const expire_1 = require("./expire");
+const utils_1 = require("./utils");
+const hashModule = (context) => {
+    const basicOps = (0, basic_1.createBasicOperations)(context);
+    const jsonbOps = (0, jsonb_1.createJsonbOperations)(context);
+    const scanOps = (0, scan_1.createScanOperations)(context);
+    const expireOps = (0, expire_1.createExpireOperations)(context);
+    return {
+        // Basic operations
+        ...basicOps,
+        // Scan operations
+        ...scanOps,
+        // Expire operations
+        ...expireOps,
+        // Enhanced hset that handles JSONB operations
+        async hset(key, fields, options, multi) {
+            const tableName = context.tableForKey(key, 'hash');
+            const isJobsTableResult = (0, utils_1.isJobsTable)(tableName);
+            // Handle JSONB operations for jobs tables
+            if (isJobsTableResult) {
+                // Check for various JSONB operations
+                if ('@context' in fields) {
+                    const { sql, params } = jsonbOps.handleContextSet(key, fields, options);
+                    return executeJsonbOperation(sql, params, multi);
+                }
+                else if ('@context:merge' in fields) {
+                    const { sql, params } = jsonbOps.handleContextMerge(key, fields, options);
+                    return executeJsonbOperation(sql, params, multi);
+                }
+                else if ('@context:delete' in fields) {
+                    const { sql, params } = jsonbOps.handleContextDelete(key, fields, options);
+                    return executeJsonbOperation(sql, params, multi);
+                }
+                else if ('@context:append' in fields) {
+                    const { sql, params } = jsonbOps.handleContextAppend(key, fields, options);
+                    return executeJsonbOperation(sql, params, multi);
+                }
+                else if ('@context:prepend' in fields) {
+                    const { sql, params } = jsonbOps.handleContextPrepend(key, fields, options);
+                    return executeJsonbOperation(sql, params, multi);
+                }
+                else if ('@context:remove' in fields) {
+                    const { sql, params } = jsonbOps.handleContextRemove(key, fields, options);
+                    return executeJsonbOperation(sql, params, multi);
+                }
+                else if ('@context:increment' in fields) {
+                    const { sql, params } = jsonbOps.handleContextIncrement(key, fields, options);
+                    return executeJsonbOperation(sql, params, multi);
+                }
+                else if ('@context:toggle' in fields) {
+                    const { sql, params } = jsonbOps.handleContextToggle(key, fields, options);
+                    return executeJsonbOperation(sql, params, multi);
+                }
+                else if ('@context:setIfNotExists' in fields) {
+                    const { sql, params } = jsonbOps.handleContextSetIfNotExists(key, fields, options);
+                    return executeJsonbOperation(sql, params, multi);
+                }
+                else if (Object.keys(fields).some(k => k.startsWith('@context:get:'))) {
+                    const { sql, params } = jsonbOps.handleContextGetPath(key, fields, options);
+                    return executeJsonbOperation(sql, params, multi);
+                }
+                else if ('@context:get' in fields) {
+                    const { sql, params } = jsonbOps.handleContextGet(key, fields, options);
+                    return executeJsonbOperation(sql, params, multi);
+                }
+            }
+            // Fall back to basic hset for all other cases
+            return basicOps.hset(key, fields, options, multi);
+        },
+        // Private methods for internal use by kvsql
+        _hset: (key, fields, options) => {
+            const tableName = context.tableForKey(key, 'hash');
+            const isJobsTableResult = (0, utils_1.isJobsTable)(tableName);
+            // Handle JSONB operations for jobs tables
+            if (isJobsTableResult) {
+                if ('@context' in fields) {
+                    return jsonbOps.handleContextSet(key, fields, options);
+                }
+                else if ('@context:merge' in fields) {
+                    return jsonbOps.handleContextMerge(key, fields, options);
+                }
+                else if ('@context:delete' in fields) {
+                    return jsonbOps.handleContextDelete(key, fields, options);
+                }
+                else if ('@context:append' in fields) {
+                    return jsonbOps.handleContextAppend(key, fields, options);
+                }
+                else if ('@context:prepend' in fields) {
+                    return jsonbOps.handleContextPrepend(key, fields, options);
+                }
+                else if ('@context:remove' in fields) {
+                    return jsonbOps.handleContextRemove(key, fields, options);
+                }
+                else if ('@context:increment' in fields) {
+                    return jsonbOps.handleContextIncrement(key, fields, options);
+                }
+                else if ('@context:toggle' in fields) {
+                    return jsonbOps.handleContextToggle(key, fields, options);
+                }
+                else if ('@context:setIfNotExists' in fields) {
+                    return jsonbOps.handleContextSetIfNotExists(key, fields, options);
+                }
+                else if (Object.keys(fields).some(k => k.startsWith('@context:get:'))) {
+                    return jsonbOps.handleContextGetPath(key, fields, options);
+                }
+                else if ('@context:get' in fields) {
+                    return jsonbOps.handleContextGet(key, fields, options);
+                }
+            }
+            // Use the imported _hset function
+            return (0, basic_1._hset)(context, key, fields, options);
+        },
+        _hget: (key, field) => {
+            return (0, basic_1._hget)(context, key, field);
+        },
+        _hdel: (key, fields) => {
+            return (0, basic_1._hdel)(context, key, fields);
+        },
+        _hmget: (key, fields) => {
+            return (0, basic_1._hmget)(context, key, fields);
+        },
+        _hincrbyfloat: (key, field, increment) => {
+            return (0, basic_1._hincrbyfloat)(context, key, field, increment);
+        },
+        _hscan: (key, cursor, count, pattern) => {
+            return (0, scan_1._hscan)(context, key, cursor, count, pattern);
+        },
+        _expire: (key, seconds) => {
+            return (0, expire_1._expire)(context, key, seconds);
+        },
+        _scan: (cursor, count, pattern) => {
+            return (0, scan_1._scan)(context, cursor, count, pattern);
+        },
+        // Utility functions
+        isJobsTable: utils_1.isJobsTable,
+    };
+    async function executeJsonbOperation(sql, params, multi) {
+        if (multi) {
+            multi.addCommand(sql, params, 'any');
+            return Promise.resolve(0);
+        }
+        else {
+            try {
+                const res = await context.pgClient.query(sql, params);
+                if (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 || res.rows[0]?.count || 0;
+            }
+            catch (err) {
+                console.error('JSONB operation error', err, sql, params);
+                return 0;
+            }
+        }
+    }
+};
+exports.hashModule = hashModule;
+// Export utility functions for other modules to use
+var utils_2 = require("./utils");
+Object.defineProperty(exports, "isJobsTable", { enumerable: true, get: function () { return utils_2.isJobsTable; } });
+Object.defineProperty(exports, "deriveType", { enumerable: true, get: function () { return utils_2.deriveType; } });
+__exportStar(require("./types"), exports);

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

@@ -0,0 +1,14 @@
+import { HashContext, SqlResult, HSetOptions } from './types';
+export declare function createJsonbOperations(context: HashContext['context']): {
+    handleContextSet: (key: string, fields: Record<string, string>, options?: HSetOptions) => SqlResult;
+    handleContextMerge: (key: string, fields: Record<string, string>, options?: HSetOptions) => SqlResult;
+    handleContextDelete: (key: string, fields: Record<string, string>, options?: HSetOptions) => SqlResult;
+    handleContextAppend: (key: string, fields: Record<string, string>, options?: HSetOptions) => SqlResult;
+    handleContextPrepend: (key: string, fields: Record<string, string>, options?: HSetOptions) => SqlResult;
+    handleContextRemove: (key: string, fields: Record<string, string>, options?: HSetOptions) => SqlResult;
+    handleContextIncrement: (key: string, fields: Record<string, string>, options?: HSetOptions) => SqlResult;
+    handleContextToggle: (key: string, fields: Record<string, string>, options?: HSetOptions) => SqlResult;
+    handleContextSetIfNotExists: (key: string, fields: Record<string, string>, options?: HSetOptions) => SqlResult;
+    handleContextGet: (key: string, fields: Record<string, string>, options?: HSetOptions) => SqlResult;
+    handleContextGetPath: (key: string, fields: Record<string, string>, options?: HSetOptions) => SqlResult;
+};