@hotmeshio/hotmesh 0.13.0 → 0.14.0

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

@@ -44,69 +44,75 @@ function createUdataOperations(context) {
             // 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)`;
+                const baseIndex = index * 4 + 3;
+                const { symbol, dimension } = (0, utils_1.splitField)(fieldName);
+                params.push(symbol, dimension, value, 'udata');
+                return `($${baseIndex}, $${baseIndex + 1}, $${baseIndex + 2}, $${baseIndex + 3}::${schemaName}.type_enum)`;
             })
                 .join(', ');
+            const { symbol: replaySym, dimension: replayDim } = (0, utils_1.splitField)(replayId);
+            const replayTypeIdx = 2 + fieldEntries.length * 4 + 1;
             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 
+          INSERT INTO ${tableName}_attributes (job_id, symbol, dimension, value, type)
+          SELECT
             job.id,
-            vals.field,
+            vals.symbol,
+            vals.dimension,
             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
+          ) AS vals(symbol, dimension, value, type)
+          ON CONFLICT (job_id, symbol, dimension) 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
+          INSERT INTO ${tableName}_attributes (job_id, symbol, dimension, value, type)
+          SELECT job.id, $2, '${replayDim}', new_fields_count::text, $${replayTypeIdx}::${schemaName}.type_enum
           FROM valid_job job, count_result
-          ON CONFLICT (job_id, field) DO UPDATE
+          ON CONFLICT (job_id, symbol, dimension) DO UPDATE
           SET value = EXCLUDED.value
           RETURNING 1
         )
         SELECT new_fields_count FROM count_result
       `;
-            params.unshift(key, replayId);
+            params.unshift(key, replaySym);
             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)`;
+                const baseIndex = index * 4 + 2;
+                const { symbol, dimension } = (0, utils_1.splitField)(fieldName);
+                params.push(symbol, dimension, value, 'udata');
+                return `($${baseIndex}, $${baseIndex + 1}, $${baseIndex + 2}, $${baseIndex + 3}::${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 
+        INSERT INTO ${tableName}_attributes (job_id, symbol, dimension, value, type)
+        SELECT
           job.id,
-          vals.field,
+          vals.symbol,
+          vals.dimension,
           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
+        ) AS vals(symbol, dimension, value, type)
+        ON CONFLICT (job_id, symbol, dimension) DO UPDATE SET value = EXCLUDED.value
         RETURNING 1 as count
       `;
             params.unshift(key);
@@ -116,38 +122,40 @@ function createUdataOperations(context) {
     function handleUdataGet(key, fields, options) {
         const tableName = context.tableForKey(key, 'hash');
         const fieldName = fields['@udata:get'];
+        const { symbol: fieldSym, dimension: fieldDim } = (0, utils_1.splitField)(fieldName);
         const replayId = Object.keys(fields).find((k) => k.includes('-') && k !== '@udata:get');
         const params = [];
         let sql = '';
         if (replayId) {
+            const { symbol: replaySym, dimension: replayDim } = (0, utils_1.splitField)(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
+          LEFT JOIN ${tableName}_attributes a ON j.id = a.job_id AND a.symbol = $2 AND a.dimension = $3
           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
+          INSERT INTO ${tableName}_attributes (job_id, symbol, dimension, value, type)
+          SELECT j.id, $4, $5, field_value, $6
           FROM ${tableName} j, field_data
           WHERE j.key = $1 AND j.is_live
-          ON CONFLICT (job_id, field) DO UPDATE
+          ON CONFLICT (job_id, symbol, dimension) 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));
+            params.push(key, fieldSym, fieldDim, replaySym, replayDim, (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
+        LEFT JOIN ${tableName}_attributes a ON j.id = a.job_id AND a.symbol = $2 AND a.dimension = $3
         WHERE j.key = $1 AND j.is_live
       `;
-            params.push(key, fieldName);
+            params.push(key, fieldSym, fieldDim);
         }
         return { sql, params };
     }
@@ -155,43 +163,54 @@ function createUdataOperations(context) {
         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 symbols = fieldNames.map((f) => (0, utils_1.splitField)(f).symbol);
+        const dimensions = fieldNames.map((f) => (0, utils_1.splitField)(f).dimension);
         const params = [];
         let sql = '';
         if (replayId) {
+            const { symbol: replaySym, dimension: replayDim } = (0, utils_1.splitField)(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
+            SELECT
+              unnest($2::text[]) as sym,
+              unnest($3::text[]) as dim,
+              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
+          LEFT JOIN ${tableName}_attributes a
+            ON j.id = a.job_id AND a.symbol = field_order.sym AND a.dimension = field_order.dim
           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
+          INSERT INTO ${tableName}_attributes (job_id, symbol, dimension, value, type)
+          SELECT j.id, $4, $5, array_to_string(field_values, '|||'), $6
           FROM ${tableName} j, field_data
           WHERE j.key = $1 AND j.is_live
-          ON CONFLICT (job_id, field) DO UPDATE
+          ON CONFLICT (job_id, symbol, dimension) 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));
+            params.push(key, symbols, dimensions, replaySym, replayDim, (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
+          SELECT
+            unnest($2::text[]) as sym,
+            unnest($3::text[]) as dim,
+            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
+        LEFT JOIN ${tableName}_attributes a
+          ON j.id = a.job_id AND a.symbol = field_order.sym AND a.dimension = field_order.dim
         WHERE j.key = $1 AND j.is_live
       `;
-            params.push(key, fieldNames);
+            params.push(key, symbols, dimensions);
         }
         return { sql, params };
     }
@@ -199,33 +218,36 @@ function createUdataOperations(context) {
         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 symbols = fieldNames.map((f) => (0, utils_1.splitField)(f).symbol);
+        const dimensions = fieldNames.map((f) => (0, utils_1.splitField)(f).dimension);
         const params = [];
         let sql = '';
         if (replayId) {
+            const { symbol: replaySym, dimension: replayDim } = (0, utils_1.splitField)(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[])
+          AND (symbol, dimension) IN (SELECT unnest($2::text[]), unnest($3::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
+          INSERT INTO ${tableName}_attributes (job_id, symbol, dimension, value, type)
+          SELECT j.id, $4, $5, total_deleted::text, $6
           FROM ${tableName} j, count_result
           WHERE j.key = $1 AND j.is_live
-          ON CONFLICT (job_id, field) DO UPDATE
+          ON CONFLICT (job_id, symbol, dimension) 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));
+            params.push(key, symbols, dimensions, replaySym, replayDim, (0, utils_1.deriveType)(replayId));
         }
         else {
             sql = `
@@ -234,66 +256,69 @@ function createUdataOperations(context) {
           WHERE job_id = (
             SELECT id FROM ${tableName} WHERE key = $1 AND is_live
           )
-          AND field = ANY($2::text[])
+          AND (symbol, dimension) IN (SELECT unnest($2::text[]), unnest($3::text[]))
           RETURNING 1 as deleted_count
         )
         SELECT COUNT(*) as new_value FROM deleted_fields
       `;
-            params.push(key, fieldNames);
+            params.push(key, symbols, dimensions);
         }
         return { sql, params };
     }
     function handleUdataIncrement(key, fields, options) {
         const tableName = context.tableForKey(key, 'hash');
         const { field, value } = JSON.parse(fields['@udata:increment']);
+        const { symbol: fieldSym, dimension: fieldDim } = (0, utils_1.splitField)(field);
         const replayId = Object.keys(fields).find((k) => k.includes('-') && k !== '@udata:increment');
         const schemaName = context.safeName(context.appId);
         const params = [];
         let sql = '';
         if (replayId) {
+            const { symbol: replaySym, dimension: replayDim } = (0, utils_1.splitField)(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
+          INSERT INTO ${tableName}_attributes (job_id, symbol, dimension, value, type)
+          SELECT id, $2, $3, $4::text, $5::${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
+          ON CONFLICT (job_id, symbol, dimension) DO UPDATE
+          SET value = ((COALESCE(${tableName}_attributes.value, '0')::double precision) + $4::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
+          INSERT INTO ${tableName}_attributes (job_id, symbol, dimension, value, type)
+          SELECT job.id, $6, $7, inc.value, $8::${schemaName}.type_enum
           FROM valid_job job, increment_result inc
-          ON CONFLICT (job_id, field) DO UPDATE
+          ON CONFLICT (job_id, symbol, dimension) 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));
+            params.push(key, fieldSym, fieldDim, value, 'udata', replaySym, replayDim, (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
+        INSERT INTO ${tableName}_attributes (job_id, symbol, dimension, value, type)
+        SELECT id, $2, $3, $4::text, $5::${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
+        ON CONFLICT (job_id, symbol, dimension) DO UPDATE
+        SET value = ((COALESCE(${tableName}_attributes.value, '0')::double precision) + $4::double precision)::text
         RETURNING value as new_value
       `;
-            params.push(key, field, value, 'udata');
+            params.push(key, fieldSym, fieldDim, 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 { symbol: fieldSym, dimension: fieldDim } = (0, utils_1.splitField)(field);
         const replayId = Object.keys(fields).find((k) => k.includes('-') && k !== '@udata:multiply');
         const schemaName = context.safeName(context.appId);
         const params = [];
@@ -301,43 +326,44 @@ function createUdataOperations(context) {
         // 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) {
+            const { symbol: replaySym, dimension: replayDim } = (0, utils_1.splitField)(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
+          INSERT INTO ${tableName}_attributes (job_id, symbol, dimension, value, type)
+          SELECT id, $2, $3, ln($4::double precision)::text, $5::${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
+          ON CONFLICT (job_id, symbol, dimension) DO UPDATE
+          SET value = (COALESCE(${tableName}_attributes.value::double precision, 0) + ln($4::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
+          INSERT INTO ${tableName}_attributes (job_id, symbol, dimension, value, type)
+          SELECT job.id, $6, $7, mult.value, $8::${schemaName}.type_enum
           FROM valid_job job, multiply_result mult
-          ON CONFLICT (job_id, field) DO UPDATE
+          ON CONFLICT (job_id, symbol, dimension) 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));
+            params.push(key, fieldSym, fieldDim, value, 'udata', replaySym, replayDim, (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
+        INSERT INTO ${tableName}_attributes (job_id, symbol, dimension, value, type)
+        SELECT id, $2, $3, ln($4::double precision)::text, $5::${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
+        ON CONFLICT (job_id, symbol, dimension) DO UPDATE
+        SET value = (COALESCE(${tableName}_attributes.value::double precision, 0) + ln($4::double precision))::text
         RETURNING value as new_value
       `;
-            params.push(key, field, value, 'udata');
+            params.push(key, fieldSym, fieldDim, value, 'udata');
         }
         return { sql, params };
     }
@@ -347,34 +373,35 @@ function createUdataOperations(context) {
         const params = [];
         let sql = '';
         if (replayId) {
+            const { symbol: replaySym, dimension: replayDim } = (0, utils_1.splitField)(replayId);
             sql = `
         WITH field_data AS (
-          SELECT jsonb_object_agg(a.field, a.value) as field_values
+          SELECT jsonb_object_agg(a.symbol, a.value) as field_values
           FROM ${tableName} j
-          LEFT JOIN ${tableName}_attributes a ON j.id = a.job_id 
+          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 '\\_%'
+          AND a.type = 'udata' AND a.symbol LIKE '\\_%'
         ),
         replay_insert AS (
-          INSERT INTO ${tableName}_attributes (job_id, field, value, type)
-          SELECT j.id, $2, field_values::text, $3
+          INSERT INTO ${tableName}_attributes (job_id, symbol, dimension, value, type)
+          SELECT j.id, $2, $3, field_values::text, $4
           FROM ${tableName} j, field_data
           WHERE j.key = $1 AND j.is_live
-          ON CONFLICT (job_id, field) DO UPDATE
+          ON CONFLICT (job_id, symbol, dimension) 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));
+            params.push(key, replaySym, replayDim, (0, utils_1.deriveType)(replayId));
         }
         else {
             sql = `
-        SELECT jsonb_object_agg(a.field, a.value) as new_value
+        SELECT jsonb_object_agg(a.symbol, a.value) as new_value
         FROM ${tableName} j
-        LEFT JOIN ${tableName}_attributes a ON j.id = a.job_id 
+        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 '\\_%'
+        AND a.type = 'udata' AND a.symbol LIKE '\\_%'
       `;
             params.push(key);
         }

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

@@ -3,6 +3,22 @@ import { PostgresJobEnumType } from './types';
  * Determines if a table name represents a jobs table
  */
 export declare function isJobsTable(tableName: string): boolean;
+/**
+ * Splits a merged field string into its symbol and dimension components.
+ * The first comma separates symbol from dimension.
+ * If no comma is present, dimension is empty string.
+ *
+ * Examples:
+ *   'ab,0,1,0'   → { symbol: 'ab',       dimension: ',0,1,0' }
+ *   '-proxy,0,0'  → { symbol: '-proxy',   dimension: ',0,0' }
+ *   '_email'       → { symbol: '_email',   dimension: '' }
+ *   'jid'          → { symbol: 'jid',      dimension: '' }
+ *   ':'            → { symbol: ':',        dimension: '' }
+ */
+export declare function splitField(field: string): {
+    symbol: string;
+    dimension: string;
+};
 /**
  * Derives the enumerated `type` value based on the field name when
  * setting a field in a jobs table (a 'jobshash' table type).

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.processRegularRows = exports.processJobsRows = exports.deriveType = exports.isJobsTable = void 0;
+exports.processRegularRows = exports.processJobsRows = exports.deriveType = exports.splitField = exports.isJobsTable = void 0;
 /**
  * Determines if a table name represents a jobs table
  */
@@ -8,29 +8,42 @@ function isJobsTable(tableName) {
     return tableName.endsWith('jobs');
 }
 exports.isJobsTable = isJobsTable;
+/**
+ * Splits a merged field string into its symbol and dimension components.
+ * The first comma separates symbol from dimension.
+ * If no comma is present, dimension is empty string.
+ *
+ * Examples:
+ *   'ab,0,1,0'   → { symbol: 'ab',       dimension: ',0,1,0' }
+ *   '-proxy,0,0'  → { symbol: '-proxy',   dimension: ',0,0' }
+ *   '_email'       → { symbol: '_email',   dimension: '' }
+ *   'jid'          → { symbol: 'jid',      dimension: '' }
+ *   ':'            → { symbol: ':',        dimension: '' }
+ */
+function splitField(field) {
+    const i = field.indexOf(',');
+    if (i === -1)
+        return { symbol: field, dimension: '' };
+    return { symbol: field.substring(0, i), dimension: field.substring(i) };
+}
+exports.splitField = splitField;
 /**
  * Derives the enumerated `type` value based on the field name when
  * setting a field in a jobs table (a 'jobshash' table type).
  */
 function deriveType(fieldName) {
-    if (fieldName === ':') {
+    const { symbol, dimension } = splitField(fieldName);
+    if (symbol === ':')
         return 'status';
-    }
-    else if (fieldName.startsWith('_')) {
+    if (symbol.startsWith('_'))
         return 'udata';
-    }
-    else if (fieldName.startsWith('-')) {
-        return fieldName.includes(',') ? 'hmark' : 'jmark';
-    }
-    else if (fieldName.length === 3) {
-        return 'jdata';
-    }
-    else if (fieldName.includes(',')) {
+    if (symbol.startsWith('-'))
+        return dimension ? 'hmark' : 'jmark';
+    if (dimension)
         return 'adata';
-    }
-    else {
-        return 'other';
-    }
+    if (symbol.length === 3)
+        return 'jdata';
+    return 'other';
 }
 exports.deriveType = deriveType;
 /**

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

@@ -159,6 +159,7 @@ declare class PostgresStoreService extends StoreService<ProviderClient, Provider
     findJobs(queryString?: string, limit?: number, batchSize?: number, cursor?: string): Promise<[string, string[]]>;
     findJobFields(jobId: string, fieldMatchPattern?: string, limit?: number, batchSize?: number, // Unused in SQL provider
     cursor?: string): Promise<[string, Record<string, string>]>;
+    setCancel(jobId: string, appId: string): Promise<void>;
     setThrottleRate(options: ThrottleOptions): Promise<void>;
     getThrottleRates(): Promise<StringStringType>;
     getThrottleRate(topic: string): Promise<number>;

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

@@ -28,6 +28,7 @@ const errors_1 = require("../../../../modules/errors");
 const key_1 = require("../../../../modules/key");
 const serializer_1 = require("../../../serializer");
 const utils_1 = require("../../../../modules/utils");
+const utils_2 = require("./kvtypes/hash/utils");
 const enums_1 = require("../../../../modules/enums");
 const cache_1 = require("../../cache");
 const __1 = require("../..");
@@ -998,7 +999,7 @@ class PostgresStoreService extends __1.StoreService {
         paramIndex++;
         // Add dimension condition if applicable
         if (dimension) {
-            conditions.push(`a.field LIKE $${paramIndex}`);
+            conditions.push(`a.dimension LIKE $${paramIndex}`);
             params.push(`%${dimension}%`);
             paramIndex++;
         }
@@ -1012,7 +1013,7 @@ class PostgresStoreService extends __1.StoreService {
       WITH valid_job AS (
         ${validJobSql}
       )
-      SELECT a.field, a.value
+      SELECT a.symbol || a.dimension AS field, a.value
       FROM ${tableName}_attributes a
       JOIN valid_job j ON a.job_id = j.id
       WHERE ${conditions.join(' AND ')}
@@ -1027,6 +1028,13 @@ class PostgresStoreService extends __1.StoreService {
         const nextCursor = res.rows.length < limit ? '0' : String(offset + res.rows.length);
         return [nextCursor, matchingFields];
     }
+    async setCancel(jobId, appId) {
+        const jobKey = this.mintKey(key_1.KeyType.JOB_STATE, { appId, jobId });
+        // Write the cancel marker as a jmark-type field via hset.
+        // The hash module's splitField/deriveType classifies '-cancelled-'
+        // as type='jmark', which findJobFields returns on re-entry.
+        await this.kvsql().hset(jobKey, { '-cancelled-': '1' });
+    }
     async setThrottleRate(options) {
         const key = this.mintKey(key_1.KeyType.THROTTLE_RATE, { appId: this.appId });
         //engine guids are session specific. no need to persist
@@ -1294,7 +1302,8 @@ class PostgresStoreService extends __1.StoreService {
         const schemaName = this.kvsql().safeName(this.appId);
         const sql = GET_ACTIVITY_INPUTS.replace(/{schema}/g, schemaName);
         const jobKeyPattern = `hmsh:${this.appId}:j:-${workflowId}-%`;
-        const result = await this.pgClient.query(sql, [jobKeyPattern, symbolField]);
+        const { symbol, dimension } = (0, utils_2.splitField)(symbolField);
+        const result = await this.pgClient.query(sql, [jobKeyPattern, symbol, dimension]);
         const byJobId = new Map();
         const byNameIndex = new Map();
         for (const row of result.rows) {
@@ -1329,7 +1338,8 @@ class PostgresStoreService extends __1.StoreService {
         const { buildChildWorkflowInputsQuery } = await Promise.resolve().then(() => __importStar(require('./exporter-sql')));
         const schemaName = this.kvsql().safeName(this.appId);
         const sql = buildChildWorkflowInputsQuery(childJobKeys.length, schemaName);
-        const result = await this.pgClient.query(sql, [...childJobKeys, symbolField]);
+        const { symbol, dimension } = (0, utils_2.splitField)(symbolField);
+        const result = await this.pgClient.query(sql, [...childJobKeys, symbol, dimension]);
         const childInputMap = new Map();
         for (const row of result.rows) {
             const jobKey = row.key;

package/build/services/stream/factory.d.ts

@@ -3,6 +3,8 @@ import { ProviderClient, ProviderTransaction } from '../../types/provider';
 import { StreamInitializable } from './providers/stream-initializable';
 import { StreamService } from './index';
 declare class StreamServiceFactory {
-    static init(provider: ProviderClient, storeProvider: ProviderClient, namespace: string, appId: string, logger: ILogger): Promise<StreamService<ProviderClient, ProviderTransaction> & StreamInitializable>;
+    static init(provider: ProviderClient, storeProvider: ProviderClient, namespace: string, appId: string, logger: ILogger, options?: {
+        securedWorker?: boolean;
+    }): Promise<StreamService<ProviderClient, ProviderTransaction> & StreamInitializable>;
 }
 export { StreamServiceFactory };

package/build/services/stream/factory.js

@@ -5,14 +5,14 @@ const utils_1 = require("../../modules/utils");
 const nats_1 = require("./providers/nats/nats");
 const postgres_1 = require("./providers/postgres/postgres");
 class StreamServiceFactory {
-    static async init(provider, storeProvider, namespace, appId, logger) {
+    static async init(provider, storeProvider, namespace, appId, logger, options) {
         let service;
         const providerType = (0, utils_1.identifyProvider)(provider);
         if (providerType === 'nats') {
             service = new nats_1.NatsStreamService(provider, storeProvider);
         }
         else if (providerType === 'postgres') {
-            service = new postgres_1.PostgresStreamService(provider, storeProvider);
+            service = new postgres_1.PostgresStreamService(provider, storeProvider, { securedWorker: options?.securedWorker });
         } //etc register other providers here
         await service.init(namespace, appId, logger);
         return service;

package/build/services/stream/index.d.ts

@@ -61,6 +61,7 @@ export declare abstract class StreamService<ClientProvider extends ProviderClien
         supportsTrimming: boolean;
         supportsRetry: boolean;
         supportsNotifications?: boolean;
+        supportsParallelProcessing?: boolean;
         maxMessageSize: number;
         maxBatchSize: number;
     };

package/build/services/stream/providers/nats/nats.d.ts

@@ -53,6 +53,7 @@ declare class NatsStreamService extends StreamService<NatsClientType, NatsPubAck
         supportsTrimming: boolean;
         supportsRetry: boolean;
         supportsNotifications: boolean;
+        supportsParallelProcessing: boolean;
         maxMessageSize: number;
         maxBatchSize: number;
     };

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

@@ -217,6 +217,7 @@ class NatsStreamService extends index_1.StreamService {
             supportsTrimming: true,
             supportsRetry: false,
             supportsNotifications: false,
+            supportsParallelProcessing: false,
             maxMessageSize: 1024 * 1024,
             maxBatchSize: 256,
         };