@async/db 0.2.0

package/dist/integrations/sqlite.js

@@ -0,0 +1,489 @@
+import { mkdirSync } from 'node:fs';
+import { mkdir } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { loadConfig } from '../config.js';
+import { dbError, listChoices } from '../errors.js';
+import { resolveResource, resourceAliasCollisionGroups } from '../names.js';
+import { assertRecordMatchesResource, loadProjectSchema } from '../schema.js';
+import { applyDefaultsToRecord } from '../sync.js';
+import { applyDefaultsToSeed } from '../features/sync/defaults.js';
+import { seedForRuntimeState } from '../features/sync/synthetic-seed.js';
+const require = createRequire(import.meta.url);
+export async function openSqliteDb(options = {}) {
+    const config = await loadConfig(options);
+    const project = options.project ?? await loadProjectSchema(config);
+    const storage = options.storage ?? {};
+    const file = storage.file ?? options.file ?? path.join(config.stateDir, 'sqlite', 'db.sqlite');
+    const { DatabaseSync } = await importNodeSqlite();
+    if (file !== ':memory:') {
+        await mkdir(path.dirname(file), { recursive: true });
+    }
+    const database = new DatabaseSync(file);
+    migrateSqliteDb(database, project.resources);
+    return new SqliteDb(config, project.resources, database);
+}
+export function sqliteStore(options = {}) {
+    const databases = new WeakMap();
+    const writeQueues = new Map();
+    return ({ config, storeName }) => {
+        const file = resolveSqliteStoreFile(config, options.file);
+        const connection = openStoreDatabase(file, databases, config);
+        const database = connection.database;
+        migrateSqliteStore(database);
+        return {
+            name: storeName,
+            capabilities: sqliteStoreCapabilities,
+            statePath() {
+                return file === ':memory:' ? undefined : file;
+            },
+            async hydrate(resources) {
+                migrateSqliteStore(database);
+                for (const resource of resources) {
+                    syncSqliteStoreResource(database, config, resource);
+                }
+            },
+            readResource(resource, fallback) {
+                const row = database.prepare('SELECT value FROM "_db_resources" WHERE name = ?').get(resource.name);
+                return row ? JSON.parse(String(row.value)) : fallback;
+            },
+            writeResource(resource, value) {
+                writeSqliteStoreResource(database, resource, value);
+            },
+            withResourceWrite(resource, operation) {
+                const queueKey = `${file}:${resource.name}`;
+                const previous = writeQueues.get(queueKey) ?? Promise.resolve();
+                const current = previous.then(operation, operation);
+                const stored = current.catch(() => { });
+                writeQueues.set(queueKey, stored);
+                stored.finally(() => {
+                    if (writeQueues.get(queueKey) === stored) {
+                        writeQueues.delete(queueKey);
+                    }
+                });
+                return current;
+            },
+            close() {
+                if (connection.closed) {
+                    return;
+                }
+                connection.closed = true;
+                database.close();
+                databases.delete(config);
+            },
+        };
+    };
+}
+function resolveSqliteStoreFile(config, file) {
+    if (file === ':memory:') {
+        return file;
+    }
+    if (file) {
+        return path.resolve(config.cwd, file);
+    }
+    return path.join(config.stateDir, 'runtime.sqlite');
+}
+export const sqliteStoreCapabilities = {
+    writable: true,
+    persistence: 'local-sqlite',
+    atomicity: 'resource',
+    liveEvents: true,
+    staticExport: false,
+    production: 'small-local',
+};
+export function migrateSqliteDb(database, resources) {
+    for (const resource of resources) {
+        if (resource.kind === 'collection') {
+            database.exec(createTableSql(resource));
+        }
+    }
+    database.exec(`CREATE TABLE IF NOT EXISTS "_db_documents" (
+    "name" TEXT PRIMARY KEY,
+    "value" TEXT NOT NULL
+  ) STRICT;`);
+}
+function migrateSqliteStore(database) {
+    database.exec(`CREATE TABLE IF NOT EXISTS "_db_resources" (
+    "name" TEXT PRIMARY KEY,
+    "kind" TEXT NOT NULL,
+    "source_hash" TEXT,
+    "value" TEXT NOT NULL
+  ) STRICT;`);
+}
+function openStoreDatabase(file, databases, config) {
+    let connection = databases.get(config);
+    if (connection && !connection.closed) {
+        return connection;
+    }
+    const { DatabaseSync } = importNodeSqliteSync();
+    if (file !== ':memory:') {
+        mkdirSync(path.dirname(file), { recursive: true });
+    }
+    connection = {
+        database: new DatabaseSync(file),
+        closed: false,
+    };
+    databases.set(config, connection);
+    return connection;
+}
+function syncSqliteStoreResource(database, config, resource) {
+    const row = database.prepare('SELECT source_hash FROM "_db_resources" WHERE name = ?').get(resource.name);
+    const sourceChanged = resource.dataHash && row?.source_hash !== resource.dataHash;
+    if (!row || sourceChanged) {
+        writeSqliteStoreResource(database, resource, applyDefaultsToSeed(seedForRuntimeState(resource, config), resource, config));
+        return;
+    }
+    if (config.defaults?.applyOnSafeMigration !== false) {
+        const current = JSON.parse(String(database.prepare('SELECT value FROM "_db_resources" WHERE name = ?').get(resource.name)?.value));
+        writeSqliteStoreResource(database, resource, applyDefaultsToSeed(current, resource, config));
+    }
+}
+function writeSqliteStoreResource(database, resource, value) {
+    database.prepare(`INSERT INTO "_db_resources" (name, kind, source_hash, value)
+    VALUES (?, ?, ?, ?)
+    ON CONFLICT(name) DO UPDATE SET
+      kind = excluded.kind,
+      source_hash = excluded.source_hash,
+      value = excluded.value`).run(resource.name, resource.kind, resource.dataHash ?? null, JSON.stringify(value));
+}
+export class SqliteDb {
+    config;
+    resources;
+    database;
+    constructor(config, resources, database) {
+        this.config = config;
+        this.resources = new Map(resources.map((resource) => [resource.name, resource]));
+        assertNoResourceAliasCollisions(this.resources);
+        this.database = database;
+    }
+    collection(name) {
+        const resource = this.requireResource(name, 'collection');
+        return new SqliteDbCollection(this.config, resource, this.database);
+    }
+    document(name) {
+        const resource = this.requireResource(name, 'document');
+        return new SqliteDbDocument(this.config, resource, this.database);
+    }
+    resourceNames() {
+        return [...this.resources.keys()];
+    }
+    close() {
+        this.database.close();
+    }
+    requireResource(name, kind) {
+        const { resource, candidates } = resolveResource(this.resources, name);
+        if (!resource) {
+            throw dbError('SQLITE_UNKNOWN_RESOURCE', `Unknown SQLite db resource "${name}".`, {
+                status: 404,
+                hint: `Use one of: ${listChoices(this.resourceNames())}.`,
+                details: {
+                    resource: name,
+                    requestedResource: name,
+                    normalizedCandidates: candidates,
+                    availableResources: this.resourceNames(),
+                },
+            });
+        }
+        if (resource.kind !== kind) {
+            throw dbError('SQLITE_RESOURCE_KIND_MISMATCH', `Resource "${name}" is a ${resource.kind}, not a ${kind}.`, {
+                status: 400,
+                hint: resource.kind === 'collection'
+                    ? `Use db.collection("${name}") for this resource.`
+                    : `Use db.document("${name}") for this resource.`,
+                details: {
+                    resource: name,
+                    expectedKind: kind,
+                    actualKind: resource.kind,
+                },
+            });
+        }
+        return resource;
+    }
+}
+function assertNoResourceAliasCollisions(resources) {
+    const collisions = resourceAliasCollisionGroups(resources);
+    if (collisions.length === 0) {
+        return;
+    }
+    const collision = collisions[0];
+    throw dbError('SQLITE_RESOURCE_ALIAS_COLLISION', `Resource aliases are ambiguous for "${collision.alias}".`, {
+        status: 400,
+        hint: 'Rename one resource so its camelCase and kebab-case aliases are unique.',
+        details: {
+            alias: collision.alias,
+            aliases: collision.aliases,
+            resources: collision.resources,
+            candidates: collision.candidates,
+            collisions,
+        },
+    });
+}
+export class SqliteDbCollection {
+    config;
+    resource;
+    database;
+    table;
+    constructor(config, resource, database) {
+        this.config = config;
+        this.resource = resource;
+        this.database = database;
+        this.table = quoteIdentifier(resource.name);
+    }
+    async all() {
+        return this.database.prepare(`SELECT * FROM ${this.table}`).all().map((row) => deserializeRow(this.resource, row));
+    }
+    async get(id) {
+        const idField = quoteIdentifier(this.resource.idField);
+        const row = this.database.prepare(`SELECT * FROM ${this.table} WHERE ${idField} = ?`).get(String(id));
+        return row ? deserializeRow(this.resource, row) : null;
+    }
+    async exists(id) {
+        const idField = quoteIdentifier(this.resource.idField);
+        const row = this.database.prepare(`SELECT 1 as found FROM ${this.table} WHERE ${idField} = ?`).get(String(id));
+        return Boolean(row);
+    }
+    async create(record) {
+        const fields = Object.keys(this.resource.fields);
+        const nextRecord = this.config.defaults?.applyOnCreate === false
+            ? stripUnknownFields(this.resource, record)
+            : applyDefaultsToRecord(stripUnknownFields(this.resource, record), this.resource);
+        if (nextRecord[this.resource.idField] === undefined || nextRecord[this.resource.idField] === null || nextRecord[this.resource.idField] === '') {
+            nextRecord[this.resource.idField] = await this.nextId();
+        }
+        assertRecordMatchesResource(nextRecord, this.resource, this.config, {
+            source: `${this.resource.name} create body`,
+        });
+        const serialized = serializeRow(this.resource, nextRecord);
+        const columns = fields.map(quoteIdentifier).join(', ');
+        const placeholders = fields.map(() => '?').join(', ');
+        try {
+            this.database.prepare(`INSERT INTO ${this.table} (${columns}) VALUES (${placeholders})`).run(...fields.map((field) => serialized[field] ?? null));
+        }
+        catch (error) {
+            if (String(error.message).includes('UNIQUE')) {
+                throw dbError('SQLITE_DUPLICATE_ID', `Cannot create "${this.resource.name}" record because id "${nextRecord[this.resource.idField]}" already exists.`, {
+                    status: 409,
+                    hint: 'Use a unique id, or call patch/update if you intended to modify the existing record.',
+                    details: {
+                        resource: this.resource.name,
+                        idField: this.resource.idField,
+                        id: nextRecord[this.resource.idField],
+                    },
+                });
+            }
+            throw error;
+        }
+        return nextRecord;
+    }
+    async update(id, patch) {
+        return this.patch(id, patch);
+    }
+    async patch(id, patch) {
+        const existing = await this.get(id);
+        if (!existing) {
+            return null;
+        }
+        const nextRecord = stripUnknownFields(this.resource, {
+            ...existing,
+            ...(isRecord(patch) ? patch : {}),
+            [this.resource.idField]: existing[this.resource.idField],
+        });
+        assertRecordMatchesResource(nextRecord, this.resource, this.config, {
+            source: `${this.resource.name} patch body`,
+        });
+        const fields = Object.keys(this.resource.fields).filter((field) => field !== this.resource.idField);
+        const serialized = serializeRow(this.resource, nextRecord);
+        const assignments = fields.map((field) => `${quoteIdentifier(field)} = ?`).join(', ');
+        this.database.prepare(`UPDATE ${this.table} SET ${assignments} WHERE ${quoteIdentifier(this.resource.idField)} = ?`).run(...fields.map((field) => serialized[field] ?? null), String(id));
+        return nextRecord;
+    }
+    async delete(id) {
+        const result = this.database.prepare(`DELETE FROM ${this.table} WHERE ${quoteIdentifier(this.resource.idField)} = ?`).run(String(id));
+        return result.changes > 0;
+    }
+    async nextId() {
+        const rows = this.database.prepare(`SELECT ${quoteIdentifier(this.resource.idField)} as id FROM ${this.table}`).all();
+        const ids = rows.map((row) => String(row.id)).filter(Boolean);
+        const numeric = ids.map((id) => Number(id)).filter((id) => Number.isInteger(id) && id > 0);
+        let next = numeric.length > 0 ? Math.max(...numeric) + 1 : ids.length + 1;
+        while (ids.includes(String(next))) {
+            next += 1;
+        }
+        return String(next);
+    }
+}
+export class SqliteDbDocument {
+    config;
+    resource;
+    database;
+    constructor(config, resource, database) {
+        this.config = config;
+        this.resource = resource;
+        this.database = database;
+    }
+    async all() {
+        const row = this.database.prepare('SELECT value FROM "_db_documents" WHERE name = ?').get(this.resource.name);
+        return row ? JSON.parse(String(row.value)) : {};
+    }
+    async get(pointer = '') {
+        const document = await this.all();
+        return pointer ? getPointer(document, pointer) : document;
+    }
+    async put(value) {
+        const nextDocument = stripUnknownFields(this.resource, value);
+        assertRecordMatchesResource(nextDocument, this.resource, this.config, {
+            source: `${this.resource.name} document body`,
+        });
+        this.database.prepare('INSERT INTO "_db_documents" (name, value) VALUES (?, ?) ON CONFLICT(name) DO UPDATE SET value = excluded.value')
+            .run(this.resource.name, JSON.stringify(nextDocument));
+        return nextDocument;
+    }
+    async set(pointer, value) {
+        const document = await this.all();
+        setPointer(document, pointer, value);
+        await this.put(document);
+        return value;
+    }
+    async update(patch) {
+        const document = await this.all();
+        return this.put({ ...document, ...(isRecord(patch) ? patch : {}) });
+    }
+}
+function createTableSql(resource) {
+    const columns = Object.entries(resource.fields).map(([fieldName, field]) => {
+        const primary = fieldName === resource.idField ? ' PRIMARY KEY' : '';
+        const required = field.required && fieldName !== resource.idField ? ' NOT NULL' : '';
+        return `  ${quoteIdentifier(fieldName)} ${sqliteTypeForField(field)}${primary}${required}`;
+    });
+    return `CREATE TABLE IF NOT EXISTS ${quoteIdentifier(resource.name)} (
+${columns.join(',\n')}
+) STRICT;`;
+}
+function sqliteTypeForField(field) {
+    switch (field.type) {
+        case 'number':
+            return 'REAL';
+        case 'boolean':
+            return 'INTEGER';
+        case 'string':
+        case 'datetime':
+        case 'enum':
+        case 'object':
+        case 'array':
+        case 'unknown':
+        default:
+            return 'TEXT';
+    }
+}
+function stripUnknownFields(resource, record) {
+    const source = isRecord(record) ? record : {};
+    const next = {};
+    for (const fieldName of Object.keys(resource.fields ?? {})) {
+        if (source[fieldName] !== undefined) {
+            next[fieldName] = source[fieldName];
+        }
+    }
+    return next;
+}
+function serializeRow(resource, record) {
+    const row = {};
+    for (const [fieldName, field] of Object.entries(resource.fields)) {
+        const value = record[fieldName];
+        if (value === undefined) {
+            row[fieldName] = null;
+        }
+        else if (field.type === 'boolean') {
+            row[fieldName] = value ? 1 : 0;
+        }
+        else if (field.type === 'object' || field.type === 'array' || field.type === 'unknown') {
+            row[fieldName] = JSON.stringify(value);
+        }
+        else {
+            row[fieldName] = value;
+        }
+    }
+    return row;
+}
+function deserializeRow(resource, row) {
+    const record = {};
+    for (const [fieldName, field] of Object.entries(resource.fields)) {
+        const value = row[fieldName];
+        if (value === null || value === undefined) {
+            continue;
+        }
+        if (field.type === 'boolean') {
+            record[fieldName] = Boolean(value);
+        }
+        else if (field.type === 'object' || field.type === 'array' || field.type === 'unknown') {
+            record[fieldName] = typeof value === 'string' ? JSON.parse(value) : value;
+        }
+        else {
+            record[fieldName] = value;
+        }
+    }
+    return record;
+}
+async function importNodeSqlite() {
+    try {
+        return await import('node:sqlite');
+    }
+    catch (error) {
+        throw sqliteRuntimeUnavailableError(error);
+    }
+}
+function importNodeSqliteSync() {
+    try {
+        return require('node:sqlite');
+    }
+    catch (error) {
+        throw sqliteRuntimeUnavailableError(error);
+    }
+}
+function sqliteRuntimeUnavailableError(error) {
+    const runtimeError = error;
+    return dbError('SQLITE_RUNTIME_UNAVAILABLE', 'SQLite store requires Node.js with node:sqlite support.', {
+        status: 500,
+        hint: 'Use Node.js 22.13 or newer for the SQLite store, or keep using the JSON store.',
+        details: {
+            parserMessage: runtimeError.message,
+        },
+    });
+}
+function quoteIdentifier(value) {
+    return `"${String(value).replaceAll('"', '""')}"`;
+}
+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;
+}
+function setPointer(document, pointer, value) {
+    const parts = parsePointer(pointer);
+    let current = document;
+    while (parts.length > 1) {
+        const part = parts.shift();
+        if (!current[part] || typeof current[part] !== 'object' || Array.isArray(current[part])) {
+            current[part] = {};
+        }
+        current = current[part];
+    }
+    current[parts[0]] = value;
+}
+function parsePointer(pointer) {
+    if (!pointer) {
+        return [];
+    }
+    return String(pointer)
+        .split('/')
+        .slice(1)
+        .map((part) => part.replaceAll('~1', '/').replaceAll('~0', '~'));
+}
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}

package/dist/integrations/vite.d.ts

@@ -0,0 +1,45 @@
+type ClientCacheOptions = boolean | {
+    enabled?: boolean;
+    readPolicy?: string;
+    writePolicy?: string;
+    eventPolicy?: string | false;
+    [key: string]: unknown;
+} | null | undefined;
+type DbVitePluginOptions = Record<string, unknown> & {
+    apiBase?: string;
+    dataPath?: string | false;
+    rootRoutes?: boolean;
+    restBasePath?: string;
+    graphqlPath?: string;
+    trace?: unknown;
+    clientVirtualModule?: string | false | null;
+    clientImport?: string;
+    clientCache?: ClientCacheOptions;
+    server?: {
+        apiBase?: string;
+        dataPath?: string | false;
+        [key: string]: unknown;
+    };
+};
+type ViteMiddleware = (request: unknown, response: unknown, next: (error?: unknown) => unknown) => unknown;
+type ViteDevServerLike = {
+    config?: {
+        logger?: {
+            warn?: (message: string) => unknown;
+        };
+    };
+    middlewares: {
+        use(handler: ViteMiddleware): unknown;
+    };
+    httpServer?: {
+        once?(event: string, listener: () => void): unknown;
+    };
+};
+export declare function dbPlugin(options?: DbVitePluginOptions): {
+    name: string;
+    apply: string;
+    configureServer(server: ViteDevServerLike): Promise<void>;
+    resolveId(id: string): string;
+    load(id: string): string;
+};
+export {};

package/dist/integrations/vite.js

@@ -0,0 +1,111 @@
+import { openDb } from '../db.js';
+import { serializeError } from '../errors.js';
+import { createDbRequestHandler, createViewerEventHub, watchSourceDir } from '../server.js';
+import { sendJson } from '../rest/handler.js';
+const DEFAULT_VIRTUAL_CLIENT_MODULE = 'virtual:db/client';
+const DEFAULT_CLIENT_IMPORT = '@async/db/client';
+export function dbPlugin(options = {}) {
+    const routes = resolveViteRoutes(options);
+    const virtualModuleId = options.clientVirtualModule === false
+        ? null
+        : options.clientVirtualModule ?? DEFAULT_VIRTUAL_CLIENT_MODULE;
+    const resolvedVirtualModuleId = virtualModuleId ? `\0${virtualModuleId}` : null;
+    return {
+        name: 'db:vite',
+        apply: 'serve',
+        async configureServer(server) {
+            const db = await openDb({
+                ...dbOptions(options),
+                allowSourceErrors: true,
+            });
+            const events = createViewerEventHub();
+            const watcher = await watchSourceDir(db, events, {
+                warn(message) {
+                    server.config?.logger?.warn?.(message);
+                },
+            });
+            const handler = createDbRequestHandler(db, {
+                ...routes,
+                events,
+                trace: options.trace,
+            });
+            server.middlewares.use((request, response, next) => {
+                return handler(request, response, next).catch((error) => {
+                    const statusError = error;
+                    sendJson(response, statusError.status ?? 500, serializeError(statusError, 'SERVER_ERROR'));
+                });
+            });
+            server.httpServer?.once?.('close', () => {
+                watcher.close();
+                events.close();
+            });
+        },
+        resolveId(id) {
+            return id === virtualModuleId ? resolvedVirtualModuleId : null;
+        },
+        load(id) {
+            if (id !== resolvedVirtualModuleId) {
+                return null;
+            }
+            return renderVirtualClient(routes, options.clientImport ?? DEFAULT_CLIENT_IMPORT, options.clientCache);
+        },
+    };
+}
+function resolveViteRoutes(options) {
+    const apiBase = normalizeBasePath(options.apiBase ?? options.server?.apiBase ?? '/__db');
+    return {
+        apiBase,
+        dataPath: options.dataPath ?? options.server?.dataPath,
+        rootRoutes: options.rootRoutes === true,
+        restBasePath: normalizeBasePath(options.restBasePath ?? `${apiBase}/rest`),
+        graphqlPath: normalizeBasePath(options.graphqlPath ?? `${apiBase}/graphql`),
+    };
+}
+function renderVirtualClient(routes, clientImport, clientCache) {
+    const cacheOption = serializeVirtualClientCache(clientCache);
+    const defaultCacheLine = cacheOption ? `  cache: ${cacheOption},\n` : '';
+    return `import { createDbClient } from ${JSON.stringify(clientImport)};
+
+export const client = createDbClient({
+  manifestPath: ${JSON.stringify(`${routes.apiBase}/manifest.json`)},
+  restBasePath: ${JSON.stringify(routes.restBasePath)},
+  restBatchPath: ${JSON.stringify(`${routes.apiBase}/batch`)},
+  graphqlPath: ${JSON.stringify(routes.graphqlPath)},
+${defaultCacheLine}
+});
+
+export default client;
+`;
+}
+function dbOptions(options) {
+    const { apiBase, dataPath, rootRoutes, restBasePath, graphqlPath, trace, clientVirtualModule, clientImport, clientCache, ...db } = options;
+    return db;
+}
+function serializeVirtualClientCache(value) {
+    if (value === undefined || value === false) {
+        return null;
+    }
+    if (value === true) {
+        return 'true';
+    }
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return null;
+    }
+    const cache = {};
+    if (value.enabled !== undefined) {
+        cache.enabled = Boolean(value.enabled);
+    }
+    for (const key of ['readPolicy', 'writePolicy']) {
+        if (typeof value[key] === 'string') {
+            cache[key] = value[key];
+        }
+    }
+    if (typeof value.eventPolicy === 'string' || value.eventPolicy === false) {
+        cache.eventPolicy = value.eventPolicy;
+    }
+    return JSON.stringify(cache);
+}
+function normalizeBasePath(value) {
+    const path = `/${String(value ?? '').replace(/^\/+/, '').replace(/\/+$/, '')}`;
+    return path === '/' ? '' : path;
+}

package/dist/json.d.ts

@@ -0,0 +1,48 @@
+import type { DbCustomStoreFactory } from './index.js';
+
+export type JsonStoreCapabilities = {
+  writable: true;
+  persistence: 'local-file';
+  atomicity: 'resource';
+  liveEvents: true;
+  staticExport: false;
+  production: 'small-local';
+};
+
+export type JsonStateConfig = {
+  stateDir: string;
+};
+
+export type JsonStateResource = {
+  name: string;
+};
+
+export type JsonFileStorage = {
+  kind: 'file';
+  root: string;
+};
+
+export type JsonS3Storage = {
+  kind: 's3';
+  bucket: string;
+  prefix?: string;
+  client?: unknown;
+  encryption?: unknown;
+};
+
+export type JsonStoreOptions = {
+  storage?: JsonFileStorage | JsonS3Storage;
+  durability?: 'current' | 'versioned' | string;
+  encryption?: unknown;
+};
+
+export const jsonStoreCapabilities: JsonStoreCapabilities;
+
+export function fileStorage(root: string): JsonFileStorage;
+export function s3Storage(options: Omit<JsonS3Storage, 'kind'>): JsonS3Storage;
+export function jsonStore(options?: JsonStoreOptions): DbCustomStoreFactory;
+export function jsonStatePathForResource(config: JsonStateConfig, resource: string | JsonStateResource): string;
+export function readJsonState<T>(filePath: string, fallback: T): Promise<T>;
+export function writeJsonState(filePath: string, value: unknown): Promise<boolean>;
+export function atomicWriteJson(filePath: string, value: unknown): Promise<boolean>;
+export function withJsonStateWrite<T>(filePath: string, operation: () => T | Promise<T>): Promise<T>;

package/dist/json.js

@@ -0,0 +1 @@
+export { atomicWriteJson, fileStorage, jsonStore, jsonRuntimeCapabilities as jsonStoreCapabilities, readJsonState, s3Storage, statePathForResource as jsonStatePathForResource, withJsonStateWrite, writeJsonState, } from './features/storage/json.js';

package/dist/jsonc.d.ts

@@ -0,0 +1 @@
+export { parseJsonc, stripJsonc } from './shared/jsonc.js';