@hotmeshio/hotmesh 0.4.0 → 0.4.2

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

@@ -0,0 +1,33 @@
+import { ProviderTransaction } from '../../../../../types/provider';
+export declare const listModule: (context: any) => {
+    lrange(key: string, start: number, end: number, multi?: ProviderTransaction): Promise<string[]>;
+    _lrange(key: string, start: number, end: number): {
+        sql: string;
+        params: any[];
+    };
+    rpush(key: string, value: string | string[], multi?: ProviderTransaction): Promise<number>;
+    _rpush(key: string, value: string | string[]): {
+        sql: string;
+        params: any[];
+    };
+    lpush(key: string, value: string | string[], multi?: ProviderTransaction): Promise<number>;
+    _lpush(key: string, value: string | string[]): {
+        sql: string;
+        params: any[];
+    };
+    lpop(key: string, multi?: ProviderTransaction): Promise<string | null>;
+    _lpop(key: string): {
+        sql: string;
+        params: any[];
+    };
+    lmove(source: string, destination: string, srcPosition: 'LEFT' | 'RIGHT', destPosition: 'LEFT' | 'RIGHT', multi?: ProviderTransaction): Promise<string | null>;
+    _lmove(source: string, destination: string, srcPosition: 'LEFT' | 'RIGHT', destPosition: 'LEFT' | 'RIGHT'): {
+        sql: string;
+        params: any[];
+    };
+    rename(oldKey: string, newKey: string, multi?: ProviderTransaction): Promise<void>;
+    _rename(oldKey: string, newKey: string): {
+        sql: string;
+        params: any[];
+    };
+};

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

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listModule = void 0;
+const listModule = (context) => ({
+    async lrange(key, start, end, multi) {
+        const { sql, params } = this._lrange(key, start, end);
+        if (multi) {
+            multi.addCommand(sql, params, 'array', (rows) => rows.map((row) => row.value));
+            return Promise.resolve([]);
+        }
+        else {
+            const res = await context.pgClient.query(sql, params);
+            return res.rows.map((row) => row.value);
+        }
+    },
+    _lrange(key, start, end) {
+        const tableName = context.tableForKey(key, 'list');
+        const sql = `
+      WITH numbered AS (
+        SELECT value,
+              ROW_NUMBER() OVER (ORDER BY "index" ASC) - 1 AS rn,
+              COUNT(*) OVER() - 1 AS max_index
+        FROM ${tableName}
+        WHERE key = $1 AND (expiry IS NULL OR expiry > NOW())
+      ),
+      indices AS (
+        SELECT
+          LEAST(GREATEST(CASE WHEN $2 >= 0 THEN $2 ELSE max_index + $2 + 1 END, 0), max_index) AS adjusted_start,
+          LEAST(GREATEST(CASE WHEN $3 >= 0 THEN $3 ELSE max_index + $3 + 1 END, 0), max_index) AS adjusted_end
+        FROM (SELECT max_index FROM numbered LIMIT 1) AS mi
+      )
+      SELECT value
+      FROM numbered, indices
+      WHERE rn BETWEEN indices.adjusted_start AND indices.adjusted_end
+      ORDER BY rn ASC
+    `;
+        const params = [key, start, end];
+        return { sql, params };
+    },
+    async rpush(key, value, multi) {
+        const { sql, params } = this._rpush(key, value);
+        if (multi) {
+            multi.addCommand(sql, params, 'number', (rows) => rows[0]?.count || 0);
+            return Promise.resolve(0);
+        }
+        else {
+            const res = await context.pgClient.query(sql, params);
+            return Number(res.rows[0]?.count || 0);
+        }
+    },
+    _rpush(key, value) {
+        const tableName = context.tableForKey(key, 'list');
+        const values = Array.isArray(value) ? value : [value];
+        const placeholders = values
+            .map((_, i) => `($1, (SELECT COALESCE(MAX("index"), 0) + ${i + 1} FROM ${tableName} WHERE key = $1), $${i + 2})`)
+            .join(', ');
+        const sql = `
+      WITH inserted AS (
+        INSERT INTO ${tableName} (key, "index", value)
+        VALUES ${placeholders}
+        RETURNING 1
+      )
+      SELECT COUNT(*) as count FROM inserted
+    `;
+        const params = [key, ...values];
+        return { sql, params };
+    },
+    async lpush(key, value, multi) {
+        const { sql, params } = this._lpush(key, value);
+        if (multi) {
+            multi.addCommand(sql, params, 'number', (rows) => rows[0]?.count || 0);
+            return Promise.resolve(0);
+        }
+        else {
+            const res = await context.pgClient.query(sql, params);
+            return Number(res.rows[0]?.count || 0);
+        }
+    },
+    _lpush(key, value) {
+        const tableName = context.tableForKey(key, 'list');
+        const values = Array.isArray(value) ? value : [value];
+        const placeholders = values
+            .map((_, i) => `($1, (SELECT COALESCE(MIN("index"), 0) - ${i + 1} FROM ${tableName} WHERE key = $1), $${i + 2})`)
+            .join(', ');
+        const sql = `
+      WITH inserted AS (
+        INSERT INTO ${tableName} (key, "index", value)
+        VALUES ${placeholders}
+        RETURNING 1
+      )
+      SELECT COUNT(*) as count FROM inserted
+    `;
+        const params = [key, ...values];
+        return { sql, params };
+    },
+    async lpop(key, multi) {
+        const { sql, params } = this._lpop(key);
+        if (multi) {
+            multi.addCommand(sql, params, 'string');
+            return Promise.resolve(null);
+        }
+        else {
+            const res = await context.pgClient.query(sql, params);
+            return res.rows[0]?.value || null;
+        }
+    },
+    _lpop(key) {
+        const tableName = context.tableForKey(key, 'list');
+        const sql = `
+      DELETE FROM ${tableName}
+      WHERE key = $1 AND "index" = (
+        SELECT MIN("index") FROM ${tableName} WHERE key = $1 AND (expiry IS NULL OR expiry > NOW())
+      )
+      RETURNING value
+    `;
+        const params = [key];
+        return { sql, params };
+    },
+    async lmove(source, destination, srcPosition, destPosition, multi) {
+        const { sql, params } = this._lmove(source, destination, srcPosition, destPosition);
+        if (multi) {
+            multi.addCommand(sql, params, 'string');
+            return Promise.resolve(null);
+        }
+        else {
+            const client = context.pgClient;
+            try {
+                await client.query('BEGIN');
+                const res = await client.query(sql, params);
+                await client.query('COMMIT');
+                return res.rows[0]?.value || null;
+            }
+            catch (err) {
+                await client.query('ROLLBACK');
+                throw err;
+            }
+        }
+    },
+    _lmove(source, destination, srcPosition, destPosition) {
+        const tableName = context.tableForKey(source, 'list');
+        const srcOrder = srcPosition === 'LEFT' ? 'ASC' : 'DESC';
+        const destIndexAdjustment = destPosition === 'LEFT'
+            ? `(SELECT COALESCE(MIN("index"), 0) - 1 FROM ${tableName} WHERE key = $2)`
+            : `(SELECT COALESCE(MAX("index"), 0) + 1 FROM ${tableName} WHERE key = $2)`;
+        const sql = `
+      WITH moved AS (
+        DELETE FROM ${tableName}
+        WHERE ctid IN (
+          SELECT ctid FROM ${tableName}
+          WHERE key = $1 AND (expiry IS NULL OR expiry > NOW())
+          ORDER BY "index" ${srcOrder}
+          LIMIT 1
+        )
+        RETURNING value
+      ),
+      inserted AS (
+        INSERT INTO ${tableName} (key, "index", value)
+        SELECT $2, ${destIndexAdjustment}, value FROM moved
+        RETURNING value
+      )
+      SELECT value FROM inserted
+    `;
+        const params = [source, destination];
+        return { sql, params };
+    },
+    async rename(oldKey, newKey, multi) {
+        const { sql, params } = this._rename(oldKey, newKey);
+        if (multi) {
+            multi.addCommand(sql, params, 'void');
+            return Promise.resolve();
+        }
+        else {
+            const client = context.pgClient;
+            try {
+                await client.query('BEGIN');
+                await client.query(sql, params);
+                await client.query('COMMIT');
+            }
+            catch (err) {
+                await client.query('ROLLBACK');
+                throw err;
+            }
+        }
+    },
+    _rename(oldKey, newKey) {
+        const tableName = context.tableForKey(oldKey, 'list');
+        const sql = `
+      UPDATE ${tableName} SET key = $2 WHERE key = $1;
+    `;
+        const params = [oldKey, newKey];
+        return { sql, params };
+    },
+});
+exports.listModule = listModule;

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

@@ -0,0 +1,20 @@
+import { ProviderTransaction, SetOptions } from '../../../../../types/provider';
+export declare const stringModule: (context: any) => {
+    get(key: string, multi?: ProviderTransaction): Promise<string | null>;
+    _get(key: string): {
+        sql: string;
+        params: any[];
+    };
+    setnx(key: string, value: string, multi?: ProviderTransaction): Promise<boolean>;
+    setnxex(key: string, value: string, delay: number, multi?: ProviderTransaction): Promise<boolean>;
+    set(key: string, value: string, options?: SetOptions, multi?: ProviderTransaction): Promise<boolean>;
+    _set(key: string, value: string, options?: SetOptions): {
+        sql: string;
+        params: any[];
+    };
+    del(key: string, multi?: ProviderTransaction): Promise<number>;
+    _del(key: string): {
+        sql: string;
+        params: any[];
+    };
+};

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

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringModule = void 0;
+const stringModule = (context) => ({
+    async get(key, multi) {
+        const { sql, params } = this._get(key);
+        if (multi) {
+            multi.addCommand(sql, params, 'string');
+            return Promise.resolve(null);
+        }
+        else {
+            const res = await context.pgClient.query(sql, params);
+            return res.rows[0]?.value || null;
+        }
+    },
+    _get(key) {
+        const tableName = context.tableForKey(key);
+        const sql = `
+      SELECT value FROM ${tableName}
+      WHERE key = $1 AND (expiry IS NULL OR expiry > NOW())
+      LIMIT 1
+    `;
+        const params = [key];
+        return { sql, params };
+    },
+    async setnx(key, value, multi) {
+        const { sql, params } = this._set(key, value, { nx: true });
+        if (multi) {
+            multi.addCommand(sql, params, 'boolean');
+            return Promise.resolve(true);
+        }
+        else {
+            const res = await context.pgClient.query(sql, params);
+            return res.rowCount > 0;
+        }
+    },
+    async setnxex(key, value, delay, multi) {
+        const { sql, params } = this._set(key, value, { nx: true, ex: delay });
+        if (multi) {
+            multi.addCommand(sql, params, 'boolean');
+            return Promise.resolve(true);
+        }
+        else {
+            const res = await context.pgClient.query(sql, params);
+            return res.rowCount > 0;
+        }
+    },
+    async set(key, value, options, multi) {
+        const { sql, params } = this._set(key, value, options);
+        if (multi) {
+            multi.addCommand(sql, params, 'boolean');
+            return Promise.resolve(true);
+        }
+        else {
+            const res = await context.pgClient.query(sql, params);
+            return res.rowCount > 0;
+        }
+    },
+    _set(key, value, options) {
+        const tableName = context.tableForKey(key);
+        let sql = '';
+        const params = [key, value];
+        let expiryClause = '';
+        if (options?.ex) {
+            expiryClause = ", expiry = NOW() + INTERVAL '" + options.ex + " seconds'";
+        }
+        if (options?.nx) {
+            // INSERT only if no valid ownership exists
+            sql = `
+        INSERT INTO ${tableName} (key, value${expiryClause ? ', expiry' : ''})
+        VALUES ($1, $2${expiryClause ? ", NOW() + INTERVAL '" + options.ex + " seconds'" : ''})
+        ON CONFLICT (key) DO UPDATE
+        SET value = EXCLUDED.value${expiryClause ? ', expiry = EXCLUDED.expiry' : ''}
+        WHERE ${tableName}.expiry IS NULL OR ${tableName}.expiry <= NOW()
+        RETURNING true as success
+      `;
+        }
+        else {
+            // INSERT or UPDATE, reclaiming expired ownership if necessary
+            sql = `
+        INSERT INTO ${tableName} (key, value${expiryClause ? ', expiry' : ''})
+        VALUES ($1, $2${expiryClause ? ", NOW() + INTERVAL '" + options.ex + " seconds'" : ''})
+        ON CONFLICT (key) DO UPDATE
+        SET value = EXCLUDED.value${expiryClause ? ', expiry = EXCLUDED.expiry' : ''}
+        WHERE ${tableName}.expiry IS NULL OR ${tableName}.expiry <= NOW()
+        RETURNING true as success
+      `;
+        }
+        return { sql, params };
+    },
+    async del(key, multi) {
+        const { sql, params } = this._del(key);
+        if (multi) {
+            multi.addCommand(sql, params, 'number');
+            return Promise.resolve(0);
+        }
+        else {
+            const res = await context.pgClient.query(sql, params);
+            return Number(res.rows[0]?.count || 0);
+        }
+    },
+    _del(key) {
+        const tableName = context.tableForKey(key);
+        const sql = `
+      WITH deleted AS (
+        DELETE FROM ${tableName} WHERE key = $1
+        RETURNING 1
+      )
+      SELECT COUNT(*) as count FROM deleted
+    `;
+        const params = [key];
+        return { sql, params };
+    },
+});
+exports.stringModule = stringModule;

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

@@ -0,0 +1,41 @@
+import { ProviderTransaction, ZAddOptions } from '../../../../../types/provider';
+export declare const zsetModule: (context: any) => {
+    zadd(key: string, score: number, member: string, options?: ZAddOptions, multi?: ProviderTransaction): Promise<number>;
+    _zadd(key: string, score: number, member: string, options?: ZAddOptions): {
+        sql: string;
+        params: any[];
+    };
+    zrange(key: string, start: number, stop: number, facet?: 'WITHSCORES', multi?: ProviderTransaction): Promise<string[]>;
+    _zrange(key: string, start: number, stop: number, facet?: 'WITHSCORES'): {
+        sql: string;
+        params: any[];
+    };
+    zscore(key: string, member: string, multi?: ProviderTransaction): Promise<number | null>;
+    _zscore(key: string, member: string): {
+        sql: string;
+        params: any[];
+    };
+    zrangebyscore(key: string, min: number, max: number, multi?: ProviderTransaction): Promise<string[]>;
+    _zrangebyscore(key: string, min: number, max: number): {
+        sql: string;
+        params: any[];
+    };
+    zrangebyscore_withscores(key: string, min: number, max: number, multi?: ProviderTransaction): Promise<{
+        member: string;
+        score: number;
+    }[]>;
+    _zrangebyscore_withscores(key: string, min: number, max: number): {
+        sql: string;
+        params: any[];
+    };
+    zrem(key: string, member: string, multi?: ProviderTransaction): Promise<number>;
+    _zrem(key: string, member: string): {
+        sql: string;
+        params: any[];
+    };
+    zrank(key: string, member: string, multi?: ProviderTransaction): Promise<number | null>;
+    _zrank(key: string, member: string): {
+        sql: string;
+        params: any[];
+    };
+};

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

@@ -0,0 +1,214 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zsetModule = void 0;
+const zsetModule = (context) => ({
+    async zadd(key, score, member, options, multi) {
+        const { sql, params } = this._zadd(key, score, member, options);
+        if (multi) {
+            multi.addCommand(sql, params, 'number', (rows) => rows[0]?.count || 0);
+            return Promise.resolve(0);
+        }
+        else {
+            const res = await context.pgClient.query(sql, params);
+            return Number(res.rows[0]?.count || 0);
+        }
+    },
+    _zadd(key, score, member, options) {
+        const tableName = context.tableForKey(key, 'sorted_set');
+        let sql = '';
+        const params = [key, member, score];
+        if (options?.nx) {
+            sql = `
+        INSERT INTO ${tableName} (key, member, score)
+        VALUES ($1, $2, $3)
+        ON CONFLICT DO NOTHING
+        RETURNING 1 as count
+      `;
+        }
+        else {
+            sql = `
+        INSERT INTO ${tableName} (key, member, score)
+        VALUES ($1, $2, $3)
+        ON CONFLICT (key, member) DO UPDATE SET score = $3
+        RETURNING 1 as count
+      `;
+        }
+        return { sql, params };
+    },
+    async zrange(key, start, stop, facet, multi) {
+        const { sql, params } = this._zrange(key, start, stop, facet);
+        if (multi) {
+            multi.addCommand(sql, params, 'array', (rows) => {
+                if (facet === 'WITHSCORES') {
+                    // Include scores in the result
+                    return rows.flatMap((row) => [row.member, row.score.toString()]);
+                }
+                else {
+                    return rows.map((row) => row.member);
+                }
+            });
+            return Promise.resolve([]);
+        }
+        else {
+            const res = await context.pgClient.query(sql, params);
+            if (facet === 'WITHSCORES') {
+                // Include scores in the result
+                return res.rows.flatMap((row) => [row.member, row.score.toString()]);
+            }
+            else {
+                return res.rows.map((row) => row.member);
+            }
+        }
+    },
+    _zrange(key, start, stop, facet) {
+        const tableName = context.tableForKey(key, 'sorted_set');
+        const selectColumns = facet === 'WITHSCORES' ? 'member, score' : 'member';
+        const sql = `
+      WITH total_entries AS (
+        SELECT COUNT(*) - 1 AS max_index FROM ${tableName}
+        WHERE key = $1 AND (expiry IS NULL OR expiry > NOW())
+      ), ordered_entries AS (
+        SELECT ${selectColumns},
+              ROW_NUMBER() OVER (ORDER BY score ASC, member ASC) - 1 AS rn,
+              (SELECT max_index FROM total_entries) AS max_index
+        FROM ${tableName}
+        WHERE key = $1 AND (expiry IS NULL OR expiry > NOW())
+      ), indices AS (
+        SELECT
+          CASE WHEN $2 >= 0 THEN $2 ELSE max_index + $2 + 1 END AS adjusted_start,
+          CASE WHEN $3 >= 0 THEN $3 ELSE max_index + $3 + 1 END AS adjusted_stop
+        FROM total_entries
+      )
+      SELECT ${selectColumns}
+      FROM ordered_entries, indices
+      WHERE rn BETWEEN LEAST(GREATEST(adjusted_start, 0), max_index)
+                  AND LEAST(GREATEST(adjusted_stop, 0), max_index)
+      ORDER BY rn ASC;
+    `;
+        const params = [key, start, stop];
+        return { sql, params };
+    },
+    async zscore(key, member, multi) {
+        const { sql, params } = this._zscore(key, member);
+        if (multi) {
+            multi.addCommand(sql, params, 'single', (row) => {
+                return row
+                    ? parseFloat(row.score)
+                    : null;
+            });
+            return Promise.resolve(null);
+        }
+        else {
+            const res = await context.pgClient.query(sql, params);
+            return res.rows.length ? parseFloat(res.rows[0].score) : null;
+        }
+    },
+    _zscore(key, member) {
+        const tableName = context.tableForKey(key, 'sorted_set');
+        const sql = `
+      SELECT score
+      FROM ${tableName}
+      WHERE key = $1 AND member = $2
+        AND (expiry IS NULL OR expiry > NOW())
+      LIMIT 1
+    `;
+        const params = [key, member];
+        return { sql, params };
+    },
+    async zrangebyscore(key, min, max, multi) {
+        const { sql, params } = this._zrangebyscore(key, min, max);
+        if (multi) {
+            multi.addCommand(sql, params, 'array', (rows) => rows.map((row) => row.member));
+            return Promise.resolve([]);
+        }
+        else {
+            const res = await context.pgClient.query(sql, params);
+            return res.rows.map((row) => row.member);
+        }
+    },
+    _zrangebyscore(key, min, max) {
+        const tableName = context.tableForKey(key, 'sorted_set');
+        const sql = `
+      SELECT member FROM ${tableName}
+      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];
+        return { sql, params };
+    },
+    async zrangebyscore_withscores(key, min, max, multi) {
+        const { sql, params } = this._zrangebyscore_withscores(key, min, max);
+        if (multi) {
+            multi.addCommand(sql, params, 'array', (rows) => rows.map((row) => ({ member: row.member, score: row.score })));
+            return Promise.resolve([]);
+        }
+        else {
+            const res = await context.pgClient.query(sql, params);
+            return res.rows.map((row) => ({ member: row.member, score: row.score }));
+        }
+    },
+    _zrangebyscore_withscores(key, min, max) {
+        const tableName = context.tableForKey(key, 'sorted_set');
+        const sql = `
+      SELECT member, score FROM ${tableName}
+      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];
+        return { sql, params };
+    },
+    async zrem(key, member, multi) {
+        const { sql, params } = this._zrem(key, member);
+        if (multi) {
+            multi.addCommand(sql, params, 'number', (rows) => rows[0]?.count || 0);
+            return Promise.resolve(0);
+        }
+        else {
+            const res = await context.pgClient.query(sql, params);
+            return Number(res.rows[0]?.count || 0);
+        }
+    },
+    _zrem(key, member) {
+        const tableName = context.tableForKey(key, 'sorted_set');
+        const sql = `
+      WITH deleted AS (
+        DELETE FROM ${tableName}
+        WHERE key = $1 AND member = $2
+        RETURNING 1
+      )
+      SELECT COUNT(*) as count FROM deleted
+    `;
+        const params = [key, member];
+        return { sql, params };
+    },
+    async zrank(key, member, multi) {
+        const { sql, params } = this._zrank(key, member);
+        if (multi) {
+            multi.addCommand(sql, params, 'number', (rows) => rows[0]?.rank !== undefined ? parseInt(rows[0].rank, 10) - 1 : null);
+            return Promise.resolve(null);
+        }
+        else {
+            const res = await context.pgClient.query(sql, params);
+            return res.rows[0]?.rank
+                ? parseInt(res.rows[0].rank, 10) > 0
+                    ? parseInt(res.rows[0].rank, 10) - 1
+                    : null
+                : null;
+        }
+    },
+    _zrank(key, member) {
+        const tableName = context.tableForKey(key, 'sorted_set');
+        const sql = `
+      WITH member_score AS (
+        SELECT score FROM ${tableName}
+        WHERE key = $1 AND member = $2 AND (expiry IS NULL OR expiry > NOW())
+      )
+      SELECT COUNT(*) AS rank FROM ${tableName} ms, member_score
+      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];
+        return { sql, params };
+    },
+});
+exports.zsetModule = zsetModule;