@serialsubscriptions/platform-integration 0.0.79

package/lib/storage/backends/PostgresBackend.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostgresBackend = void 0;
+const pg_1 = require("pg");
+class PostgresBackend {
+    constructor(opts) {
+        this.table = opts.table;
+        if (opts.url) {
+            this.client = new pg_1.Client({ connectionString: opts.url, ssl: opts.ssl ? { rejectUnauthorized: false } : undefined });
+        }
+        else {
+            this.client = new pg_1.Client({
+                host: opts.host ?? 'localhost',
+                port: opts.port ?? 5432,
+                user: opts.user,
+                password: opts.password,
+                database: opts.database,
+                ssl: opts.ssl ? { rejectUnauthorized: false } : undefined,
+            });
+        }
+    }
+    async ensure() {
+        // One connect per process; re-use thereafter
+        // pg Client connects once and keeps pool-less connection
+        if (this.client._connected !== true) {
+            await this.client.connect();
+            this.client._connected = true;
+            // Ensure table exists (idempotent)
+            // Note: Use safe identifiers: we assume table was provided by trusted env.
+            await this.client.query(`
+        CREATE TABLE IF NOT EXISTS "${this.table}" (
+          class TEXT NOT NULL,
+          object_id TEXT NOT NULL,
+          key TEXT NOT NULL,
+          value JSONB,
+          updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+          expires_at TIMESTAMPTZ NULL,
+          PRIMARY KEY (class, object_id, key)
+        );
+        CREATE INDEX IF NOT EXISTS "${this.table}_expires_idx" ON "${this.table}" (expires_at);
+      `);
+        }
+    }
+    parsePrefixedKey(prefixed) {
+        // ssi_container/[class]/[object_id]/[key] — class is "_" if omitted
+        const parts = prefixed.split('/');
+        if (parts.length < 4)
+            throw new Error(`Invalid prefixed key: ${prefixed}`);
+        const container = parts[0];
+        const cls = parts[1];
+        const objectId = parts[2];
+        const key = parts.slice(3).join('/'); // allow slashes in the tail key
+        return { container, cls, objectId, key };
+    }
+    async get(prefixedKey) {
+        await this.ensure();
+        const { cls, objectId, key } = this.parsePrefixedKey(prefixedKey);
+        const { rows } = await this.client.query(`SELECT value, expires_at FROM "${this.table}" WHERE class=$1 AND object_id=$2 AND key=$3`, [cls, objectId, key]);
+        if (rows.length === 0)
+            return null;
+        const r = rows[0];
+        if (r.expires_at && new Date(r.expires_at) < new Date()) {
+            // Expired — best-effort delete & return null
+            await this.del(prefixedKey);
+            return null;
+        }
+        return r.value;
+    }
+    async set(prefixedKey, value, ttlSeconds) {
+        await this.ensure();
+        const { cls, objectId, key } = this.parsePrefixedKey(prefixedKey);
+        const expiresAt = ttlSeconds && ttlSeconds > 0
+            ? new Date(Date.now() + ttlSeconds * 1000)
+            : null;
+        await this.client.query(`INSERT INTO "${this.table}" (class, object_id, key, value, updated_at, expires_at)
+       VALUES ($1,$2,$3,$4,NOW(),$5)
+       ON CONFLICT (class, object_id, key)
+       DO UPDATE SET value=EXCLUDED.value, updated_at=NOW(), expires_at=EXCLUDED.expires_at`, [cls, objectId, key, value, expiresAt]);
+    }
+    async del(prefixedKey) {
+        await this.ensure();
+        const { cls, objectId, key } = this.parsePrefixedKey(prefixedKey);
+        await this.client.query(`DELETE FROM "${this.table}" WHERE class=$1 AND object_id=$2 AND key=$3`, [cls, objectId, key]);
+    }
+    async close() {
+        if (this.client._connected) {
+            await this.client.end();
+            this.client._connected = false;
+        }
+    }
+    async getRemainingTtl(prefixedKey) {
+        await this.ensure();
+        const { cls, objectId, key } = this.parsePrefixedKey(prefixedKey);
+        const { rows } = await this.client.query(`SELECT expires_at FROM "${this.table}" WHERE class=$1 AND object_id=$2 AND key=$3`, [cls, objectId, key]);
+        if (rows.length === 0)
+            return null; // no such key
+        const expiresAt = rows[0].expires_at;
+        if (!expiresAt)
+            return null; // no expiry
+        const msRemaining = new Date(expiresAt).getTime() - Date.now();
+        if (msRemaining <= 0)
+            return 0; // expired
+        return Math.ceil(msRemaining / 1000);
+    }
+}
+exports.PostgresBackend = PostgresBackend;

package/lib/storage/backends/RedisBackend.d.ts

@@ -0,0 +1,19 @@
+import type { Backend, KVValue } from '../types';
+export declare class RedisBackend implements Backend {
+    private client;
+    constructor(opts: {
+        url?: string;
+        host?: string;
+        port?: number;
+        user?: string;
+        password?: string;
+        tls?: boolean;
+    });
+    private ensure;
+    get(key: string): Promise<KVValue | null>;
+    set(key: string, value: KVValue, ttlSeconds?: number): Promise<void>;
+    del(key: string): Promise<void>;
+    keys(prefix: string): Promise<string[]>;
+    close(): Promise<void>;
+    getRemainingTtl(key: string): Promise<number | null>;
+}

package/lib/storage/backends/RedisBackend.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisBackend = void 0;
+const ioredis_1 = require("ioredis");
+class RedisBackend {
+    constructor(opts) {
+        if (opts.url) {
+            this.client = new ioredis_1.Redis(opts.url);
+        }
+        else {
+            this.client = new ioredis_1.Redis({
+                host: opts.host ?? 'localhost',
+                port: opts.port ?? 6379,
+                username: opts.user,
+                password: opts.password,
+                tls: opts.tls ? {} : undefined,
+                lazyConnect: true,
+            });
+        }
+    }
+    async ensure() {
+        if (this.client.status === 'wait')
+            await this.client.connect();
+    }
+    async get(key) {
+        await this.ensure();
+        const raw = await this.client.get(key);
+        if (raw === null)
+            return null;
+        try {
+            return JSON.parse(raw);
+        }
+        catch {
+            return raw;
+        }
+    }
+    async set(key, value, ttlSeconds) {
+        await this.ensure();
+        const payload = typeof value === 'string' ? value : JSON.stringify(value);
+        if (ttlSeconds && ttlSeconds > 0) {
+            await this.client.set(key, payload, 'EX', ttlSeconds);
+        }
+        else {
+            await this.client.set(key, payload);
+        }
+    }
+    async del(key) {
+        await this.ensure();
+        await this.client.del(key);
+    }
+    async keys(prefix) {
+        await this.ensure();
+        // Use SCAN to avoid blocking (simple but effective)
+        const keys = [];
+        let cursor = '0';
+        do {
+            const [next, batch] = await this.client.scan(cursor, 'MATCH', `${prefix}*`, 'COUNT', 500);
+            cursor = next;
+            keys.push(...batch);
+        } while (cursor !== '0');
+        return keys;
+    }
+    async close() {
+        await this.client.quit();
+    }
+    async getRemainingTtl(key) {
+        await this.ensure();
+        const ms = await this.client.pttl(key);
+        if (ms === -2)
+            return null; // no such key
+        if (ms === -1)
+            return null; // no expiry
+        if (ms <= 0)
+            return 0; // expired
+        return Math.ceil(ms / 1000);
+    }
+}
+exports.RedisBackend = RedisBackend;

package/lib/storage/types.d.ts

@@ -0,0 +1,27 @@
+export type StorageBackendType = 'memory' | 'redis' | 'postgres';
+export interface StorageInitOpts {
+    backend?: StorageBackendType;
+    container: string;
+    host?: string;
+    port?: number;
+    user?: string;
+    password?: string;
+    database?: string;
+    ssl?: boolean;
+    url?: string;
+}
+export type KVValue = string | number | boolean | Record<string, unknown> | null;
+export interface Backend {
+    get(prefixedKey: string): Promise<KVValue | null>;
+    set(prefixedKey: string, value: KVValue, ttlSeconds?: number): Promise<void>;
+    del(prefixedKey: string): Promise<void>;
+    /**
+     * Return remaining TTL in seconds for the given key.
+     * - Returns a non-negative number if the key exists and has an expiry
+     * - Returns 0 if the key exists but is already expired (and may be deleted lazily)
+     * - Returns null if the key does not exist or has no expiry
+     */
+    getRemainingTtl(prefixedKey: string): Promise<number | null>;
+    keys?(prefix: string): Promise<string[]>;
+    close?(): Promise<void>;
+}

package/lib/storage/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,71 @@
+{
+    "name": "@serialsubscriptions/platform-integration",
+    "version": "0.0.79",
+    "description": "Serial Subscriptions Libraries",
+    "main": "lib/index.js",
+    "types": "lib/index.d.ts",
+    "browser": "./lib/frontend/index.js",
+    "publishConfig": {
+        "access": "public"
+    },
+    "exports": {
+        ".": {
+            "browser": {
+                "import": "./lib/frontend/index.js",
+                "require": "./lib/frontend/index.js",
+                "types": "./lib/frontend/index.d.ts"
+            },
+            "edge-light": {
+                "import": "./lib/frontend/index.js",
+                "require": "./lib/frontend/index.js",
+                "types": "./lib/frontend/index.d.ts"
+            },
+            "node": {
+                "import": "./lib/index.js",
+                "require": "./lib/index.js",
+                "types": "./lib/index.d.ts"
+            },
+            "import": "./lib/index.js",
+            "require": "./lib/index.js",
+            "default": "./lib/index.js",
+            "types": "./lib/index.d.ts"
+        },
+        "./auth.server": {
+            "import": "./lib/auth.server.js",
+            "require": "./lib/auth.server.js",
+            "default": "./lib/auth.server.js",
+            "types": "./lib/auth.server.d.ts"
+        },
+        "./stateStore": {
+            "import": "./lib/stateStore.js",
+            "require": "./lib/stateStore.js",
+            "default": "./lib/stateStore.js",
+            "types": "./lib/stateStore.d.ts"
+        }
+    },
+    "files": [
+        "lib/**",
+        "README.md"
+    ],
+    "scripts": {
+        "build": "tsc"
+    },
+    "dependencies": {
+        "@auth0/nextjs-auth0": "^3.5.0",
+        "ioredis": "^5.4.1",
+        "jose": "^5.9.3",
+        "node-cache": "^5.1.2",
+        "node-fetch": "^3.3.2",
+        "pg": "^8.16.3"
+    },
+    "devDependencies": {
+        "@types/node": "^22.7.4",
+        "@types/pg": "^8.15.6",
+        "next": "^15.0.0",
+        "typescript": "^5.6.2"
+    },
+    "peerDependencies": {
+        "next": "^15.0.0"
+    },
+    "license": "MIT"
+}