@hotmeshio/hotmesh 0.3.32 → 0.4.1

package/build/services/search/providers/redis/ioredis.js

@@ -1 +1,121 @@
-'use strict';const j=b;(function(c,d){const i=b,e=c();while(!![]){try{const f=parseInt(i(0x1f4))/0x1*(parseInt(i(0x202))/0x2)+parseInt(i(0x1d7))/0x3*(parseInt(i(0x1dc))/0x4)+parseInt(i(0x1dd))/0x5*(-parseInt(i(0x1ff))/0x6)+parseInt(i(0x1d9))/0x7*(parseInt(i(0x1ed))/0x8)+-parseInt(i(0x1e2))/0x9*(parseInt(i(0x1eb))/0xa)+-parseInt(i(0x1e5))/0xb*(-parseInt(i(0x1f9))/0xc)+-parseInt(i(0x1f5))/0xd*(parseInt(i(0x1f8))/0xe);if(f===d)break;else e['push'](e['shift']());}catch(g){e['push'](e['shift']());}}}(a,0x967e0));function a(){const u=['Error\x20executing\x20query','IORedisSearchService','9GayifV','toString','7THiXUf','hmget','sendQuery','31308SJKrIQ','115rhhWyl','hget','__esModule','getField','incrementFieldByFloat','117nrtamV','HASH','../../index','407OxfXpM','error','sendIndexedQuery','defineProperty','Error\x20getting\x20fields\x20for\x20key:\x20','SearchService','423060luLnal','call','8947688fyOIbD','\x20for\x20key:\x20','listSearchIndexes','Error\x20setting\x20fields\x20for\x20key:\x20','FT.SEARCH','FT.CREATE','Error\x20getting\x20field\x20','10UsyyrF','184275IbGpsk','searchClient','startsWith','294OmTJUZ','30420bwQZOX','SCHEMA','logger','Error\x20incrementing\x20field\x20','FT._LIST','Error\x20deleting\x20fields\x20for\x20key:\x20','243816eXykvL','init','setFields','232592GzEBiG','info','hincrbyfloat','PREFIX'];a=function(){return u;};return a();}Object[j(0x1e8)](exports,j(0x1df),{'value':!0x0}),exports[j(0x1d6)]=void 0x0;const index_1=require(j(0x1e4));class IORedisSearchService extends index_1[j(0x1ea)]{constructor(c,d){super(c,d);}async[j(0x200)](c,d,f){this['namespace']=c,this['appId']=d,this['logger']=f;}async['createSearchIndex'](c,d,f){const k=j;try{await this[k(0x1f6)][k(0x1ec)](k(0x1f2),c,'ON',k(0x1e3),k(0x205),d['length'][k(0x1d8)](),...d,k(0x1fa),...f);}catch(g){throw this[k(0x1fb)]['info']('Error\x20creating\x20search\x20index',{'error':g}),g;}}async[j(0x1ef)](){const l=j;try{return await this[l(0x1f6)][l(0x1ec)](l(0x1fd));}catch(c){throw this[l(0x1fb)][l(0x203)]('Error\x20listing\x20search\x20indexes',{'error':c}),c;}}async[j(0x201)](c,d){const m=j;try{const f=await this[m(0x1f6)]['hset'](c,d);return Number(f);}catch(g){throw this[m(0x1fb)][m(0x1e6)](m(0x1f0)+c,{'error':g}),g;}}async[j(0x1e0)](c,d){const n=j;try{return await this[n(0x1f6)][n(0x1de)](c,d);}catch(f){throw this[n(0x1fb)][n(0x1e6)](n(0x1f3)+d+n(0x1ee)+c,{'error':f}),f;}}async['getFields'](c,d){const o=j;try{return await this['searchClient'][o(0x1da)](c,[...d]);}catch(f){throw this['logger']['error'](o(0x1e9)+c,{'error':f}),f;}}async['getAllFields'](c){const p=j;try{return await this['searchClient']['hgetall'](c);}catch(d){throw this['logger'][p(0x1e6)](p(0x1e9)+c,{'error':d}),d;}}async['deleteFields'](c,d){const q=j;try{const f=await this[q(0x1f6)]['hdel'](c,...d);return Number(f);}catch(g){throw this[q(0x1fb)][q(0x1e6)](q(0x1fe)+c,{'error':g}),g;}}async[j(0x1e1)](c,d,f){const r=j;try{const g=await this['searchClient'][r(0x204)](c,d,f);return Number(g);}catch(h){throw this[r(0x1fb)][r(0x1e6)](r(0x1fc)+d+r(0x1ee)+c,{'error':h}),h;}}async[j(0x1db)](...c){const s=j;try{return await this['searchClient'][s(0x1ec)](...c);}catch(d){throw this[s(0x1fb)][s(0x1e6)](s(0x206),{'error':d}),d;}}async[j(0x1e7)](c,d){const t=j;try{if(d[0x0]?.[t(0x1f7)]('FT.')){const [f,...g]=d;return await this[t(0x1f6)][t(0x1ec)](f,...g);}return await this[t(0x1f6)][t(0x1ec)](t(0x1f1),c,...d);}catch(h){throw this[t(0x1fb)]['error'](t(0x206),{'error':h}),h;}}}function b(c,d){const e=a();return b=function(f,g){f=f-0x1d6;let h=e[f];return h;},b(c,d);}exports['IORedisSearchService']=IORedisSearchService;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IORedisSearchService = void 0;
+const index_1 = require("../../index");
+class IORedisSearchService extends index_1.SearchService {
+    constructor(searchClient, storeClient) {
+        super(searchClient, storeClient);
+    }
+    async init(namespace, appId, logger) {
+        this.namespace = namespace;
+        this.appId = appId;
+        this.logger = logger;
+    }
+    async createSearchIndex(indexName, prefixes, schema) {
+        try {
+            await this.searchClient.call('FT.CREATE', indexName, 'ON', 'HASH', 'PREFIX', prefixes.length.toString(), ...prefixes, 'SCHEMA', ...schema);
+        }
+        catch (error) {
+            this.logger.info('Error creating search index', { error });
+            throw error;
+        }
+    }
+    async listSearchIndexes() {
+        try {
+            const indexes = await this.searchClient.call('FT._LIST');
+            return indexes;
+        }
+        catch (error) {
+            this.logger.info('Error listing search indexes', { error });
+            throw error;
+        }
+    }
+    async updateContext(key, fields) {
+        //no-op;
+        throw new Error('Not implemented');
+    }
+    async setFields(key, fields) {
+        try {
+            const result = await this.searchClient.hset(key, fields);
+            return Number(result);
+        }
+        catch (error) {
+            this.logger.error(`Error setting fields for key: ${key}`, { error });
+            throw error;
+        }
+    }
+    async getField(key, field) {
+        try {
+            return await this.searchClient.hget(key, field);
+        }
+        catch (error) {
+            this.logger.error(`Error getting field ${field} for key: ${key}`, {
+                error,
+            });
+            throw error;
+        }
+    }
+    async getFields(key, fields) {
+        try {
+            return await this.searchClient.hmget(key, [...fields]);
+        }
+        catch (error) {
+            this.logger.error(`Error getting fields for key: ${key}`, { error });
+            throw error;
+        }
+    }
+    async getAllFields(key) {
+        try {
+            return await this.searchClient.hgetall(key);
+        }
+        catch (error) {
+            this.logger.error(`Error getting fields for key: ${key}`, { error });
+            throw error;
+        }
+    }
+    async deleteFields(key, fields) {
+        try {
+            const result = await this.searchClient.hdel(key, ...fields);
+            return Number(result);
+        }
+        catch (error) {
+            this.logger.error(`Error deleting fields for key: ${key}`, { error });
+            throw error;
+        }
+    }
+    async incrementFieldByFloat(key, field, increment) {
+        try {
+            const result = await this.searchClient.hincrbyfloat(key, field, increment);
+            return Number(result);
+        }
+        catch (error) {
+            this.logger.error(`Error incrementing field ${field} for key: ${key}`, {
+                error,
+            });
+            throw error;
+        }
+    }
+    async sendQuery(...query) {
+        try {
+            return await this.searchClient.call(...query);
+        }
+        catch (error) {
+            this.logger.error('Error executing query', { error });
+            throw error;
+        }
+    }
+    async sendIndexedQuery(index, query) {
+        try {
+            if (query[0]?.startsWith('FT.')) {
+                const [cmd, ...rest] = query;
+                return (await this.searchClient.call(cmd, ...rest));
+            }
+            return (await this.searchClient.call('FT.SEARCH', index, ...query));
+        }
+        catch (error) {
+            this.logger.error('Error executing query', { error });
+            throw error;
+        }
+    }
+}
+exports.IORedisSearchService = IORedisSearchService;

package/build/services/search/providers/redis/redis.d.ts

@@ -6,6 +6,7 @@ declare class RedisSearchService extends SearchService<RedisRedisClientType> {
     init(namespace: string, appId: string, logger: ILogger): Promise<void>;
     createSearchIndex(indexName: string, prefixes: string[], schema: string[]): Promise<void>;
     listSearchIndexes(): Promise<string[]>;
+    updateContext(key: string, fields: Record<string, string>): Promise<any>;
     setFields(key: string, fields: Record<string, string>): Promise<number>;
     getField(key: string, field: string): Promise<string>;
     getFields(key: string, fields: string[]): Promise<string[]>;

package/build/services/search/providers/redis/redis.js

@@ -1 +1,134 @@
-'use strict';const j=b;(function(c,d){const i=b,e=c();while(!![]){try{const f=-parseInt(i(0x184))/0x1*(-parseInt(i(0x15e))/0x2)+-parseInt(i(0x166))/0x3*(-parseInt(i(0x173))/0x4)+parseInt(i(0x168))/0x5*(parseInt(i(0x183))/0x6)+-parseInt(i(0x180))/0x7+-parseInt(i(0x15d))/0x8+-parseInt(i(0x16e))/0x9*(-parseInt(i(0x161))/0xa)+-parseInt(i(0x189))/0xb*(parseInt(i(0x169))/0xc);if(f===d)break;else e['push'](e['shift']());}catch(g){e['push'](e['shift']());}}}(a,0xab193));function b(c,d){const e=a();return b=function(f,g){f=f-0x159;let h=e[f];return h;},b(c,d);}Object[j(0x162)](exports,j(0x177),{'value':!0x0}),exports[j(0x163)]=void 0x0;const index_1=require(j(0x165));function a(){const v=['sendCommand','145JApbBj','3467892psyClD','FT.CREATE','HDEL','init','info','639FaoPwR','Error\x20creating\x20search\x20index','HGETALL','getAllFields','HSET','8jxzHVO','Error\x20incrementing\x20field\x20','createSearchIndex','error','__esModule','setFields','incrementFieldByFloat','HASH','\x20for\x20key:\x20','FT.SEARCH','getFields','Error\x20getting\x20fields\x20for\x20key:\x20','Error\x20setting\x20fields\x20for\x20key:\x20','4119248hhJGRp','SearchService','namespace','208836rtkStq','2KeNyDD','listSearchIndexes','Error\x20executing\x20query','toString','FT._LIST','44wYdRhi','sendQuery','HGET','appId','searchClient','7652768myBdgQ','1310356MnstlD','getField','length','121190dqQySt','defineProperty','RedisSearchService','logger','../../index','332496nQkFJJ'];a=function(){return v;};return a();}class RedisSearchService extends index_1[j(0x181)]{constructor(c,d){super(c,d);}async[j(0x16c)](c,d,f){const k=j;this[k(0x182)]=c,this[k(0x15b)]=d,this[k(0x164)]=f;}async[j(0x175)](c,d,f){const l=j;try{await this[l(0x15c)][l(0x167)]([l(0x16a),c,'ON',l(0x17a),'PREFIX',d[l(0x160)][l(0x187)](),...d,'SCHEMA',...f]);}catch(g){throw this[l(0x164)][l(0x16d)](l(0x16f),{'error':g}),g;}}async[j(0x185)](){const m=j;try{return await this[m(0x15c)]['sendCommand']([m(0x188)]);}catch(c){throw this['logger'][m(0x16d)]('Error\x20listing\x20search\x20indexes',{'error':c}),c;}}async[j(0x178)](c,d){const n=j;try{const f=await this[n(0x15c)][n(0x172)](c,d);return Number(f);}catch(g){throw this[n(0x164)]['error'](n(0x17f)+c,{'error':g}),g;}}async[j(0x15f)](c,d){const o=j;try{return await this[o(0x15c)][o(0x15a)](c,d);}catch(f){throw this[o(0x164)][o(0x176)]('Error\x20getting\x20field\x20'+d+o(0x17b)+c,{'error':f}),f;}}async[j(0x17d)](c,d){const p=j;try{return await this[p(0x15c)]['HMGET'](c,[...d]);}catch(f){throw this[p(0x164)]['error']('Error\x20getting\x20fields\x20for\x20key:\x20'+c,{'error':f}),f;}}async[j(0x171)](c){const q=j;try{return await this[q(0x15c)][q(0x170)](c);}catch(d){throw this[q(0x164)][q(0x176)](q(0x17e)+c,{'error':d}),d;}}async['deleteFields'](c,d){const r=j;try{const f=await this['searchClient'][r(0x16b)](c,d);return Number(f);}catch(g){throw this[r(0x164)][r(0x176)]('Error\x20deleting\x20fields\x20for\x20key:\x20'+c,{'error':g}),g;}}async[j(0x179)](c,d,f){const s=j;try{const g=await this[s(0x15c)]['HINCRBYFLOAT'](c,d,f);return Number(g);}catch(h){throw this[s(0x164)][s(0x176)](s(0x174)+d+'\x20for\x20key:\x20'+c,{'error':h}),h;}}async[j(0x159)](...c){const t=j;try{return await this[t(0x15c)][t(0x167)](c);}catch(d){throw this[t(0x164)]['error'](t(0x186),{'error':d}),d;}}async['sendIndexedQuery'](c,d){const u=j;try{return d[0x0]?.['startsWith']('FT.')?await this[u(0x15c)]['sendCommand'](d):await this['searchClient'][u(0x167)]([u(0x17c),c,...d]);}catch(f){throw this['logger'][u(0x176)](u(0x186),{'error':f}),f;}}}exports['RedisSearchService']=RedisSearchService;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisSearchService = void 0;
+const index_1 = require("../../index");
+class RedisSearchService extends index_1.SearchService {
+    constructor(searchClient, storeClient) {
+        super(searchClient, storeClient);
+    }
+    async init(namespace, appId, logger) {
+        this.namespace = namespace;
+        this.appId = appId;
+        this.logger = logger;
+    }
+    async createSearchIndex(indexName, prefixes, schema) {
+        try {
+            await this.searchClient.sendCommand([
+                'FT.CREATE',
+                indexName,
+                'ON',
+                'HASH',
+                'PREFIX',
+                prefixes.length.toString(),
+                ...prefixes,
+                'SCHEMA',
+                ...schema,
+            ]);
+        }
+        catch (error) {
+            this.logger.info('Error creating search index', { error });
+            throw error;
+        }
+    }
+    async listSearchIndexes() {
+        try {
+            const indexes = await this.searchClient.sendCommand(['FT._LIST']);
+            return indexes;
+        }
+        catch (error) {
+            this.logger.info('Error listing search indexes', { error });
+            throw error;
+        }
+    }
+    async updateContext(key, fields) {
+        //no-op;
+        throw new Error('Not implemented');
+    }
+    async setFields(key, fields) {
+        try {
+            const result = await this.searchClient.HSET(key, fields);
+            return Number(result);
+        }
+        catch (error) {
+            this.logger.error(`Error setting fields for key: ${key}`, { error });
+            throw error;
+        }
+    }
+    async getField(key, field) {
+        try {
+            return await this.searchClient.HGET(key, field);
+        }
+        catch (error) {
+            this.logger.error(`Error getting field ${field} for key: ${key}`, {
+                error,
+            });
+            throw error;
+        }
+    }
+    async getFields(key, fields) {
+        try {
+            return await this.searchClient.HMGET(key, [...fields]);
+        }
+        catch (error) {
+            this.logger.error(`Error getting fields for key: ${key}`, { error });
+            throw error;
+        }
+    }
+    async getAllFields(key) {
+        try {
+            return await this.searchClient.HGETALL(key);
+        }
+        catch (error) {
+            this.logger.error(`Error getting fields for key: ${key}`, { error });
+            throw error;
+        }
+    }
+    async deleteFields(key, fields) {
+        try {
+            const result = await this.searchClient.HDEL(key, fields);
+            return Number(result);
+        }
+        catch (error) {
+            this.logger.error(`Error deleting fields for key: ${key}`, { error });
+            throw error;
+        }
+    }
+    async incrementFieldByFloat(key, field, increment) {
+        try {
+            const result = await this.searchClient.HINCRBYFLOAT(key, field, increment);
+            return Number(result);
+        }
+        catch (error) {
+            this.logger.error(`Error incrementing field ${field} for key: ${key}`, {
+                error,
+            });
+            throw error;
+        }
+    }
+    async sendQuery(...query) {
+        try {
+            return await this.searchClient.sendCommand(query);
+        }
+        catch (error) {
+            this.logger.error('Error executing query', { error });
+            throw error;
+        }
+    }
+    async sendIndexedQuery(index, query) {
+        try {
+            if (query[0]?.startsWith('FT.')) {
+                return (await this.searchClient.sendCommand(query));
+            }
+            return (await this.searchClient.sendCommand([
+                'FT.SEARCH',
+                index,
+                ...query,
+            ]));
+        }
+        catch (error) {
+            this.logger.error('Error executing query', { error });
+            throw error;
+        }
+    }
+}
+exports.RedisSearchService = RedisSearchService;

package/build/services/serializer/index.js

@@ -1 +1,282 @@
-'use strict';function b(c,d){const e=a();return b=function(f,g){f=f-0x151;let h=e[f];return h;},b(c,d);}const q=b;(function(c,d){const p=b,e=c();while(!![]){try{const f=-parseInt(p(0x16b))/0x1+parseInt(p(0x16d))/0x2*(parseInt(p(0x194))/0x3)+-parseInt(p(0x18f))/0x4*(-parseInt(p(0x170))/0x5)+-parseInt(p(0x169))/0x6*(parseInt(p(0x157))/0x7)+-parseInt(p(0x176))/0x8*(-parseInt(p(0x177))/0x9)+-parseInt(p(0x18e))/0xa*(parseInt(p(0x188))/0xb)+parseInt(p(0x16f))/0xc*(parseInt(p(0x167))/0xd);if(f===d)break;else e['push'](e['shift']());}catch(g){e['push'](e['shift']());}}}(a,0x2fc2b));Object['defineProperty'](exports,q(0x160),{'value':!0x0}),exports[q(0x184)]=exports[q(0x15b)]=void 0x0;function a(){const K=['get','392tlsKCH','compress','parse','size','MDATA_SYMBOLS','includes','toString','metadata/','getReverseKeyMap','__esModule','entries','gid','dIds','push','symValMaps','has','1431547YwpqUn','stp','39708TiKXYd','err','176322wqczRt','object','2ySERZC','l2s','60YlPupr','100155umrBCr','abbreviate','symReverseKeys','resetSymbols','unpackage','$ADJACENT','8vxBsep','677007gsiEwy','metadata','data/','resolveDimensionalIndex','ngn','slice','values','dad','add','stringify','set','number','atp','SerializerService','boolean','key','package','1826ZbWWOw','export','decompress','l1s','undefined','symValReverseMaps','13190FrwAjM','16MfZydx','split','fromString','getReverseValueMap','isLiteralKeyType','766707kYSajj','jid','exec','isJobPath','startsWith','data','string','app','../../modules/utils','aid','symKeys'];a=function(){return K;};return a();}const utils_1=require(q(0x153)),dateReg=/^"\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z)?"$/;exports[q(0x15b)]={'SLOTS':0x1a,'ACTIVITY':{'KEYS':['aid',q(0x17e),'as',q(0x183),q(0x168),'ac','au',q(0x16a),q(0x18b),q(0x16e)]},'ACTIVITY_UPDATE':{'KEYS':['au','err',q(0x16e)]},'JOB':{'KEYS':[q(0x17b),'tpc','pj','pg','pd','px','pa',q(0x186),q(0x152),'vrs',q(0x195),q(0x162),q(0x154),'ts','jc','ju','js',q(0x16a),'trc']},'JOB_UPDATE':{'KEYS':['ju',q(0x16a)]}};class SerializerService{constructor(){this['resetSymbols']({},{},{});}[q(0x171)](c,d,f=[]){const r=q;for(const g of d){const h=this[r(0x155)][r(0x156)](g),j=c[g];for(const k of j){const l=h[r(0x156)](k);if(l){const m=this[r(0x17a)](k);f[r(0x164)](''+l+m);}else f[r(0x164)](k);}}return f;}[q(0x17a)](c){const s=q;if(this[s(0x197)](c))return'';{const [d]=c[s(0x190)]('/');return d in this[s(0x163)]?this[s(0x163)][d]:s(0x175)in this[s(0x163)]?this['dIds'][s(0x175)]:',0';}}[q(0x197)](c){const t=q;return c['startsWith'](t(0x179))||c[t(0x198)](t(0x15e));}[q(0x173)](c,d,f){const u=q;this[u(0x155)]=new Map(),this['symReverseKeys']=new Map();for(const g in c)this[u(0x155)]['set'](g,new Map(Object[u(0x161)](c[g])));this[u(0x165)]=new Map(Object[u(0x161)](d)),this[u(0x18d)]=this[u(0x192)](this[u(0x165)]),this[u(0x163)]=f;}[q(0x15f)](c,d){const v=q;let f=this[v(0x172)][v(0x156)](d);if(!f){f=new Map();for(const [g,h]of c[v(0x161)]())f[v(0x181)](h,g);this['symReverseKeys']['set'](d,f);}return f;}[q(0x192)](c){const w=q,d=new Map();for(const [f,g]of c[w(0x161)]())d[w(0x181)](g,f);return d;}static['filterSymVals'](c,d,f,g){const x=q,h={},j={...f},k=new Set(Object[x(0x17d)](j));for(const l of g)if(!k[x(0x166)](l)){if(c>d)return h;const m=(0x0,utils_1['getSymVal'])(c);c++,h[m]=l,k[x(0x17f)](l);}return h;}[q(0x158)](c,d){const y=q;if(0x0===this[y(0x155)][y(0x15a)])return c;const f={...c},g={},h=(j,k)=>{const z=y;for(const l in f)if(l[z(0x198)](k+'/')||k[z(0x198)]('$')&&[z(0x199),z(0x178)][z(0x15c)](l[z(0x190)]('/')[0x0])){const m=this[z(0x17a)](l),o=j[z(0x156)](l)||l;g[''+o+m]=f[l];}else!(l in g)&&this[z(0x193)](l)&&(g[l]=f[l]);};for(const j of d){const k=this['symKeys'][y(0x156)](j);k&&h(k,j);}return g;}[q(0x193)](c){const A=q;return c[A(0x198)]('-')||c[A(0x198)]('_');}[q(0x18a)](c,d){const C=q;if(0x0===this['symKeys']['size'])return c;const f={...c},g=(h,j)=>{const B=b,k=this[B(0x15f)](h,j);for(const l in f){const m=l['split'](',')[0x0],n=k[B(0x156)](m);n&&(f[n]=f[l],delete f[l]);}};for(const h of d){const i=this[C(0x155)][C(0x156)](h);i&&g(i,h);}return f;}[q(0x180)](c){const D=q,d={};for(const f in c){const g=SerializerService[D(0x15d)](c[f]);g&&(d[f]=g);}return d;}[q(0x159)](c){const E=q,d={};for(const [f,g]of Object[E(0x161)](c))null!=g&&(d[f]=SerializerService[E(0x191)](g));return d;}static[q(0x15d)](c){const F=q;switch(typeof c){case F(0x151):break;case F(0x185):c=c?'/t':'/f';break;case F(0x182):c='/d'+c[F(0x15d)]();break;case F(0x18c):return;case F(0x16c):c=null===c?'/n':'/s'+JSON[F(0x180)](c);}return c;}static[q(0x191)](c){const G=q;if('string'!=typeof c)return;const d=c[G(0x17c)](0x0,0x2),f=c[G(0x17c)](0x2);switch(d){case'/t':return!0x0;case'/f':return!0x1;case'/d':return Number(f);case'/n':return null;case'/s':return dateReg[G(0x196)](f)?new Date(JSON[G(0x159)](f)):JSON['parse'](f);default:return c;}}[q(0x187)](c,d){const H=q,f=this[H(0x180)](c);return this[H(0x158)](f,d);}[q(0x174)](c,d){const I=q,f=this[I(0x18a)](c,d);return this['parse'](f);}[q(0x189)](){const J=q,c={};for(const [d,f]of this['symKeys'][J(0x161)]()){c[d]={};for(const [g,h]of f[J(0x161)]())c[d][g]=h;}return c;}}exports[q(0x184)]=SerializerService;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerializerService = exports.MDATA_SYMBOLS = void 0;
+const utils_1 = require("../../modules/utils");
+const dateReg = /^"\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z)?"$/;
+exports.MDATA_SYMBOLS = {
+    SLOTS: 26,
+    ACTIVITY: {
+        KEYS: ['aid', 'dad', 'as', 'atp', 'stp', 'ac', 'au', 'err', 'l1s', 'l2s'],
+    },
+    ACTIVITY_UPDATE: {
+        KEYS: ['au', 'err', 'l2s'],
+    },
+    JOB: {
+        KEYS: [
+            'ngn',
+            'tpc',
+            'pj',
+            'pg',
+            'pd',
+            'px',
+            'pa',
+            'key',
+            'app',
+            'vrs',
+            'jid',
+            'gid',
+            'aid',
+            'ts',
+            'jc',
+            'ju',
+            'js',
+            'err',
+            'trc',
+        ],
+    },
+    JOB_UPDATE: {
+        KEYS: ['ju', 'err'],
+    },
+};
+class SerializerService {
+    constructor() {
+        this.resetSymbols({}, {}, {});
+    }
+    abbreviate(consumes, symbolNames, fields = []) {
+        for (const symbolName of symbolNames) {
+            const symbolSet = this.symKeys.get(symbolName);
+            const symbolPaths = consumes[symbolName];
+            for (const symbolPath of symbolPaths) {
+                const abbreviation = symbolSet.get(symbolPath);
+                if (abbreviation) {
+                    const dimensionalIndex = this.resolveDimensionalIndex(symbolPath);
+                    fields.push(`${abbreviation}${dimensionalIndex}`);
+                }
+                else {
+                    fields.push(symbolPath);
+                }
+            }
+        }
+        return fields;
+    }
+    resolveDimensionalIndex(path) {
+        if (this.isJobPath(path)) {
+            return '';
+        }
+        else {
+            const [activityId] = path.split('/');
+            if (activityId in this.dIds) {
+                return this.dIds[activityId];
+            }
+            else if ('$ADJACENT' in this.dIds) {
+                //else=> pre-authorizing adjacent activity entry
+                return this.dIds['$ADJACENT'];
+            }
+            return ',0';
+        }
+    }
+    isJobPath(path) {
+        return path.startsWith('data/') || path.startsWith('metadata/');
+    }
+    resetSymbols(symKeys, symVals, dIds) {
+        this.symKeys = new Map();
+        this.symReverseKeys = new Map();
+        for (const id in symKeys) {
+            this.symKeys.set(id, new Map(Object.entries(symKeys[id])));
+        }
+        this.symValMaps = new Map(Object.entries(symVals));
+        this.symValReverseMaps = this.getReverseValueMap(this.symValMaps);
+        this.dIds = dIds;
+    }
+    getReverseKeyMap(keyMap, id) {
+        let map = this.symReverseKeys.get(id);
+        if (!map) {
+            map = new Map();
+            for (const [key, val] of keyMap.entries()) {
+                map.set(val, key);
+            }
+            this.symReverseKeys.set(id, map);
+        }
+        return map;
+    }
+    getReverseValueMap(valueMap) {
+        const map = new Map();
+        for (const [key, val] of valueMap.entries()) {
+            map.set(val, key);
+        }
+        return map;
+    }
+    static filterSymVals(startIndex, maxIndex, existingSymbolValues, proposedValues) {
+        const newSymbolValues = {};
+        const currentSymbolValues = { ...existingSymbolValues };
+        const currentValuesSet = new Set(Object.values(currentSymbolValues));
+        for (const value of proposedValues) {
+            if (!currentValuesSet.has(value)) {
+                if (startIndex > maxIndex) {
+                    return newSymbolValues;
+                }
+                const symbol = (0, utils_1.getSymVal)(startIndex);
+                startIndex++;
+                newSymbolValues[symbol] = value;
+                currentValuesSet.add(value);
+            }
+        }
+        return newSymbolValues;
+    }
+    compress(document, ids) {
+        if (this.symKeys.size === 0) {
+            return document;
+        }
+        const source = { ...document };
+        const result = {};
+        const compressWithMap = (abbreviationMap, id) => {
+            for (const key in source) {
+                if (key.startsWith(`${id}/`) ||
+                    id.startsWith('$') &&
+                        ['data', 'metadata'].includes(key.split('/')[0])) {
+                    const dimensionalIndex = this.resolveDimensionalIndex(key);
+                    const shortKey = abbreviationMap.get(key) || key;
+                    const shortDimensionalKey = `${shortKey}${dimensionalIndex}`;
+                    result[shortDimensionalKey] = source[key];
+                }
+                else if (!(key in result) && this.isLiteralKeyType(key)) {
+                    //mark (-) and search (_)
+                    result[key] = source[key];
+                }
+            }
+        };
+        for (const id of ids) {
+            const abbreviationMap = this.symKeys.get(id);
+            if (abbreviationMap) {
+                compressWithMap(abbreviationMap, id);
+            }
+        }
+        return result;
+    }
+    isLiteralKeyType(key) {
+        return key.startsWith('-') || key.startsWith('_');
+    }
+    decompress(document, ids) {
+        if (this.symKeys.size === 0) {
+            return document;
+        }
+        const result = { ...document };
+        const inflateWithMap = (abbreviationMap, id) => {
+            const reversedAbbreviationMap = this.getReverseKeyMap(abbreviationMap, id);
+            for (const key in result) {
+                //strip dimensional index from key
+                const shortKey = key.split(',')[0];
+                const longKey = reversedAbbreviationMap.get(shortKey);
+                if (longKey) {
+                    result[longKey] = result[key];
+                    delete result[key];
+                }
+            }
+        };
+        for (const id of ids) {
+            const abbreviationMap = this.symKeys.get(id);
+            if (abbreviationMap) {
+                inflateWithMap(abbreviationMap, id);
+            }
+        }
+        return result;
+    }
+    //stringify: convert a n-dimensional document to a 2-d hash
+    stringify(document) {
+        const result = {};
+        for (const key in document) {
+            const value = SerializerService.toString(document[key]);
+            if (value) {
+                // if (/^:*[a-zA-Z]{2}$/.test(value)) {
+                //   value = ':' + value;
+                // } else if (this.symValReverseMaps.has(value)) {
+                //   value = this.symValReverseMaps.get(value);
+                // }
+                result[key] = value;
+            }
+        }
+        return result;
+    }
+    //parse: convert a 2-d hash to a n-dimensional document
+    parse(document) {
+        const result = {};
+        for (const [key, value] of Object.entries(document)) {
+            if (value === undefined || value === null)
+                continue;
+            // if (/^:+[a-zA-Z]{2}$/.test(value)) {
+            //   result[key] = value.slice(1);
+            // } else {
+            //   if (value?.length === 2 && this.symValMaps.has(value)) {
+            //     value = this.symValMaps.get(value);
+            //   }
+            result[key] = SerializerService.fromString(value);
+            // }
+        }
+        return result;
+    }
+    static toString(value) {
+        switch (typeof value) {
+            case 'string':
+                break;
+            case 'boolean':
+                value = value ? '/t' : '/f';
+                break;
+            case 'number':
+                value = '/d' + value.toString();
+                break;
+            case 'undefined':
+                return undefined;
+            case 'object':
+                if (value === null) {
+                    value = '/n';
+                }
+                else {
+                    value = '/s' + JSON.stringify(value);
+                }
+                break;
+        }
+        return value;
+    }
+    static fromString(value) {
+        if (typeof value !== 'string')
+            return undefined;
+        const prefix = value.slice(0, 2);
+        const rest = value.slice(2);
+        switch (prefix) {
+            case '/t': // boolean true
+                return true;
+            case '/f': // boolean false
+                return false;
+            case '/d': // number
+                return Number(rest);
+            case '/n': // null
+                return null;
+            case '/s': // object (JSON string)
+                if (dateReg.exec(rest)) {
+                    return new Date(JSON.parse(rest));
+                }
+                return JSON.parse(rest);
+            default: // string
+                return value;
+        }
+    }
+    package(multiDimensionalDocument, ids) {
+        const flatDocument = this.stringify(multiDimensionalDocument);
+        return this.compress(flatDocument, ids);
+    }
+    unpackage(document, ids) {
+        const multiDimensionalDocument = this.decompress(document, ids);
+        return this.parse(multiDimensionalDocument);
+    }
+    export() {
+        const obj = {};
+        for (const [id, map] of this.symKeys.entries()) {
+            obj[id] = {};
+            for (const [key, value] of map.entries()) {
+                obj[id][key] = value;
+            }
+        }
+        return obj;
+    }
+}
+exports.SerializerService = SerializerService;

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

@@ -47,7 +47,7 @@ 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<number>;
+    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[];