@lastshotlabs/bunshot 0.0.27 → 0.1.0

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

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

@@ -0,0 +1,296 @@
+// ---------------------------------------------------------------------------
+// Memory
+// ---------------------------------------------------------------------------
+export function createMemoryWsMessageRepository() {
+    // key: "endpoint\0room"
+    const store = new Map();
+    function scopeKey(endpoint, room) {
+        return `${endpoint}\0${room}`;
+    }
+    return {
+        async persist(message, config) {
+            const key = scopeKey(message.endpoint, message.room);
+            if (!store.has(key))
+                store.set(key, []);
+            const msgs = store.get(key);
+            msgs.push(message);
+            if (msgs.length > config.maxCount) {
+                msgs.splice(0, msgs.length - config.maxCount);
+            }
+            return message;
+        },
+        async getHistory(endpoint, room, opts) {
+            const key = scopeKey(endpoint, room);
+            const msgs = store.get(key) ?? [];
+            const limit = opts?.limit ?? 50;
+            let filtered = msgs.slice();
+            if (opts?.before) {
+                const idx = filtered.findIndex(m => m.id === opts.before);
+                if (idx > 0)
+                    filtered = filtered.slice(0, idx);
+            }
+            else if (opts?.after) {
+                const idx = filtered.findIndex(m => m.id === opts.after);
+                if (idx >= 0)
+                    filtered = filtered.slice(idx + 1);
+            }
+            return filtered.slice(-limit);
+        },
+        async clear() {
+            store.clear();
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// Redis
+// ---------------------------------------------------------------------------
+export function createRedisWsMessageRepository(redis) {
+    const knownKeys = new Set();
+    function rkey(endpoint, room) {
+        return `wsmsg:${endpoint}\0${room}`;
+    }
+    return {
+        async persist(message, config) {
+            const key = rkey(message.endpoint, message.room);
+            knownKeys.add(key);
+            const serialized = JSON.stringify(message);
+            await redis.lpush(key, serialized);
+            await redis.ltrim(key, 0, config.maxCount - 1);
+            await redis.expire(key, config.ttlSeconds);
+            return message;
+        },
+        async getHistory(endpoint, room, opts) {
+            const key = rkey(endpoint, room);
+            const limit = opts?.limit ?? 50;
+            const raw = await redis.lrange(key, 0, -1);
+            let msgs = raw.map(s => JSON.parse(s)).reverse(); // oldest-first
+            if (opts?.before) {
+                const idx = msgs.findIndex(m => m.id === opts.before);
+                if (idx > 0)
+                    msgs = msgs.slice(0, idx);
+            }
+            else if (opts?.after) {
+                const idx = msgs.findIndex(m => m.id === opts.after);
+                if (idx >= 0)
+                    msgs = msgs.slice(idx + 1);
+            }
+            return msgs.slice(-limit);
+        },
+        async clear() {
+            if (knownKeys.size === 0)
+                return;
+            await redis.del(...knownKeys);
+            knownKeys.clear();
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// MongoDB
+// ---------------------------------------------------------------------------
+const DEFAULT_TTL_SECONDS = 86_400;
+export function createMongoWsMessageRepository(conn, mongoosePkg) {
+    let model = null;
+    function getModel() {
+        if (model)
+            return model;
+        const mongoose = mongoosePkg;
+        const schema = new mongoose.Schema({
+            _id: { type: String, default: () => crypto.randomUUID() },
+            endpoint: { type: String, required: true },
+            room: { type: String, required: true },
+            senderId: { type: String, default: null },
+            payload: { type: mongoose.Schema.Types.Mixed },
+            createdAt: { type: Number, required: true },
+        }, { collection: 'ws_messages' });
+        schema.index({ endpoint: 1, room: 1, createdAt: -1, _id: -1 });
+        schema.index({ createdAt: 1 }, { expireAfterSeconds: DEFAULT_TTL_SECONDS });
+        model = conn.model('WsMessage', schema);
+        return model;
+    }
+    return {
+        async persist(message, config) {
+            const Model = getModel();
+            await Model.create({
+                _id: message.id,
+                endpoint: message.endpoint,
+                room: message.room,
+                senderId: message.senderId,
+                payload: message.payload,
+                createdAt: message.createdAt,
+            });
+            const count = await Model.countDocuments({ endpoint: message.endpoint, room: message.room });
+            if (count > config.maxCount) {
+                const oldest = await Model.find({ endpoint: message.endpoint, room: message.room })
+                    .sort({ createdAt: 1, _id: 1 })
+                    .limit(count - config.maxCount)
+                    .select('_id');
+                if (oldest.length > 0) {
+                    await Model.deleteMany({ _id: { $in: oldest.map((d) => d._id) } });
+                }
+            }
+            return message;
+        },
+        async getHistory(endpoint, room, opts) {
+            const Model = getModel();
+            const limit = opts?.limit ?? 50;
+            const filter = { endpoint, room };
+            if (opts?.before) {
+                const cursor = await Model.findById(opts.before).lean();
+                if (cursor) {
+                    filter.$or = [
+                        { createdAt: { $lt: cursor.createdAt } },
+                        { createdAt: cursor.createdAt, _id: { $lt: opts.before } },
+                    ];
+                }
+            }
+            else if (opts?.after) {
+                const cursor = await Model.findById(opts.after).lean();
+                if (cursor) {
+                    filter.$or = [
+                        { createdAt: { $gt: cursor.createdAt } },
+                        { createdAt: cursor.createdAt, _id: { $gt: opts.after } },
+                    ];
+                }
+            }
+            const docs = await Model.find(filter).sort({ createdAt: -1, _id: -1 }).limit(limit).lean();
+            return docs.reverse().map((d) => ({
+                id: d._id,
+                endpoint: d.endpoint,
+                room: d.room,
+                senderId: d.senderId,
+                payload: d.payload,
+                createdAt: d.createdAt,
+            }));
+        },
+        async clear() {
+            // Mongo clear — drop all documents. Used for test isolation.
+            try {
+                await getModel().deleteMany({});
+            }
+            catch {
+                /* best-effort */
+            }
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// SQLite
+// ---------------------------------------------------------------------------
+export function createSqliteWsMessageRepository(db) {
+    let initialized = false;
+    const trimCounters = new Map();
+    function scopeKey(endpoint, room) {
+        return `${endpoint}\0${room}`;
+    }
+    function ensureTable() {
+        if (initialized)
+            return;
+        db.run(`
+      CREATE TABLE IF NOT EXISTS ws_messages (
+        id         TEXT PRIMARY KEY,
+        endpoint   TEXT NOT NULL,
+        room       TEXT NOT NULL,
+        sender_id  TEXT,
+        payload    TEXT,
+        created_at INTEGER NOT NULL
+      )
+    `);
+        db.run('CREATE INDEX IF NOT EXISTS idx_ws_messages_scope ON ws_messages (endpoint, room, created_at DESC)');
+        initialized = true;
+    }
+    return {
+        async persist(message, config) {
+            ensureTable();
+            db.run('INSERT INTO ws_messages (id, endpoint, room, sender_id, payload, created_at) VALUES (?, ?, ?, ?, ?, ?)', [
+                message.id,
+                message.endpoint,
+                message.room,
+                message.senderId,
+                JSON.stringify(message.payload),
+                message.createdAt,
+            ]);
+            // Modulo-based trimming
+            const key = scopeKey(message.endpoint, message.room);
+            const counter = (trimCounters.get(key) ?? 0) + 1;
+            const trimInterval = Math.max(10, Math.floor(config.maxCount * 0.1));
+            trimCounters.set(key, counter);
+            if (counter >= trimInterval) {
+                trimCounters.set(key, 0);
+                db.run(`DELETE FROM ws_messages WHERE endpoint = ? AND room = ? AND id NOT IN (
+            SELECT id FROM ws_messages WHERE endpoint = ? AND room = ? ORDER BY created_at DESC, id DESC LIMIT ?
+          )`, [message.endpoint, message.room, message.endpoint, message.room, config.maxCount]);
+                const ttlMs = config.ttlSeconds * 1000;
+                db.run('DELETE FROM ws_messages WHERE endpoint = ? AND room = ? AND created_at < ?', [
+                    message.endpoint,
+                    message.room,
+                    Date.now() - ttlMs,
+                ]);
+            }
+            return message;
+        },
+        async getHistory(endpoint, room, opts) {
+            ensureTable();
+            const limit = opts?.limit ?? 50;
+            let sql;
+            let params;
+            if (opts?.before) {
+                sql = `
+          SELECT * FROM ws_messages
+          WHERE endpoint = ? AND room = ? AND (created_at, id) < (
+            (SELECT created_at FROM ws_messages WHERE id = ?), ?
+          )
+          ORDER BY created_at DESC, id DESC LIMIT ?
+        `;
+                params = [endpoint, room, opts.before, opts.before, limit];
+            }
+            else if (opts?.after) {
+                sql = `
+          SELECT * FROM ws_messages
+          WHERE endpoint = ? AND room = ? AND (created_at, id) > (
+            (SELECT created_at FROM ws_messages WHERE id = ?), ?
+          )
+          ORDER BY created_at ASC, id ASC LIMIT ?
+        `;
+                params = [endpoint, room, opts.after, opts.after, limit];
+            }
+            else {
+                sql =
+                    'SELECT * FROM ws_messages WHERE endpoint = ? AND room = ? ORDER BY created_at DESC, id DESC LIMIT ?';
+                params = [endpoint, room, limit];
+            }
+            const rows = db.query(sql).all(...params);
+            if (!opts?.after)
+                rows.reverse();
+            return rows.map((r) => ({
+                id: r.id,
+                endpoint: r.endpoint,
+                room: r.room,
+                senderId: r.sender_id,
+                payload: JSON.parse(r.payload),
+                createdAt: r.created_at,
+            }));
+        },
+        async clear() {
+            try {
+                ensureTable();
+                db.run('DELETE FROM ws_messages');
+                trimCounters.clear();
+            }
+            catch {
+                /* best-effort */
+            }
+        },
+    };
+}
+export const wsMessageFactories = {
+    memory: () => createMemoryWsMessageRepository(),
+    sqlite: infra => createSqliteWsMessageRepository(infra.getSqliteDb()),
+    redis: infra => createRedisWsMessageRepository(infra.getRedis()),
+    mongo: infra => {
+        const { conn, mg } = infra.getMongo();
+        return createMongoWsMessageRepository(conn, mg);
+    },
+    // TODO: implement a native postgres WS message store.
+    // For now postgres deployments fall back to in-memory (no cross-process fan-out).
+    postgres: () => createMemoryWsMessageRepository(),
+};

package/dist/src/framework/preloadSchemas.d.ts

@@ -0,0 +1,24 @@
+export interface ModelSchemasConfig {
+    /**
+     * One or more absolute directory paths or glob patterns containing shared Zod schemas.
+     * All matching .ts files are imported before routes so schemas are registered first.
+     * Optional when registration is "explicit" — in that case your registerSchema /
+     * registerSchemas calls run at the time each schema file is imported by a route.
+     * Examples:
+     *   import.meta.dir + "/schemas"
+     *   [import.meta.dir + "/schemas", import.meta.dir + "/models"]
+     *   import.meta.dir + "/models/**\/*.schema.ts"
+     */
+    paths?: string | string[];
+    /**
+     * How schemas found in the files are registered in `components/schemas`.
+     * - "auto" (default): exported Zod schemas are registered automatically. The export
+     *   name is used as the schema name, with a trailing "Schema" suffix stripped
+     *   (e.g. `LedgerItemSchema` → `"LedgerItem"`). Schemas already registered via
+     *   `registerSchema` or `registerSchemas` inside the file are never overwritten.
+     * - "explicit": files are imported but registration is entirely up to the user —
+     *   call `registerSchema` or `registerSchemas` inside each file.
+     */
+    registration?: 'auto' | 'explicit';
+}
+export declare function preloadModelSchemas(modelSchemas: string | string[] | ModelSchemasConfig | undefined): Promise<void>;

package/dist/src/framework/preloadSchemas.js

@@ -0,0 +1,42 @@
+/**
+ * Schema pre-loading — extracted from createApp().
+ *
+ * Imports shared Zod schema files before route discovery so registerSchema /
+ * registerSchemas calls run first, guaranteeing $ref instead of inline shapes.
+ */
+import { maybeAutoRegister } from './lib/createRoute';
+export async function preloadModelSchemas(modelSchemas) {
+    if (!modelSchemas)
+        return;
+    const { paths, registration = 'auto' } = typeof modelSchemas === 'string' || Array.isArray(modelSchemas)
+        ? { paths: modelSchemas, registration: 'auto' }
+        : modelSchemas;
+    const pathArray = paths ? (Array.isArray(paths) ? paths : [paths]) : [];
+    for (const entry of pathArray) {
+        // Normalize to forward slashes so splitting works on both Windows and Unix.
+        const normalized = entry.replaceAll('\\', '/');
+        // Split glob patterns: everything before the first wildcard segment is the cwd.
+        let cwd;
+        let pattern;
+        if (!normalized.includes('*')) {
+            cwd = normalized;
+            pattern = '**/*.ts';
+        }
+        else {
+            const parts = normalized.split('/');
+            const starIdx = parts.findIndex(p => p.includes('*'));
+            cwd = parts.slice(0, starIdx).join('/');
+            pattern = parts.slice(starIdx).join('/');
+        }
+        const schemaGlob = new Bun.Glob(pattern);
+        for await (const file of schemaGlob.scan({ cwd })) {
+            const mod = await import(`${cwd}/${file}`);
+            if (registration === 'auto') {
+                for (const [exportName, value] of Object.entries(mod)) {
+                    maybeAutoRegister(exportName, value);
+                }
+            }
+            // "explicit": file imported; any registerSchema/registerSchemas calls inside already ran
+        }
+    }
+}

package/dist/src/framework/registerBoundaryAdapters.d.ts

@@ -0,0 +1,23 @@
+import type { Connection } from 'mongoose';
+import { type CacheAdapter, type CoreRegistrar, type FingerprintBuilder, type RateLimitAdapter } from '../../packages/bunshot-core/src/index.js';
+import type { StoreType } from '../../packages/bunshot-core/src/index.js';
+export interface RegisterBoundaryAdaptersOptions {
+    /** Whether Redis is connected and available. */
+    redisEnabled: boolean;
+    /** Mongo connection mode — false means no Mongo. */
+    mongoMode: 'single' | 'separate' | false;
+    /** Redis client handle, or null when Redis is disabled. */
+    redis: import('ioredis').default | null;
+    /** App Mongo connection, or null when Mongo is disabled. */
+    appConnection: Connection | null;
+    /** SQLite database handle, or null when SQLite is not configured. */
+    sqliteDb: import('bun:sqlite').Database | null;
+}
+export interface BoundaryAdaptersSnapshot {
+    readonly rateLimitAdapter: RateLimitAdapter;
+    readonly fingerprintBuilder: FingerprintBuilder;
+    readonly cacheAdapters: ReadonlyMap<StoreType, CacheAdapter>;
+}
+export declare function resolveBoundaryAdapters(options: RegisterBoundaryAdaptersOptions): Promise<BoundaryAdaptersSnapshot>;
+export declare function applyBoundaryAdapters(registrar: CoreRegistrar, boundaryAdapters: BoundaryAdaptersSnapshot): void;
+export declare function registerBoundaryAdapters(registrar: CoreRegistrar, options: RegisterBoundaryAdaptersOptions): Promise<void>;