@lastshotlabs/bunshot 0.0.25 → 0.0.28

package/dist/src/framework/persistence/cronRegistry.js

@@ -0,0 +1,139 @@
+// ---------------------------------------------------------------------------
+// Memory
+// ---------------------------------------------------------------------------
+export function createMemoryCronRegistry() {
+    let stored = new Set();
+    return {
+        async getAll() {
+            return new Set(stored);
+        },
+        async save(names) {
+            stored = new Set(names);
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// Redis
+// ---------------------------------------------------------------------------
+export function createRedisCronRegistry(getRedis, appName) {
+    const key = `cron-registry:${appName}`;
+    return {
+        async getAll() {
+            const raw = await getRedis().get(key);
+            if (!raw)
+                return new Set();
+            try {
+                const parsed = JSON.parse(raw);
+                if (Array.isArray(parsed))
+                    return new Set(parsed.filter((x) => typeof x === 'string'));
+            }
+            catch { }
+            return new Set();
+        },
+        async save(names) {
+            await getRedis().set(key, JSON.stringify([...names]));
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// SQLite
+// ---------------------------------------------------------------------------
+export function createSqliteCronRegistry(getDb) {
+    let initialized = false;
+    function ensureTable() {
+        if (initialized)
+            return;
+        getDb().run(`CREATE TABLE IF NOT EXISTS cron_scheduler_registry (
+        name TEXT NOT NULL,
+        PRIMARY KEY (name)
+      )`);
+        initialized = true;
+    }
+    return {
+        async getAll() {
+            ensureTable();
+            const rows = getDb()
+                .query('SELECT name FROM cron_scheduler_registry')
+                .all();
+            return new Set(rows.map(r => r.name));
+        },
+        async save(names) {
+            ensureTable();
+            const db = getDb();
+            db.run('DELETE FROM cron_scheduler_registry');
+            for (const name of names) {
+                db.run('INSERT INTO cron_scheduler_registry (name) VALUES (?)', [name]);
+            }
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// MongoDB
+// ---------------------------------------------------------------------------
+export function createMongoCronRegistry(getConn, getMg, appName) {
+    const docId = appName || 'default';
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let _model;
+    function getModel() {
+        if (_model)
+            return _model;
+        const conn = getConn();
+        if (conn.models['CronSchedulerRegistry']) {
+            _model = conn.models['CronSchedulerRegistry'];
+            return _model;
+        }
+        const mg = getMg();
+        const schema = new mg.Schema({ _id: String, names: [String] }, { collection: 'cron_scheduler_registry' });
+        _model = conn.model('CronSchedulerRegistry', schema);
+        return _model;
+    }
+    return {
+        async getAll() {
+            const doc = (await getModel().findById(docId).lean());
+            if (!doc?.names)
+                return new Set();
+            return new Set(doc.names);
+        },
+        async save(names) {
+            await getModel().findByIdAndUpdate(docId, { $set: { names: [...names] } }, { upsert: true });
+        },
+    };
+}
+export function createPostgresCronRegistry(pool, appName) {
+    const docId = appName || 'default';
+    let initialized = false;
+    async function ensureTable() {
+        if (initialized)
+            return;
+        await pool.query(`
+      CREATE TABLE IF NOT EXISTS bunshot_cron_registry (
+        id    TEXT PRIMARY KEY,
+        names TEXT[] NOT NULL DEFAULT '{}'
+      )
+    `);
+        initialized = true;
+    }
+    return {
+        async getAll() {
+            await ensureTable();
+            const result = await pool.query('SELECT names FROM bunshot_cron_registry WHERE id = $1', [docId]);
+            return new Set(result.rows[0]?.names ?? []);
+        },
+        async save(names) {
+            await ensureTable();
+            await pool.query(`INSERT INTO bunshot_cron_registry (id, names)
+         VALUES ($1, $2)
+         ON CONFLICT (id) DO UPDATE SET names = EXCLUDED.names`, [docId, [...names]]);
+        },
+    };
+}
+export const cronRegistryFactories = {
+    memory: () => createMemoryCronRegistry(),
+    redis: infra => createRedisCronRegistry(infra.getRedis, infra.appName),
+    sqlite: infra => createSqliteCronRegistry(infra.getSqliteDb),
+    mongo: infra => {
+        const { conn, mg } = infra.getMongo();
+        return createMongoCronRegistry(() => conn, () => mg, infra.appName);
+    },
+    postgres: infra => createPostgresCronRegistry(infra.getPostgres().pool, infra.appName),
+};

package/dist/src/framework/persistence/idempotency.d.ts

@@ -0,0 +1,26 @@
+import type { IdempotencyAdapter } from '../../../packages/bunshot-core/src/index.js';
+import type { RepoFactories } from '../../../packages/bunshot-core/src/index.js';
+export declare function createMemoryIdempotencyAdapter(): IdempotencyAdapter;
+export declare function createRedisIdempotencyAdapter(redis: {
+    get(key: string): Promise<string | null>;
+    set(...args: any[]): Promise<unknown>;
+}, prefix: string): IdempotencyAdapter;
+export declare function createMongoIdempotencyAdapter(appConn: {
+    models: Record<string, unknown>;
+    model<T>(name: string, schema: unknown): unknown;
+}, mongoosePkg: unknown): IdempotencyAdapter;
+export declare function createSqliteIdempotencyAdapter(db: {
+    run(sql: string, params?: unknown[]): void;
+    query<T>(sql: string): {
+        get(...args: unknown[]): T | null;
+    };
+}): IdempotencyAdapter;
+type PgPool = {
+    query<R extends Record<string, unknown> = Record<string, unknown>>(sql: string, params?: unknown[]): Promise<{
+        rows: R[];
+        rowCount: number | null;
+    }>;
+};
+export declare function createPostgresIdempotencyAdapter(pool: PgPool): IdempotencyAdapter;
+export declare const idempotencyFactories: RepoFactories<IdempotencyAdapter>;
+export {};

package/dist/src/framework/persistence/idempotency.js

@@ -0,0 +1,178 @@
+import { DEFAULT_MAX_ENTRIES, evictOldest } from '../../../packages/bunshot-core/src/index.js';
+// ---------------------------------------------------------------------------
+// Memory
+// ---------------------------------------------------------------------------
+export function createMemoryIdempotencyAdapter() {
+    const store = new Map();
+    return {
+        async get(key) {
+            const record = store.get(key);
+            if (!record)
+                return null;
+            if (Date.now() > record.expiresAt) {
+                store.delete(key);
+                return null;
+            }
+            return { response: record.body, status: record.status, createdAt: record.createdAt };
+        },
+        async set(key, response, status, ttlSeconds) {
+            if (store.has(key))
+                return; // NX semantics — don't overwrite
+            evictOldest(store, DEFAULT_MAX_ENTRIES);
+            store.set(key, {
+                status,
+                body: response,
+                createdAt: Date.now(),
+                expiresAt: Date.now() + ttlSeconds * 1000,
+            });
+        },
+        async clear() {
+            store.clear();
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// Redis
+// ---------------------------------------------------------------------------
+export function createRedisIdempotencyAdapter(redis, prefix) {
+    function rkey(key) {
+        return `idempotency:${prefix}:${key}`;
+    }
+    return {
+        async get(key) {
+            const raw = await redis.get(rkey(key));
+            if (!raw)
+                return null;
+            const record = JSON.parse(raw);
+            return { response: record.body, status: record.status, createdAt: record.createdAt };
+        },
+        async set(key, response, status, ttlSeconds) {
+            const value = JSON.stringify({ status, body: response, createdAt: Date.now() });
+            await redis.set(rkey(key), value, 'EX', ttlSeconds, 'NX');
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// MongoDB
+// ---------------------------------------------------------------------------
+export function createMongoIdempotencyAdapter(appConn, mongoosePkg) {
+    function getModel() {
+        if (appConn.models['Idempotency'])
+            return appConn.models['Idempotency'];
+        const { Schema } = mongoosePkg;
+        const schema = new Schema({
+            key: { type: String, required: true, unique: true },
+            status: { type: Number, required: true },
+            body: { type: String, required: true },
+            createdAt: { type: Date, required: true },
+            expiresAt: { type: Date, required: true, index: { expireAfterSeconds: 0 } },
+        }, { collection: 'idempotency' });
+        return appConn.model('Idempotency', schema);
+    }
+    return {
+        async get(key) {
+            const doc = await getModel()
+                .findOne({ key, expiresAt: { $gt: new Date() } }, 'status body createdAt')
+                .lean();
+            if (!doc)
+                return null;
+            return { status: doc.status, response: doc.body, createdAt: doc.createdAt.getTime() };
+        },
+        async set(key, response, status, ttlSeconds) {
+            const now = new Date();
+            try {
+                await getModel().create({
+                    key,
+                    status,
+                    body: response,
+                    createdAt: now,
+                    expiresAt: new Date(now.getTime() + ttlSeconds * 1000),
+                });
+            }
+            catch (err) {
+                // Duplicate key — NX semantics: ignore
+                if (err?.code === 11000 || err?.code === '11000')
+                    return;
+                throw err;
+            }
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// SQLite
+// ---------------------------------------------------------------------------
+export function createSqliteIdempotencyAdapter(db) {
+    let initialized = false;
+    function ensureTable() {
+        if (initialized)
+            return;
+        db.run(`CREATE TABLE IF NOT EXISTS idempotency (
+      key       TEXT PRIMARY KEY,
+      status    INTEGER NOT NULL,
+      body      TEXT NOT NULL,
+      createdAt INTEGER NOT NULL,
+      expiresAt INTEGER NOT NULL
+    )`);
+        initialized = true;
+    }
+    return {
+        async get(key) {
+            ensureTable();
+            const row = db
+                .query('SELECT status, body, createdAt FROM idempotency WHERE key = ? AND expiresAt > ?')
+                .get(key, Date.now());
+            if (!row)
+                return null;
+            return { status: row.status, response: row.body, createdAt: row.createdAt };
+        },
+        async set(key, response, status, ttlSeconds) {
+            ensureTable();
+            const now = Date.now();
+            db.run('INSERT OR IGNORE INTO idempotency (key, status, body, createdAt, expiresAt) VALUES (?, ?, ?, ?, ?)', [key, status, response, now, now + ttlSeconds * 1000]);
+        },
+    };
+}
+export function createPostgresIdempotencyAdapter(pool) {
+    let initialized = false;
+    async function ensureTable() {
+        if (initialized)
+            return;
+        await pool.query(`
+      CREATE TABLE IF NOT EXISTS bunshot_idempotency (
+        key        TEXT PRIMARY KEY,
+        status     INTEGER NOT NULL,
+        body       TEXT NOT NULL,
+        created_at BIGINT NOT NULL,
+        expires_at BIGINT NOT NULL
+      )
+    `);
+        initialized = true;
+    }
+    return {
+        async get(key) {
+            await ensureTable();
+            const result = await pool.query('SELECT status, body, created_at FROM bunshot_idempotency WHERE key = $1 AND expires_at > $2', [key, Date.now()]);
+            const row = result.rows[0];
+            if (!row)
+                return null;
+            return { status: row.status, response: row.body, createdAt: Number(row.created_at) };
+        },
+        async set(key, response, status, ttlSeconds) {
+            await ensureTable();
+            const now = Date.now();
+            await pool.query(`INSERT INTO bunshot_idempotency (key, status, body, created_at, expires_at)
+         VALUES ($1, $2, $3, $4, $5)
+         ON CONFLICT (key) DO NOTHING`, [key, status, response, now, now + ttlSeconds * 1000]);
+        },
+    };
+}
+export const idempotencyFactories = {
+    memory: () => createMemoryIdempotencyAdapter(),
+    sqlite: infra => createSqliteIdempotencyAdapter(infra.getSqliteDb()),
+    redis: infra => createRedisIdempotencyAdapter(infra.getRedis(), infra.appName),
+    mongo: infra => {
+        const { conn, mg } = infra.getMongo();
+        return createMongoIdempotencyAdapter(conn, mg);
+    },
+    postgres: infra => createPostgresIdempotencyAdapter(infra.getPostgres().pool),
+};

package/dist/src/framework/persistence/index.d.ts

@@ -0,0 +1,6 @@
+export { createMemoryUploadRegistry, createRedisUploadRegistry, createMongoUploadRegistry, createSqliteUploadRegistry, createUploadRegistryFactories, uploadRegistryFactories, } from './uploadRegistry';
+export { createMemoryIdempotencyAdapter, createRedisIdempotencyAdapter, createMongoIdempotencyAdapter, createSqliteIdempotencyAdapter, idempotencyFactories, } from './idempotency';
+export { createMemoryWsMessageRepository, createRedisWsMessageRepository, createMongoWsMessageRepository, createSqliteWsMessageRepository, wsMessageFactories, } from './wsMessages';
+export { createMemoryCronRegistry, createRedisCronRegistry, createSqliteCronRegistry, createMongoCronRegistry, cronRegistryFactories, } from './cronRegistry';
+export type { StoreType, StoreInfra, RepoFactories } from '../../../packages/bunshot-core/src/index.js';
+export { resolveRepo } from '../../../packages/bunshot-core/src/index.js';

package/dist/src/framework/persistence/index.js

@@ -0,0 +1,8 @@
+// ---------------------------------------------------------------------------
+// Persistence — barrel export
+// ---------------------------------------------------------------------------
+export { createMemoryUploadRegistry, createRedisUploadRegistry, createMongoUploadRegistry, createSqliteUploadRegistry, createUploadRegistryFactories, uploadRegistryFactories, } from './uploadRegistry';
+export { createMemoryIdempotencyAdapter, createRedisIdempotencyAdapter, createMongoIdempotencyAdapter, createSqliteIdempotencyAdapter, idempotencyFactories, } from './idempotency';
+export { createMemoryWsMessageRepository, createRedisWsMessageRepository, createMongoWsMessageRepository, createSqliteWsMessageRepository, wsMessageFactories, } from './wsMessages';
+export { createMemoryCronRegistry, createRedisCronRegistry, createSqliteCronRegistry, createMongoCronRegistry, cronRegistryFactories, } from './cronRegistry';
+export { resolveRepo } from '../../../packages/bunshot-core/src/index.js';

package/dist/src/framework/persistence/storeInfra.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Re-exports from the canonical bunshot-core StoreInfra module.
+ *
+ * Framework-specific aliases (FrameworkStoreType, FrameworkStoreInfra) are
+ * preserved for backwards compatibility with existing imports.
+ */
+export type { StoreInfra as FrameworkStoreInfra, RepoFactories } from '../../../packages/bunshot-core/src/index.js';
+export type { StoreType as FrameworkStoreType } from '../../../packages/bunshot-core/src/index.js';
+export { resolveRepo } from '../../../packages/bunshot-core/src/index.js';

package/dist/src/framework/persistence/storeInfra.js

@@ -0,0 +1 @@
+export { resolveRepo } from '../../../packages/bunshot-core/src/index.js';

package/dist/src/framework/persistence/uploadRegistry.d.ts

@@ -0,0 +1,35 @@
+import type { UploadRegistryRepository } from '../../../packages/bunshot-core/src/index.js';
+import type { RepoFactories } from '../../../packages/bunshot-core/src/index.js';
+export declare const DEFAULT_UPLOAD_REGISTRY_TTL_SECONDS: number;
+export interface Clearable {
+    clear(): Promise<void> | void;
+}
+export type ClearableRepository<T> = T & Clearable;
+export declare function createMemoryUploadRegistry(ttlSeconds?: number): ClearableRepository<UploadRegistryRepository>;
+export declare function createRedisUploadRegistry(redis: {
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string, exFlag?: 'EX', ttl?: number): Promise<unknown>;
+    del(key: string): Promise<number>;
+}, prefix: string, ttlSeconds?: number): UploadRegistryRepository;
+export declare function createMongoUploadRegistry(appConn: {
+    models: Record<string, unknown>;
+    model<T>(name: string, schema: unknown): unknown;
+}, mongoosePkg: unknown, ttlSeconds?: number): UploadRegistryRepository;
+export declare function createSqliteUploadRegistry(db: {
+    run(sql: string, params?: unknown[]): void;
+    query<T>(sql: string): {
+        get(...args: unknown[]): T | null;
+        all(...args: unknown[]): T[];
+    };
+}, ttlSeconds?: number): UploadRegistryRepository;
+type PgPool = {
+    query<R extends Record<string, unknown> = Record<string, unknown>>(sql: string, params?: unknown[]): Promise<{
+        rows: R[];
+        rowCount: number | null;
+    }>;
+};
+export declare function createPostgresUploadRegistry(pool: PgPool, ttlSeconds?: number): UploadRegistryRepository;
+export declare function createUploadRegistryFactories(ttlSeconds?: number): RepoFactories<UploadRegistryRepository>;
+/** @deprecated Use createUploadRegistryFactories() instead */
+export declare const uploadRegistryFactories: RepoFactories<UploadRegistryRepository>;
+export {};

package/dist/src/framework/persistence/uploadRegistry.js

@@ -0,0 +1,235 @@
+import { DEFAULT_MAX_ENTRIES, evictOldest } from '../../../packages/bunshot-core/src/index.js';
+export const DEFAULT_UPLOAD_REGISTRY_TTL_SECONDS = 30 * 24 * 60 * 60; // 30 days
+export function createMemoryUploadRegistry(ttlSeconds = DEFAULT_UPLOAD_REGISTRY_TTL_SECONDS) {
+    const store = new Map();
+    return {
+        async register(record) {
+            evictOldest(store, DEFAULT_MAX_ENTRIES);
+            store.set(record.key, record);
+        },
+        async get(key) {
+            const record = store.get(key);
+            if (!record)
+                return null;
+            if (Date.now() - record.createdAt > ttlSeconds * 1000) {
+                store.delete(key);
+                return null;
+            }
+            return record;
+        },
+        async delete(key) {
+            return store.delete(key);
+        },
+        async clear() {
+            store.clear();
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// Redis
+// ---------------------------------------------------------------------------
+export function createRedisUploadRegistry(redis, prefix, ttlSeconds = DEFAULT_UPLOAD_REGISTRY_TTL_SECONDS) {
+    function rkey(key) {
+        return `ur:${prefix}:${key}`;
+    }
+    return {
+        async register(record) {
+            await redis.set(rkey(record.key), JSON.stringify(record), 'EX', ttlSeconds);
+        },
+        async get(key) {
+            const raw = await redis.get(rkey(key));
+            if (!raw)
+                return null;
+            return JSON.parse(raw);
+        },
+        async delete(key) {
+            const deleted = await redis.del(rkey(key));
+            return deleted > 0;
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// MongoDB
+// ---------------------------------------------------------------------------
+export function createMongoUploadRegistry(appConn, mongoosePkg, ttlSeconds = DEFAULT_UPLOAD_REGISTRY_TTL_SECONDS) {
+    function getModel() {
+        if (appConn.models['UploadRegistry'])
+            return appConn.models['UploadRegistry'];
+        const { Schema } = mongoosePkg;
+        const schema = new Schema({
+            key: { type: String, required: true, unique: true },
+            ownerUserId: { type: String },
+            tenantId: { type: String },
+            mimeType: { type: String },
+            bucket: { type: String },
+            createdAt: { type: Number, required: true },
+            expiresAt: { type: Date, required: true },
+        }, { collection: 'upload_registry' });
+        schema.index({ expiresAt: 1 }, { expireAfterSeconds: 0 });
+        return appConn.model('UploadRegistry', schema);
+    }
+    function expiresAt() {
+        return new Date(Date.now() + ttlSeconds * 1000);
+    }
+    return {
+        async register(record) {
+            await getModel().updateOne({ key: record.key }, { $set: { ...record, expiresAt: expiresAt() } }, { upsert: true });
+        },
+        async get(key) {
+            const doc = await getModel().findOne({ key }).lean();
+            if (!doc)
+                return null;
+            return {
+                key: doc.key,
+                ownerUserId: doc.ownerUserId,
+                tenantId: doc.tenantId,
+                mimeType: doc.mimeType,
+                bucket: doc.bucket,
+                createdAt: doc.createdAt,
+            };
+        },
+        async delete(key) {
+            const result = await getModel().deleteOne({ key });
+            return result.deletedCount > 0;
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// SQLite
+// ---------------------------------------------------------------------------
+export function createSqliteUploadRegistry(db, ttlSeconds = DEFAULT_UPLOAD_REGISTRY_TTL_SECONDS) {
+    let initialized = false;
+    function ensureTable() {
+        if (initialized)
+            return;
+        db.run(`CREATE TABLE IF NOT EXISTS upload_registry (
+      key          TEXT PRIMARY KEY,
+      owner_user_id TEXT,
+      tenant_id    TEXT,
+      mime_type    TEXT,
+      bucket       TEXT,
+      created_at   INTEGER NOT NULL,
+      expires_at   INTEGER NOT NULL
+    )`);
+        initialized = true;
+    }
+    function nowPlusTtl() {
+        return Date.now() + ttlSeconds * 1000;
+    }
+    return {
+        async register(record) {
+            ensureTable();
+            // Lazy cleanup: remove expired entries on each write
+            db.run('DELETE FROM upload_registry WHERE expires_at < ?', [Date.now()]);
+            db.run(`INSERT OR REPLACE INTO upload_registry (key, owner_user_id, tenant_id, mime_type, bucket, created_at, expires_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?)`, [
+                record.key,
+                record.ownerUserId ?? null,
+                record.tenantId ?? null,
+                record.mimeType ?? null,
+                record.bucket ?? null,
+                record.createdAt,
+                nowPlusTtl(),
+            ]);
+        },
+        async get(key) {
+            ensureTable();
+            const row = db
+                .query('SELECT * FROM upload_registry WHERE key = ? AND expires_at > ?')
+                .get(key, Date.now());
+            if (!row)
+                return null;
+            return {
+                key: row.key,
+                ownerUserId: row.owner_user_id ?? undefined,
+                tenantId: row.tenant_id ?? undefined,
+                mimeType: row.mime_type ?? undefined,
+                bucket: row.bucket ?? undefined,
+                createdAt: row.created_at,
+            };
+        },
+        async delete(key) {
+            ensureTable();
+            db.run('DELETE FROM upload_registry WHERE key = ?', [key]);
+            const changes = db.query('SELECT changes() as changes').get()?.changes ?? 0;
+            return changes > 0;
+        },
+    };
+}
+export function createPostgresUploadRegistry(pool, ttlSeconds = DEFAULT_UPLOAD_REGISTRY_TTL_SECONDS) {
+    let initialized = false;
+    async function ensureTable() {
+        if (initialized)
+            return;
+        await pool.query(`
+      CREATE TABLE IF NOT EXISTS bunshot_upload_registry (
+        key            TEXT PRIMARY KEY,
+        owner_user_id  TEXT,
+        tenant_id      TEXT,
+        mime_type      TEXT,
+        bucket         TEXT,
+        created_at     BIGINT NOT NULL,
+        expires_at     BIGINT NOT NULL
+      )
+    `);
+        initialized = true;
+    }
+    return {
+        async register(record) {
+            await ensureTable();
+            const expiresAt = Date.now() + ttlSeconds * 1000;
+            await pool.query(`INSERT INTO bunshot_upload_registry
+           (key, owner_user_id, tenant_id, mime_type, bucket, created_at, expires_at)
+         VALUES ($1, $2, $3, $4, $5, $6, $7)
+         ON CONFLICT (key) DO UPDATE SET
+           owner_user_id = EXCLUDED.owner_user_id,
+           tenant_id     = EXCLUDED.tenant_id,
+           mime_type     = EXCLUDED.mime_type,
+           bucket        = EXCLUDED.bucket,
+           created_at    = EXCLUDED.created_at,
+           expires_at    = EXCLUDED.expires_at`, [
+                record.key,
+                record.ownerUserId ?? null,
+                record.tenantId ?? null,
+                record.mimeType ?? null,
+                record.bucket ?? null,
+                record.createdAt,
+                expiresAt,
+            ]);
+        },
+        async get(key) {
+            await ensureTable();
+            const result = await pool.query('SELECT key, owner_user_id, tenant_id, mime_type, bucket, created_at FROM bunshot_upload_registry WHERE key = $1 AND expires_at > $2', [key, Date.now()]);
+            const row = result.rows[0];
+            if (!row)
+                return null;
+            return {
+                key: row.key,
+                ownerUserId: row.owner_user_id ?? undefined,
+                tenantId: row.tenant_id ?? undefined,
+                mimeType: row.mime_type ?? undefined,
+                bucket: row.bucket ?? undefined,
+                createdAt: Number(row.created_at),
+            };
+        },
+        async delete(key) {
+            await ensureTable();
+            const result = await pool.query('DELETE FROM bunshot_upload_registry WHERE key = $1', [key]);
+            return (result.rowCount ?? 0) > 0;
+        },
+    };
+}
+export function createUploadRegistryFactories(ttlSeconds = DEFAULT_UPLOAD_REGISTRY_TTL_SECONDS) {
+    return {
+        memory: () => createMemoryUploadRegistry(ttlSeconds),
+        sqlite: infra => createSqliteUploadRegistry(infra.getSqliteDb(), ttlSeconds),
+        redis: infra => createRedisUploadRegistry(infra.getRedis(), infra.appName, ttlSeconds),
+        mongo: infra => {
+            const { conn, mg } = infra.getMongo();
+            return createMongoUploadRegistry(conn, mg, ttlSeconds);
+        },
+        postgres: infra => createPostgresUploadRegistry(infra.getPostgres().pool, ttlSeconds),
+    };
+}
+/** @deprecated Use createUploadRegistryFactories() instead */
+export const uploadRegistryFactories = createUploadRegistryFactories();

package/dist/src/framework/persistence/wsMessages.d.ts

@@ -0,0 +1,22 @@
+import type { WsMessageRepository } from '../../../packages/bunshot-core/src/index.js';
+import type { RepoFactories } from '../../../packages/bunshot-core/src/index.js';
+export declare function createMemoryWsMessageRepository(): WsMessageRepository;
+export declare function createRedisWsMessageRepository(redis: {
+    lpush(key: string, value: string): Promise<number>;
+    ltrim(key: string, start: number, stop: number): Promise<string>;
+    expire(key: string, seconds: number): Promise<number>;
+    lrange(key: string, start: number, stop: number): Promise<string[]>;
+    del(...keys: string[]): Promise<number>;
+}): WsMessageRepository;
+export declare function createMongoWsMessageRepository(conn: {
+    models: Record<string, unknown>;
+    model(name: string, schema: unknown): unknown;
+}, mongoosePkg: unknown): WsMessageRepository;
+export declare function createSqliteWsMessageRepository(db: {
+    run(sql: string, params?: unknown[]): void;
+    query<T>(sql: string): {
+        get(...args: unknown[]): T | null;
+        all(...args: unknown[]): T[];
+    };
+}): WsMessageRepository;
+export declare const wsMessageFactories: RepoFactories<WsMessageRepository>;