@evumi/berth 0.0.8 → 0.0.10

package/dist/cjs/documents.js

@@ -0,0 +1,187 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocumentCollection = exports.DocumentCursor = exports.MAX_DOCUMENT_BYTES = exports.DocumentError = void 0;
+exports.createDocumentStore = createDocumentStore;
+const sha256_js_1 = require("./sha256.js");
+const json_js_1 = require("./documents/json.js");
+Object.defineProperty(exports, "DocumentError", { enumerable: true, get: function () { return json_js_1.DocumentError; } });
+Object.defineProperty(exports, "MAX_DOCUMENT_BYTES", { enumerable: true, get: function () { return json_js_1.MAX_DOCUMENT_BYTES; } });
+const query_js_1 = require("./documents/query.js");
+const TABLE = '"_berth_documents"';
+const SCHEMA = `CREATE TABLE IF NOT EXISTS ${TABLE} (
+  collection TEXT NOT NULL, id TEXT NOT NULL,
+  data TEXT NOT NULL CHECK (
+    json_valid(data) AND json_type(data) = 'object' AND
+    json_type(data, '$._id') IS 'text' AND json_extract(data, '$._id') = id AND
+    length(CAST(data AS BLOB)) <= ${json_js_1.MAX_DOCUMENT_BYTES}
+  ), PRIMARY KEY (collection, id)
+)`;
+/** A collection is a query namespace, not an authorization boundary. Give each
+ * project/environment its own database credential or local file. No retry occurs. */
+function createDocumentStore(client) {
+    const execute = async (sql, args = []) => {
+        try {
+            return (await client.execute({ sql, args })).rows;
+        }
+        catch {
+            throw new json_js_1.DocumentError('database_error', 'Document database operation failed; a write outcome may be unknown. No retry was attempted.');
+        }
+    };
+    let initialization;
+    const ready = () => initialization ??= execute(SCHEMA).then(() => { });
+    const run = async (sql, args = []) => { await ready(); return execute(sql, args); };
+    return { ready, collection(name) {
+            if (typeof name !== 'string' || !name.length || name.length > 128 || name.includes('\0'))
+                (0, json_js_1.invalid)('Collection name must contain 1 to 128 characters and no NUL');
+            return new DocumentCollection(name, run);
+        } };
+}
+function filterSQL(filter) { (0, json_js_1.validateJSON)(filter); return (0, query_js_1.compileFilter)(filter); }
+function decode(row) {
+    try {
+        if (typeof row.data !== 'string' || typeof row.id !== 'string')
+            throw new Error();
+        const doc = JSON.parse(row.data);
+        (0, json_js_1.validateJSON)(doc);
+        if (doc === null || Array.isArray(doc) || typeof doc !== 'object' || doc._id !== row.id)
+            throw new Error();
+        return doc;
+    }
+    catch {
+        throw new json_js_1.DocumentError('invalid_data', 'Stored document is invalid');
+    }
+}
+class DocumentCursor {
+    collection;
+    execute;
+    filter;
+    order;
+    take;
+    offset;
+    constructor(collection, execute, filter, order = 'id ASC', take = 100, offset = 0) {
+        this.collection = collection;
+        this.execute = execute;
+        this.filter = filter;
+        this.order = order;
+        this.take = take;
+        this.offset = offset;
+    }
+    sort(sort) {
+        return new DocumentCursor(this.collection, this.execute, this.filter, (0, query_js_1.compileSort)(sort), this.take, this.offset);
+    }
+    limit(n) {
+        if (!Number.isInteger(n) || n < 0 || n > 1000)
+            (0, json_js_1.invalid)('Limit must be an integer from 0 to 1000');
+        return new DocumentCursor(this.collection, this.execute, this.filter, this.order, n, this.offset);
+    }
+    skip(n) {
+        if (!Number.isSafeInteger(n) || n < 0 || n > 1_000_000)
+            (0, json_js_1.invalid)('Skip must be an integer from 0 to 1000000');
+        return new DocumentCursor(this.collection, this.execute, this.filter, this.order, this.take, n);
+    }
+    async toArray() {
+        const rows = await this.execute(`SELECT id, data FROM ${TABLE} WHERE collection = ? AND (${this.filter.sql}) ORDER BY ${this.order} LIMIT ? OFFSET ?`, [this.collection, ...this.filter.args, this.take, this.offset]);
+        return rows.map(row => decode(row));
+    }
+}
+exports.DocumentCursor = DocumentCursor;
+class DocumentCollection {
+    name;
+    execute;
+    constructor(name, execute) {
+        this.name = name;
+        this.execute = execute;
+    }
+    async insertOne(document) {
+        const input = (0, json_js_1.entries)(document, 'document');
+        (0, json_js_1.validateJSON)(document);
+        const supplied = input.find(([key]) => key === '_id');
+        const id = supplied ? supplied[1] : globalThis.crypto.randomUUID();
+        if (typeof id !== 'string' || !id.length || id.length > 256 || id.includes('\0'))
+            (0, json_js_1.invalid)('_id must contain 1 to 256 characters and no NUL');
+        const data = Object.fromEntries(input);
+        data._id = id;
+        await this.execute(`INSERT INTO ${TABLE} (collection, id, data) VALUES (?, ?, ?)`, [this.name, id, (0, json_js_1.jsonText)(data)]);
+        return { insertedId: id };
+    }
+    find(filter = {}) { return new DocumentCursor(this.name, this.execute, filterSQL(filter)); }
+    async findOne(filter = {}) { return (await this.find(filter).limit(1).toArray())[0] ?? null; }
+    async countDocuments(filter = {}) {
+        const f = filterSQL(filter);
+        const rows = await this.execute(`SELECT count(*) AS count FROM ${TABLE} WHERE collection = ? AND (${f.sql})`, [this.name, ...f.args]);
+        const n = Number(rows[0]?.count);
+        if (!Number.isSafeInteger(n) || n < 0)
+            throw new json_js_1.DocumentError('invalid_data', 'Document count exceeds the supported range');
+        return n;
+    }
+    async deleteOne(filter) {
+        const f = filterSQL(filter);
+        const rows = await this.execute(`DELETE FROM ${TABLE} WHERE collection = ? AND id = (SELECT id FROM ${TABLE} WHERE collection = ? AND (${f.sql}) ORDER BY id LIMIT 1) RETURNING id`, [this.name, this.name, ...f.args]);
+        return { deletedCount: rows.length };
+    }
+    async updateOne(filter, update) {
+        const f = filterSQL(filter), u = compileUpdate(update);
+        const rows = await this.execute(`UPDATE ${TABLE} SET data = ${u.sql} WHERE collection = ? AND id = (SELECT id FROM ${TABLE} WHERE collection = ? AND (${f.sql}) ORDER BY id LIMIT 1) RETURNING id`, [...u.args, this.name, this.name, ...f.args]);
+        return { matchedCount: rows.length };
+    }
+    /** Indexes cover all collections, with collection as the leading key.
+     * Identical specs share one index. Queries still bind the collection. */
+    async createIndex(spec) {
+        const fields = (0, query_js_1.sortFields)(spec);
+        if (!fields.some(([field]) => field === '_id'))
+            fields.push(['_id', 1]);
+        const digest = Array.from((0, sha256_js_1.sha256)(new TextEncoder().encode(JSON.stringify(fields))), b => b.toString(16).padStart(2, '0')).join('').slice(0, 32);
+        const name = `_berth_docs_idx_${digest}`;
+        const expressions = fields.map(([field, order]) => `${(0, query_js_1.valueSQL)(field)} ${order === 1 ? 'ASC' : 'DESC'}`);
+        await this.execute(`CREATE INDEX IF NOT EXISTS "${name}" ON ${TABLE} (collection, ${expressions.join(', ')})`);
+        return name;
+    }
+}
+exports.DocumentCollection = DocumentCollection;
+function compileUpdate(update) {
+    (0, json_js_1.validateJSON)(update);
+    const paths = [], guards = [], guardArgs = [], args = [];
+    let expression = 'data';
+    for (const [operator, value] of (0, json_js_1.entries)(update, 'update')) {
+        if (!['$set', '$unset', '$inc'].includes(operator))
+            (0, json_js_1.invalid)('Unsupported update operator');
+        for (const [field, operand] of (0, json_js_1.entries)(value, 'update fields')) {
+            const jsonPath = (0, query_js_1.path)(field);
+            if (field === '_id' || field.startsWith('_id.'))
+                (0, json_js_1.invalid)('_id is immutable');
+            if (paths.some(p => p === field || p.startsWith(field + '.') || field.startsWith(p + '.')))
+                (0, json_js_1.invalid)('Update paths must not overlap');
+            paths.push(field);
+            if (paths.length > 32)
+                (0, json_js_1.invalid)('Update exceeds 32 fields');
+            const segments = field.split('.');
+            for (let i = 1; i < segments.length; i++) {
+                const parent = (0, query_js_1.typeSQL)(segments.slice(0, i).join('.'));
+                guards.push(`(${parent} IS NULL OR ${parent} = 'object')`);
+            }
+            if (operator === '$set') {
+                expression = `json_set(${expression}, '${jsonPath}', json(?))`;
+                args.push((0, json_js_1.jsonText)(operand));
+            }
+            else if (operator === '$unset') {
+                if (operand !== true && operand !== 1)
+                    (0, json_js_1.invalid)('$unset values must be true or 1');
+                expression = `json_remove(${expression}, '${jsonPath}')`;
+            }
+            else {
+                if (typeof operand !== 'number' || !Number.isFinite(operand))
+                    (0, json_js_1.invalid)('$inc requires a finite number');
+                const type = (0, query_js_1.typeSQL)(field), current = (0, query_js_1.valueSQL)(field);
+                guards.push(`(${type} IS NULL OR ${type} IN ('integer', 'real'))`);
+                guards.push(`(coalesce(${current}, 0) + ? BETWEEN ? AND ?)`);
+                guardArgs.push(operand, -Number.MAX_VALUE, Number.MAX_VALUE);
+                expression = `json_set(${expression}, '${jsonPath}', coalesce(${current}, 0) + ?)`;
+                args.push(operand);
+            }
+        }
+    }
+    if (!paths.length)
+        (0, json_js_1.invalid)('Update must change at least one field');
+    // A bad selected target aborts this one statement, including all other fields.
+    return { sql: guards.length ? `CASE WHEN ${guards.join(' AND ')} THEN ${expression} ELSE json('invalid document update') END` : expression, args: [...guardArgs, ...args] };
+}

package/dist/cjs/worker.d.ts

@@ -0,0 +1,25 @@
+/** State lives only in one running project/environment process and is lost on restart. */
+export interface WorkerRuntime {
+    readonly state: Map<string, unknown>;
+    readonly startedAt: Date;
+}
+/** A fresh context and state map are created for each HTTP request. */
+export interface FunctionContext {
+    readonly request: Request & {
+        readonly params: Record<string, string>;
+    };
+    readonly params: Record<string, string>;
+    readonly query: URLSearchParams;
+    readonly state: Map<string, unknown>;
+    readonly runtime: WorkerRuntime;
+}
+export type FunctionHandler = (context: FunctionContext) => unknown | Promise<unknown>;
+/** May be called once. Direct imports between functions do not re-enter interception. */
+export type Next = (context?: FunctionContext) => Promise<Response>;
+export type Interceptor = (context: FunctionContext, next: Next) => unknown | Promise<unknown>;
+export interface WorkerLifecycle {
+    default?: Interceptor;
+    onStart?(runtime: WorkerRuntime): unknown | Promise<unknown>;
+    onStop?(runtime: WorkerRuntime): unknown | Promise<unknown>;
+    onError?(error: unknown, context: FunctionContext): unknown | Promise<unknown>;
+}

package/dist/cjs/worker.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/esm/documents/bun.d.ts

@@ -0,0 +1,3 @@
+import { type OwnedDocumentStore } from '../documents.js';
+/** Local durable SQLite. Native Bun code is loaded only from this optional entry. */
+export declare function openBunDocumentStore(filename: string): Promise<OwnedDocumentStore>;

package/dist/esm/documents/bun.js

@@ -0,0 +1,18 @@
+import { createDocumentStore } from '../documents.js';
+/** Local durable SQLite. Native Bun code is loaded only from this optional entry. */
+export async function openBunDocumentStore(filename) {
+    const moduleName = 'bun:sqlite';
+    const { Database } = await import(moduleName);
+    const db = new Database(filename);
+    try {
+        db.exec('PRAGMA journal_mode=WAL; PRAGMA synchronous=FULL; PRAGMA busy_timeout=5000;');
+        const client = { async execute({ sql, args }) { return { rows: db.query(sql).all(...args) }; } };
+        const store = createDocumentStore(client);
+        await store.ready();
+        return { ...store, close: () => db.close() };
+    }
+    catch (error) {
+        db.close();
+        throw error;
+    }
+}

package/dist/esm/documents/json.d.ts

@@ -0,0 +1,14 @@
+export type JSONScalar = string | number | boolean | null;
+export type JSONValue = JSONScalar | JSONValue[] | {
+    [key: string]: JSONValue;
+};
+export declare const MAX_DOCUMENT_BYTES: number;
+export declare class DocumentError extends Error {
+    readonly code: 'invalid_input' | 'database_error' | 'invalid_data';
+    constructor(code: 'invalid_input' | 'database_error' | 'invalid_data', message: string);
+}
+export declare function invalid(message: string): never;
+export declare function entries(value: unknown, label?: string): [string, unknown][];
+export declare function validateJSON(value: unknown, ancestors?: Set<object>, depth?: number): asserts value is JSONValue;
+export declare function jsonText(value: unknown): string;
+export declare function scalar(value: unknown): asserts value is JSONScalar;

package/dist/esm/documents/json.js

@@ -0,0 +1,70 @@
+export const MAX_DOCUMENT_BYTES = 1024 * 1024;
+export class DocumentError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'DocumentError';
+    }
+}
+export function invalid(message) {
+    throw new DocumentError('invalid_input', message);
+}
+// Read descriptors rather than properties: validation must not execute getters/toJSON.
+export function entries(value, label = 'object') {
+    if (value === null || typeof value !== 'object' || Array.isArray(value) ||
+        ![Object.prototype, null].includes(Object.getPrototypeOf(value)))
+        invalid(`${label} must be a plain object`);
+    return Reflect.ownKeys(value).map(key => {
+        const desc = Object.getOwnPropertyDescriptor(value, key);
+        if (typeof key !== 'string' || !desc.enumerable || !('value' in desc))
+            invalid(`${label} must contain enumerable data properties only`);
+        return [key, desc.value];
+    });
+}
+export function validateJSON(value, ancestors = new Set(), depth = 0) {
+    if (depth > 32)
+        invalid('JSON nesting exceeds 32 levels');
+    if (value === null || typeof value === 'string' || typeof value === 'boolean')
+        return;
+    if (typeof value === 'number') {
+        if (!Number.isFinite(value))
+            invalid('JSON numbers must be finite');
+        return;
+    }
+    if (typeof value !== 'object')
+        invalid('Value is not JSON');
+    if (ancestors.has(value))
+        invalid('JSON must not contain cycles');
+    ancestors.add(value);
+    if (Array.isArray(value)) {
+        if (Object.getPrototypeOf(value) !== Array.prototype || Reflect.ownKeys(value).length !== value.length + 1)
+            invalid('JSON arrays must not contain holes or extra properties');
+        for (let i = 0; i < value.length; i++) {
+            const desc = Object.getOwnPropertyDescriptor(value, String(i));
+            if (!desc || !('value' in desc) || !desc.enumerable)
+                invalid('JSON arrays must contain data values');
+            validateJSON(desc.value, ancestors, depth + 1);
+        }
+    }
+    else {
+        for (const [, child] of entries(value, 'JSON object'))
+            validateJSON(child, ancestors, depth + 1);
+    }
+    ancestors.delete(value);
+}
+export function jsonText(value) {
+    validateJSON(value);
+    const text = JSON.stringify(value);
+    if (new TextEncoder().encode(text).byteLength > MAX_DOCUMENT_BYTES)
+        invalid('Document exceeds 1 MiB');
+    return text;
+}
+export function scalar(value) {
+    if (value !== null && typeof value !== 'string' && typeof value !== 'boolean' && typeof value !== 'number')
+        invalid('Query operands must be JSON scalars');
+    if (typeof value === 'number' && !Number.isFinite(value))
+        invalid('Query numbers must be finite');
+    if (typeof value === 'string' && value.length > MAX_DOCUMENT_BYTES)
+        invalid('Query string is too large');
+}

package/dist/esm/documents/libsql.d.ts

@@ -0,0 +1,7 @@
+import { type OwnedDocumentStore } from '../documents.js';
+export interface LibSQLDocumentConfig {
+    url: string;
+    authToken?: string;
+}
+/** Install @libsql/client separately. Remote durability is a server setting. */
+export declare function openLibSQLDocumentStore(config: LibSQLDocumentConfig): Promise<OwnedDocumentStore>;

package/dist/esm/documents/libsql.js

@@ -0,0 +1,20 @@
+import { createDocumentStore } from '../documents.js';
+/** Install @libsql/client separately. Remote durability is a server setting. */
+export async function openLibSQLDocumentStore(config) {
+    const { createClient } = await import('@libsql/client');
+    const client = createClient(config);
+    try {
+        if (config.url.startsWith('file:')) {
+            await client.execute('PRAGMA journal_mode=WAL');
+            await client.execute('PRAGMA synchronous=FULL');
+            await client.execute('PRAGMA busy_timeout=5000');
+        }
+        const store = createDocumentStore(client);
+        await store.ready();
+        return { ...store, close: () => client.close() };
+    }
+    catch (error) {
+        client.close();
+        throw error;
+    }
+}

package/dist/esm/documents/query.d.ts

@@ -0,0 +1,17 @@
+export type SQLValue = string | number | null;
+export type Filter = {
+    [field: string]: unknown;
+};
+export type Sort = {
+    [field: string]: 1 | -1;
+};
+export type Fragment = {
+    sql: string;
+    args: SQLValue[];
+};
+export declare function path(field: string): string;
+export declare function valueSQL(field: string): string;
+export declare function typeSQL(field: string): string;
+export declare function compileFilter(filter?: Filter): Fragment;
+export declare function sortFields(sort: Sort): [string, 1 | -1][];
+export declare function compileSort(sort: Sort): string;

package/dist/esm/documents/query.js

@@ -0,0 +1,98 @@
+import { entries, invalid, scalar } from './json.js';
+export function path(field) {
+    if (field.length > 256 || field.split('.').length > 16 || !/^[A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)*$/.test(field))
+        invalid('Invalid object field path');
+    return '$.' + field.split('.').map(p => `"${p}"`).join('.');
+}
+// Paths are validated identifiers, never caller-supplied SQL. Keeping their literal
+// representation identical lets SQLite use expression indexes for these predicates.
+export function valueSQL(field) {
+    return field === '_id' ? 'id' : `json_extract(data, '${path(field)}')`;
+}
+export function typeSQL(field) {
+    return field === '_id' ? "'text'" : `json_type(data, '${path(field)}')`;
+}
+function comparison(field, operator, value) {
+    scalar(value);
+    const type = typeSQL(field), expr = valueSQL(field);
+    if (operator !== '=' && (value === null || typeof value === 'boolean'))
+        invalid('Range comparisons require a number or string');
+    if (value === null)
+        return { sql: `${type} = 'null'`, args: [] };
+    if (typeof value === 'boolean')
+        return { sql: `${type} = '${value ? 'true' : 'false'}'`, args: [] };
+    const guard = typeof value === 'number' ? `${type} IN ('integer', 'real')` : `${type} = 'text'`;
+    return { sql: `(${guard} AND ${expr} ${operator} ?)`, args: [value] };
+}
+export function compileFilter(filter = {}) {
+    let conditions = 0;
+    const walk = (input, depth) => {
+        if (depth > 10)
+            invalid('Filter nesting exceeds 10 levels');
+        const parts = [], args = [];
+        const append = (f) => { parts.push(`(${f.sql})`); args.push(...f.args); };
+        for (const [field, condition] of entries(input, 'filter')) {
+            if (++conditions > 64)
+                invalid('Filter exceeds 64 conditions');
+            if (field === '$and' || field === '$or') {
+                if (!Array.isArray(condition) || !condition.length || condition.length > 64)
+                    invalid('Logical filters require 1 to 64 child filters');
+                const children = condition.map(child => walk(child, depth + 1));
+                append({ sql: children.map(c => `(${c.sql})`).join(field === '$and' ? ' AND ' : ' OR '), args: children.flatMap(c => c.args) });
+                continue;
+            }
+            path(field);
+            if (condition === null || typeof condition !== 'object') {
+                append(comparison(field, '=', condition));
+                continue;
+            }
+            const operators = entries(condition, 'field operators');
+            if (!operators.length)
+                invalid('Field operators must not be empty');
+            for (const [operator, operand] of operators) {
+                if (++conditions > 64)
+                    invalid('Filter exceeds 64 conditions');
+                if (operator === '$exists') {
+                    if (typeof operand !== 'boolean')
+                        invalid('$exists requires a boolean');
+                    append({ sql: `${typeSQL(field)} IS ${operand ? 'NOT ' : ''}NULL`, args: [] });
+                }
+                else if (operator === '$in') {
+                    if (!Array.isArray(operand) || operand.length > 100)
+                        invalid('$in requires at most 100 scalar values');
+                    const choices = operand.map(v => comparison(field, '=', v));
+                    append({ sql: choices.length ? choices.map(c => `(${c.sql})`).join(' OR ') : '0', args: choices.flatMap(c => c.args) });
+                }
+                else if (operator === '$ne') {
+                    const equal = comparison(field, '=', operand);
+                    append({ sql: `NOT coalesce((${equal.sql}), 0)`, args: equal.args });
+                }
+                else {
+                    const sqlOperator = { $eq: '=', $gt: '>', $gte: '>=', $lt: '<', $lte: '<=' }[operator];
+                    if (!sqlOperator)
+                        invalid('Unsupported query operator');
+                    append(comparison(field, sqlOperator, operand));
+                }
+            }
+        }
+        return { sql: parts.length ? parts.join(' AND ') : '1', args };
+    };
+    return walk(filter, 0);
+}
+export function sortFields(sort) {
+    const fields = entries(sort, 'sort');
+    if (!fields.length || fields.length > 4)
+        invalid('Sort/index requires 1 to 4 fields');
+    return fields.map(([field, order]) => {
+        path(field);
+        if (order !== 1 && order !== -1)
+            invalid('Sort direction must be 1 or -1');
+        return [field, order];
+    });
+}
+export function compileSort(sort) {
+    const fields = sortFields(sort);
+    if (!fields.some(([field]) => field === '_id'))
+        fields.push(['_id', 1]);
+    return fields.map(([field, order]) => `${valueSQL(field)} ${order === 1 ? 'ASC' : 'DESC'}`).join(', ');
+}

package/dist/esm/documents.d.ts

@@ -0,0 +1,66 @@
+import { DocumentError, MAX_DOCUMENT_BYTES, type JSONValue } from './documents/json.js';
+import { type Filter, type Sort, type SQLValue, type Fragment } from './documents/query.js';
+export { DocumentError, MAX_DOCUMENT_BYTES };
+export type { JSONValue, Filter, Sort, SQLValue };
+export type Document<T extends object = Record<string, JSONValue>> = T & {
+    _id: string;
+};
+export type Update = {
+    $set?: Record<string, JSONValue>;
+    $unset?: Record<string, true | 1>;
+    $inc?: Record<string, number>;
+};
+export interface DocumentClient {
+    execute(statement: {
+        sql: string;
+        args: SQLValue[];
+    }): PromiseLike<{
+        rows: readonly Record<string, unknown>[];
+    }>;
+}
+export interface DocumentStore {
+    ready(): Promise<void>;
+    collection<T extends object = Record<string, JSONValue>>(name: string): DocumentCollection<T>;
+}
+export interface OwnedDocumentStore extends DocumentStore {
+    close(): void | Promise<void>;
+}
+type Execute = (sql: string, args?: SQLValue[]) => Promise<readonly Record<string, unknown>[]>;
+/** A collection is a query namespace, not an authorization boundary. Give each
+ * project/environment its own database credential or local file. No retry occurs. */
+export declare function createDocumentStore(client: DocumentClient): DocumentStore;
+export declare class DocumentCursor<T extends object> {
+    private readonly collection;
+    private readonly execute;
+    private readonly filter;
+    private readonly order;
+    private readonly take;
+    private readonly offset;
+    constructor(collection: string, execute: Execute, filter: Fragment, order?: string, take?: number, offset?: number);
+    sort(sort: Sort): DocumentCursor<T>;
+    limit(n: number): DocumentCursor<T>;
+    skip(n: number): DocumentCursor<T>;
+    toArray(): Promise<Document<T>[]>;
+}
+export declare class DocumentCollection<T extends object> {
+    private readonly name;
+    private readonly execute;
+    constructor(name: string, execute: Execute);
+    insertOne(document: Omit<T, '_id'> & {
+        _id?: string;
+    }): Promise<{
+        insertedId: string;
+    }>;
+    find(filter?: Filter): DocumentCursor<T>;
+    findOne(filter?: Filter): Promise<Document<T> | null>;
+    countDocuments(filter?: Filter): Promise<number>;
+    deleteOne(filter: Filter): Promise<{
+        deletedCount: number;
+    }>;
+    updateOne(filter: Filter, update: Update): Promise<{
+        matchedCount: number;
+    }>;
+    /** Indexes cover all collections, with collection as the leading key.
+     * Identical specs share one index. Queries still bind the collection. */
+    createIndex(spec: Sort): Promise<string>;
+}