@async/db 0.2.0

package/dist/features/operations/runtime.js

@@ -0,0 +1,288 @@
+import { readFile } from 'node:fs/promises';
+import { dbError } from '../../errors.js';
+import { executeGraphql } from '../../graphql/index.js';
+import { handleRestRequest } from '../../rest/handler.js';
+import { normalizeOperationTemplate, operationRequest, } from '../../shared/operations.js';
+import { buildOperationRegistry } from './index.js';
+import { operationMapFromEntries } from './maps.js';
+export function createDbOperationHandler(db, options = {}) {
+    const operationOptions = normalizeOperationOptions(db, options);
+    return {
+        enabled: operationOptions.enabled === true,
+        options: operationOptions,
+        async resolve(ref) {
+            return resolveOperationRef(db, operationOptions, ref);
+        },
+        async execute(ref, variables = {}, executionOptions = {}) {
+            if (operationOptions.enabled !== true) {
+                throw dbError('OPERATIONS_DISABLED', 'Registered operations are not enabled.', {
+                    status: 404,
+                    hint: 'Set operations.enabled to true and provide operations.registry or outputs.operationRegistry.',
+                });
+            }
+            const operation = await resolveOperationRef(db, operationOptions, ref);
+            if (!operation) {
+                throw operationNotFound(ref);
+            }
+            const operationResult = operationRequest(operation, variables);
+            if (operationResult.kind === 'graphql') {
+                if (db.config.graphql?.enabled === false) {
+                    return {
+                        kind: 'graphql',
+                        status: 404,
+                        headers: {
+                            'content-type': 'application/json; charset=utf-8',
+                        },
+                        body: {
+                            error: {
+                                code: 'GRAPHQL_DISABLED',
+                                message: 'GraphQL endpoint is disabled.',
+                                hint: 'Set graphql.enabled to true in db.config.mjs to enable registered GraphQL operations.',
+                                details: {
+                                    graphqlEnabled: false,
+                                    ref: decodeOperationRef(ref),
+                                },
+                            },
+                        },
+                    };
+                }
+                return {
+                    kind: 'graphql',
+                    status: 200,
+                    headers: {
+                        'content-type': 'application/json; charset=utf-8',
+                    },
+                    body: await executeGraphql(db, {
+                        query: operationResult.query,
+                        variables: operationResult.variables,
+                        operationName: operationResult.operationName,
+                    }),
+                };
+            }
+            const response = makeResultResponse();
+            await handleRestRequest(db, internalRestRequest(operationResult), response, new URL(operationResult.path, 'http://db.local'), executionOptions.routes
+                ? { ...executionOptions.routes, trace: executionOptions.trace }
+                : { trace: executionOptions.trace });
+            return {
+                kind: 'rest',
+                status: response.status,
+                headers: response.headers,
+                body: response.bodyValue(),
+                rawBody: response.body,
+            };
+        },
+        async executeRequest(ref, body = {}, executionOptions = {}) {
+            return this.execute(ref, body?.variables ?? {}, executionOptions);
+        },
+    };
+}
+function normalizeOperationOptions(db, options = {}) {
+    const globalOptions = db.config.operations ?? {};
+    const localOptions = isOperationOptionsWrapper(options)
+        ? options.operations
+        : options;
+    if (localOptions === false) {
+        return {
+            ...globalOptions,
+            enabled: false,
+            acceptRefs: normalizeAcceptRefs(globalOptions.acceptRefs),
+        };
+    }
+    if (localOptions === true || localOptions === 'auto' || localOptions === undefined || localOptions === null) {
+        return {
+            ...globalOptions,
+            enabled: globalOptions.enabled === true,
+            acceptRefs: normalizeAcceptRefs(globalOptions.acceptRefs),
+        };
+    }
+    if (typeof localOptions !== 'object') {
+        return {
+            ...globalOptions,
+            enabled: globalOptions.enabled === true,
+            acceptRefs: normalizeAcceptRefs(globalOptions.acceptRefs),
+        };
+    }
+    const hasLocalRegistry = Boolean(localOptions.registry && Object.keys(localOptions.registry).length > 0)
+        || typeof localOptions.resolveRef === 'function'
+        || Boolean(localOptions.outFile);
+    return {
+        ...globalOptions,
+        ...localOptions,
+        enabled: localOptions.enabled ?? (hasLocalRegistry ? true : globalOptions.enabled === true),
+        acceptRefs: normalizeAcceptRefs(localOptions.acceptRefs ?? globalOptions.acceptRefs),
+    };
+}
+function normalizeAcceptRefs(value) {
+    if (value === 'ref' || value === 'name' || value === 'both') {
+        return value;
+    }
+    if (value === 'hash') {
+        return 'ref';
+    }
+    return 'both';
+}
+async function resolveOperationRef(db, options, ref) {
+    const decodedRef = decodeOperationRef(ref);
+    const registry = await operationRegistry(db.config, options);
+    const context = {
+        ref,
+        decodedRef,
+        acceptRefs: options.acceptRefs,
+        registry,
+        operation: null,
+    };
+    let operation = null;
+    if (typeof options.resolveRef === 'function') {
+        const resolvedOperation = await options.resolveRef(decodedRef, context);
+        if (resolvedOperation) {
+            operation = normalizeRegistryOperation(decodedRef, resolvedOperation);
+        }
+    }
+    operation ??= defaultOperationForRef(registry, decodedRef, options.acceptRefs);
+    context.operation = operation ?? null;
+    if (typeof options.validateRef === 'function') {
+        const result = await options.validateRef(context);
+        if (result && (typeof result === 'object' || typeof result === 'string')) {
+            return normalizeRegistryOperation(decodedRef, result);
+        }
+        if (result === true) {
+            return context.operation;
+        }
+        return null;
+    }
+    return operation;
+}
+function defaultOperationForRef(registry, decodedRef, acceptRefs) {
+    for (const [key, operation] of Object.entries(registry)) {
+        if (!operation || typeof operation !== 'object') {
+            continue;
+        }
+        const name = operation.name ?? key;
+        const ref = operation.ref ?? key;
+        const acceptsRef = acceptRefs === 'ref' || acceptRefs === 'both';
+        const acceptsName = acceptRefs === 'name' || acceptRefs === 'both';
+        if (acceptsRef && ref && decodedRef === ref) {
+            return operation;
+        }
+        if (acceptsName && name && decodedRef === name) {
+            return operation;
+        }
+    }
+    return null;
+}
+async function operationRegistry(config, options) {
+    if (options.registry && Object.keys(options.registry).length > 0) {
+        return normalizeOperationRegistry(options.registry);
+    }
+    if (options.outFile) {
+        try {
+            const manifest = JSON.parse(await readFile(options.outFile, 'utf8'));
+            return normalizeOperationRegistry(manifest.operations ?? {});
+        }
+        catch (error) {
+            throw operationRegistryLoadFailed(options.outFile, error);
+        }
+    }
+    if (typeof options.resolveRef === 'function') {
+        return operationMapFromEntries();
+    }
+    if (options.sourceDir) {
+        return buildOperationRegistry({
+            ...config,
+            operations: {
+                ...(config.operations ?? {}),
+                sourceDir: options.sourceDir,
+            },
+        });
+    }
+    return operationMapFromEntries();
+}
+function normalizeOperationRegistry(registry) {
+    return operationMapFromEntries(Object.entries(registry ?? {}).map(([key, operation]) => [key, normalizeRegistryOperation(key, operation)]));
+}
+function normalizeRegistryOperation(key, operation) {
+    const normalized = normalizeOperationTemplate(operation);
+    const source = operation && typeof operation === 'object' && !Array.isArray(operation) ? operation : {};
+    if (source.name || normalized.name || key) {
+        normalized.name = String(source.name ?? normalized.name ?? key);
+    }
+    if (source.ref || normalized.ref || key) {
+        normalized.ref = String(source.ref ?? normalized.ref ?? key);
+    }
+    return normalized;
+}
+function operationNotFound(ref) {
+    const decodedRef = decodeOperationRef(ref);
+    return dbError('OPERATION_NOT_FOUND', `Unknown registered operation "${decodedRef}".`, {
+        status: 404,
+        hint: 'Register the operation name or ref in operations.registry, provide a custom operations.resolveRef, or generate an operations manifest.',
+        details: { ref: decodedRef },
+    });
+}
+function operationRegistryLoadFailed(outFile, error) {
+    const reason = 'code' in error && error.code === 'ENOENT'
+        ? 'missing'
+        : error instanceof SyntaxError
+            ? 'invalid-json'
+            : 'read-failed';
+    return dbError('OPERATION_REGISTRY_LOAD_FAILED', 'Registered operation registry could not be loaded.', {
+        status: 500,
+        hint: reason === 'missing'
+            ? 'Run async-db operations build or check outputs.operationRegistry points at the generated registry.'
+            : 'Check outputs.operationRegistry and regenerate the operation registry.',
+        details: {
+            outFile: String(outFile),
+            reason,
+        },
+    });
+}
+function decodeOperationRef(ref) {
+    return decodeURIComponent(String(ref ?? ''));
+}
+function internalRestRequest(restRequest) {
+    return {
+        method: restRequest.method,
+        headers: {
+            'content-type': 'application/json',
+        },
+        async *[Symbol.asyncIterator]() {
+            if (restRequest.body !== undefined) {
+                yield Buffer.from(JSON.stringify(restRequest.body));
+            }
+        },
+    };
+}
+function makeResultResponse() {
+    return {
+        status: 200,
+        headers: {},
+        body: '',
+        writeHead(status, headers = {}) {
+            this.status = status;
+            this.headers = normalizeHeaders(headers);
+        },
+        end(chunk = '') {
+            this.body += chunk;
+        },
+        bodyValue() {
+            if (!this.body) {
+                return null;
+            }
+            if (String(this.headers['content-type'] ?? '').includes('application/json')) {
+                try {
+                    return JSON.parse(this.body);
+                }
+                catch {
+                    return this.body;
+                }
+            }
+            return this.body;
+        },
+    };
+}
+function normalizeHeaders(headers) {
+    return Object.fromEntries(Object.entries(headers ?? {}).map(([key, value]) => [key.toLowerCase(), value]));
+}
+function isOperationOptionsWrapper(options) {
+    return Boolean(options) && typeof options === 'object' && Object.hasOwn(options, 'operations');
+}

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

@@ -0,0 +1,51 @@
+type RuntimeRecord = Record<string, unknown>;
+type RuntimeConfig = {
+    schema?: {
+        unknownFields?: string;
+    };
+    defaults?: {
+        applyOnCreate?: boolean;
+    };
+    cwd?: string;
+    stateDir?: string;
+    [key: string]: unknown;
+};
+type RuntimeResource = {
+    name: string;
+    kind?: string;
+    idField?: 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 DbCollection {
+    db: DbLike;
+    config: RuntimeConfig;
+    resource: RuntimeResource;
+    path: unknown;
+    constructor(db: DbLike | RuntimeConfig, resource: RuntimeResource);
+    all(): Promise<RuntimeRecord[]>;
+    get(id: unknown): Promise<RuntimeRecord | null>;
+    exists(id: unknown): Promise<boolean>;
+    create(record: RuntimeRecord): Promise<RuntimeRecord>;
+    update(id: unknown, patch: RuntimeRecord): Promise<RuntimeRecord | null>;
+    patch(id: unknown, patch: RuntimeRecord): Promise<RuntimeRecord | null>;
+    delete(id: unknown): Promise<boolean>;
+    replaceAll(records: RuntimeRecord[]): Promise<RuntimeRecord[]>;
+    adapter(): RuntimeAdapter;
+    emit(op: string, details?: Record<string, unknown>): void;
+}
+export {};

package/dist/features/runtime/collection.js

@@ -0,0 +1,198 @@
+import { dbError } from '../../errors.js';
+import { createSchemaValidator, validateUniqueCollectionFields } from '../../schema.js';
+import { applyDefaultsToRecord } from '../../sync.js';
+import { createRuntime } from '../storage/runtime.js';
+export class DbCollection {
+    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 await this.adapter().readResource?.(this.resource, []);
+    }
+    async get(id) {
+        const records = await this.all();
+        return records.find((record) => idMatches(record?.[this.resource.idField], id)) ?? null;
+    }
+    async exists(id) {
+        return await this.get(id) !== null;
+    }
+    async create(record) {
+        this.db.assertResourceWritable?.(this.resource.name);
+        return this.adapter().withResourceWrite(this.resource, async () => {
+            const records = await this.all();
+            const nextRecord = this.config.defaults?.applyOnCreate === false
+                ? { ...record }
+                : applyDefaultsToRecord(record, this.resource);
+            let id = nextRecord[this.resource.idField];
+            if (id === undefined || id === null || id === '') {
+                id = nextCollectionId(records, this.resource.idField);
+                nextRecord[this.resource.idField] = id;
+            }
+            const validatedRecord = await assertRuntimeRecord(nextRecord, this.resource, this.config, {
+                mode: 'create',
+                source: `${this.resource.name} create body`,
+            });
+            id = validatedRecord[this.resource.idField];
+            if (records.some((existing) => idMatches(existing?.[this.resource.idField], id))) {
+                throw dbError('DB_CREATE_DUPLICATE_ID', `Cannot create "${this.resource.name}" record because id "${id}" 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,
+                    },
+                });
+            }
+            assertUniqueCollectionRecords([...records, validatedRecord], this.resource);
+            const nextRecords = [...records, validatedRecord];
+            await this.adapter().writeResource?.(this.resource, nextRecords);
+            this.emit('create', { id });
+            return validatedRecord;
+        });
+    }
+    async update(id, patch) {
+        this.db.assertResourceWritable?.(this.resource.name);
+        return this.adapter().withResourceWrite(this.resource, async () => {
+            const records = await this.all();
+            const index = records.findIndex((record) => idMatches(record?.[this.resource.idField], id));
+            if (index === -1) {
+                return null;
+            }
+            const existingId = records[index]?.[this.resource.idField];
+            const nextRecord = {
+                ...records[index],
+                ...patch,
+                [this.resource.idField]: existingId,
+            };
+            const nextRecords = [...records];
+            nextRecords[index] = await assertRuntimeRecord(nextRecord, this.resource, this.config, {
+                mode: 'replace',
+                source: `${this.resource.name} patch body`,
+            });
+            assertUniqueCollectionRecords(nextRecords, this.resource);
+            await this.adapter().writeResource?.(this.resource, nextRecords);
+            this.emit('update', { id: existingId });
+            return nextRecords[index];
+        });
+    }
+    async patch(id, patch) {
+        return this.update(id, patch);
+    }
+    async delete(id) {
+        this.db.assertResourceWritable?.(this.resource.name);
+        return this.adapter().withResourceWrite(this.resource, async () => {
+            const records = await this.all();
+            const nextRecords = records.filter((record) => !idMatches(record?.[this.resource.idField], id));
+            const deleted = nextRecords.length !== records.length;
+            await this.adapter().writeResource?.(this.resource, nextRecords);
+            if (deleted) {
+                this.emit('delete', { id });
+            }
+            return deleted;
+        });
+    }
+    async replaceAll(records) {
+        this.db.assertResourceWritable?.(this.resource.name);
+        return this.adapter().withResourceWrite(this.resource, async () => {
+            const validatedRecords = [];
+            for (const [index, record] of records.entries()) {
+                validatedRecords.push(await assertRuntimeRecord(record, this.resource, this.config, {
+                    mode: 'replace',
+                    source: `${this.resource.name}[${index}] replaceAll body`,
+                }));
+            }
+            assertUniqueCollectionRecords(validatedRecords, this.resource);
+            await this.adapter().writeResource?.(this.resource, validatedRecords);
+            this.emit('replaceAll');
+            return validatedRecords;
+        });
+    }
+    adapter() {
+        return this.db.runtime.adapterFor(this.resource);
+    }
+    emit(op, details = {}) {
+        this.db.runtime.emit({
+            resource: this.resource.name,
+            kind: 'collection',
+            op,
+            ...details,
+        });
+    }
+}
+function assertRuntimeRecord(record, resource, config, options = {}) {
+    const validator = createSchemaValidator(resource, config, {
+        mode: options.mode,
+        unknownFields: config.schema?.unknownFields ?? 'warn',
+        applyDefaults: false,
+    });
+    return validator.validateAsync(record, {
+        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);
+}
+function assertUniqueCollectionRecords(records, resource) {
+    const diagnostics = validateUniqueCollectionFields(resource, records)
+        .filter((diagnostic) => diagnostic.severity === 'error');
+    if (diagnostics.length === 0) {
+        return;
+    }
+    throw dbError('DB_SCHEMA_VALIDATION_FAILED', `${resource.name} record does not match its schema: ${diagnostics[0].message}`, {
+        status: 400,
+        hint: 'Update the record to satisfy unique schema fields.',
+        details: {
+            resource: resource.name,
+            diagnostics,
+        },
+    });
+}
+function idMatches(left, right) {
+    return left !== undefined && left !== null && right !== undefined && right !== null && String(left) === String(right);
+}
+function nextCollectionId(records, idField) {
+    const usedIds = new Set(records
+        .map((record) => record?.[idField])
+        .filter((id) => id !== undefined && id !== null && id !== '')
+        .map((id) => String(id)));
+    const numericIds = [...usedIds]
+        .map((id) => Number(id))
+        .filter((id) => Number.isInteger(id) && id > 0);
+    let next = numericIds.length > 0 ? Math.max(...numericIds) + 1 : records.length + 1;
+    while (usedIds.has(String(next))) {
+        next += 1;
+    }
+    return String(next);
+}

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

@@ -0,0 +1,152 @@
+import { createRuntime } from '../storage/runtime.js';
+import { DbCollection } from './collection.js';
+import { DbDocument } from './document.js';
+import { type DbScope, type MigrationLock } from './scope-state.js';
+type DbConfig = {
+    cwd: string;
+    stateDir: string;
+    schemaLoadMode?: string;
+    resources?: Record<string, unknown>;
+    __asyncDbScope?: DbScope;
+    [key: string]: unknown;
+};
+type DbResource = {
+    name: string;
+    kind: 'collection' | 'document' | string;
+    [key: string]: unknown;
+};
+type OpenDbOptions = Record<string, unknown> & {
+    from?: string;
+    schema?: unknown;
+    syncOnOpen?: boolean;
+    allowSourceErrors?: boolean;
+    load?: string;
+};
+type RuntimeFacade = ReturnType<typeof createRuntime>;
+type ForkSource = 'main' | {
+    fork?: string | null;
+    branch: string;
+} | {
+    fork?: string | null;
+    snapshot: string;
+};
+type ForkCreateOptions = {
+    from?: ForkSource;
+    metadata?: Record<string, unknown>;
+};
+type BranchCreateOptions = {
+    from?: string;
+    metadata?: Record<string, unknown>;
+};
+type SnapshotCreateOptions = {
+    label?: string;
+    resources?: string[];
+};
+type SnapshotRestoreOptions = {
+    resources?: string[];
+};
+type MigrationStartOptions = {
+    resources: string[];
+    mode?: 'read-only';
+};
+type MigrationVerifyOptions = {
+    resources: string[];
+    checks?: Array<'count' | 'schema' | 'checksum'>;
+};
+type ResourceMigrateOptions = {
+    from: string;
+    to: string;
+};
+type SnapshotResult = {
+    id: string;
+    label?: string;
+    fork: string | null;
+    branch: string;
+    resources: string[];
+    path: string;
+};
+declare class DbResourceRegistry extends Map<string, DbResource> {
+    private readonly migrateResource;
+    constructor(entries: Array<[string, DbResource]>, migrateResource: (name: string, options: ResourceMigrateOptions) => Promise<void>);
+    migrate(name: string, options: ResourceMigrateOptions): Promise<void>;
+}
+export declare function openDb(options?: OpenDbOptions | string): Promise<Db>;
+export declare class Db {
+    config: DbConfig;
+    resources: DbResourceRegistry;
+    diagnostics: unknown[];
+    schemaVersion: number;
+    runtime: RuntimeFacade;
+    events: RuntimeFacade['events'];
+    scope: DbScope;
+    forks: {
+        create: (name: string, options?: ForkCreateOptions) => Promise<Db>;
+        open: (name: string) => Promise<Db>;
+        ensure: (name: string, options?: ForkCreateOptions) => Promise<Db>;
+        list: () => Promise<Array<Record<string, unknown>>>;
+        delete: (name: string) => Promise<boolean>;
+    };
+    branches: {
+        create: (name: string, options?: BranchCreateOptions) => Promise<Db>;
+        open: (name: string) => Promise<Db>;
+        ensure: (name: string, options?: BranchCreateOptions) => Promise<Db>;
+        list: () => Promise<Array<Record<string, unknown>>>;
+        delete: (name: string) => Promise<boolean>;
+    };
+    snapshots: {
+        create: (options?: SnapshotCreateOptions) => Promise<SnapshotResult>;
+        restore: (id: string, options?: SnapshotRestoreOptions) => Promise<void>;
+    };
+    migrations: {
+        start: (name: string, options: MigrationStartOptions) => Promise<MigrationLock>;
+        verify: (name: string, options: MigrationVerifyOptions) => Promise<void>;
+        finish: (name: string) => Promise<void>;
+    };
+    routing: {
+        set: (routes: Record<string, string>) => Promise<Record<string, string>>;
+    };
+    private migrationLocks;
+    constructor(config: DbConfig, resources: DbResource[], diagnostics?: unknown[], scope?: DbScope);
+    collection(name: string): DbCollection;
+    document(name: string): DbDocument;
+    operation(template: string, variables?: Record<string, unknown>): Promise<unknown>;
+    query(template: string, variables?: Record<string, unknown>): Promise<unknown>;
+    fork(name: string): Db;
+    branch(name: string): Db;
+    assertResourceWritable(resourceName: string): void;
+    requireResource(name: string, kind: 'collection' | 'document'): DbResource;
+    resourceNames(): string[];
+    close(): Promise<void>;
+    private scopedDb;
+    private createFork;
+    private openFork;
+    private ensureFork;
+    private listForks;
+    private deleteFork;
+    private createBranch;
+    private openBranch;
+    private ensureBranch;
+    private listBranches;
+    private deleteBranch;
+    private createSnapshot;
+    private restoreSnapshot;
+    private startMigration;
+    private migrateResource;
+    private verifyMigration;
+    private finishMigration;
+    private setRouting;
+    private activeMigrationForResource;
+    private assertRootForkLifecycle;
+    private assertForkExists;
+    private assertBranchExists;
+    private resolveForkSource;
+    private sourceScope;
+    private writeBranchRegistry;
+    private recordMigrationCopy;
+    private persistMigrationLocks;
+    resourceForName(name: string): DbResource;
+    private migrationLocksPath;
+    private routingPath;
+}
+export declare function stateFileForDebug(db: Db, resourceName: string): string;
+export {};