@lastshotlabs/bunshot 0.0.27 → 0.1.0

package/dist/src/framework/mountRoutes.js

@@ -0,0 +1,144 @@
+/**
+ * Route discovery and mounting — extracted from createApp().
+ *
+ * Handles both versioned (routes/v1/, routes/v2/, ...) and non-versioned
+ * (routes/**) discovery. Each versioned sub-app gets its own OpenAPI spec,
+ * Scalar docs, and schema stripping pass.
+ */
+import { stripUnreferencedSchemas } from './lib/stripUnreferencedSchemas';
+import { OpenAPIHono } from '@hono/zod-openapi';
+import { Scalar } from '@scalar/hono-api-reference';
+import { defaultHook } from '../../packages/bunshot-core/src/index.js';
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function registerSecuritySchemes(registry) {
+    registry.registerComponent('securitySchemes', 'cookieAuth', {
+        type: 'apiKey',
+        in: 'cookie',
+        name: 'token',
+        description: 'Session cookie set automatically on login/register.',
+    });
+    registry.registerComponent('securitySchemes', 'userToken', {
+        type: 'apiKey',
+        in: 'header',
+        name: 'x-user-token',
+        description: 'JWT session token passed as the x-user-token request header (alternative to the session cookie).',
+    });
+    registry.registerComponent('securitySchemes', 'bearerAuth', {
+        type: 'http',
+        scheme: 'bearer',
+        description: 'API key passed as Authorization: Bearer <token>. Required on all endpoints unless bearer auth is disabled in CreateAppConfig or the path is in the bypass list.',
+    });
+}
+// ---------------------------------------------------------------------------
+// Implementation
+// ---------------------------------------------------------------------------
+export async function mountRoutes(app, routesDir, versioning, appName, openApiVersion) {
+    if (versioning) {
+        await mountVersionedRoutes(app, routesDir, versioning, appName, openApiVersion);
+    }
+    else {
+        await mountFlatRoutes(app, routesDir, appName, openApiVersion);
+    }
+}
+async function mountVersionedRoutes(app, routesDir, versioning, appName, openApiVersion) {
+    const { versions, sharedDir = 'shared', defaultVersion = versions[versions.length - 1], } = Array.isArray(versioning) ? { versions: versioning } : versioning;
+    // Import shared routes with no prefix — schemas stay unprefixed (version-agnostic)
+    let sharedMods = [];
+    if (sharedDir !== false) {
+        const sharedRoutesDir = `${routesDir}/${sharedDir}`;
+        const sharedFiles = [];
+        try {
+            const sharedGlob = new Bun.Glob('**/*.ts');
+            for await (const file of sharedGlob.scan({ cwd: sharedRoutesDir })) {
+                sharedFiles.push(file);
+            }
+        }
+        catch {
+            // sharedDir doesn't exist — fine
+        }
+        sharedMods = await Promise.all(sharedFiles.map(async (file) => ({ file, mod: await import(`${sharedRoutesDir}/${file}`) })));
+    }
+    // For each version: import routes, mount on isolated OpenAPIHono
+    for (const version of versions) {
+        const vApp = new OpenAPIHono({ defaultHook });
+        const versionRoutesDir = `${routesDir}/${version}`;
+        const versionFiles = [];
+        try {
+            const versionGlob = new Bun.Glob('**/*.ts');
+            for await (const file of versionGlob.scan({ cwd: versionRoutesDir })) {
+                versionFiles.push(file);
+            }
+        }
+        catch {
+            // version dir doesn't exist — fine
+        }
+        // Import all version route files in parallel
+        const versionMods = await Promise.all(versionFiles.map(async (file) => ({ file, mod: await import(`${versionRoutesDir}/${file}`) })));
+        // Mount version-specific routes (sorted by priority)
+        versionMods
+            .sort((a, b) => (a.mod.priority ?? Infinity) - (b.mod.priority ?? Infinity))
+            .forEach(({ mod }) => {
+            if (mod.router)
+                vApp.route('/', mod.router);
+        });
+        // Mount shared routes on this versioned app
+        for (const { mod } of sharedMods) {
+            if (mod.router)
+                vApp.route('/', mod.router);
+        }
+        registerSecuritySchemes(vApp.openAPIRegistry);
+        // Serve per-version spec stripped of schemas from other versions
+        vApp.get('/openapi.json', c => {
+            const spec = vApp.getOpenAPIDocument({
+                openapi: '3.0.0',
+                info: { title: `${appName} ${version.toUpperCase()}`, version: openApiVersion },
+            });
+            return c.json(stripUnreferencedSchemas(spec));
+        });
+        // Per-version Scalar docs
+        vApp.get('/docs', Scalar({ url: `/${version}/openapi.json` }));
+        // Mount versioned app under /v1, /v2, etc.
+        app.route(`/${version}`, vApp);
+    }
+    // Root /docs → version selector page
+    app.get('/docs', c => {
+        const links = versions
+            .map(v => `<li><a href="/${v}/docs" style="font-size:1.1em">${v.toUpperCase()}</a></li>`)
+            .join('\n');
+        const html = `<!DOCTYPE html>
+<html lang="en">
+<head><meta charset="utf-8"><title>${appName} — API Docs</title>
+<style>body{font-family:sans-serif;padding:2rem}ul{list-style:none;padding:0}li{margin:.5rem 0}</style>
+</head>
+<body>
+<h1>${appName}</h1>
+<h2>API Documentation</h2>
+<ul>${links}</ul>
+</body></html>`;
+        return c.html(html);
+    });
+    // Root /openapi.json → 302 to default version (no merged spec exists)
+    app.get('/openapi.json', c => c.redirect(`/${defaultVersion}/openapi.json`, 302));
+}
+async function mountFlatRoutes(app, routesDir, appName, openApiVersion) {
+    const serviceGlob = new Bun.Glob('**/*.ts');
+    const serviceFiles = [];
+    for await (const file of serviceGlob.scan({ cwd: routesDir })) {
+        serviceFiles.push(file);
+    }
+    const serviceMods = await Promise.all(serviceFiles.map(async (file) => ({
+        file,
+        mod: await import(`${routesDir}/${file}`),
+    })));
+    serviceMods
+        .sort((a, b) => (a.mod.priority ?? Infinity) - (b.mod.priority ?? Infinity))
+        .forEach(({ mod }) => {
+        if (mod.router)
+            app.route('/', mod.router);
+    });
+    registerSecuritySchemes(app.openAPIRegistry);
+    app.doc('/openapi.json', { openapi: '3.0.0', info: { title: appName, version: openApiVersion } });
+    app.get('/docs', Scalar({ url: '/openapi.json' }));
+}

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

@@ -0,0 +1,28 @@
+import type { ICronRegistryRepository } from '../../../packages/bunshot-core/src/index.js';
+import type { RepoFactories } from '../../../packages/bunshot-core/src/index.js';
+export declare function createMemoryCronRegistry(): ICronRegistryRepository;
+export declare function createRedisCronRegistry(getRedis: () => {
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string): Promise<unknown>;
+}, appName: string): ICronRegistryRepository;
+export declare function createSqliteCronRegistry(getDb: () => {
+    run(sql: string, params?: unknown[]): void;
+    query<T>(sql: string): {
+        all(...args: unknown[]): T[];
+    };
+}): ICronRegistryRepository;
+export declare function createMongoCronRegistry(getConn: () => {
+    models: Record<string, unknown>;
+    model(name: string, schema: unknown): unknown;
+}, getMg: () => {
+    Schema: new (def: object, opts?: object) => unknown;
+}, appName: string): ICronRegistryRepository;
+type PgPool = {
+    query<R extends Record<string, unknown> = Record<string, unknown>>(sql: string, params?: unknown[]): Promise<{
+        rows: R[];
+        rowCount: number | null;
+    }>;
+};
+export declare function createPostgresCronRegistry(pool: PgPool, appName: string): ICronRegistryRepository;
+export declare const cronRegistryFactories: RepoFactories<ICronRegistryRepository>;
+export {};

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 {};