@async/db 0.2.0

package/dist/features/runtime/document.d.ts

@@ -0,0 +1,43 @@
+type RuntimeConfig = {
+    schema?: {
+        unknownFields?: string;
+    };
+    cwd?: string;
+    stateDir?: string;
+    [key: string]: unknown;
+};
+type RuntimeResource = {
+    name: string;
+    kind?: string;
+    [key: string]: unknown;
+};
+type RuntimeAdapter = {
+    statePath?: (resource: RuntimeResource) => unknown;
+    readResource?: (resource: RuntimeResource, fallback: unknown) => Promise<unknown> | unknown;
+    writeResource?: (resource: RuntimeResource, value: unknown) => Promise<unknown> | unknown;
+    withResourceWrite?: <T>(resource: RuntimeResource, operation: () => T | Promise<T>) => Promise<T> | T;
+};
+type RuntimeFacade = {
+    adapterFor(resource: RuntimeResource): RuntimeAdapter;
+    emit(change: Record<string, unknown>): unknown;
+};
+type DbLike = {
+    config: RuntimeConfig;
+    runtime: RuntimeFacade;
+    assertResourceWritable?: (resourceName: string) => void;
+};
+export declare class DbDocument {
+    db: DbLike;
+    config: RuntimeConfig;
+    resource: RuntimeResource;
+    path: unknown;
+    constructor(db: DbLike | RuntimeConfig, resource: RuntimeResource);
+    all(): Promise<unknown>;
+    get(pointer?: string): Promise<unknown>;
+    put(value: unknown): Promise<unknown>;
+    set(pointer: string, value: unknown): Promise<unknown>;
+    update(patch: Record<string, unknown>): Promise<unknown>;
+    adapter(): RuntimeAdapter;
+    emit(op: string, details?: Record<string, unknown>): void;
+}
+export {};

package/dist/features/runtime/document.js

@@ -0,0 +1,111 @@
+import { dbError } from '../../errors.js';
+import { createSchemaValidator } from '../../schema.js';
+import { createRuntime } from '../storage/runtime.js';
+import { getPointer, setPointer } from './json-pointer.js';
+export class DbDocument {
+    db;
+    config;
+    resource;
+    path;
+    constructor(db, resource) {
+        this.db = normalizeDb(db, resource);
+        this.config = this.db.config;
+        this.resource = resource;
+        this.path = this.db.runtime.adapterFor(resource).statePath?.(resource);
+    }
+    async all() {
+        return this.adapter().readResource?.(this.resource, {});
+    }
+    async get(pointer = '') {
+        const document = await this.all();
+        return pointer ? getPointer(document, pointer) : document;
+    }
+    async put(value) {
+        this.db.assertResourceWritable?.(this.resource.name);
+        return this.adapter().withResourceWrite(this.resource, async () => {
+            const document = await assertRuntimeDocument(value, this.resource, this.config, {
+                source: `${this.resource.name} document body`,
+            });
+            await this.adapter().writeResource?.(this.resource, document);
+            this.emit('put');
+            return document;
+        });
+    }
+    async set(pointer, value) {
+        this.db.assertResourceWritable?.(this.resource.name);
+        return this.adapter().withResourceWrite(this.resource, async () => {
+            const document = await this.all();
+            setPointer(document, pointer, value);
+            const nextDocument = await assertRuntimeDocument(document, this.resource, this.config, {
+                source: `${this.resource.name} document body`,
+            });
+            await this.adapter().writeResource?.(this.resource, nextDocument);
+            this.emit('set', { pointer });
+            return getPointer(nextDocument, pointer);
+        });
+    }
+    async update(patch) {
+        this.db.assertResourceWritable?.(this.resource.name);
+        return this.adapter().withResourceWrite(this.resource, async () => {
+            const document = await this.all();
+            const nextDocument = {
+                ...document,
+                ...patch,
+            };
+            const validatedDocument = await assertRuntimeDocument(nextDocument, this.resource, this.config, {
+                source: `${this.resource.name} document patch body`,
+            });
+            await this.adapter().writeResource?.(this.resource, validatedDocument);
+            this.emit('update');
+            return validatedDocument;
+        });
+    }
+    adapter() {
+        return this.db.runtime.adapterFor(this.resource);
+    }
+    emit(op, details = {}) {
+        this.db.runtime.emit({
+            resource: this.resource.name,
+            kind: 'document',
+            op,
+            ...details,
+        });
+    }
+}
+function assertRuntimeDocument(document, resource, config, options = {}) {
+    const validator = createSchemaValidator(resource, config, {
+        mode: 'replace',
+        unknownFields: config.schema?.unknownFields ?? 'warn',
+        applyDefaults: false,
+    });
+    return validator.validateAsync(document, {
+        source: options.source,
+        applyDefaults: false,
+    }).then((result) => {
+        if (result.ok) {
+            return result.value;
+        }
+        throw dbError('DB_SCHEMA_VALIDATION_FAILED', `${resource.name} record does not match its schema: ${result.errors[0].message}`, {
+            status: 400,
+            hint: 'Update the record to match the schema field types, required fields, enum values, and constraints.',
+            details: {
+                resource: resource.name,
+                diagnostics: result.errors,
+            },
+        });
+    });
+}
+function normalizeDb(db, resource) {
+    if (isDbLike(db)) {
+        return db;
+    }
+    const config = db;
+    const runtime = createRuntime(config, [resource]);
+    return {
+        config,
+        runtime,
+    };
+}
+function isDbLike(value) {
+    return Boolean(value?.runtime && value?.config);
+}

package/dist/features/runtime/fanout.d.ts

@@ -0,0 +1,24 @@
+type RuntimeRecord = Record<string, unknown>;
+type RuntimeDb = {
+    config?: unknown;
+    [key: string]: unknown;
+};
+type ComputedFieldResolver = {
+    resolve?: (...args: unknown[]) => unknown;
+    resolveMany?: (...args: unknown[]) => unknown;
+};
+type RuntimeResource = {
+    fields?: Record<string, {
+        computed?: boolean;
+    }>;
+    resolvers?: {
+        fields?: Record<string, ComputedFieldResolver>;
+    };
+    [key: string]: unknown;
+};
+type ComputedFanoutOptions = {
+    cache?: Map<unknown, unknown>;
+    context?: unknown;
+};
+export declare function resolveSelectedComputedFields(db: RuntimeDb, resource: RuntimeResource, records: RuntimeRecord[], fieldNames: string[], options?: ComputedFanoutOptions): Promise<RuntimeRecord[]>;
+export {};

package/dist/features/runtime/fanout.js

@@ -0,0 +1,77 @@
+import { callFieldResolver, valueFromResolveManyResult } from '../schema/resolvers.js';
+export async function resolveSelectedComputedFields(db, resource, records, fieldNames, options = {}) {
+    const selected = [...new Set(fieldNames)]
+        .filter((fieldName) => resource.fields?.[fieldName]?.computed)
+        .filter((fieldName) => resource.resolvers?.fields?.[fieldName]);
+    if (selected.length === 0 || records.length === 0) {
+        return records;
+    }
+    const nextRecords = records.map((record) => record && typeof record === 'object' && !Array.isArray(record)
+        ? { ...record }
+        : record);
+    const cache = options.cache ?? new Map();
+    for (const fieldName of selected) {
+        const resolver = resource.resolvers?.fields?.[fieldName];
+        if (!resolver) {
+            continue;
+        }
+        if (typeof resolver.resolveMany === 'function') {
+            const args = {
+                records: nextRecords,
+                db,
+                resource,
+                cache,
+            };
+            const values = await callFieldResolver(resolver.resolveMany, args, {
+                db,
+                config: db.config,
+                resource,
+                fieldName,
+                cache,
+                context: options.context,
+                value: nextRecords,
+            });
+            applyManyResolvedValues(nextRecords, resource, fieldName, values);
+            continue;
+        }
+        if (typeof resolver.resolve === 'function') {
+            for (const record of nextRecords) {
+                const args = {
+                    record,
+                    db,
+                    resource,
+                    cache,
+                };
+                record[fieldName] = await callFieldResolver(resolver.resolve, args, {
+                    db,
+                    config: db.config,
+                    resource,
+                    fieldName,
+                    cache,
+                    context: options.context,
+                    value: record,
+                });
+            }
+        }
+    }
+    return nextRecords;
+}
+function applyManyResolvedValues(records, resource, fieldName, values) {
+    if (Array.isArray(values)) {
+        for (const [index, record] of records.entries()) {
+            record[fieldName] = valueFromResolveManyResult(values, resource, record, index);
+        }
+        return;
+    }
+    if (values instanceof Map) {
+        for (const [index, record] of records.entries()) {
+            record[fieldName] = valueFromResolveManyResult(values, resource, record, index);
+        }
+        return;
+    }
+    if (values && typeof values === 'object') {
+        for (const [index, record] of records.entries()) {
+            record[fieldName] = valueFromResolveManyResult(values, resource, record, index);
+        }
+    }
+}

package/dist/features/runtime/json-pointer.d.ts

@@ -0,0 +1,5 @@
+type JsonContainer = Record<string, unknown> | unknown[];
+export declare function getPointer(document: unknown, pointer: string): unknown;
+export declare function setPointer(document: JsonContainer, pointer: string, value: unknown): void;
+export declare function parsePointer(pointer: string): string[];
+export {};

package/dist/features/runtime/json-pointer.js

@@ -0,0 +1,49 @@
+import { dbError } from '../../errors.js';
+export function getPointer(document, pointer) {
+    const parts = parsePointer(pointer);
+    let value = document;
+    for (const part of parts) {
+        if (value === null || value === undefined) {
+            return undefined;
+        }
+        value = value[part];
+    }
+    return value;
+}
+export function setPointer(document, pointer, value) {
+    const parts = parsePointer(pointer);
+    if (parts.length === 0) {
+        throw dbError('DB_DOCUMENT_SET_ROOT', 'Cannot set the root document with set().', {
+            status: 400,
+            hint: 'Use document.put(value) to replace the whole document, or pass a JSON pointer like "/theme" to set a nested value.',
+        });
+    }
+    let current = document;
+    for (const part of parts.slice(0, -1)) {
+        if (!current[part] || typeof current[part] !== 'object') {
+            current[part] = {};
+        }
+        current = current[part];
+    }
+    const last = parts.at(-1);
+    if (last !== undefined) {
+        current[last] = value;
+    }
+}
+export function parsePointer(pointer) {
+    if (!pointer || pointer === '/') {
+        return [];
+    }
+    if (!pointer.startsWith('/')) {
+        throw dbError('DB_INVALID_JSON_POINTER', `Invalid JSON pointer "${pointer}".`, {
+            status: 400,
+            hint: 'JSON pointers must start with "/". For example: "/theme" or "/features/billing".',
+            details: { pointer },
+        });
+    }
+    return pointer
+        .slice(1)
+        .split('/')
+        .filter(Boolean)
+        .map((part) => part.replaceAll('~1', '/').replaceAll('~0', '~'));
+}

package/dist/features/runtime/scope-state.d.ts

@@ -0,0 +1,44 @@
+export type DbScope = {
+    fork: string | null;
+    branch: string;
+    rootStateDir: string;
+};
+export type RuntimeScopeConfig = {
+    cwd: string;
+    stateDir: string;
+    resources?: Record<string, unknown>;
+    __asyncDbScope?: DbScope;
+    [key: string]: unknown;
+};
+export type MigrationLock = {
+    name: string;
+    resources: string[];
+    mode: 'read-only';
+    startedAt: string;
+    copies?: Record<string, MigrationResourceCopy>;
+};
+export type MigrationResourceCopy = {
+    resource: string;
+    from: string;
+    to: string;
+    copiedAt: string;
+};
+export declare function normalizeScopedConfig<TConfig extends RuntimeScopeConfig>(config: TConfig, scope?: DbScope): {
+    config: TConfig;
+    scope: DbScope;
+};
+export declare function scopedConfig(config: RuntimeScopeConfig, scope: DbScope): RuntimeScopeConfig;
+export declare function forkRegistryPath(rootStateDir: string): string;
+export declare function branchRegistryPath(rootStateDir: string, fork: string): string;
+export declare function snapshotDirForScope(scope: DbScope, snapshotId: string): string;
+export declare function routingPathForScope(scope: DbScope): string;
+export declare function migrationLocksPathForScope(scope: DbScope): string;
+export declare function loadPersistedMigrationLocks(scope: DbScope): Map<string, MigrationLock>;
+export declare function readJsonFile<T>(filePath: string, fallback: T): Promise<T>;
+export declare function writeJsonFile(filePath: string, value: unknown): Promise<void>;
+export declare function snapshotId(label?: string): string;
+export declare function assertValidSnapshotId(id: string): void;
+export declare function assertValidScopedName(name: string, kind: string): void;
+export declare function configRecord(value: unknown): Record<string, unknown>;
+export declare function cloneConfigResources(value: unknown): Record<string, unknown> | undefined;
+export declare function readJsonFileSync<T>(filePath: string, fallback: T): T;

package/dist/features/runtime/scope-state.js

@@ -0,0 +1,185 @@
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import { dbError } from '../../errors.js';
+import { readJsonState, writeJsonState } from '../storage/json.js';
+export function normalizeScopedConfig(config, scope) {
+    const next = {
+        ...config,
+        resources: cloneConfigResources(config.resources),
+    };
+    const nextScope = scope ?? next.__asyncDbScope ?? {
+        fork: null,
+        branch: 'main',
+        rootStateDir: config.stateDir,
+    };
+    next.__asyncDbScope = nextScope;
+    applyPersistedRouting(next, nextScope);
+    return {
+        config: next,
+        scope: nextScope,
+    };
+}
+export function scopedConfig(config, scope) {
+    const stateDir = scope.fork
+        ? path.join(scope.rootStateDir, 'forks', scope.fork, 'branches', scope.branch)
+        : scope.rootStateDir;
+    return {
+        ...config,
+        stateDir,
+        __asyncDbScope: scope,
+    };
+}
+export function forkRegistryPath(rootStateDir) {
+    return path.join(rootStateDir, 'forks', 'registry.json');
+}
+export function branchRegistryPath(rootStateDir, fork) {
+    return path.join(rootStateDir, 'forks', fork, 'branches', 'registry.json');
+}
+export function snapshotDirForScope(scope, snapshotId) {
+    return scope.fork
+        ? path.join(scope.rootStateDir, 'forks', scope.fork, 'snapshots', snapshotId)
+        : path.join(scope.rootStateDir, 'snapshots', snapshotId);
+}
+export function routingPathForScope(scope) {
+    return path.join(branchMetaDirForScope(scope), 'routing.json');
+}
+export function migrationLocksPathForScope(scope) {
+    return path.join(branchMetaDirForScope(scope), 'migration-locks.json');
+}
+export function loadPersistedMigrationLocks(scope) {
+    const state = readJsonFileSync(migrationLocksPathForScope(scope), { locks: {} });
+    const locks = new Map();
+    for (const [name, value] of Object.entries(configRecord(state.locks))) {
+        const lock = configRecord(value);
+        if (!Array.isArray(lock.resources)) {
+            continue;
+        }
+        locks.set(name, {
+            name,
+            resources: lock.resources.map(String),
+            mode: 'read-only',
+            startedAt: typeof lock.startedAt === 'string' ? lock.startedAt : '',
+            copies: migrationCopiesRecord(lock.copies),
+        });
+    }
+    return locks;
+}
+export async function readJsonFile(filePath, fallback) {
+    return readJsonState(filePath, fallback);
+}
+export async function writeJsonFile(filePath, value) {
+    await writeJsonState(filePath, value);
+}
+export function snapshotId(label) {
+    const safeLabel = label
+        ? `_${slugPart(label)}`
+        : '';
+    return `snap_${new Date().toISOString().replace(/[-:.TZ]/g, '')}${safeLabel}_${Math.random().toString(36).slice(2, 8)}`;
+}
+export function assertValidSnapshotId(id) {
+    if (/^[A-Za-z0-9][A-Za-z0-9_.-]*$/.test(id)) {
+        return;
+    }
+    throw dbError('DB_SNAPSHOT_ID_INVALID', `Invalid snapshot id "${id}".`, {
+        status: 400,
+        hint: 'Use a snapshot id with letters, numbers, dots, underscores, or hyphens.',
+        details: {
+            snapshot: id,
+        },
+    });
+}
+export function assertValidScopedName(name, kind) {
+    if (/^[A-Za-z0-9][A-Za-z0-9_-]*$/.test(String(name ?? ''))) {
+        return;
+    }
+    throw dbError('DB_SCOPE_NAME_INVALID', `Invalid ${kind} name "${name}".`, {
+        status: 400,
+        hint: 'Use a folder-style name with letters, numbers, underscores, or hyphens.',
+        details: {
+            kind,
+            name,
+        },
+    });
+}
+export function configRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : {};
+}
+export function cloneConfigResources(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return undefined;
+    }
+    return Object.fromEntries(Object.entries(value)
+        .map(([name, config]) => [name, cloneConfigValue(config)]));
+}
+function branchMetaDirForScope(scope) {
+    return scope.fork
+        ? path.join(scope.rootStateDir, 'forks', scope.fork, 'branches', scope.branch, 'meta')
+        : path.join(scope.rootStateDir, 'meta');
+}
+function applyPersistedRouting(config, scope) {
+    const routes = readJsonFileSync(routingPathForScope(scope), {});
+    if (Object.keys(routes).length === 0) {
+        return;
+    }
+    const resourcesConfig = cloneConfigResources(config.resources) ?? {};
+    for (const [resourceName, storeName] of Object.entries(routes)) {
+        const existing = configRecord(resourcesConfig[resourceName]);
+        resourcesConfig[resourceName] = {
+            ...existing,
+            store: storeName,
+        };
+    }
+    config.resources = resourcesConfig;
+}
+export function readJsonFileSync(filePath, fallback) {
+    try {
+        return JSON.parse(readFileSync(filePath, 'utf8'));
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return fallback;
+        }
+        if (error instanceof SyntaxError) {
+            throw dbError('JSON_STATE_INVALID', `JSON state file is not valid JSON: ${filePath}`, {
+                status: 500,
+                hint: 'Restore this file from a known-good snapshot, delete it to rehydrate from seed data when safe, or fix the JSON syntax before restarting.',
+                details: {
+                    filePath,
+                    parserMessage: error.message,
+                },
+            });
+        }
+        throw error;
+    }
+}
+function migrationCopiesRecord(value) {
+    const copies = configRecord(value);
+    const normalized = {};
+    for (const [resource, copyValue] of Object.entries(copies)) {
+        const copy = configRecord(copyValue);
+        if (typeof copy.from !== 'string' || typeof copy.to !== 'string') {
+            continue;
+        }
+        normalized[resource] = {
+            resource,
+            from: copy.from,
+            to: copy.to,
+            copiedAt: typeof copy.copiedAt === 'string' ? copy.copiedAt : '',
+        };
+    }
+    return Object.keys(normalized).length > 0 ? normalized : undefined;
+}
+function slugPart(value) {
+    return value
+        .toLowerCase()
+        .replace(/[^a-z0-9_-]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, 48);
+}
+function cloneConfigValue(value) {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? { ...value }
+        : value;
+}

package/dist/features/runtime/state.d.ts

@@ -0,0 +1 @@
+export { atomicWriteJson, readJsonState, statePathForResource, withJsonStateWrite, writeJsonState, } from '../storage/json.js';

package/dist/features/runtime/state.js

@@ -0,0 +1 @@
+export { atomicWriteJson, readJsonState, statePathForResource, withJsonStateWrite, writeJsonState, } from '../storage/json.js';

package/dist/features/schema/api.d.ts

@@ -0,0 +1,107 @@
+import type { SchemaField } from './fields.js';
+import type { SchemaLoadMode } from './locator.js';
+import { callFieldResolver } from './resolvers.js';
+import { type SchemaDiagnostic, type StandardSchemaV1 } from './standard-schema.js';
+type ValidationMode = 'create' | 'replace' | 'patch';
+type ValidatorUnknownFields = 'allow' | 'warn' | 'error' | 'strip';
+type DbConfig = Record<string, unknown> & {
+    schemaLoadMode?: SchemaLoadMode;
+    schema?: {
+        unknownFields?: ValidatorUnknownFields | string;
+        [key: string]: unknown;
+    };
+    services?: Record<string, unknown>;
+};
+type LoadDbSchemaOptions = string | (DbConfig & {
+    from?: string;
+    load?: SchemaLoadMode;
+});
+type SchemaFieldResolverDefinition = {
+    resolve?: Parameters<typeof callFieldResolver>[0];
+    resolveMany?: Parameters<typeof callFieldResolver>[0];
+    [key: string]: unknown;
+};
+type SchemaResource = {
+    name: string;
+    kind?: 'collection' | 'document' | string;
+    idField?: string;
+    fields?: Record<string, SchemaField>;
+    fieldsAuthoritative?: boolean;
+    resolvers?: {
+        fields?: Record<string, SchemaFieldResolverDefinition>;
+        [key: string]: unknown;
+    };
+    validators?: {
+        standard?: StandardSchemaV1;
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+};
+type SchemaProject = {
+    resources: SchemaResource[];
+    diagnostics: SchemaDiagnostic[];
+    schema: unknown;
+    loadMode?: SchemaLoadMode;
+    locator?: unknown;
+    rootSchema?: unknown;
+};
+type LoadedDbSchema = {
+    kind: 'DbSchema';
+    config: DbConfig;
+    loadMode?: SchemaLoadMode;
+    locator?: unknown;
+    rootSchema?: unknown;
+    resources: Map<string, SchemaResource>;
+    diagnostics: SchemaDiagnostic[];
+    schema: unknown;
+    resource(name: string): SchemaResource;
+    resourceNames(): string[];
+    validator(name: string, options?: SchemaValidatorOptions): SchemaValidator;
+    resolver(selector: string, options?: SchemaResolverOptions): SchemaFieldResolver | Record<string, SchemaFieldResolver>;
+    validate(name: string, value: unknown, options?: SchemaValidatorOptions): ValidationResult;
+    assert(name: string, value: unknown, options?: SchemaValidatorOptions): unknown;
+    validateAsync(name: string, value: unknown, options?: SchemaValidatorOptions): Promise<ValidationResult>;
+    assertAsync(name: string, value: unknown, options?: SchemaValidatorOptions): Promise<unknown>;
+    toJSON(): unknown;
+};
+type SchemaResolverOptions = {
+    db?: unknown;
+    cache?: Map<unknown, unknown>;
+    context?: unknown;
+    services?: Record<string, unknown>;
+    value?: unknown;
+    [key: string]: unknown;
+};
+type SchemaFieldResolver = ((args?: unknown) => Promise<unknown>) & {
+    resolve?: (args?: unknown) => Promise<unknown>;
+    resolveMany?: (args?: unknown) => Promise<unknown>;
+};
+type SchemaValidatorOptions = {
+    mode?: ValidationMode | string;
+    unknownFields?: ValidatorUnknownFields | 'ignore' | string;
+    source?: string;
+    applyDefaults?: boolean;
+};
+type ValidationResult<TValue = Record<string, unknown>> = {
+    ok: boolean;
+    value: TValue;
+    diagnostics: SchemaDiagnostic[];
+    errors: SchemaDiagnostic[];
+    resource: string;
+    mode: ValidationMode;
+};
+type SchemaValidator<TValue = Record<string, unknown>> = {
+    resource: string;
+    mode: ValidationMode;
+    unknownFields: ValidatorUnknownFields;
+    validate(value: unknown, validateOptions?: SchemaValidatorOptions): ValidationResult<TValue>;
+    validateAsync(value: unknown, validateOptions?: SchemaValidatorOptions): Promise<ValidationResult<TValue>>;
+    assert(value: unknown, assertOptions?: SchemaValidatorOptions): TValue;
+    assertAsync(value: unknown, assertOptions?: SchemaValidatorOptions): Promise<TValue>;
+};
+export declare function loadDbSchema(options?: LoadDbSchemaOptions): Promise<LoadedDbSchema>;
+export declare function createDbSchema(project: SchemaProject, config: DbConfig): LoadedDbSchema;
+export declare function createSchemaResourceResolverMap(resource: SchemaResource, config: DbConfig, options?: SchemaResolverOptions): Record<string, SchemaFieldResolver>;
+export declare function createSchemaFieldResolver(resource: SchemaResource, fieldName: string, config: DbConfig, options?: SchemaResolverOptions): SchemaFieldResolver;
+export declare function createSchemaValidator(resource: SchemaResource, config: DbConfig, options?: SchemaValidatorOptions): SchemaValidator;
+export {};