@evumi/berth 0.0.8 → 0.0.10

package/README.md

@@ -1,6 +1,6 @@
 # @evumi/berth
 
-Berth 项目 Queues（队列）和 Alarms（定时器）的客户端，用法照 Cloudflare Queues 和 Durable Object alarms。也负责处理平台推给应用的请求（队列批次、定时器、Cron HTTP 目标），并校验签名。零运行时依赖，支持 Node ≥ 18、Bun、Deno 和 edge 运行时。
+Berth 项目 Queues（队列）和 Alarms（定时器）的客户端，用法照 Cloudflare Queues 和 Durable Object alarms。也负责处理平台推给应用的请求（队列批次、定时器、Cron HTTP 目标），并校验签名。主入口零运行时依赖，支持 Node ≥ 18、Bun、Deno 和 edge 运行时。文档数据库是独立子路径，驱动按需安装。
 
 项目开了 `queues` 或 `alarms` 能力后，Berth 会给容器注入 `BERTH_CONFIG_URL`、`BERTH_CONFIG_TOKEN` 和 `BERTH_SIGNING_SECRET`。环境是请求来源的那个环境：预览环境只会用到自己的队列和定时器。
 
@@ -134,10 +134,73 @@ await trialEnd.deleteAlarm();             // 没有也不报错
 
 请求失败抛 `BerthError`，带 `status`、`code`、`message`（429 时还有 `retryAfterMs`）。`code` 取服务器返回的值：`unauthorized`、`capability_disabled`、`not_found`、`bad_request`、`conflict`、`too_large`、`rate_limited`、`quota_exceeded`、`unavailable`、`queue_full`。客户端自己的 `code`：`timeout`、`network`、`invalid_response`、`missing_env`。错误信息里不含令牌。
 
+
+## 文档数据库（SQLite / libSQL）
+
+`@evumi/berth/documents` 提供一个刻意收小的 Mongo 风格接口，不用定义业务表或 schema。底层是一张 JSON 文档表；不是 MongoDB 协议、Mongoose 或完整 MongoDB 兼容层。
+
+Bun 本地持久化（Worker 默认路径是 `/data/worker.sqlite`）：
+
+```ts
+import { openBunDocumentStore } from '@evumi/berth/documents/bun';
+
+const db = await openBunDocumentStore(Bun.env.BERTH_SQLITE_PATH ?? '/data/worker.sqlite');
+const notes = db.collection<{ title: string; views: number; author?: { name: string } }>('notes');
+const { insertedId } = await notes.insertOne({ title: 'hello', views: 0 });
+await notes.updateOne({ _id: insertedId }, { $inc: { views: 1 } });
+const page = await notes.find({ views: { $gte: 1 } }).sort({ views: -1 }).limit(20).skip(0).toArray();
+await notes.createIndex({ views: -1 });
+await db.close(); // 通常在应用关闭时调用
+```
+
+远程 libSQL 复用 Berth 已有的绑定变量：
+
+```sh
+pnpm add @libsql/client
+```
+
+```ts
+import { openLibSQLDocumentStore } from '@evumi/berth/documents/libsql';
+const db = await openLibSQLDocumentStore({
+  url: Bun.env.LIBSQL_URL!,
+  authToken: Bun.env.LIBSQL_AUTH_TOKEN,
+});
+```
+
+也能注入已有的官方 libSQL 客户端或自定义 adapter：
+
+```ts
+import { createClient } from '@libsql/client';
+import { createDocumentStore } from '@evumi/berth/documents';
+const client = createClient({ url: 'file:./app.sqlite' });
+const db = createDocumentStore(client);
+await db.ready(); // 幂等初始化；各 CRUD 也会等待初始化
+// 低层工厂不接管 client 的生命周期或改变它的 PRAGMA。
+```
+
+Bun 和本地 `file:` 便利工厂使用 WAL、`synchronous=FULL`、`busy_timeout=5000`。远程工厂服从服务器的持久化设置；它不承诺复制、节点或磁盘丢失后的数据安全。`busy_timeout` 是 SQLite 锁等待，不会重放已发送的写操作。所有工厂均无透明重试；数据库错误可能表示写入已执行但响应丢失，不能据此直接重发 `$inc`。
+
+API 和边界：
+
+- `insertOne(document)` 返回 `{ insertedId }`；可传 1–256 字符的字符串 `_id`，否则生成 UUID。`findOne(filter?)` 返回文档或 `null`；`find(filter?)` 返回不可变 cursor。`updateOne(filter, update)` 返回 `{ matchedCount }`，不声称内容一定改变；`deleteOne(filter)` 返回 `{ deletedCount }`；`countDocuments(filter?)` 返回匹配总数。
+- 查询支持标量等值、`$eq/$ne/$gt/$gte/$lt/$lte/$in/$exists`、`$and/$or`。点路径仅遍历对象，例如 `author.name`；每段为 ASCII 字母或下划线开头，后接字母、数字、下划线。没有数组元素匹配、正则、任意 JS、聚合、join、upsert、unique index 或跨调用事务。
+- `null` 只匹配显式 JSON null；missing 独立，`$exists:false` 只匹配 missing。`$ne` 包括 missing。布尔与数值严格区分；范围查询只比较同类的 number 或 string。`$in:[]` 不匹配任何文档。JSON 数值是 JS number；高精度业务值用字符串保存。
+- 排序使用 SQLite JSON 提取值的排序：missing/null 同组，然后 number/boolean（false=0、true=1），然后 text、array/object 的 JSON 文本。字符串使用 SQLite BINARY 顺序；这个跨类型排序不是 MongoDB BSON 顺序。末尾追加 `_id ASC` 保证稳定结果；未指定排序时按 `_id ASC`。`findOne/updateOne/deleteOne` 选匹配中的最小 `_id`。
+- 默认读取 100 条，最大 1000；`limit(0)` 是空结果。skip 最大 1,000,000，较大 offset 和无索引过滤会扫描；计数不受读取条数上限影响。过滤最多 64 条件、10 层逻辑嵌套、每个 `$in` 最多 100 项。
+- `$set` 支持 JSON 值，`$unset` 的值为 `true` 或 `1`，`$inc` 支持有限数。missing 的自增从 0 开始；已有 null、布尔、字符串、对象、数组会让整次更新失败。父路径如果存在但不是对象，也失败；不允许重叠更新路径或修改 `_id`。每次更新是一条原子 SQL，最多 32 个字段，不会先读取到 JS 再写回。
+- 单文档最多 1 MiB（UTF-8 JSON），最多 32 层；仅接受普通 JSON。undefined、NaN/Infinity、Date、BigInt、循环、getter、稀疏数组和自定义原型均拒绝。数组可以存储但没有数组查询语义。
+- `createIndex({ field: 1|-1 })` 创建最多 4 字段的普通表达式索引，返回名称。物理索引以 collection 为首列，覆盖同库全部 collection；相同规格共享索引，新增索引会影响所有 collection 的写入成本。查询中的 collection 和值始终绑定参数；字段路径经过校验，表达式与索引完全一致。
+- collection 是命名空间，不是权限隔离。每个项目/环境应使用自己的数据库文件或凭据；持有同一数据库客户端的业务代码可以访问该库所有 collection。内部 `_berth_documents` 表不应手动改写。
+
+错误为 `DocumentError`，`code` 是 `invalid_input`、`database_error` 或 `invalid_data`。数据库错误不包含 SQL 参数或文档内容。`database_error` 不说明远端是否已提交；需要业务幂等设计才能安全重试。
+
+真实数据库测试和三条执行路径的复现基准见 [bench/README.md](bench/README.md)。
+
 ## 开发
 
 ```sh
 pnpm install
 pnpm typecheck
 pnpm test   # 先构建，再跑 vitest（含 sdk/testdata 的共享签名向量）
+pnpm test:bun # Bun持久化烟测 + 4个Bun写进程、2个读进程共享SQLite的并发检查
 ```

package/dist/cjs/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/cjs/documents/bun.js

@@ -0,0 +1,54 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openBunDocumentStore = openBunDocumentStore;
+const documents_js_1 = require("../documents.js");
+/** Local durable SQLite. Native Bun code is loaded only from this optional entry. */
+async function openBunDocumentStore(filename) {
+    const moduleName = 'bun:sqlite';
+    const { Database } = await Promise.resolve(`${moduleName}`).then(s => __importStar(require(s)));
+    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 = (0, documents_js_1.createDocumentStore)(client);
+        await store.ready();
+        return { ...store, close: () => db.close() };
+    }
+    catch (error) {
+        db.close();
+        throw error;
+    }
+}

package/dist/cjs/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/cjs/documents/json.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocumentError = exports.MAX_DOCUMENT_BYTES = void 0;
+exports.invalid = invalid;
+exports.entries = entries;
+exports.validateJSON = validateJSON;
+exports.jsonText = jsonText;
+exports.scalar = scalar;
+exports.MAX_DOCUMENT_BYTES = 1024 * 1024;
+class DocumentError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'DocumentError';
+    }
+}
+exports.DocumentError = DocumentError;
+function invalid(message) {
+    throw new DocumentError('invalid_input', message);
+}
+// Read descriptors rather than properties: validation must not execute getters/toJSON.
+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];
+    });
+}
+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);
+}
+function jsonText(value) {
+    validateJSON(value);
+    const text = JSON.stringify(value);
+    if (new TextEncoder().encode(text).byteLength > exports.MAX_DOCUMENT_BYTES)
+        invalid('Document exceeds 1 MiB');
+    return text;
+}
+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 > exports.MAX_DOCUMENT_BYTES)
+        invalid('Query string is too large');
+}

package/dist/cjs/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/cjs/documents/libsql.js

@@ -0,0 +1,56 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openLibSQLDocumentStore = openLibSQLDocumentStore;
+const documents_js_1 = require("../documents.js");
+/** Install @libsql/client separately. Remote durability is a server setting. */
+async function openLibSQLDocumentStore(config) {
+    const { createClient } = await Promise.resolve().then(() => __importStar(require('@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 = (0, documents_js_1.createDocumentStore)(client);
+        await store.ready();
+        return { ...store, close: () => client.close() };
+    }
+    catch (error) {
+        client.close();
+        throw error;
+    }
+}

package/dist/cjs/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/cjs/documents/query.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.path = path;
+exports.valueSQL = valueSQL;
+exports.typeSQL = typeSQL;
+exports.compileFilter = compileFilter;
+exports.sortFields = sortFields;
+exports.compileSort = compileSort;
+const json_js_1 = require("./json.js");
+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))
+        (0, json_js_1.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.
+function valueSQL(field) {
+    return field === '_id' ? 'id' : `json_extract(data, '${path(field)}')`;
+}
+function typeSQL(field) {
+    return field === '_id' ? "'text'" : `json_type(data, '${path(field)}')`;
+}
+function comparison(field, operator, value) {
+    (0, json_js_1.scalar)(value);
+    const type = typeSQL(field), expr = valueSQL(field);
+    if (operator !== '=' && (value === null || typeof value === 'boolean'))
+        (0, json_js_1.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] };
+}
+function compileFilter(filter = {}) {
+    let conditions = 0;
+    const walk = (input, depth) => {
+        if (depth > 10)
+            (0, json_js_1.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 (0, json_js_1.entries)(input, 'filter')) {
+            if (++conditions > 64)
+                (0, json_js_1.invalid)('Filter exceeds 64 conditions');
+            if (field === '$and' || field === '$or') {
+                if (!Array.isArray(condition) || !condition.length || condition.length > 64)
+                    (0, json_js_1.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 = (0, json_js_1.entries)(condition, 'field operators');
+            if (!operators.length)
+                (0, json_js_1.invalid)('Field operators must not be empty');
+            for (const [operator, operand] of operators) {
+                if (++conditions > 64)
+                    (0, json_js_1.invalid)('Filter exceeds 64 conditions');
+                if (operator === '$exists') {
+                    if (typeof operand !== 'boolean')
+                        (0, json_js_1.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)
+                        (0, json_js_1.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)
+                        (0, json_js_1.invalid)('Unsupported query operator');
+                    append(comparison(field, sqlOperator, operand));
+                }
+            }
+        }
+        return { sql: parts.length ? parts.join(' AND ') : '1', args };
+    };
+    return walk(filter, 0);
+}
+function sortFields(sort) {
+    const fields = (0, json_js_1.entries)(sort, 'sort');
+    if (!fields.length || fields.length > 4)
+        (0, json_js_1.invalid)('Sort/index requires 1 to 4 fields');
+    return fields.map(([field, order]) => {
+        path(field);
+        if (order !== 1 && order !== -1)
+            (0, json_js_1.invalid)('Sort direction must be 1 or -1');
+        return [field, order];
+    });
+}
+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/cjs/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>;
+}