@hotmeshio/hotmesh 0.14.2 → 0.14.4

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

@@ -110,16 +110,12 @@ class KVSQL {
         return '';
     }
     /**
-     * Resolves the table name when provided a key
+     * Resolves the table name when provided a key.
+     * Public tables (applications, connections) are no longer routed through
+     * the KV layer — they use direct SQL in postgres.ts.
      */
     tableForKey(key, stats_type) {
-        if (key === key_1.HMNS) {
-            return 'public.hotmesh_connections';
-        }
         const [_, appName, abbrev, ...rest] = key.split(':');
-        if (appName === 'a') {
-            return 'public.hotmesh_applications';
-        }
         const id = rest?.length ? rest.join(':') : '';
         const entity = key_1.KeyService.resolveEntityType(abbrev, id);
         if (this.safeName(this.appId) !== this.safeName(appName)) {
@@ -145,13 +141,27 @@ class KVSQL {
         if (entity === 'unknown_entity') {
             throw new Error(`Unknown entity type abbreviation: ${abbrev}`);
         }
-        else if (entity === 'applications') {
-            return 'public.hotmesh_applications';
-        }
         else {
             return `${schemaName}.${entity}`;
         }
     }
+    /**
+     * Strips the `hmsh:<appId>:<entity>:` prefix from a full Redis-style key,
+     * keeping only the meaningful suffix for SQL storage. Applied only to the
+     * `key` column in SQL params — never to member values, field names, or values.
+     *
+     * Excluded tables (jobs, streams, job attributes) retain the full key.
+     */
+    storageKey(fullKey) {
+        const parts = fullKey.split(':');
+        if (parts.length < 3)
+            return fullKey;
+        const entity = parts[2];
+        // Excluded tables: jobs (j), streams (x), job attributes (d)
+        if (entity === 'j' || entity === 'x' || entity === 'd')
+            return fullKey;
+        return parts.slice(3).join(':');
+    }
     safeName(input, prefix = '') {
         if (!input) {
             return 'connections';
@@ -186,6 +196,7 @@ class KVSQL {
           AND (expired_at IS NULL OR expired_at > NOW())
         LIMIT 1;
       `;
+            return { sql, params: [key] };
         }
         else {
             sql = `
@@ -194,9 +205,8 @@ class KVSQL {
           AND (expiry IS NULL OR expiry > NOW())
         LIMIT 1;
       `;
+            return { sql, params: [this.storageKey(key)] };
         }
-        const params = [key];
-        return { sql, params };
     }
 }
 exports.KVSQL = KVSQL;

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

@@ -137,6 +137,39 @@ const KVTables = (context) => ({
             for (const tableDef of tableDefinitions) {
                 const fullTableName = `${tableDef.schema}.${tableDef.name}`;
                 switch (tableDef.type) {
+                    case 'relational_app':
+                        await client.query(`
+              CREATE TABLE IF NOT EXISTS ${fullTableName} (
+                app_id TEXT PRIMARY KEY,
+                version TEXT NOT NULL DEFAULT '1',
+                active BOOLEAN DEFAULT TRUE,
+                settings JSONB DEFAULT '{}',
+                created_at TIMESTAMPTZ DEFAULT NOW(),
+                updated_at TIMESTAMPTZ DEFAULT NOW()
+              );
+            `);
+                        await client.query(`
+              CREATE TABLE IF NOT EXISTS public.hmsh_application_versions (
+                app_id TEXT NOT NULL REFERENCES public.hmsh_applications(app_id) ON DELETE CASCADE,
+                version TEXT NOT NULL,
+                status TEXT NOT NULL DEFAULT 'deployed',
+                deployed_at TIMESTAMPTZ DEFAULT NOW(),
+                PRIMARY KEY (app_id, version)
+              );
+            `);
+                        break;
+                    case 'relational_connection':
+                        await client.query(`
+              CREATE TABLE IF NOT EXISTS ${fullTableName} (
+                guid TEXT NOT NULL,
+                app_id TEXT NOT NULL,
+                role TEXT NOT NULL,
+                version TEXT NOT NULL,
+                connected_at TIMESTAMPTZ DEFAULT NOW(),
+                PRIMARY KEY (guid, app_id)
+              );
+            `);
+                        break;
                     case 'string':
                         await client.query(`
               CREATE TABLE IF NOT EXISTS ${fullTableName} (
@@ -375,8 +408,8 @@ const KVTables = (context) => ({
     },
     getTableNames(appName) {
         const tableNames = [];
-        // Applications table (only hotmesh prefix)
-        tableNames.push('hotmesh_applications', 'hotmesh_connections');
+        // Public relational tables
+        tableNames.push('public.hmsh_applications', 'public.hmsh_application_versions', 'public.hmsh_connections');
         // Other tables with appName
         const tablesWithAppName = [
             'throttles',
@@ -404,13 +437,13 @@ const KVTables = (context) => ({
         const tableDefinitions = [
             {
                 schema: 'public',
-                name: 'hotmesh_applications',
-                type: 'hash',
+                name: 'hmsh_applications',
+                type: 'relational_app',
             },
             {
                 schema: 'public',
-                name: 'hotmesh_connections',
-                type: 'hash',
+                name: 'hmsh_connections',
+                type: 'relational_connection',
             },
             {
                 schema: schemaName,

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

@@ -351,7 +351,7 @@ function _hset(context, key, fields, options) {
       ${conflictAction}
       RETURNING 1 as count
     `;
-        params.unshift(key); // Add key as the first parameter
+        params.unshift(context.storageKey(key)); // Add stripped key as the first parameter
     }
     return { sql, params };
 }
@@ -401,7 +401,7 @@ function _hget(context, key, field) {
       WHERE key = $1 AND field = $2
     `;
         const sql = context.appendExpiryClause(baseQuery, tableName);
-        return { sql, params: [key, field] };
+        return { sql, params: [context.storageKey(key), field] };
     }
 }
 exports._hget = _hget;
@@ -438,7 +438,7 @@ function _hdel(context, key, fields) {
       )
       SELECT COUNT(*) as count FROM deleted
     `;
-        return { sql, params: [key, ...fields] };
+        return { sql, params: [context.storageKey(key), ...fields] };
     }
 }
 exports._hdel = _hdel;
@@ -495,7 +495,7 @@ function _hmget(context, key, fields) {
         AND field = ANY($2::text[])
     `;
         const sql = context.appendExpiryClause(baseQuery, tableName);
-        return { sql, params: [key, fields] };
+        return { sql, params: [context.storageKey(key), fields] };
     }
 }
 exports._hmget = _hmget;
@@ -538,7 +538,7 @@ function _hgetall(context, key) {
         FROM ${tableName}
         WHERE key = $1
       `, tableName);
-        return { sql, params: [key] };
+        return { sql, params: [context.storageKey(key)] };
     }
 }
 exports._hgetall = _hgetall;
@@ -582,7 +582,7 @@ function _hincrbyfloat(context, key, field, increment) {
       SET value = ((COALESCE(${tableName}.value, '0')::double precision + $3::double precision)::text)
       RETURNING value
     `;
-        return { sql, params: [key, field, increment] };
+        return { sql, params: [context.storageKey(key), field, increment] };
     }
 }
 exports._hincrbyfloat = _hincrbyfloat;

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

@@ -68,7 +68,8 @@ function createScanOperations(context) {
 exports.createScanOperations = createScanOperations;
 function _hscan(context, key, cursor, count, pattern) {
     const tableName = context.tableForKey(key, 'hash');
-    const params = [key];
+    const isJobs = tableName.endsWith('jobs');
+    const params = [isJobs ? key : context.storageKey(key)];
     let sql = `
     SELECT field, value FROM ${tableName}
     WHERE key = $1 AND (expiry IS NULL OR expiry > NOW())

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

@@ -44,7 +44,7 @@ const listModule = (context) => ({
       WHERE rn BETWEEN indices.adjusted_start AND indices.adjusted_end
       ORDER BY rn ASC
     `;
-        const params = [key, start, end];
+        const params = [context.storageKey(key), start, end];
         return { sql, params };
     },
     async rpush(key, value, multi) {
@@ -82,7 +82,7 @@ const listModule = (context) => ({
       )
       SELECT COUNT(*) as count FROM inserted
     `;
-        const params = [key, ...values];
+        const params = [context.storageKey(key), ...values];
         return { sql, params };
     },
     async lpush(key, value, multi) {
@@ -120,7 +120,7 @@ const listModule = (context) => ({
       )
       SELECT COUNT(*) as count FROM inserted
     `;
-        const params = [key, ...values];
+        const params = [context.storageKey(key), ...values];
         return { sql, params };
     },
     async lpop(key, multi) {
@@ -146,6 +146,7 @@ const listModule = (context) => ({
     },
     _lpop(key) {
         const tableName = context.tableForKey(key, 'list');
+        const sKey = context.storageKey(key);
         const sql = `
       DELETE FROM ${tableName}
       WHERE key = $1 AND "index" = (
@@ -153,7 +154,7 @@ const listModule = (context) => ({
       )
       RETURNING value
     `;
-        const params = [key];
+        const params = [sKey];
         return { sql, params };
     },
     async lmove(source, destination, srcPosition, destPosition, multi) {
@@ -209,7 +210,7 @@ const listModule = (context) => ({
       )
       SELECT value FROM inserted
     `;
-        const params = [source, destination];
+        const params = [context.storageKey(source), context.storageKey(destination)];
         return { sql, params };
     },
     async rename(oldKey, newKey, multi) {
@@ -245,7 +246,7 @@ const listModule = (context) => ({
         const sql = `
       UPDATE ${tableName} SET key = $2 WHERE key = $1;
     `;
-        const params = [oldKey, newKey];
+        const params = [context.storageKey(oldKey), context.storageKey(newKey)];
         return { sql, params };
     },
 });

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

@@ -30,7 +30,7 @@ const stringModule = (context) => ({
       WHERE key = $1 AND (expiry IS NULL OR expiry > NOW())
       LIMIT 1
     `;
-        const params = [key];
+        const params = [context.storageKey(key)];
         return { sql, params };
     },
     async setnx(key, value, multi) {
@@ -99,7 +99,7 @@ const stringModule = (context) => ({
     _set(key, value, options) {
         const tableName = context.tableForKey(key);
         let sql = '';
-        const params = [key, value];
+        const params = [context.storageKey(key), value];
         let expiryClause = '';
         if (options?.ex) {
             expiryClause = ", expiry = NOW() + INTERVAL '" + options.ex + " seconds'";
@@ -158,7 +158,7 @@ const stringModule = (context) => ({
       )
       SELECT COUNT(*) as count FROM deleted
     `;
-        const params = [key];
+        const params = [context.storageKey(key)];
         return { sql, params };
     },
 });

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

@@ -26,7 +26,7 @@ const zsetModule = (context) => ({
     _zadd(key, score, member, options) {
         const tableName = context.tableForKey(key, 'sorted_set');
         let sql = '';
-        const params = [key, member, score];
+        const params = [context.storageKey(key), member, score];
         if (options?.nx) {
             sql = `
         INSERT INTO ${tableName} (key, member, score)
@@ -105,7 +105,7 @@ const zsetModule = (context) => ({
                   AND LEAST(GREATEST(adjusted_stop, 0), max_index)
       ORDER BY rn ASC;
     `;
-        const params = [key, start, stop];
+        const params = [context.storageKey(key), start, stop];
         return { sql, params };
     },
     async zscore(key, member, multi) {
@@ -142,7 +142,7 @@ const zsetModule = (context) => ({
         AND (expiry IS NULL OR expiry > NOW())
       LIMIT 1
     `;
-        const params = [key, member];
+        const params = [context.storageKey(key), member];
         return { sql, params };
     },
     async zrangebyscore(key, min, max, multi) {
@@ -173,7 +173,7 @@ const zsetModule = (context) => ({
       WHERE key = $1 AND score BETWEEN $2 AND $3 AND (expiry IS NULL OR expiry > NOW())
       ORDER BY score ASC, member ASC
     `;
-        const params = [key, min, max];
+        const params = [context.storageKey(key), min, max];
         return { sql, params };
     },
     async zrangebyscore_withscores(key, min, max, multi) {
@@ -204,7 +204,7 @@ const zsetModule = (context) => ({
       WHERE key = $1 AND score BETWEEN $2 AND $3 AND (expiry IS NULL OR expiry > NOW())
       ORDER BY score ASC, member ASC
     `;
-        const params = [key, min, max];
+        const params = [context.storageKey(key), min, max];
         return { sql, params };
     },
     async zrem(key, member, multi) {
@@ -238,7 +238,7 @@ const zsetModule = (context) => ({
       )
       SELECT COUNT(*) as count FROM deleted
     `;
-        const params = [key, member];
+        const params = [context.storageKey(key), member];
         return { sql, params };
     },
     async zrank(key, member, multi) {
@@ -277,7 +277,7 @@ const zsetModule = (context) => ({
       WHERE ms.key = $1 AND (expiry IS NULL OR expiry > NOW())
       AND (ms.score < member_score.score OR (ms.score = member_score.score AND ms.member < $2))
     `;
-        const params = [key, member];
+        const params = [context.storageKey(key), member];
         return { sql, params };
     },
 });

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

@@ -21,7 +21,7 @@ declare class PostgresStoreService extends StoreService<ProviderClient, Provider
     isScout: boolean;
     transact(): ProviderTransaction;
     constructor(storeClient: ProviderClient);
-    init(namespace: string, appId: string, logger: ILogger): Promise<HotMeshApps>;
+    init(namespace: string, appId: string, logger: ILogger, guid?: string, role?: string): Promise<HotMeshApps>;
     isSuccessful(result: any): boolean;
     delistSignalKey(key: string, target: string): Promise<void>;
     zAdd(key: string, score: number | string, value: string | number, transaction?: ProviderTransaction): Promise<any>;
@@ -40,8 +40,9 @@ declare class PostgresStoreService extends StoreService<ProviderClient, Provider
      */
     reserveScoutRole(scoutType: ScoutType, delay?: number): Promise<boolean>;
     releaseScoutRole(scoutType: ScoutType): Promise<boolean>;
-    getSettings(bCreate?: boolean): Promise<HotMeshSettings>;
+    getSettings(bCreate?: boolean, guid?: string, role?: string): Promise<HotMeshSettings>;
     setSettings(manifest: HotMeshSettings): Promise<any>;
+    registerConnection(guid: string, role: string, version: string): Promise<void>;
     reserveSymbolRange(target: string, size: number, type: 'JOB' | 'ACTIVITY', tryCount?: number): Promise<[number, number, Symbols]>;
     getAllSymbols(): Promise<Symbols>;
     getSymbols(activityId: string): Promise<Symbols>;

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

@@ -50,7 +50,7 @@ class PostgresStoreService extends __1.StoreService {
         //kvTables will provision tables and indexes in the Postgres db as necessary
         this.kvTables = (0, kvtables_1.KVTables)(this);
     }
-    async init(namespace = key_1.HMNS, appId, logger) {
+    async init(namespace = key_1.HMNS, appId, logger, guid, role) {
         //bind appId and namespace to storeClient once initialized
         // (it uses these values to construct keys for the store)
         this.storeClient.namespace = this.namespace = namespace;
@@ -61,7 +61,7 @@ class PostgresStoreService extends __1.StoreService {
         // Deploy time notification triggers
         await this.deployTimeNotificationTriggers(appId);
         //note: getSettings will contact db to confirm r/w access
-        const settings = await this.getSettings(true);
+        const settings = await this.getSettings(true, guid, role);
         this.cache = new cache_1.Cache(appId, settings);
         this.serializer = new serializer_1.SerializerService();
         await this.getApp(appId);
@@ -119,7 +119,7 @@ class PostgresStoreService extends __1.StoreService {
         const success = await this.kvsql().del(key);
         return this.isSuccessful(success);
     }
-    async getSettings(bCreate = false) {
+    async getSettings(bCreate = false, guid, role) {
         let settings = this.cache?.getSettings();
         if (settings) {
             return settings;
@@ -129,17 +129,25 @@ class PostgresStoreService extends __1.StoreService {
                 const packageJson = await Promise.resolve().then(() => __importStar(require('../../../../package.json')));
                 const version = packageJson['version'] || '0.0.0';
                 settings = { namespace: key_1.HMNS, version };
-                await this.setSettings(settings);
+                if (guid && role) {
+                    await this.registerConnection(guid, role, version);
+                }
                 return settings;
             }
         }
         throw new Error('settings not found');
     }
     async setSettings(manifest) {
-        //HotMesh heartbeat. If a connection is made, the version will be set
-        const params = {};
-        const key = this.mintKey(key_1.KeyType.HOTMESH, params);
-        return await this.kvsql().hset(key, manifest);
+        // No-op for Postgres — settings are derived from package.json
+        // and connections are registered via registerConnection()
+        return;
+    }
+    async registerConnection(guid, role, version) {
+        const sql = `INSERT INTO public.hmsh_connections (guid, app_id, role, version)
+      VALUES ($1, $2, $3, $4)
+      ON CONFLICT (guid, app_id) DO UPDATE SET
+        version = EXCLUDED.version, connected_at = NOW()`;
+        await this.pgClient.query(sql, [guid, this.appId, role, version]);
     }
     async reserveSymbolRange(target, size, type, tryCount = 1) {
         const rangeKey = this.mintKey(key_1.KeyType.SYMKEYS, { appId: this.appId });
@@ -294,73 +302,65 @@ class PostgresStoreService extends __1.StoreService {
         return symKeys;
     }
     async getApp(id, refresh = false) {
-        let app = this.cache.getApp(id);
+        let app = this.cache?.getApp(id);
         if (refresh || !(app && Object.keys(app).length > 0)) {
-            const params = { appId: id };
-            const key = this.mintKey(key_1.KeyType.APP, params);
-            const sApp = await this.kvsql().hgetall(key);
-            if (!sApp)
+            // Fetch from relational tables
+            const appResult = await this.pgClient.query(`SELECT app_id, version, active, settings FROM public.hmsh_applications WHERE app_id = $1`, [id]);
+            if (!appResult.rows.length)
                 return null;
-            app = {};
-            for (const field in sApp) {
-                try {
-                    if (field === 'active') {
-                        app[field] = sApp[field] === 'true';
-                    }
-                    else {
-                        app[field] = sApp[field];
-                    }
-                }
-                catch (e) {
-                    app[field] = sApp[field];
-                }
+            const row = appResult.rows[0];
+            app = {
+                id: row.app_id,
+                version: row.version,
+                active: row.active,
+            };
+            // Fetch version history
+            const versionsResult = await this.pgClient.query(`SELECT version, status, deployed_at FROM public.hmsh_application_versions WHERE app_id = $1`, [id]);
+            for (const vRow of versionsResult.rows) {
+                app[`versions/${vRow.version}`] = `${vRow.status}:${(0, utils_1.formatISODate)(new Date(vRow.deployed_at))}`;
             }
-            this.cache.setApp(id, app);
+            this.cache?.setApp(id, app);
         }
         return app;
     }
     async setApp(id, version) {
-        const params = { appId: id };
-        const key = this.mintKey(key_1.KeyType.APP, params);
-        const versionId = `versions/${version}`;
+        const now = new Date();
+        // Upsert into applications
+        await this.pgClient.query(`INSERT INTO public.hmsh_applications (app_id, version, active, updated_at)
+       VALUES ($1, $2, TRUE, $3)
+       ON CONFLICT (app_id) DO UPDATE SET version = $2, updated_at = $3`, [id, version, now]);
+        // Insert version record
+        await this.pgClient.query(`INSERT INTO public.hmsh_application_versions (app_id, version, status, deployed_at)
+       VALUES ($1, $2, 'deployed', $3)
+       ON CONFLICT (app_id, version) DO UPDATE SET status = 'deployed', deployed_at = $3`, [id, version, now]);
         const payload = {
             id,
             version,
-            [versionId]: `deployed:${(0, utils_1.formatISODate)(new Date())}`,
+            [`versions/${version}`]: `deployed:${(0, utils_1.formatISODate)(now)}`,
         };
-        await this.kvsql().hset(key, payload);
-        this.cache.setApp(id, payload);
+        this.cache?.setApp(id, payload);
         return payload;
     }
     async activateAppVersion(id, version) {
-        const params = { appId: id };
-        const key = this.mintKey(key_1.KeyType.APP, params);
-        const versionId = `versions/${version}`;
         const app = await this.getApp(id, true);
+        const versionId = `versions/${version}`;
         if (app && app[versionId]) {
-            const payload = {
-                id,
-                version: version.toString(),
-                [versionId]: `activated:${(0, utils_1.formatISODate)(new Date())}`,
-                active: true,
-            };
-            Object.entries(payload).forEach(([key, value]) => {
-                payload[key] = value.toString();
-            });
-            await this.kvsql().hset(key, payload);
+            const now = new Date();
+            await this.pgClient.query(`UPDATE public.hmsh_applications SET active = TRUE, version = $2, updated_at = $3 WHERE app_id = $1`, [id, version, now]);
+            await this.pgClient.query(`UPDATE public.hmsh_application_versions SET status = 'activated', deployed_at = $3 WHERE app_id = $1 AND version = $2`, [id, version, now]);
             return true;
         }
         throw new Error(`Version ${version} does not exist for app ${id}`);
     }
     async registerAppVersion(appId, version) {
-        const params = { appId };
-        const key = this.mintKey(key_1.KeyType.APP, params);
-        const payload = {
-            id: appId,
-            version: version.toString(),
-            [`versions/${version}`]: (0, utils_1.formatISODate)(new Date()),
-        };
-        return await this.kvsql().hset(key, payload);
+        const now = new Date();
+        await this.pgClient.query(`INSERT INTO public.hmsh_applications (app_id, version, active, updated_at)
+       VALUES ($1, $2, TRUE, $3)
+       ON CONFLICT (app_id) DO UPDATE SET version = $2, updated_at = $3`, [appId, version, now]);
+        await this.pgClient.query(`INSERT INTO public.hmsh_application_versions (app_id, version, status, deployed_at)
+       VALUES ($1, $2, 'deployed', $3)
+       ON CONFLICT (app_id, version) DO UPDATE SET status = 'deployed', deployed_at = $3`, [appId, version, now]);
+        return 1;
     }
     async setStats(jobKey, jobId, dateTime, stats, appVersion, transaction) {
         const params = {
@@ -1252,7 +1252,7 @@ class PostgresStoreService extends __1.StoreService {
      */
     async getNextAwakeningTime() {
         const schemaName = this.kvsql().safeName(this.appId);
-        const appKey = `${this.appId}:time_range`;
+        const appKey = '';
         try {
             const result = await this.pgClient.query(`SELECT ${schemaName}.get_next_awakening_time($1) as next_time`, [appKey]);
             if (result.rows[0]?.next_time) {

package/build/services/store/providers/postgres/time-notify.js

@@ -20,25 +20,26 @@ DECLARE
     next_time TIMESTAMP WITH TIME ZONE;
 BEGIN
     -- Get the earliest (lowest score) entry from the time range ZSET
+    -- After normalization, the key is empty string (prefix stripped)
     SELECT score INTO next_score
     FROM ${schema}.task_schedules
-    WHERE key = app_key
+    WHERE key = ''
     AND (expiry IS NULL OR expiry > NOW())
     ORDER BY score ASC
     LIMIT 1;
-    
+
     IF next_score IS NULL THEN
         RETURN NULL;
     END IF;
-    
+
     -- Convert epoch milliseconds to timestamp
     next_time := to_timestamp(next_score / 1000.0);
-    
+
     -- Only return if it's in the future
     IF next_time > NOW() THEN
         RETURN next_time;
     END IF;
-    
+
     RETURN NULL;
 END;
 $$ LANGUAGE plpgsql;
@@ -54,8 +55,8 @@ DECLARE
     current_next_time TIMESTAMP WITH TIME ZONE;
     app_key TEXT;
 BEGIN
-    -- Build the time range key for this app
-    app_key := app_id || ':time_range';
+    -- After normalization, the key is empty string
+    app_key := '';
     channel_name := 'time_hooks_' || app_id;
     
     -- Get the current next awakening time
@@ -101,18 +102,14 @@ $$ LANGUAGE plpgsql;
 CREATE OR REPLACE FUNCTION ${schema}.on_time_hook_change()
 RETURNS TRIGGER AS $$
 DECLARE
-    app_id_extracted TEXT;
     awakening_time TIMESTAMP WITH TIME ZONE;
 BEGIN
-    -- Extract app_id from the key (assumes format: app_id:time_range)
-    app_id_extracted := split_part(NEW.key, ':time_range', 1);
-    
     -- Convert the score (epoch milliseconds) to timestamp
     awakening_time := to_timestamp(NEW.score / 1000.0);
-    
-    -- Schedule notification for this new awakening time
-    PERFORM ${schema}.schedule_time_notification(app_id_extracted, awakening_time);
-    
+
+    -- Schedule notification (app_id is the schema name)
+    PERFORM ${schema}.schedule_time_notification('${schema}', awakening_time);
+
     RETURN NEW;
 END;
 $$ LANGUAGE plpgsql;
@@ -120,15 +117,10 @@ $$ LANGUAGE plpgsql;
 -- Trigger function for when time hooks are removed
 CREATE OR REPLACE FUNCTION ${schema}.on_time_hook_remove()
 RETURNS TRIGGER AS $$
-DECLARE
-    app_id_extracted TEXT;
 BEGIN
-    -- Extract app_id from the key
-    app_id_extracted := split_part(OLD.key, ':time_range', 1);
-    
     -- Recalculate and notify about the schedule update
-    PERFORM ${schema}.schedule_time_notification(app_id_extracted);
-    
+    PERFORM ${schema}.schedule_time_notification('${schema}');
+
     RETURN OLD;
 END;
 $$ LANGUAGE plpgsql;
@@ -141,22 +133,23 @@ DROP TRIGGER IF EXISTS trg_time_hook_update ON ${schema}.task_schedules;
 DROP TRIGGER IF EXISTS trg_time_hook_delete ON ${schema}.task_schedules;
 
 -- Create new triggers
+-- After normalization, the task_schedules key for time range is empty string
 CREATE TRIGGER trg_time_hook_insert
     AFTER INSERT ON ${schema}.task_schedules
     FOR EACH ROW
-    WHEN (NEW.key LIKE '%:time_range')
+    WHEN (NEW.key = '')
     EXECUTE FUNCTION ${schema}.on_time_hook_change();
 
 CREATE TRIGGER trg_time_hook_update
     AFTER UPDATE ON ${schema}.task_schedules
     FOR EACH ROW
-    WHEN (NEW.key LIKE '%:time_range')
+    WHEN (NEW.key = '')
     EXECUTE FUNCTION ${schema}.on_time_hook_change();
 
 CREATE TRIGGER trg_time_hook_delete
     AFTER DELETE ON ${schema}.task_schedules
     FOR EACH ROW
-    WHEN (OLD.key LIKE '%:time_range')
+    WHEN (OLD.key = '')
     EXECUTE FUNCTION ${schema}.on_time_hook_remove();
 `;
 }

package/build/services/store/providers/store-initializable.d.ts

@@ -1,5 +1,5 @@
 import { ILogger } from '../../logger';
 import { HotMeshApps } from '../../../types/hotmesh';
 export interface StoreInitializable {
-    init(namespace: string, appId: string, logger: ILogger): Promise<HotMeshApps>;
+    init(namespace: string, appId: string, logger: ILogger, guid?: string, role?: string): Promise<HotMeshApps>;
 }