@async/db 0.2.0

package/dist/features/storage/json.js

@@ -0,0 +1,239 @@
+import { mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { dbError } from '../../errors.js';
+import { applyDefaultsToSeed } from '../sync/defaults.js';
+import { seedForRuntimeState } from '../sync/synthetic-seed.js';
+import { updateSourceMetadataResource } from './source-metadata.js';
+const writeQueues = new Map();
+export const jsonRuntimeCapabilities = {
+    writable: true,
+    persistence: 'local-file',
+    atomicity: 'resource',
+    liveEvents: true,
+    staticExport: false,
+    production: 'small-local',
+};
+export function fileStorage(root) {
+    return {
+        kind: 'file',
+        root,
+    };
+}
+export function s3Storage(options) {
+    return {
+        kind: 's3',
+        ...options,
+    };
+}
+export function jsonStore(options = {}) {
+    return ({ config, storeName }) => {
+        const storage = options.storage ?? fileStorage(config.__asyncDbScope?.rootStateDir ?? config.stateDir);
+        if (storage.kind !== 'file') {
+            return unsupportedObjectStorageAdapter(storeName, storage, options);
+        }
+        const fileBackend = storage;
+        const rootDirectory = options.storage ? 'resources' : 'state';
+        function statePath(resource) {
+            return jsonStoreStatePath(config, fileBackend, resource.name, rootDirectory);
+        }
+        return {
+            name: storeName,
+            capabilities: {
+                ...jsonRuntimeCapabilities,
+                durability: options.durability ?? 'current',
+                encryption: options.encryption ?? null,
+                layout: 'resource-files',
+            },
+            statePath,
+            readResource(resource, fallback) {
+                return readJsonState(statePath(resource), fallback);
+            },
+            writeResource(resource, value) {
+                return writeJsonState(statePath(resource), value);
+            },
+            withResourceWrite(resource, operation) {
+                return withJsonStateWrite(statePath(resource), operation);
+            },
+        };
+    };
+}
+export function createJsonRuntimeAdapter(config) {
+    return {
+        name: 'json',
+        capabilities: jsonRuntimeCapabilities,
+        statePath(resource) {
+            return statePathForResource(config, resource.name);
+        },
+        async hydrate(resources) {
+            await mkdir(jsonResourceStateDir(config), { recursive: true });
+            const sourceMetadataPath = path.join(jsonResourceStateDir(config), '.sources.json');
+            const sourceMetadata = await readJsonState(sourceMetadataPath, { resources: {} });
+            sourceMetadata.resources ??= {};
+            for (const resource of resources) {
+                await syncJsonResourceState(config, resource, sourceMetadata);
+            }
+            await writeJsonState(sourceMetadataPath, sourceMetadata);
+        },
+        readResource(resource, fallback) {
+            return readJsonState(statePathForResource(config, resource.name), fallback);
+        },
+        writeResource(resource, value) {
+            return writeJsonState(statePathForResource(config, resource.name), value);
+        },
+        withResourceWrite(resource, operation) {
+            return withJsonStateWrite(statePathForResource(config, resource.name), operation);
+        },
+    };
+}
+export function statePathForResource(config, resourceName) {
+    const name = typeof resourceName === 'string'
+        ? resourceName
+        : resourceName.name;
+    return jsonResourcePath({
+        root: config.__asyncDbScope?.rootStateDir ?? config.stateDir,
+        rootDirectory: 'state',
+        scope: config.__asyncDbScope,
+        resourceName: name,
+    });
+}
+function jsonResourceStateDir(config) {
+    return jsonResourceDir({
+        root: config.__asyncDbScope?.rootStateDir ?? config.stateDir,
+        rootDirectory: 'state',
+        scope: config.__asyncDbScope,
+    });
+}
+function jsonStoreStatePath(config, storage, resourceName, rootDirectory) {
+    const root = path.isAbsolute(storage.root)
+        ? storage.root
+        : path.resolve(config.cwd, storage.root);
+    return jsonResourcePath({
+        root,
+        rootDirectory,
+        scope: config.__asyncDbScope,
+        resourceName,
+    });
+}
+function jsonResourcePath(options) {
+    return path.join(jsonResourceDir(options), `${options.resourceName}.json`);
+}
+function jsonResourceDir(options) {
+    const { root, rootDirectory, scope } = options;
+    if (scope?.fork) {
+        return path.join(root, 'forks', scope.fork, 'branches', scope.branch ?? 'main', 'resources');
+    }
+    return path.join(root, rootDirectory);
+}
+function unsupportedObjectStorageAdapter(storeName, storage, options) {
+    const error = () => dbError('JSON_STORAGE_BACKEND_UNAVAILABLE', `JSON store "${storeName}" cannot use "${storage.kind}" storage in this runtime yet.`, {
+        status: 500,
+        hint: 'Use fileStorage() for the built-in runtime today, or provide a custom object-storage adapter that implements read/write semantics.',
+        details: {
+            store: storeName,
+            storage: storage.kind,
+        },
+    });
+    return {
+        name: storeName,
+        capabilities: {
+            ...jsonRuntimeCapabilities,
+            persistence: 'object-storage',
+            durability: options.durability ?? 'versioned',
+            encryption: storage.encryption ?? options.encryption ?? null,
+            layout: 'resource-files',
+        },
+        readResource() {
+            throw error();
+        },
+        writeResource() {
+            throw error();
+        },
+        withResourceWrite(_resource, operation) {
+            throw error();
+        },
+    };
+}
+export async function readJsonState(filePath, fallback) {
+    try {
+        return JSON.parse(await readFile(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;
+    }
+}
+export async function writeJsonState(filePath, value) {
+    return atomicWriteJson(filePath, value);
+}
+export async function atomicWriteJson(filePath, value) {
+    await mkdir(path.dirname(filePath), { recursive: true });
+    const text = `${JSON.stringify(value, null, 2)}\n`;
+    try {
+        if ((await readFile(filePath, 'utf8')) === text) {
+            return false;
+        }
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT') {
+            throw error;
+        }
+    }
+    const tempPath = path.join(path.dirname(filePath), `.${path.basename(filePath)}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`);
+    try {
+        await writeFile(tempPath, text, 'utf8');
+        await rename(tempPath, filePath);
+        return true;
+    }
+    catch (error) {
+        try {
+            await rm(tempPath, { force: true });
+        }
+        catch {
+            // Best-effort cleanup only.
+        }
+        throw error;
+    }
+}
+export function withJsonStateWrite(filePath, operation) {
+    const previous = writeQueues.get(filePath) ?? Promise.resolve();
+    const current = previous.then(operation, operation);
+    const stored = current.catch(() => { });
+    writeQueues.set(filePath, stored);
+    stored.finally(() => {
+        if (writeQueues.get(filePath) === stored) {
+            writeQueues.delete(filePath);
+        }
+    });
+    return current;
+}
+export async function syncJsonResourceState(config, resource, sourceMetadata) {
+    const statePath = statePathForResource(config, resource.name);
+    const existing = await readJsonState(statePath, undefined);
+    const metadata = sourceMetadata.resources[resource.name];
+    const sourceChanged = resource.dataHash
+        && metadata?.hash !== resource.dataHash;
+    if (existing === undefined || sourceChanged) {
+        await writeJsonState(statePath, applyDefaultsToSeed(seedForRuntimeState(resource, config), resource, config));
+        updateSourceMetadata(sourceMetadata, config, resource);
+        return;
+    }
+    if (config.defaults?.applyOnSafeMigration !== false) {
+        await writeJsonState(statePath, applyDefaultsToSeed(existing, resource, config));
+    }
+    updateSourceMetadata(sourceMetadata, config, resource);
+}
+function updateSourceMetadata(sourceMetadata, config, resource) {
+    updateSourceMetadataResource(sourceMetadata, config, resource);
+}

package/dist/features/storage/memory.d.ts

@@ -0,0 +1,30 @@
+type RuntimeConfig = Record<string, unknown>;
+type RuntimeResource = {
+    name: string;
+    [key: string]: unknown;
+};
+type ResourceWriteOperation<T> = () => T | Promise<T>;
+export declare const memoryRuntimeCapabilities: {
+    writable: boolean;
+    persistence: string;
+    atomicity: string;
+    liveEvents: boolean;
+    staticExport: boolean;
+    production: boolean;
+};
+export declare function createMemoryRuntimeAdapter(config: RuntimeConfig): {
+    name: string;
+    capabilities: {
+        writable: boolean;
+        persistence: string;
+        atomicity: string;
+        liveEvents: boolean;
+        staticExport: boolean;
+        production: boolean;
+    };
+    hydrate(resources: RuntimeResource[]): Promise<void>;
+    readResource(resource: RuntimeResource, fallback: unknown): Promise<unknown>;
+    writeResource(resource: RuntimeResource, value: unknown): Promise<void>;
+    withResourceWrite<T>(resource: RuntimeResource, operation: ResourceWriteOperation<T>): Promise<T>;
+};
+export {};

package/dist/features/storage/memory.js

@@ -0,0 +1,44 @@
+import { applyDefaultsToSeed } from '../sync/defaults.js';
+import { seedForRuntimeState } from '../sync/synthetic-seed.js';
+export const memoryRuntimeCapabilities = {
+    writable: true,
+    persistence: 'memory',
+    atomicity: 'process',
+    liveEvents: true,
+    staticExport: false,
+    production: false,
+};
+export function createMemoryRuntimeAdapter(config) {
+    const values = new Map();
+    const queues = new Map();
+    return {
+        name: 'memory',
+        capabilities: memoryRuntimeCapabilities,
+        async hydrate(resources) {
+            for (const resource of resources) {
+                values.set(resource.name, clone(applyDefaultsToSeed(seedForRuntimeState(resource, config), resource, config)));
+            }
+        },
+        async readResource(resource, fallback) {
+            return values.has(resource.name) ? clone(values.get(resource.name)) : clone(fallback);
+        },
+        async writeResource(resource, value) {
+            values.set(resource.name, clone(value));
+        },
+        withResourceWrite(resource, operation) {
+            const previous = queues.get(resource.name) ?? Promise.resolve();
+            const current = previous.then(operation, operation);
+            const stored = current.catch(() => { });
+            queues.set(resource.name, stored);
+            stored.finally(() => {
+                if (queues.get(resource.name) === stored) {
+                    queues.delete(resource.name);
+                }
+            });
+            return current;
+        },
+    };
+}
+function clone(value) {
+    return value === undefined ? value : structuredClone(value);
+}

package/dist/features/storage/resource-json.d.ts

@@ -0,0 +1,31 @@
+type RuntimeConfig = {
+    defaults?: {
+        applyOnSafeMigration?: boolean;
+    };
+    [key: string]: unknown;
+};
+type RuntimeResource = {
+    kind?: string;
+    name: string;
+    dataHash?: string | null;
+    [key: string]: unknown;
+};
+export type ResourceEnvelope<T = unknown> = {
+    kind?: string;
+    sourceHash?: string | null;
+    value: T;
+};
+type EnvelopeReader<T> = (resource: RuntimeResource) => Promise<ResourceEnvelope<T> | null | undefined>;
+type EnvelopeWriter<T> = (resource: RuntimeResource, envelope: ResourceEnvelope<T>) => Promise<unknown>;
+type ResourceWriteOperation<T> = () => T | Promise<T>;
+export declare function createResourceWriteQueue(): <T>(queueKey: string, operation: ResourceWriteOperation<T>) => Promise<T>;
+export declare function hydrateJsonResourceStore<T = unknown>({ config, resource, readEnvelope, writeEnvelope, }: {
+    config: RuntimeConfig;
+    resource: RuntimeResource;
+    readEnvelope: EnvelopeReader<T>;
+    writeEnvelope: EnvelopeWriter<T>;
+}): Promise<void>;
+export declare function envelopeForResource<T>(resource: RuntimeResource, value: T): ResourceEnvelope<T>;
+export declare function parseJsonEnvelope<T = unknown>(raw: string | ResourceEnvelope<T> | null | undefined, storeName: string): ResourceEnvelope<T> | null;
+export declare function closeInjectedClient(client: Record<string, unknown> | null | undefined, closeOption: boolean | ((client: Record<string, unknown> | null | undefined) => unknown | Promise<unknown>)): Promise<void>;
+export {};

package/dist/features/storage/resource-json.js

@@ -0,0 +1,76 @@
+import { dbError } from '../../errors.js';
+import { applyDefaultsToSeed } from '../sync/defaults.js';
+import { seedForRuntimeState } from '../sync/synthetic-seed.js';
+export function createResourceWriteQueue() {
+    const queues = new Map();
+    return function withQueuedResourceWrite(queueKey, operation) {
+        const previous = queues.get(queueKey) ?? Promise.resolve();
+        const current = previous.then(operation, operation);
+        const stored = current.catch(() => { });
+        queues.set(queueKey, stored);
+        stored.finally(() => {
+            if (queues.get(queueKey) === stored) {
+                queues.delete(queueKey);
+            }
+        });
+        return current;
+    };
+}
+export async function hydrateJsonResourceStore({ config, resource, readEnvelope, writeEnvelope, }) {
+    const envelope = await readEnvelope(resource);
+    const sourceChanged = resource.dataHash && envelope?.sourceHash !== resource.dataHash;
+    if (!envelope || sourceChanged) {
+        await writeEnvelope(resource, {
+            kind: resource.kind,
+            sourceHash: resource.dataHash ?? null,
+            value: applyDefaultsToSeed(seedForRuntimeState(resource, config), resource, config),
+        });
+        return;
+    }
+    if (config.defaults?.applyOnSafeMigration !== false) {
+        await writeEnvelope(resource, {
+            kind: resource.kind,
+            sourceHash: resource.dataHash ?? envelope.sourceHash ?? null,
+            value: applyDefaultsToSeed(envelope.value, resource, config),
+        });
+    }
+}
+export function envelopeForResource(resource, value) {
+    return {
+        kind: resource.kind,
+        sourceHash: resource.dataHash ?? null,
+        value,
+    };
+}
+export function parseJsonEnvelope(raw, storeName) {
+    if (raw === undefined || raw === null) {
+        return null;
+    }
+    const envelope = (typeof raw === 'string' ? JSON.parse(raw) : raw);
+    if (!envelope || typeof envelope !== 'object' || !('value' in envelope)) {
+        throw dbError('STORE_INVALID_RESOURCE_ENVELOPE', `Store "${storeName}" returned an invalid resource envelope.`, {
+            status: 500,
+            hint: 'Resource JSON stores must persist { kind, sourceHash, value } envelopes.',
+            details: {
+                store: storeName,
+            },
+        });
+    }
+    return envelope;
+}
+export async function closeInjectedClient(client, closeOption) {
+    if (!closeOption) {
+        return;
+    }
+    if (typeof closeOption === 'function') {
+        await closeOption(client);
+        return;
+    }
+    for (const method of ['close', 'end', 'quit', 'disconnect']) {
+        const closeMethod = client?.[method];
+        if (typeof closeMethod === 'function') {
+            await closeMethod.call(client);
+            return;
+        }
+    }
+}

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

@@ -0,0 +1,37 @@
+type RuntimeResource = {
+    name: string;
+    [key: string]: unknown;
+};
+type RuntimeConfig = {
+    cwd: string;
+    stateDir: string;
+    resources?: Record<string, unknown>;
+    stores?: Record<string, unknown>;
+    [key: string]: unknown;
+};
+type RuntimeAdapter = {
+    name: string;
+    capabilities?: unknown;
+    statePath?: (resource: RuntimeResource) => unknown;
+    hydrate?: (resources: RuntimeResource[]) => unknown | Promise<unknown>;
+    readResource?: (resource: RuntimeResource, fallback: unknown) => unknown | Promise<unknown>;
+    writeResource?: (resource: RuntimeResource, value: unknown) => unknown | Promise<unknown>;
+    withResourceWrite?: <T>(resource: RuntimeResource, operation: () => T | Promise<T>) => T | Promise<T>;
+    close?: () => unknown | Promise<unknown>;
+};
+export declare function createRuntime(config: RuntimeConfig, resources: RuntimeResource[]): {
+    events: {
+        readonly version: number;
+        emit(change: import("./events.js").RuntimeEventChange): import("./events.js").RuntimeEvent;
+        subscribe(subscriber: import("./events.js").RuntimeEventSubscriber): () => void;
+        close(): void;
+    };
+    adapterNames(): string[];
+    strategyFor(resource: RuntimeResource): string;
+    adapterForStore(resource: RuntimeResource, storeName: string): RuntimeAdapter;
+    adapterFor(resource: RuntimeResource): RuntimeAdapter;
+    hydrate(): Promise<void>;
+    emit(change: Record<string, unknown>): import("./events.js").RuntimeEvent;
+    close(): Promise<void>;
+};
+export {};

package/dist/features/storage/runtime.js

@@ -0,0 +1,184 @@
+import { dbError, listChoices } from '../../errors.js';
+import { resourceConfigValue } from '../../names.js';
+import { createJsonRuntimeAdapter } from './json.js';
+import { createMemoryRuntimeAdapter } from './memory.js';
+import { createSourceRuntimeAdapter } from './source.js';
+import { createStaticRuntimeAdapter } from './static.js';
+import { createRuntimeEventHub } from './events.js';
+export function createRuntime(config, resources) {
+    const events = createRuntimeEventHub();
+    const adapters = new Map();
+    const storeDefinitions = new Map();
+    const customStoreQueues = new Map();
+    let closed = false;
+    for (const adapter of builtinAdapters(config)) {
+        adapters.set(adapter.name, adapter);
+    }
+    for (const [storeName, storeDefinition] of Object.entries(config.stores ?? {})) {
+        if (storeName === 'default' || typeof storeDefinition === 'string' || storeRecord(storeDefinition)?.driver) {
+            continue;
+        }
+        const store = typeof storeDefinition === 'function'
+            ? storeDefinition({ config, resources, storeName })
+            : storeDefinition;
+        if (store) {
+            storeDefinitions.set(storeName, store);
+            adapters.set(storeName, customStoreAdapter(storeName, store, customStoreQueues));
+        }
+    }
+    return {
+        events,
+        adapterNames() {
+            return [...adapters.keys()];
+        },
+        strategyFor(resource) {
+            const resourceConfig = storeRecord(resourceConfigValue(config.resources, resource.name));
+            const storeName = String(resourceConfig?.store ?? config.stores?.default ?? 'json');
+            return strategyForStoreName(resource, storeName, config, adapters, storeDefinitions);
+        },
+        adapterForStore(resource, storeName) {
+            const strategy = strategyForStoreName(resource, storeName, config, adapters, storeDefinitions);
+            const adapter = adapters.get(strategy);
+            if (!adapter) {
+                throw dbError('STORE_DRIVER_NOT_FOUND', `Store driver "${strategy}" is not registered for resource "${resource.name}".`, {
+                    status: 500,
+                    hint: `Register one of: ${listChoices([...adapters.keys()])}.`,
+                    details: {
+                        resource: resource.name,
+                        store: strategy,
+                        availableStores: [...adapters.keys()],
+                    },
+                });
+            }
+            return adapter;
+        },
+        adapterFor(resource) {
+            const strategy = this.strategyFor(resource);
+            const adapter = adapters.get(strategy);
+            if (!adapter) {
+                throw dbError('STORE_DRIVER_NOT_FOUND', `Store driver "${strategy}" is not registered for resource "${resource.name}".`, {
+                    status: 500,
+                    hint: `Register one of: ${listChoices([...adapters.keys()])}.`,
+                    details: {
+                        resource: resource.name,
+                        store: strategy,
+                        availableStores: [...adapters.keys()],
+                    },
+                });
+            }
+            return adapter;
+        },
+        async hydrate() {
+            const byAdapter = new Map();
+            for (const resource of resources) {
+                const adapter = this.adapterFor(resource);
+                const group = byAdapter.get(adapter) ?? [];
+                group.push(resource);
+                byAdapter.set(adapter, group);
+            }
+            for (const [adapter, adapterResources] of byAdapter) {
+                await adapter.hydrate?.(adapterResources);
+            }
+        },
+        emit(change) {
+            return events.emit(change);
+        },
+        async close() {
+            if (closed) {
+                return;
+            }
+            closed = true;
+            for (const adapter of new Set(adapters.values())) {
+                await adapter.close?.();
+            }
+            events.close();
+        },
+    };
+}
+function strategyForStoreName(resource, storeName, config, adapters, storeDefinitions) {
+    const configured = storeDefinitions.has(storeName)
+        ? storeName
+        : config.stores?.[storeName] ?? storeName;
+    if (!adapters.has(storeName) && config.stores?.[storeName] === undefined) {
+        throw missingStoreError(resource, storeName, config, adapters);
+    }
+    const configuredRecord = storeRecord(configured);
+    return typeof configured === 'string' ? configured : configuredRecord?.driver ?? storeName;
+}
+function customStoreAdapter(storeName, store, queues) {
+    return {
+        name: store.name ?? storeName,
+        capabilities: store.capabilities,
+        statePath(resource) {
+            return store.statePath?.(resource);
+        },
+        hydrate(resources) {
+            return store.hydrate?.(resources);
+        },
+        readResource(resource, fallback) {
+            if (store.readResource) {
+                return store.readResource(resource, fallback);
+            }
+            if (store.get) {
+                return store.get(resource, fallback);
+            }
+            return store.read(resource, fallback);
+        },
+        writeResource(resource, value) {
+            if (store.writeResource) {
+                return store.writeResource(resource, value);
+            }
+            if (store.set) {
+                return store.set(resource, value);
+            }
+            return store.write(resource, value);
+        },
+        withResourceWrite(resource, operation) {
+            if (store.withResourceWrite) {
+                return store.withResourceWrite(resource, operation);
+            }
+            const queueKey = `${storeName}:${resource.name}`;
+            const previous = queues.get(queueKey) ?? Promise.resolve();
+            const current = previous.then(operation, operation);
+            const stored = current.catch(() => { });
+            queues.set(queueKey, stored);
+            stored.finally(() => {
+                if (queues.get(queueKey) === stored) {
+                    queues.delete(queueKey);
+                }
+            });
+            return current;
+        },
+        close() {
+            return store.close?.();
+        },
+    };
+}
+function missingStoreError(resource, storeName, config, adapters) {
+    const availableStores = [
+        ...new Set([
+            ...adapters.keys(),
+            ...Object.keys(config.stores ?? {}).filter((name) => name !== 'default'),
+        ]),
+    ];
+    return dbError('STORE_NOT_FOUND', `Store "${storeName}" is not configured for resource "${resource.name}".`, {
+        status: 500,
+        hint: `Configure stores.${storeName}, choose stores.default, or use one of: ${listChoices(availableStores)}.`,
+        details: {
+            resource: resource.name,
+            store: storeName,
+            availableStores,
+        },
+    });
+}
+function builtinAdapters(config) {
+    return [
+        createJsonRuntimeAdapter(config),
+        createMemoryRuntimeAdapter(config),
+        createSourceRuntimeAdapter(config),
+        createStaticRuntimeAdapter(config),
+    ];
+}
+function storeRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : null;
+}

package/dist/features/storage/source-metadata.d.ts

@@ -0,0 +1,20 @@
+type SourceMetadataEntry = {
+    path?: string | null;
+    format?: unknown;
+    hash?: unknown;
+    updatedAt?: string;
+};
+export type SourceMetadata = {
+    resources: Record<string, SourceMetadataEntry>;
+};
+type SourceMetadataConfig = {
+    cwd: string;
+};
+type SourceMetadataResource = {
+    name: string;
+    dataHash?: unknown;
+    dataPath?: string | null;
+    dataFormat?: unknown;
+};
+export declare function updateSourceMetadataResource(sourceMetadata: SourceMetadata, config: SourceMetadataConfig, resource: SourceMetadataResource): void;
+export {};

package/dist/features/storage/source-metadata.js

@@ -0,0 +1,25 @@
+export function updateSourceMetadataResource(sourceMetadata, config, resource) {
+    if (!resource.dataHash) {
+        return;
+    }
+    const previous = sourceMetadata.resources[resource.name];
+    const next = {
+        path: resource.dataPath ? relativePath(config, resource.dataPath) : null,
+        format: resource.dataFormat,
+        hash: resource.dataHash,
+    };
+    sourceMetadata.resources[resource.name] = {
+        ...next,
+        updatedAt: sameSource(previous, next) && previous.updatedAt
+            ? previous.updatedAt
+            : new Date().toISOString(),
+    };
+}
+function sameSource(previous, next) {
+    return previous?.path === next.path
+        && previous?.format === next.format
+        && previous?.hash === next.hash;
+}
+function relativePath(config, filePath) {
+    return filePath.startsWith(config.cwd) ? filePath.slice(config.cwd.length + 1).split('\\').join('/') : filePath;
+}