@lastshotlabs/bunshot 0.0.25 → 0.0.28

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

@@ -0,0 +1,91 @@
+/**
+ * Middleware mounting — extracted from createApp().
+ *
+ * Handles the framework middleware stack: request ID, validation formatter,
+ * metrics collection, request logging, secure headers, CORS, bot protection,
+ * rate limiting, and tenant resolution.
+ */
+import type { MetricsState } from './lib/metrics';
+import type { LogLevel, RequestLogEntry } from './middleware/requestLogger';
+import type { OpenAPIHono } from '@hono/zod-openapi';
+import type { MiddlewareHandler } from 'hono';
+import type { AppEnv, ValidationErrorFormatter } from '../../packages/bunshot-core/src/index.js';
+export interface SecurityConfig {
+    cors?: string | string[];
+    headers?: {
+        contentSecurityPolicy?: string;
+        permissionsPolicy?: string;
+    };
+    rateLimit?: {
+        windowMs: number;
+        max: number;
+    };
+    botProtection?: {
+        blockList?: string[];
+        fingerprintRateLimit?: boolean;
+    };
+    trustProxy?: false | number;
+    signing?: unknown;
+    captcha?: unknown;
+}
+export interface LoggingConfig {
+    enabled?: boolean;
+    onLog?: (entry: RequestLogEntry) => void | Promise<void>;
+    level?: LogLevel;
+    excludePaths?: (string | RegExp)[];
+    excludeMethods?: string[];
+}
+export interface MetricsConfig {
+    enabled?: boolean;
+    auth?: 'userAuth' | 'none' | MiddlewareHandler<AppEnv>[];
+    excludePaths?: (string | RegExp)[];
+    normalizePath?: (path: string) => string;
+    queues?: string[];
+    unsafePublic?: boolean;
+}
+export interface TenancyConfig {
+    resolution: 'header' | 'subdomain' | 'path';
+    headerName?: string;
+    pathSegment?: number;
+    onResolve?: (tenantId: string) => Promise<Record<string, unknown> | null>;
+    cacheTtlMs?: number;
+    cacheMaxSize?: number;
+    exemptPaths?: string[];
+    rejectionStatus?: 403 | 404;
+}
+export interface MountMiddlewareConfig {
+    security: SecurityConfig;
+    logging?: LoggingConfig;
+    metrics?: MetricsConfig;
+    metricsState?: MetricsState;
+    tenancy?: TenancyConfig;
+    validation?: {
+        formatError?: ValidationErrorFormatter;
+    };
+    middleware?: MiddlewareHandler<AppEnv>[];
+}
+/**
+ * Mount all framework middleware on the Hono app in the correct order.
+ *
+ * Order:
+ * 1. Request ID
+ * 2. Validation error formatter (context variable)
+ * 3. Metrics collection (if enabled)
+ * 4. Request logging (if enabled)
+ * 5. Secure headers
+ * 6. Custom security headers
+ * 7. CORS
+ * 8. Bot protection (if configured)
+ * 9. Rate limiting
+ *
+ * Plugin middleware and tenant resolution are mounted separately
+ * (after this function returns) to maintain correct ordering.
+ */
+export declare function mountFrameworkMiddleware(app: OpenAPIHono<AppEnv>, config: MountMiddlewareConfig): Promise<void>;
+/**
+ * Mount tenant resolution middleware. Called after plugin middleware phase
+ * so tenant context is available in routes but plugins can set up auth first.
+ */
+export declare function mountTenantMiddleware(app: OpenAPIHono<AppEnv>, tenancy: TenancyConfig, carrier?: {
+    cache: import('./middleware/tenant').TenantResolutionCache | null;
+}): Promise<void>;

package/dist/src/framework/mountMiddleware.js

@@ -0,0 +1,128 @@
+import { rateLimit } from './middleware/rateLimit';
+import { requestId } from './middleware/requestId';
+import { requestLogger } from './middleware/requestLogger';
+import { cors } from 'hono/cors';
+import { secureHeaders } from 'hono/secure-headers';
+import { HEADER_CSRF_TOKEN, HEADER_REFRESH_TOKEN, HEADER_REQUEST_ID, HEADER_USER_TOKEN, defaultValidationErrorFormatter, } from '../../packages/bunshot-core/src/index.js';
+// ---------------------------------------------------------------------------
+// Implementation
+// ---------------------------------------------------------------------------
+/**
+ * Mount all framework middleware on the Hono app in the correct order.
+ *
+ * Order:
+ * 1. Request ID
+ * 2. Validation error formatter (context variable)
+ * 3. Metrics collection (if enabled)
+ * 4. Request logging (if enabled)
+ * 5. Secure headers
+ * 6. Custom security headers
+ * 7. CORS
+ * 8. Bot protection (if configured)
+ * 9. Rate limiting
+ *
+ * Plugin middleware and tenant resolution are mounted separately
+ * (after this function returns) to maintain correct ordering.
+ */
+export async function mountFrameworkMiddleware(app, config) {
+    const { security: securityConfig = {} } = config;
+    app.use(requestId);
+    // Set the validation error formatter on context so defaultHook and onError both pick it up
+    const validationFormatter = config.validation?.formatError ?? defaultValidationErrorFormatter;
+    app.use('*', async (c, next) => {
+        c.set('validationErrorFormatter', validationFormatter);
+        await next();
+    });
+    // Metrics collection middleware (before requestLogger so it captures all requests)
+    if (config.metrics?.enabled) {
+        const metricsAuth = config.metrics.auth ?? 'none';
+        if (metricsAuth === 'none' && !config.metrics.unsafePublic) {
+            if (process.env.NODE_ENV === 'production') {
+                throw new Error('[security] metrics.auth is required in production. Set metrics.auth or explicitly set unsafePublic: true with auth: "none".');
+            }
+            console.warn('[security] /metrics is enabled without auth. Configure metrics.auth for production.');
+        }
+        const { metricsCollector } = await import('./middleware/metrics');
+        app.use(metricsCollector({
+            state: config.metricsState ??
+                (() => {
+                    throw new Error('metricsState is required when metrics are enabled');
+                })(),
+            excludePaths: config.metrics.excludePaths,
+            normalizePath: config.metrics.normalizePath,
+        }));
+    }
+    // Request logging
+    const loggingConfig = config.logging ?? {};
+    if (loggingConfig.enabled !== false) {
+        app.use(requestLogger({
+            onLog: loggingConfig.onLog,
+            level: loggingConfig.level,
+            excludePaths: loggingConfig.excludePaths,
+            excludeMethods: loggingConfig.excludeMethods,
+        }));
+    }
+    // Secure headers
+    const headerOpts = {};
+    if (securityConfig.headers?.contentSecurityPolicy) {
+        headerOpts['Content-Security-Policy'] = securityConfig.headers.contentSecurityPolicy;
+    }
+    if (securityConfig.headers?.permissionsPolicy) {
+        headerOpts['Permissions-Policy'] = securityConfig.headers.permissionsPolicy;
+    }
+    app.use(secureHeaders());
+    if (Object.keys(headerOpts).length > 0) {
+        app.use(async (c, next) => {
+            await next();
+            for (const [k, v] of Object.entries(headerOpts)) {
+                c.res.headers.set(k, v);
+            }
+        });
+    }
+    // CORS
+    const corsOrigins = securityConfig.cors ?? '*';
+    if (corsOrigins === '*' && process.env.NODE_ENV === 'production') {
+        console.warn('[security] CORS is set to wildcard (*) in production. Configure security.cors with specific origins to restrict cross-origin access.');
+    }
+    const corsAllowHeaders = [
+        'Content-Type',
+        'Authorization',
+        HEADER_USER_TOKEN,
+        HEADER_REFRESH_TOKEN,
+        HEADER_CSRF_TOKEN,
+    ];
+    app.use(cors({
+        origin: corsOrigins,
+        allowHeaders: corsAllowHeaders,
+        exposeHeaders: ['x-cache', HEADER_REQUEST_ID],
+        credentials: true,
+    }));
+    // Bot protection
+    const botCfg = securityConfig.botProtection ?? {};
+    if ((botCfg.blockList?.length ?? 0) > 0) {
+        const { botProtection } = await import('./middleware/botProtection');
+        app.use(botProtection({ blockList: botCfg.blockList }));
+    }
+    // Rate limiting
+    const rlConfig = securityConfig.rateLimit ?? { windowMs: 60_000, max: 100 };
+    app.use(rateLimit({ ...rlConfig, fingerprintLimit: botCfg.fingerprintRateLimit ?? false }));
+}
+/**
+ * Mount tenant resolution middleware. Called after plugin middleware phase
+ * so tenant context is available in routes but plugins can set up auth first.
+ */
+export async function mountTenantMiddleware(app, tenancy, carrier) {
+    if (!tenancy.onResolve) {
+        if (process.env.NODE_ENV === 'production') {
+            throw new Error('[security] Tenancy is configured without an onResolve callback. ' +
+                'In production, onResolve is required to validate tenant IDs and prevent cross-tenant access. ' +
+                'Provide tenancy.onResolve or remove the tenancy config.');
+        }
+        else {
+            console.warn('[security] Tenancy is configured without an onResolve callback — ' +
+                'tenant IDs will be trusted without validation. This is unsafe in production.');
+        }
+    }
+    const { createTenantMiddleware } = await import('./middleware/tenant');
+    app.use(createTenantMiddleware(tenancy, carrier));
+}

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

@@ -0,0 +1,103 @@
+/**
+ * Optional endpoint mounting — extracted from createApp().
+ *
+ * Mounts the jobs status endpoint, /metrics endpoint, and upload presigned-URL
+ * endpoint when each is enabled in the app config.
+ */
+import type { MetricsState } from './lib/metrics';
+import type { OpenAPIHono } from '@hono/zod-openapi';
+import type { MiddlewareHandler } from 'hono';
+import type { AppEnv } from '../../packages/bunshot-core/src/index.js';
+export interface JobsConfig {
+    /** Enable the job status endpoint. Default: false. */
+    statusEndpoint?: boolean;
+    /**
+     * Auth protection for job endpoints.
+     * - `"userAuth"` — requires authenticated user session (cookie/token).
+     * - `"none"` — no auth (not recommended for production).
+     * - `MiddlewareHandler[]` — custom middleware stack (e.g., `[userAuth, requireRole("admin")]`).
+     *
+     * Default: `"none"`. You must explicitly configure auth.
+     */
+    auth?: 'userAuth' | 'none' | MiddlewareHandler<AppEnv>[];
+    /** Required roles for accessing job endpoints. Only works when auth includes userAuth. */
+    roles?: string[];
+    /** Whitelist of queue names exposed. Default: [] (nothing exposed). */
+    allowedQueues?: string[];
+    /** When using userAuth, restrict job visibility to the user who created it. Default: false. */
+    scopeToUser?: boolean;
+    /**
+     * Explicitly acknowledge that jobs endpoint is public in production.
+     * Set to true only when auth is "none" and you understand the risk.
+     * Without this, createApp throws in production when auth is "none".
+     */
+    unsafePublic?: boolean;
+}
+export interface MetricsConfig {
+    /** Enable the /metrics endpoint. Default: false (must be explicitly enabled). */
+    enabled?: boolean;
+    /**
+     * Auth protection for the /metrics endpoint.
+     * - `"userAuth"` — requires authenticated user session.
+     * - `"none"` — no auth (default — logs a production warning).
+     * - `MiddlewareHandler[]` — custom middleware stack.
+     */
+    auth?: 'userAuth' | 'none' | MiddlewareHandler<AppEnv>[];
+    /** Paths to exclude from metrics collection. Strings use prefix matching. */
+    excludePaths?: (string | RegExp)[];
+    /** Custom path normalizer to prevent high-cardinality labels. */
+    normalizePath?: (path: string) => string;
+    /** BullMQ queue names to report depth gauges for. */
+    queues?: string[];
+    /**
+     * Explicitly acknowledge that metrics endpoint is public in production.
+     * Set to true only when auth is "none" and you understand the risk.
+     * Without this, createApp throws in production when auth is "none".
+     */
+    unsafePublic?: boolean;
+}
+export interface PresignedUrlConfig {
+    expirySeconds?: number;
+    path?: string;
+}
+export interface UploadConfig {
+    storage: import('./lib/storageAdapter').StorageAdapter;
+    maxFileSize?: number;
+    maxFiles?: number;
+    allowedMimeTypes?: string[];
+    keyPrefix?: string;
+    generateKey?: (file: File, ctx: {
+        userId?: string;
+        tenantId?: string;
+    }) => string;
+    tenantScopedKeys?: boolean;
+    presignedUrls?: boolean | PresignedUrlConfig;
+    /**
+     * TTL in seconds for upload registry entries across all backends.
+     * Default: 2592000 (30 days).
+     */
+    registryTtlSeconds?: number;
+    /**
+     * Authorization callback for upload read/delete operations.
+     * Called when registry ownership check fails or key is not in registry.
+     */
+    authorization?: {
+        authorize?: (input: {
+            action: 'read' | 'delete';
+            key: string;
+            userId?: string;
+            tenantId?: string;
+        }) => boolean | Promise<boolean>;
+    };
+    /**
+     * Allow operations on keys not in the upload registry.
+     * When false (default), operations on unknown keys return 404.
+     * When true, requires an authorize callback — denies if absent.
+     */
+    allowExternalKeys?: boolean;
+}
+export declare function mountOptionalEndpoints(app: OpenAPIHono<AppEnv>, coreRoutesDir: string, jobs: JobsConfig | undefined, metrics: MetricsConfig | undefined, upload: UploadConfig | undefined, metricsState: MetricsState, resolvedSecrets: {
+    redisHost?: string;
+    redisUser?: string;
+    redisPassword?: string;
+}): Promise<void>;

package/dist/src/framework/mountOptionalEndpoints.js

@@ -0,0 +1,47 @@
+import { createQueueFactory } from '../lib/queue';
+// ---------------------------------------------------------------------------
+// Implementation
+// ---------------------------------------------------------------------------
+export async function mountOptionalEndpoints(app, coreRoutesDir, jobs, metrics, upload, metricsState, resolvedSecrets) {
+    const needsQueueFactory = !!jobs?.statusEndpoint || !!metrics?.queues?.length;
+    const queueFactory = needsQueueFactory
+        ? (() => {
+            if (!resolvedSecrets.redisHost) {
+                throw new Error('[queue] Jobs/metrics queue helpers require REDIS_HOST via the Bunshot secret bundle at startup.');
+            }
+            return createQueueFactory({
+                host: resolvedSecrets.redisHost,
+                user: resolvedSecrets.redisUser,
+                password: resolvedSecrets.redisPassword,
+            });
+        })()
+        : undefined;
+    if (jobs?.statusEndpoint) {
+        const jobsAuth = jobs.auth ?? 'none';
+        if (jobsAuth === 'none' && !jobs.unsafePublic) {
+            if (process.env.NODE_ENV === 'production') {
+                throw new Error('[security] jobs.auth is required in production. Set jobs.auth or explicitly set unsafePublic: true with auth: "none".');
+            }
+            console.warn('[security] /jobs is enabled without auth. Configure jobs.auth for production.');
+        }
+        const { createJobsRouter } = await import(`${coreRoutesDir}/jobs`);
+        app.route('/', createJobsRouter(jobs, queueFactory));
+    }
+    if (metrics?.enabled) {
+        const { createMetricsRouter } = await import(`${coreRoutesDir}/metrics`);
+        app.route('/', createMetricsRouter({
+            auth: metrics.auth,
+            queues: metrics.queues,
+            unsafePublic: metrics.unsafePublic,
+        }, metricsState, queueFactory));
+    }
+    if (upload?.presignedUrls) {
+        const { createUploadsRouter } = await import(`${coreRoutesDir}/uploads`);
+        const presignConfig = upload.presignedUrls === true ? {} : upload.presignedUrls;
+        app.route('/', createUploadsRouter({
+            ...presignConfig,
+            authorization: upload.authorization,
+            allowExternalKeys: upload.allowExternalKeys,
+        }));
+    }
+}

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

@@ -0,0 +1,21 @@
+import { OpenAPIHono } from '@hono/zod-openapi';
+import type { AppEnv } from '../../packages/bunshot-core/src/index.js';
+export interface VersioningConfig {
+    /**
+     * Version identifiers in ascending order, e.g. `["v1", "v2"]`.
+     * Each version needs a matching subdirectory under `routesDir` (e.g. `routes/v1/`).
+     */
+    versions: string[];
+    /**
+     * Subdirectory name for routes shared across all versions. Shared route schemas
+     * receive unprefixed names since they are version-agnostic. Default: `"shared"`.
+     * Set `false` to disable shared route discovery.
+     */
+    sharedDir?: string | false;
+    /**
+     * Which version `/docs` and `/openapi.json` redirect to.
+     * Defaults to the last version in the array (i.e. the latest).
+     */
+    defaultVersion?: string;
+}
+export declare function mountRoutes(app: OpenAPIHono<AppEnv>, routesDir: string, versioning: VersioningConfig | string[] | undefined, appName: string, openApiVersion: string): Promise<void>;

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