ts-prorm-orm 1.1.0 → 1.2.1

package/dist/nosql/rocksdb/document-layer.d.ts

@@ -0,0 +1,162 @@
+/**
+ * Document/query layer for embedded ordered key-value stores (RocksDB, LevelDB).
+ *
+ * The raw stores only expose `put`/`get`/`del`/`batch`/ordered-iteration. That
+ * is a great substrate, but it forces users to hand-roll key design, secondary
+ * indexes, range scans and in-memory filtering every time they want to store
+ * and query documents. This module lifts the KV surface into the ORM's model
+ * API (`findAll`/`findOne`/`findByPk`/`create`/`bulkCreate`/`update`/`destroy`/
+ * `count`/`truncate`/associations/transactions) so callers never touch a raw
+ * iterator or design a keyspace by hand.
+ *
+ * ## Key design
+ *
+ * Documents live under a per-collection prefix:
+ *
+ *   `<collection>\x01<pk>`  ->  JSON document
+ *
+ * A prefix range scan (`gte: "<collection>\x01"`, `lt: "<collection>\x02"`)
+ * therefore yields exactly the documents of one collection, in primary-key
+ * order. `where`/`order`/`limit`/`offset` and the full ORM operator set are
+ * evaluated in-memory over the decoded documents, which keeps every standard
+ * operator (ranges, `in`, `like`, `between`, `and`/`or`/`not`, ...) correct
+ * without maintaining a bespoke index per operator. `create`/`bulkCreate`/
+ * `update`/`destroy`/`truncate` compile to atomic `batch()` writes, which also
+ * gives us transactional multi-document writes.
+ */
+import { matchWhere, applyOrder, type WhereClause, type OrderSpec } from './where-match';
+export { matchWhere, applyOrder };
+export type { WhereClause, OrderSpec } from './where-match';
+/** A decoded document. Always carries its primary-key field. */
+export type Doc = Record<string, unknown>;
+/** Minimal ordered-KV surface the document layer needs from a backing store. */
+export interface KvBackend {
+    get(key: string): Promise<unknown>;
+    put(key: string, value: unknown): Promise<void>;
+    del(key: string): Promise<void>;
+    batch(ops: Array<{
+        type: 'put';
+        key: string;
+        value: unknown;
+    } | {
+        type: 'del';
+        key: string;
+    }>): Promise<void>;
+    /** Ordered iteration over `[key, value]` pairs whose key is in `[gte, lt)`. */
+    scanRange(gte: string, lt: string): AsyncIterable<[string, unknown]>;
+}
+/** Options accepted by {@link KvDocumentLayer.findAll} and friends. */
+export interface FindOptions {
+    where?: WhereClause;
+    /** `[[field, 'ASC'|'DESC'], ...]`, `['field', ...]`, or a single `'field'`. */
+    order?: OrderSpec;
+    limit?: number;
+    offset?: number;
+    /** Return only these fields (plus the primary key) on each row. */
+    attributes?: string[];
+    /** Eager-load related documents from other collections. */
+    include?: IncludeSpec[];
+}
+/**
+ * Declarative association join. Because embedded KV stores carry no schema,
+ * the relationship is described explicitly instead of being read from model
+ * metadata - this is what lets associations work through the ORM API without
+ * the caller writing their own cross-collection iteration.
+ */
+export interface IncludeSpec {
+    /** Property name to attach the loaded record(s) under. */
+    as: string;
+    /** Collection to load the related document(s) from. */
+    collection: string;
+    /** Field on the *parent* document holding the join value. Defaults to the parent PK. */
+    localKey?: string;
+    /** Field on the *related* document matched against `localKey`. Defaults to the related PK. */
+    foreignKey?: string;
+    /** `true` (default) attaches a single record (or `null`); `false` attaches an array. */
+    single?: boolean;
+    /** Optional extra filter applied to the related documents. */
+    where?: WhereClause;
+}
+/**
+ * Maps the ORM model API onto a single ordered-KV backend. One instance
+ * services every collection; the collection name is passed per call. The
+ * `primaryKey` is the document field used to form keys (default `'id'`).
+ */
+export declare class KvDocumentLayer {
+    private readonly backend;
+    private readonly primaryKey;
+    constructor(backend: KvBackend, primaryKey?: string);
+    private docKey;
+    private prefixRange;
+    private requirePk;
+    /** Load every decoded document of a collection, in primary-key order. */
+    private scanAll;
+    /** Fetch one document by primary key, or `null` if absent. */
+    findByPk(collection: string, pk: unknown, options?: FindOptions): Promise<Doc | null>;
+    /** Return all documents matching `where`, honoring order/limit/offset/include. */
+    findAll(collection: string, options?: FindOptions): Promise<Doc[]>;
+    /** Return the first document matching `where` (respecting order), or `null`. */
+    findOne(collection: string, options?: FindOptions): Promise<Doc | null>;
+    /** Count documents matching `where` (no filter counts the whole collection). */
+    count(collection: string, where?: WhereClause): Promise<number>;
+    /** Insert a single document. Returns the stored document. */
+    create(collection: string, data: Doc): Promise<Doc>;
+    /** Insert many documents atomically. Returns the stored documents. */
+    bulkCreate(collection: string, rows: Doc[]): Promise<Doc[]>;
+    /**
+     * Merge `values` into every document matching `where` (all documents when
+     * `where` is omitted). Returns the number of documents updated.
+     */
+    update(collection: string, values: Doc, where?: WhereClause): Promise<number>;
+    /**
+     * Delete every document matching `where` (all documents when `where` is
+     * omitted). Returns the number of documents deleted.
+     */
+    destroy(collection: string, where?: WhereClause): Promise<number>;
+    /** Delete every document in a collection. Returns the number deleted. */
+    truncate(collection: string): Promise<number>;
+    /**
+     * Upsert: replace the document with the same primary key (or insert it).
+     * Returns the stored document.
+     */
+    upsert(collection: string, data: Doc): Promise<Doc>;
+    /**
+     * Increment numeric `fields` on the document identified by `pk`.
+     * `fields` maps field name to the (default `1`) delta. Returns the new doc.
+     */
+    increment(collection: string, pk: unknown, fields: Record<string, number> | string[]): Promise<Doc | null>;
+    /**
+     * Run `fn` and apply all writes it stages atomically. `fn` receives a
+     * transaction handle whose `create`/`bulkCreate`/`update`/`destroy` stage
+     * `batch` operations instead of writing immediately; on success they are
+     * committed in one atomic `batch()`. Reads inside the transaction see the
+     * committed store (writes are not visible until commit), mirroring the KV
+     * driver's own single-batch atomicity guarantee.
+     */
+    transaction<T>(fn: (tx: KvTransaction) => Promise<T>): Promise<T>;
+    /** Internal: stage-free access used by KvTransaction for reads/keys. */
+    _docKey(collection: string, pk: unknown): string;
+    _encode(value: unknown): string;
+    _requirePk(doc: Doc, collection: string): unknown;
+    _backend(): KvBackend;
+    _scanAll(collection: string): Promise<Doc[]>;
+    _pk(): string;
+    /** Attach related documents to each parent row per the include specs. */
+    private loadIncludes;
+}
+/**
+ * Transaction handle: stages `put`/`del` operations and commits them in a
+ * single atomic `batch()`. Reads delegate to the committed store.
+ */
+export declare class KvTransaction {
+    private readonly layer;
+    private readonly ops;
+    private committed;
+    constructor(layer: KvDocumentLayer);
+    create(collection: string, data: Doc): this;
+    bulkCreate(collection: string, rows: Doc[]): this;
+    update(collection: string, values: Doc, where?: WhereClause): Promise<this>;
+    destroy(collection: string, where?: WhereClause): Promise<this>;
+    /** Commit staged operations atomically. Called automatically by `transaction()`. */
+    commit(): Promise<void>;
+}

package/dist/nosql/rocksdb/document-layer.js

@@ -0,0 +1,338 @@
+"use strict";
+/**
+ * Document/query layer for embedded ordered key-value stores (RocksDB, LevelDB).
+ *
+ * The raw stores only expose `put`/`get`/`del`/`batch`/ordered-iteration. That
+ * is a great substrate, but it forces users to hand-roll key design, secondary
+ * indexes, range scans and in-memory filtering every time they want to store
+ * and query documents. This module lifts the KV surface into the ORM's model
+ * API (`findAll`/`findOne`/`findByPk`/`create`/`bulkCreate`/`update`/`destroy`/
+ * `count`/`truncate`/associations/transactions) so callers never touch a raw
+ * iterator or design a keyspace by hand.
+ *
+ * ## Key design
+ *
+ * Documents live under a per-collection prefix:
+ *
+ *   `<collection>\x01<pk>`  ->  JSON document
+ *
+ * A prefix range scan (`gte: "<collection>\x01"`, `lt: "<collection>\x02"`)
+ * therefore yields exactly the documents of one collection, in primary-key
+ * order. `where`/`order`/`limit`/`offset` and the full ORM operator set are
+ * evaluated in-memory over the decoded documents, which keeps every standard
+ * operator (ranges, `in`, `like`, `between`, `and`/`or`/`not`, ...) correct
+ * without maintaining a bespoke index per operator. `create`/`bulkCreate`/
+ * `update`/`destroy`/`truncate` compile to atomic `batch()` writes, which also
+ * gives us transactional multi-document writes.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KvTransaction = exports.KvDocumentLayer = exports.applyOrder = exports.matchWhere = void 0;
+const where_match_1 = require("./where-match");
+Object.defineProperty(exports, "matchWhere", { enumerable: true, get: function () { return where_match_1.matchWhere; } });
+Object.defineProperty(exports, "applyOrder", { enumerable: true, get: function () { return where_match_1.applyOrder; } });
+const SEP = '\x01';
+function encodeValue(value) {
+    return JSON.stringify(value);
+}
+function decodeValue(value) {
+    if (typeof value === 'string') {
+        return JSON.parse(value);
+    }
+    if (value instanceof Uint8Array || Buffer.isBuffer(value)) {
+        return JSON.parse(Buffer.from(value).toString('utf8'));
+    }
+    // Some drivers deserialize JSON automatically; accept plain objects too.
+    return value;
+}
+function project(doc, attributes, pk) {
+    if (!attributes || attributes.length === 0)
+        return doc;
+    const out = {};
+    for (const field of attributes) {
+        if (field in doc)
+            out[field] = doc[field];
+    }
+    // Always retain the primary key so records stay addressable.
+    if (!(pk in out) && pk in doc)
+        out[pk] = doc[pk];
+    return out;
+}
+/**
+ * Maps the ORM model API onto a single ordered-KV backend. One instance
+ * services every collection; the collection name is passed per call. The
+ * `primaryKey` is the document field used to form keys (default `'id'`).
+ */
+class KvDocumentLayer {
+    constructor(backend, primaryKey = 'id') {
+        this.backend = backend;
+        this.primaryKey = primaryKey;
+    }
+    docKey(collection, pk) {
+        return `${collection}${SEP}${String(pk)}`;
+    }
+    prefixRange(collection) {
+        const gte = `${collection}${SEP}`;
+        // '\x02' is the next byte after the '\x01' separator, so this upper bound
+        // excludes every key of any other collection while including all of ours.
+        const lt = `${collection}\x02`;
+        return [gte, lt];
+    }
+    requirePk(doc, collection) {
+        const pk = doc[this.primaryKey];
+        if (pk === undefined || pk === null) {
+            throw new TypeError(`Document for collection "${collection}" is missing primary key "${this.primaryKey}"`);
+        }
+        return pk;
+    }
+    /** Load every decoded document of a collection, in primary-key order. */
+    async scanAll(collection) {
+        const [gte, lt] = this.prefixRange(collection);
+        const docs = [];
+        for await (const [, value] of this.backend.scanRange(gte, lt)) {
+            docs.push(decodeValue(value));
+        }
+        return docs;
+    }
+    /** Fetch one document by primary key, or `null` if absent. */
+    async findByPk(collection, pk, options = {}) {
+        let raw;
+        try {
+            raw = await this.backend.get(this.docKey(collection, pk));
+        }
+        catch {
+            return null; // NotFound in abstract-level throws; treat as absent.
+        }
+        if (raw === undefined || raw === null)
+            return null;
+        const doc = decodeValue(raw);
+        const withIncludes = options.include ? await this.loadIncludes([doc], options.include) : [doc];
+        return project(withIncludes[0], options.attributes, this.primaryKey);
+    }
+    /** Return all documents matching `where`, honoring order/limit/offset/include. */
+    async findAll(collection, options = {}) {
+        let rows = await this.scanAll(collection);
+        if (options.where) {
+            rows = rows.filter((doc) => (0, where_match_1.matchWhere)(doc, options.where));
+        }
+        if (options.order) {
+            rows = (0, where_match_1.applyOrder)(rows, options.order);
+        }
+        const offset = options.offset ?? 0;
+        if (offset > 0)
+            rows = rows.slice(offset);
+        if (typeof options.limit === 'number')
+            rows = rows.slice(0, options.limit);
+        if (options.include)
+            rows = await this.loadIncludes(rows, options.include);
+        if (options.attributes)
+            rows = rows.map((doc) => project(doc, options.attributes, this.primaryKey));
+        return rows;
+    }
+    /** Return the first document matching `where` (respecting order), or `null`. */
+    async findOne(collection, options = {}) {
+        const rows = await this.findAll(collection, { ...options, limit: 1 });
+        return rows.length > 0 ? rows[0] : null;
+    }
+    /** Count documents matching `where` (no filter counts the whole collection). */
+    async count(collection, where) {
+        const rows = await this.scanAll(collection);
+        if (!where)
+            return rows.length;
+        let n = 0;
+        for (const doc of rows)
+            if ((0, where_match_1.matchWhere)(doc, where))
+                n++;
+        return n;
+    }
+    /** Insert a single document. Returns the stored document. */
+    async create(collection, data) {
+        const pk = this.requirePk(data, collection);
+        await this.backend.put(this.docKey(collection, pk), encodeValue(data));
+        return data;
+    }
+    /** Insert many documents atomically. Returns the stored documents. */
+    async bulkCreate(collection, rows) {
+        const ops = rows.map((data) => {
+            const pk = this.requirePk(data, collection);
+            return { type: 'put', key: this.docKey(collection, pk), value: encodeValue(data) };
+        });
+        await this.backend.batch(ops);
+        return rows;
+    }
+    /**
+     * Merge `values` into every document matching `where` (all documents when
+     * `where` is omitted). Returns the number of documents updated.
+     */
+    async update(collection, values, where) {
+        const rows = await this.scanAll(collection);
+        const ops = [];
+        for (const doc of rows) {
+            if (where && !(0, where_match_1.matchWhere)(doc, where))
+                continue;
+            const merged = { ...doc, ...values };
+            // Keep the primary key stable even if `values` tries to change it.
+            merged[this.primaryKey] = doc[this.primaryKey];
+            ops.push({ type: 'put', key: this.docKey(collection, doc[this.primaryKey]), value: encodeValue(merged) });
+        }
+        if (ops.length > 0)
+            await this.backend.batch(ops);
+        return ops.length;
+    }
+    /**
+     * Delete every document matching `where` (all documents when `where` is
+     * omitted). Returns the number of documents deleted.
+     */
+    async destroy(collection, where) {
+        const rows = await this.scanAll(collection);
+        const ops = [];
+        for (const doc of rows) {
+            if (where && !(0, where_match_1.matchWhere)(doc, where))
+                continue;
+            ops.push({ type: 'del', key: this.docKey(collection, doc[this.primaryKey]) });
+        }
+        if (ops.length > 0)
+            await this.backend.batch(ops);
+        return ops.length;
+    }
+    /** Delete every document in a collection. Returns the number deleted. */
+    async truncate(collection) {
+        return this.destroy(collection);
+    }
+    /**
+     * Upsert: replace the document with the same primary key (or insert it).
+     * Returns the stored document.
+     */
+    async upsert(collection, data) {
+        return this.create(collection, data);
+    }
+    /**
+     * Increment numeric `fields` on the document identified by `pk`.
+     * `fields` maps field name to the (default `1`) delta. Returns the new doc.
+     */
+    async increment(collection, pk, fields) {
+        const doc = await this.findByPk(collection, pk);
+        if (!doc)
+            return null;
+        const deltas = Array.isArray(fields)
+            ? Object.fromEntries(fields.map((f) => [f, 1]))
+            : fields;
+        for (const [field, delta] of Object.entries(deltas)) {
+            doc[field] = (typeof doc[field] === 'number' ? doc[field] : 0) + delta;
+        }
+        await this.backend.put(this.docKey(collection, pk), encodeValue(doc));
+        return doc;
+    }
+    /**
+     * Run `fn` and apply all writes it stages atomically. `fn` receives a
+     * transaction handle whose `create`/`bulkCreate`/`update`/`destroy` stage
+     * `batch` operations instead of writing immediately; on success they are
+     * committed in one atomic `batch()`. Reads inside the transaction see the
+     * committed store (writes are not visible until commit), mirroring the KV
+     * driver's own single-batch atomicity guarantee.
+     */
+    async transaction(fn) {
+        const tx = new KvTransaction(this);
+        const result = await fn(tx);
+        await tx.commit();
+        return result;
+    }
+    /** Internal: stage-free access used by KvTransaction for reads/keys. */
+    _docKey(collection, pk) {
+        return this.docKey(collection, pk);
+    }
+    _encode(value) {
+        return encodeValue(value);
+    }
+    _requirePk(doc, collection) {
+        return this.requirePk(doc, collection);
+    }
+    _backend() {
+        return this.backend;
+    }
+    async _scanAll(collection) {
+        return this.scanAll(collection);
+    }
+    _pk() {
+        return this.primaryKey;
+    }
+    /** Attach related documents to each parent row per the include specs. */
+    async loadIncludes(rows, includes) {
+        if (rows.length === 0)
+            return rows;
+        for (const inc of includes) {
+            const localKey = inc.localKey ?? this.primaryKey;
+            const foreignKey = inc.foreignKey ?? this.primaryKey;
+            const single = inc.single ?? true;
+            const related = await this.scanAll(inc.collection);
+            const filtered = inc.where ? related.filter((d) => (0, where_match_1.matchWhere)(d, inc.where)) : related;
+            // Index related docs by their foreign key value for O(1) attachment.
+            const byKey = new Map();
+            for (const rel of filtered) {
+                const k = String(rel[foreignKey]);
+                const bucket = byKey.get(k);
+                if (bucket)
+                    bucket.push(rel);
+                else
+                    byKey.set(k, [rel]);
+            }
+            for (const parent of rows) {
+                const matches = byKey.get(String(parent[localKey])) ?? [];
+                parent[inc.as] = single ? matches[0] ?? null : matches;
+            }
+        }
+        return rows;
+    }
+}
+exports.KvDocumentLayer = KvDocumentLayer;
+/**
+ * Transaction handle: stages `put`/`del` operations and commits them in a
+ * single atomic `batch()`. Reads delegate to the committed store.
+ */
+class KvTransaction {
+    constructor(layer) {
+        this.layer = layer;
+        this.ops = [];
+        this.committed = false;
+    }
+    create(collection, data) {
+        const pk = this.layer._requirePk(data, collection);
+        this.ops.push({ type: 'put', key: this.layer._docKey(collection, pk), value: this.layer._encode(data) });
+        return this;
+    }
+    bulkCreate(collection, rows) {
+        for (const data of rows)
+            this.create(collection, data);
+        return this;
+    }
+    async update(collection, values, where) {
+        const rows = await this.layer._scanAll(collection);
+        const pk = this.layer._pk();
+        for (const doc of rows) {
+            if (where && !(0, where_match_1.matchWhere)(doc, where))
+                continue;
+            const merged = { ...doc, ...values };
+            merged[pk] = doc[pk];
+            this.ops.push({ type: 'put', key: this.layer._docKey(collection, doc[pk]), value: this.layer._encode(merged) });
+        }
+        return this;
+    }
+    async destroy(collection, where) {
+        const rows = await this.layer._scanAll(collection);
+        const pk = this.layer._pk();
+        for (const doc of rows) {
+            if (where && !(0, where_match_1.matchWhere)(doc, where))
+                continue;
+            this.ops.push({ type: 'del', key: this.layer._docKey(collection, doc[pk]) });
+        }
+        return this;
+    }
+    /** Commit staged operations atomically. Called automatically by `transaction()`. */
+    async commit() {
+        if (this.committed)
+            return;
+        this.committed = true;
+        if (this.ops.length > 0)
+            await this.layer._backend().batch(this.ops);
+    }
+}
+exports.KvTransaction = KvTransaction;

package/dist/nosql/rocksdb/index.d.ts

@@ -0,0 +1,112 @@
+import type { NoSqlStore } from '../store';
+import { KvDocumentLayer, type Doc, type FindOptions, type KvTransaction } from './document-layer';
+import type { WhereClause } from './where-match';
+export { KvDocumentLayer, KvTransaction, type Doc, type FindOptions, type IncludeSpec, } from './document-layer';
+export type { WhereClause, OrderSpec } from './where-match';
+/** A single entry in a `batch()` write: a `put` (with value) or a `del`. */
+export type RocksDBBatchOp = {
+    type: 'put';
+    key: string;
+    value: unknown;
+} | {
+    type: 'del';
+    key: string;
+};
+/**
+ * Minimal structural type for the pieces of a `rocksdb` client this store
+ * uses. Kept local (rather than importing from `rocksdb`) so this module
+ * type-checks without the optional driver installed.
+ */
+export interface RocksDBClientLike {
+    put(key: string, value: unknown): Promise<void>;
+    get(key: string): Promise<unknown>;
+    del(key: string): Promise<void>;
+    batch(ops: RocksDBBatchOp[]): Promise<void>;
+    iterator(options?: Record<string, unknown>): AsyncIterable<[unknown, unknown]>;
+    close(): Promise<void>;
+}
+/** Connection options for `RocksDBStore`. */
+export interface RocksDBStoreOptions {
+    /** Filesystem path for the RocksDB database directory. Defaults to `'./data/rocksdb'`. */
+    path?: string;
+    /**
+     * A pre-built `rocksdb` client (or a compatible mock). When provided,
+     * `connect()` uses it directly and skips `require('rocksdb')` entirely —
+     * this is how tests inject a mock without the real driver installed.
+     */
+    client?: RocksDBClientLike;
+}
+/**
+ * `RocksDBStore` wraps a `rocksdb` client and exposes its embedded KV surface:
+ * `put`/`get`/`del` for single keys, `batch` for atomic multi-key writes,
+ * and `list` for ordered key iteration (optionally by prefix).
+ */
+export declare class RocksDBStore implements NoSqlStore {
+    readonly name = "rocksdb";
+    readonly library = "rocksdb";
+    private readonly options;
+    private readonly path;
+    private client;
+    private connected;
+    constructor(options?: RocksDBStoreOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /** Returns the underlying `rocksdb` client for anything not wrapped here. */
+    getClient(): RocksDBClientLike;
+    private requireClient;
+    private wrapError;
+    /** Writes (or overwrites) the value at `key`. */
+    put(key: string, value: unknown): Promise<void>;
+    /** Reads the value at `key`. */
+    get(key: string): Promise<unknown>;
+    /** Deletes the value at `key`. */
+    del(key: string): Promise<void>;
+    /** Applies a list of `put`/`del` operations as a single atomic batch. */
+    batch(ops: RocksDBBatchOp[]): Promise<void>;
+    /**
+     * Lists keys in order. With `prefix`, restricts to keys `>= prefix` and
+     * `< prefix + '\xff'` (a standard prefix-scan range for byte-ordered keys).
+     */
+    list(prefix?: string): Promise<string[]>;
+    /**
+     * Ordered iteration over `[key, value]` pairs whose key is in `[gte, lt)`.
+     * Values are returned as stored (JSON strings, when written through the
+     * document layer). Used internally by the document layer's range scans.
+     */
+    scanRange(gte: string, lt: string): AsyncIterable<[string, unknown]>;
+    private docLayer;
+    private kvBackend;
+    /**
+     * Returns a document layer bound to this store, keyed by `primaryKey`
+     * (default `'id'`). Exposes the full ORM model API
+     * (`findAll`/`findOne`/`findByPk`/`create`/`bulkCreate`/`update`/`destroy`/
+     * `count`/`truncate`/`upsert`/`increment`/`transaction`).
+     */
+    documents(primaryKey?: string): KvDocumentLayer;
+    /** ORM `findAll` over a collection: where/order/limit/offset/include. */
+    findAll(collection: string, options?: FindOptions): Promise<Doc[]>;
+    /** ORM `findOne` over a collection. */
+    findOne(collection: string, options?: FindOptions): Promise<Doc | null>;
+    /** ORM `findByPk` over a collection. */
+    findByPk(collection: string, pk: unknown, options?: FindOptions): Promise<Doc | null>;
+    /** ORM `count` over a collection. */
+    count(collection: string, where?: WhereClause): Promise<number>;
+    /** ORM `create` for a single document. */
+    create(collection: string, data: Doc): Promise<Doc>;
+    /** ORM `bulkCreate` for many documents (atomic batch). */
+    bulkCreate(collection: string, rows: Doc[]): Promise<Doc[]>;
+    /** ORM `update`: merge `values` into documents matching `where`. */
+    updateWhere(collection: string, values: Doc, where?: WhereClause): Promise<number>;
+    /** ORM `destroy`: delete documents matching `where`. */
+    destroy(collection: string, where?: WhereClause): Promise<number>;
+    /** ORM `truncate`: delete every document in a collection. */
+    truncate(collection: string): Promise<number>;
+    /** Upsert a document by primary key. */
+    upsert(collection: string, data: Doc): Promise<Doc>;
+    /** Atomically increment numeric fields of one document. */
+    increment(collection: string, pk: unknown, fields: Record<string, number> | string[]): Promise<Doc | null>;
+    /** Run a function inside an atomic multi-document transaction (single batch commit). */
+    transaction<T>(fn: (tx: KvTransaction) => Promise<T>): Promise<T>;
+}
+export default RocksDBStore;