@async/db 0.2.0

package/dist/features/config/defaults.js

@@ -0,0 +1,95 @@
+export const DEFAULT_CONFIG = {
+    dbDir: './db',
+    sourceDir: './db',
+    stateDir: './.db',
+    outputs: {
+        stateDir: './.db',
+        types: './.db/types/index.d.ts',
+        committedTypes: null,
+        schemaManifest: null,
+        viewerManifest: null,
+        operationRegistry: null,
+        operationRefs: null,
+        honoStarterDir: './db-api',
+    },
+    schemaOutFile: null,
+    viewerManifestOutFile: null,
+    schemaManifest: {},
+    sources: {
+        readers: [],
+        writePolicy: 'preserve',
+    },
+    stores: {
+        default: 'json',
+        json: {
+            driver: 'json',
+        },
+    },
+    types: {
+        enabled: true,
+        outFile: './.db/types/index.d.ts',
+        commitOutFile: null,
+        useReadonly: false,
+        emitComments: true,
+        exportRuntimeHelpers: true,
+    },
+    schema: {
+        source: 'auto',
+        allowJsonc: true,
+        autoModulePackageJson: true,
+        standardSchema: false,
+        unknownFields: 'warn',
+        additiveChanges: 'auto',
+        destructiveChanges: 'manual',
+        typeChanges: 'manual',
+    },
+    defaults: {
+        applyOnCreate: true,
+        applyOnSafeMigration: true,
+    },
+    seed: {
+        generateFromSchema: false,
+        generatedCount: 5,
+    },
+    collections: {},
+    resources: {
+        naming: 'basename',
+    },
+    server: {
+        apiBase: '/__db',
+        dataPath: '/db',
+        host: '127.0.0.1',
+        port: 7331,
+        maxBodyBytes: 1048576,
+        viewerLinks: [],
+    },
+    rest: {
+        enabled: true,
+    },
+    graphql: {
+        enabled: true,
+        path: '/graphql',
+    },
+    operations: {
+        enabled: false,
+        sourceDir: './db/operations',
+        outFile: null,
+        refsOutFile: null,
+        acceptRefs: 'both',
+        registry: {},
+    },
+    mock: {
+        delay: [30, 100],
+        errors: null,
+    },
+    generate: {
+        hono: {
+            outDir: './db-api',
+            api: ['rest'],
+            db: 'sqlite',
+            app: 'standalone',
+            runtime: 'node-sqlite',
+            seed: false,
+        },
+    },
+};

package/dist/features/config/load.d.ts

@@ -0,0 +1,11 @@
+import { type SchemaLoadMode } from '../schema/locator.js';
+type ConfigRecord = Record<string, any>;
+type LoadConfigOptions = string | (ConfigRecord & {
+    configPath?: string;
+    cwd?: string;
+    from?: string;
+    load?: SchemaLoadMode;
+});
+export declare function loadConfig(options?: LoadConfigOptions): Promise<ConfigRecord>;
+export declare function mergeDeep(base: unknown, override: unknown): unknown;
+export {};

package/dist/features/config/load.js

@@ -0,0 +1,265 @@
+import { access } from 'node:fs/promises';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { dbError } from '../../errors.js';
+import { resolveFrom } from '../../fs-utils.js';
+import { DEFAULT_CONFIG } from './defaults.js';
+import { normalizeSchemaLoadMode, resolveSchemaLocator } from '../schema/locator.js';
+export async function loadConfig(options = {}) {
+    const rawOptions = typeof options === 'string' ? { from: options } : options;
+    const locator = await resolveSchemaLocator(rawOptions);
+    const cwd = locator.cwd;
+    const configPath = rawOptions.configPath
+        ? resolveFrom(cwd, rawOptions.configPath)
+        : await findConfigPath(cwd);
+    let userConfig = {};
+    if (configPath) {
+        const url = pathToFileURL(configPath);
+        url.searchParams.set('dbConfigLoad', String(Date.now()));
+        const module = await import(url.href);
+        userConfig = module.default ?? module.config ?? {};
+    }
+    const inlineOptions = { ...rawOptions };
+    delete inlineOptions.cwd;
+    delete inlineOptions.configPath;
+    delete inlineOptions.from;
+    delete inlineOptions.load;
+    rejectUnsupportedRuntimeConfig(userConfig);
+    rejectUnsupportedRuntimeConfig(inlineOptions);
+    rejectRemovedFixtureForkConfig(userConfig);
+    rejectRemovedFixtureForkConfig(inlineOptions);
+    const merged = mergeDeep(mergeDeep(structuredClone(DEFAULT_CONFIG), userConfig), inlineOptions);
+    normalizeOutputAliases(merged, userConfig, inlineOptions);
+    merged.cwd = cwd;
+    merged.configPath = configPath;
+    const hasInlineSourceDir = hasOwnConfigValue(inlineOptions, 'sourceDir') || hasOwnConfigValue(inlineOptions, 'dbDir');
+    const hasUserSourceDir = hasOwnConfigValue(userConfig, 'sourceDir') || hasOwnConfigValue(userConfig, 'dbDir');
+    const sourceDir = hasInlineSourceDir
+        ? (hasOwnConfigValue(inlineOptions, 'sourceDir') ? merged.sourceDir : merged.dbDir)
+        : rawOptions.from
+            ? locator.sourceDir
+            : hasUserSourceDir
+                ? (hasOwnConfigValue(userConfig, 'sourceDir') ? merged.sourceDir : merged.dbDir)
+                : merged.dbDir;
+    merged.sourceDir = resolveFrom(cwd, sourceDir);
+    merged.dbDir = merged.sourceDir;
+    merged.schemaLocator = {
+        ...locator,
+        cwd,
+        sourceDir: merged.sourceDir,
+    };
+    merged.schemaLoadMode = normalizeSchemaLoadMode(rawOptions.load ?? 'data');
+    merged.stateDir = resolveFrom(cwd, merged.stateDir);
+    merged.outputs.stateDir = merged.stateDir;
+    if (merged.types?.outFile) {
+        merged.types.outFile = resolveFrom(cwd, merged.types.outFile);
+    }
+    merged.outputs.types = merged.types?.outFile ?? null;
+    if (merged.types?.commitOutFile) {
+        merged.types.commitOutFile = resolveFrom(cwd, merged.types.commitOutFile);
+    }
+    merged.outputs.committedTypes = merged.types?.commitOutFile ?? null;
+    if (merged.schemaOutFile) {
+        merged.schemaOutFile = resolveFrom(cwd, merged.schemaOutFile);
+    }
+    merged.outputs.schemaManifest = merged.schemaOutFile ?? null;
+    if (merged.viewerManifestOutFile) {
+        merged.viewerManifestOutFile = resolveFrom(cwd, merged.viewerManifestOutFile);
+    }
+    merged.outputs.viewerManifest = merged.viewerManifestOutFile ?? null;
+    if (merged.operations?.sourceDir) {
+        merged.operations.sourceDir = resolveFrom(cwd, merged.operations.sourceDir);
+    }
+    if (merged.operations?.outFile) {
+        merged.operations.outFile = resolveFrom(cwd, merged.operations.outFile);
+    }
+    merged.outputs.operationRegistry = merged.operations?.outFile ?? null;
+    if (merged.operations?.refsOutFile) {
+        merged.operations.refsOutFile = resolveFrom(cwd, merged.operations.refsOutFile);
+    }
+    merged.outputs.operationRefs = merged.operations?.refsOutFile ?? null;
+    if (merged.generate?.hono?.outDir) {
+        merged.generate.hono.outDir = resolveFrom(cwd, merged.generate.hono.outDir);
+    }
+    merged.outputs.honoStarterDir = merged.generate?.hono?.outDir ?? null;
+    return merged;
+}
+function normalizeOutputAliases(config, userConfig, inlineOptions) {
+    config.outputs = config.outputs ?? {};
+    config.types = config.types ?? {};
+    config.operations = config.operations ?? {};
+    config.generate = config.generate ?? {};
+    config.generate.hono = config.generate.hono ?? {};
+    mirrorOutput(config, userConfig, inlineOptions, 'stateDir', ['stateDir']);
+    mirrorOutput(config, userConfig, inlineOptions, 'types', ['types', 'outFile']);
+    mirrorOutput(config, userConfig, inlineOptions, 'committedTypes', ['types', 'commitOutFile']);
+    mirrorOutput(config, userConfig, inlineOptions, 'schemaManifest', ['schemaOutFile']);
+    mirrorOutput(config, userConfig, inlineOptions, 'viewerManifest', ['viewerManifestOutFile']);
+    mirrorOutput(config, userConfig, inlineOptions, 'operationRegistry', ['operations', 'outFile']);
+    mirrorOutput(config, userConfig, inlineOptions, 'operationRefs', ['operations', 'refsOutFile']);
+    mirrorOutput(config, userConfig, inlineOptions, 'honoStarterDir', ['generate', 'hono', 'outDir']);
+}
+function mirrorOutput(config, userConfig, inlineOptions, outputKey, legacyPath) {
+    const outputPath = ['outputs', outputKey];
+    const value = configuredOutputValue({
+        config,
+        userConfig,
+        inlineOptions,
+        outputPath,
+        legacyPath,
+    });
+    setPath(config, outputPath, value);
+    setPath(config, legacyPath, value);
+}
+function configuredOutputValue({ config, userConfig, inlineOptions, outputPath, legacyPath, }) {
+    if (hasOwnPath(inlineOptions, outputPath)) {
+        return getPath(inlineOptions, outputPath);
+    }
+    if (hasOwnPath(inlineOptions, legacyPath)) {
+        return getPath(inlineOptions, legacyPath);
+    }
+    if (hasOwnPath(userConfig, outputPath)) {
+        return getPath(userConfig, outputPath);
+    }
+    if (hasOwnPath(userConfig, legacyPath)) {
+        return getPath(userConfig, legacyPath);
+    }
+    return getPath(config, legacyPath);
+}
+async function findConfigPath(cwd) {
+    for (const filename of ['db.config.mjs', 'db.config.js']) {
+        const candidate = path.join(cwd, filename);
+        try {
+            await access(candidate);
+            return candidate;
+        }
+        catch {
+            // keep looking
+        }
+    }
+    return null;
+}
+export function mergeDeep(base, override) {
+    if (!isPlainObject(base) || !isPlainObject(override)) {
+        return override === undefined ? base : override;
+    }
+    const output = { ...base };
+    for (const [key, value] of Object.entries(override)) {
+        if (value === undefined) {
+            continue;
+        }
+        if (isPlainObject(value) && isPlainObject(output[key])) {
+            output[key] = mergeDeep(output[key], value);
+        }
+        else {
+            output[key] = value;
+        }
+    }
+    return output;
+}
+function isPlainObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function hasOwnConfigValue(config, key) {
+    if (!isPlainObject(config)) {
+        return false;
+    }
+    return Object.prototype.hasOwnProperty.call(config, key) && config[key] !== undefined;
+}
+function hasOwnPath(config, pathParts) {
+    let current = config;
+    for (const pathPart of pathParts) {
+        if (!isPlainObject(current) || !Object.prototype.hasOwnProperty.call(current, pathPart)) {
+            return false;
+        }
+        current = current[pathPart];
+    }
+    return current !== undefined;
+}
+function getPath(config, pathParts) {
+    let current = config;
+    for (const pathPart of pathParts) {
+        if (!isPlainObject(current)) {
+            return undefined;
+        }
+        current = current[pathPart];
+    }
+    return current;
+}
+function setPath(config, pathParts, value) {
+    const last = pathParts.at(-1);
+    if (last === undefined) {
+        return;
+    }
+    let current = config;
+    for (const pathPart of pathParts.slice(0, -1)) {
+        if (!isPlainObject(current[pathPart])) {
+            current[pathPart] = {};
+        }
+        current = current[pathPart];
+    }
+    current[last] = value;
+}
+function rejectRemovedFixtureForkConfig(config) {
+    if (!isPlainObject(config)) {
+        return;
+    }
+    for (const key of ['forks', 'templates']) {
+        if (!hasOwnConfigValue(config, key)) {
+            continue;
+        }
+        throw dbError('CONFIG_LEGACY_FIXTURE_FORKS_REMOVED', `Unsupported config "${key}". Fixture-folder forks were removed so forks only mean runtime logical databases.`, {
+            hint: 'Use runtime forks with db.forks.create(), db.forks.open(), db.forks.ensure(), branches, and snapshots. Keep alternate seed data in normal fixture folders or app-owned import scripts.',
+            details: {
+                configKey: key,
+            },
+        });
+    }
+}
+function rejectUnsupportedRuntimeConfig(config) {
+    const diagnostics = unsupportedRuntimeConfigDiagnostics(config);
+    if (diagnostics.length === 0) {
+        return;
+    }
+    const error = new Error(diagnostics.map((diagnostic) => diagnostic.message).join('\n'));
+    error.code = 'CONFIG_UNSUPPORTED_RUNTIME_BOUNDARY';
+    error.diagnostics = diagnostics;
+    throw error;
+}
+function unsupportedRuntimeConfigDiagnostics(config) {
+    if (!isPlainObject(config)) {
+        return [];
+    }
+    const diagnostics = [];
+    if (hasOwnConfigValue(config, 'mode')) {
+        diagnostics.push(unsupportedRuntimeConfigDiagnostic('mode'));
+    }
+    if (isPlainObject(config.runtime)) {
+        if (hasOwnConfigValue(config.runtime, 'default')) {
+            diagnostics.push(unsupportedRuntimeConfigDiagnostic('runtime.default'));
+        }
+        if (hasOwnConfigValue(config.runtime, 'adapters')) {
+            diagnostics.push(unsupportedRuntimeConfigDiagnostic('runtime.adapters'));
+        }
+    }
+    else if (hasOwnConfigValue(config, 'runtime')) {
+        diagnostics.push(unsupportedRuntimeConfigDiagnostic('runtime'));
+    }
+    if (isPlainObject(config.resources)) {
+        for (const [resourceName, resourceConfig] of Object.entries(config.resources)) {
+            if (isPlainObject(resourceConfig) && hasOwnConfigValue(resourceConfig, 'runtime')) {
+                diagnostics.push(unsupportedRuntimeConfigDiagnostic(`resources.${resourceName}.runtime`));
+            }
+        }
+    }
+    return diagnostics;
+}
+function unsupportedRuntimeConfigDiagnostic(configPath) {
+    return {
+        code: 'CONFIG_UNSUPPORTED_RUNTIME_BOUNDARY',
+        severity: 'error',
+        path: configPath,
+        message: `Unsupported runtime config at "${configPath}". Runtime config is no longer a public configuration boundary.`,
+        hint: 'Use stores.default, named stores, and resources.<name>.store to configure the public storage boundary.',
+    };
+}

package/dist/features/config/public.d.ts

@@ -0,0 +1,17 @@
+type PlainObject = Record<string, unknown>;
+type ResourceNamingStrategy = 'basename' | 'folder-prefixed' | 'path';
+export type ParsedFixturePath = {
+    file: string;
+    folders: string[];
+    folder: string | null;
+    filename: string;
+    basename: string;
+    extension: string;
+};
+export declare function defineConfig<TConfig extends PlainObject>(config: TConfig): TConfig;
+export declare function mergeManifest(base: unknown, patch: unknown): unknown;
+export declare function resourceNameFromPath(file: string, options?: {
+    strategy?: ResourceNamingStrategy;
+}): string;
+export declare function parseFixturePath(file: string): ParsedFixturePath;
+export {};

package/dist/features/config/public.js

@@ -0,0 +1,75 @@
+export function defineConfig(config) {
+    return config;
+}
+export function mergeManifest(base, patch) {
+    return mergePlainObjects(structuredClone(base), patch);
+}
+export function resourceNameFromPath(file, options = {}) {
+    const strategy = options.strategy ?? 'basename';
+    const parsed = parseFixturePath(file);
+    const parts = strategy === 'basename'
+        ? [parsed.basename]
+        : strategy === 'folder-prefixed'
+            ? [...parsed.folders.slice(-1), parsed.basename]
+            : [...parsed.folders, parsed.basename];
+    return camelCase(parts.filter(Boolean).join('-'));
+}
+export function parseFixturePath(file) {
+    const normalized = String(file).split('\\').join('/');
+    const parts = normalized.split('/').filter(Boolean);
+    const filename = parts.at(-1) ?? '';
+    const extension = fixtureExtension(filename);
+    const folders = parts.slice(1, -1);
+    const basename = extension ? filename.slice(0, -extension.length) : filename;
+    return {
+        file: normalized,
+        folders,
+        folder: folders.at(-1) ?? null,
+        filename,
+        basename,
+        extension,
+    };
+}
+function mergePlainObjects(base, patch) {
+    if (!isPlainObject(base) || !isPlainObject(patch)) {
+        return structuredClone(patch);
+    }
+    const output = { ...base };
+    for (const [key, value] of Object.entries(patch)) {
+        if (value === undefined) {
+            continue;
+        }
+        if (isPlainObject(value) && isPlainObject(output[key])) {
+            output[key] = mergePlainObjects(output[key], value);
+            continue;
+        }
+        output[key] = structuredClone(value);
+    }
+    return output;
+}
+function isPlainObject(value) {
+    return value !== null
+        && typeof value === 'object'
+        && !Array.isArray(value)
+        && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null);
+}
+function camelCase(value) {
+    const words = String(value)
+        .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+        .split(/[^A-Za-z0-9]+/)
+        .filter(Boolean)
+        .map((part) => part.toLowerCase());
+    return words.map((word, index) => (index === 0 ? word : `${word.charAt(0).toUpperCase()}${word.slice(1)}`)).join('');
+}
+function fixtureExtension(filename) {
+    const schemaMatch = filename.match(/\.schema\.(json|jsonc|mjs|js)$/i);
+    if (schemaMatch) {
+        return `.schema.${schemaMatch[1].toLowerCase()}`;
+    }
+    const dataMatch = filename.match(/\.(json|jsonc|csv)$/i);
+    if (dataMatch) {
+        return `.${dataMatch[1].toLowerCase()}`;
+    }
+    const genericMatch = filename.match(/(\.[^./\\]+)$/);
+    return genericMatch ? genericMatch[1].toLowerCase() : '';
+}

package/dist/features/doctor/duplicate-ids.d.ts

@@ -0,0 +1,18 @@
+type DoctorResource = {
+    name: string;
+    idField: string;
+    seed: Array<Record<string, unknown>>;
+};
+type DoctorFinding = {
+    code: string;
+    severity: 'warn';
+    source: 'doctor';
+    resource: string;
+    field: string;
+    message: string;
+    hint: string;
+    details: Record<string, unknown>;
+};
+export declare function duplicateIdFindings(resource: DoctorResource): DoctorFinding[];
+export declare function mixedIdTypeFindings(resource: DoctorResource): DoctorFinding[];
+export {};

package/dist/features/doctor/duplicate-ids.js

@@ -0,0 +1,79 @@
+export function duplicateIdFindings(resource) {
+    const seen = new Map();
+    const findings = [];
+    for (const [index, record] of resource.seed.entries()) {
+        const value = record?.[resource.idField];
+        if (isEmpty(value)) {
+            continue;
+        }
+        const key = String(value);
+        const firstIndex = seen.get(key);
+        if (firstIndex !== undefined) {
+            findings.push({
+                code: 'DOCTOR_DUPLICATE_ID',
+                severity: 'warn',
+                source: 'doctor',
+                resource: resource.name,
+                field: resource.idField,
+                message: `${resource.name} has duplicate ${resource.idField} "${value}" in records ${firstIndex} and ${index}.`,
+                hint: `Make each ${resource.name}.${resource.idField} value unique before relying on update, delete, or relation expansion behavior.`,
+                details: {
+                    idField: resource.idField,
+                    value,
+                    firstRecordIndex: firstIndex,
+                    recordIndex: index,
+                },
+            });
+            continue;
+        }
+        seen.set(key, index);
+    }
+    return findings;
+}
+export function mixedIdTypeFindings(resource) {
+    const counts = valueTypeCounts(resource.seed.map((record) => record?.[resource.idField]));
+    if (counts.size <= 1) {
+        return [];
+    }
+    return [
+        {
+            code: 'DOCTOR_MIXED_ID_TYPES',
+            severity: 'warn',
+            source: 'doctor',
+            resource: resource.name,
+            field: resource.idField,
+            message: `${resource.name}.${resource.idField} uses mixed value types: ${describeCounts(counts)}.`,
+            hint: 'Use one id type consistently. String ids are usually safest for JSON fixtures.',
+            details: {
+                idField: resource.idField,
+                types: Object.fromEntries(counts),
+            },
+        },
+    ];
+}
+function valueTypeCounts(values) {
+    const counts = new Map();
+    for (const value of values) {
+        if (isEmpty(value)) {
+            continue;
+        }
+        const kind = valueKind(value);
+        counts.set(kind, (counts.get(kind) ?? 0) + 1);
+    }
+    return counts;
+}
+function valueKind(value) {
+    if (Array.isArray(value)) {
+        return 'array';
+    }
+    if (value === null) {
+        return 'null';
+    }
+    return typeof value;
+}
+function describeCounts(counts) {
+    return [...counts.entries()].map(([kind, count]) => `${kind} (${count})`).join(', ');
+}
+function isEmpty(value) {
+    return value === undefined || value === null || value === '';
+}

package/dist/features/doctor/field-consistency.d.ts

@@ -0,0 +1,17 @@
+type DoctorResource = {
+    name: string;
+    idField: string;
+    seed: unknown[];
+};
+type DoctorFinding = {
+    code: string;
+    severity: 'warn';
+    source: 'doctor';
+    resource: string;
+    field: string;
+    message: string;
+    hint: string;
+    details: Record<string, unknown>;
+};
+export declare function inconsistentFieldTypeFindings(resource: DoctorResource): DoctorFinding[];
+export {};

package/dist/features/doctor/field-consistency.js

@@ -0,0 +1,48 @@
+export function inconsistentFieldTypeFindings(resource) {
+    const fieldTypes = new Map();
+    for (const record of resource.seed) {
+        if (!isPlainRecord(record)) {
+            continue;
+        }
+        for (const [fieldName, value] of Object.entries(record)) {
+            if (fieldName === resource.idField || isEmpty(value)) {
+                continue;
+            }
+            const counts = fieldTypes.get(fieldName) ?? new Map();
+            counts.set(valueKind(value), (counts.get(valueKind(value)) ?? 0) + 1);
+            fieldTypes.set(fieldName, counts);
+        }
+    }
+    return [...fieldTypes.entries()]
+        .filter(([, counts]) => counts.size > 1)
+        .map(([fieldName, counts]) => ({
+        code: 'DOCTOR_INCONSISTENT_FIELD_TYPES',
+        severity: 'warn',
+        source: 'doctor',
+        resource: resource.name,
+        field: fieldName,
+        message: `${resource.name}.${fieldName} has inconsistent value types: ${describeCounts(counts)}.`,
+        hint: `Normalize ${resource.name}.${fieldName} values or add a schema if the mixed shape is intentional.`,
+        details: {
+            types: Object.fromEntries(counts),
+        },
+    }));
+}
+function valueKind(value) {
+    if (Array.isArray(value)) {
+        return 'array';
+    }
+    if (value === null) {
+        return 'null';
+    }
+    return typeof value;
+}
+function describeCounts(counts) {
+    return [...counts.entries()].map(([kind, count]) => `${kind} (${count})`).join(', ');
+}
+function isPlainRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function isEmpty(value) {
+    return value === undefined || value === null || value === '';
+}

package/dist/features/doctor/index.d.ts

@@ -0,0 +1,39 @@
+type DiagnosticSeverity = 'error' | 'warn' | 'info';
+type DoctorFinding = {
+    code: string;
+    severity: DiagnosticSeverity;
+    source: string;
+    resource?: string;
+    field?: string;
+    message: string;
+    hint: string;
+    details: Record<string, unknown>;
+    [key: string]: unknown;
+};
+type DoctorSummary = Record<DiagnosticSeverity, number>;
+type ResourceConfig = {
+    store?: string;
+    indexes?: unknown[];
+    [key: string]: unknown;
+};
+type StoreConfig = string | {
+    driver?: string;
+    [key: string]: unknown;
+};
+type DoctorConfig = {
+    doctor?: {
+        production?: boolean;
+    };
+    schema?: Record<string, unknown>;
+    resources?: Record<string, ResourceConfig>;
+    stores?: Record<string, StoreConfig> & {
+        default?: string;
+    };
+    [key: string]: unknown;
+};
+type DoctorResult = {
+    summary: DoctorSummary;
+    findings: DoctorFinding[];
+};
+export declare function runDbDoctor(config: DoctorConfig): Promise<DoctorResult>;
+export {};