ts-prorm-orm 1.1.0 → 1.2.1

package/dist/nosql/mongodb/where.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.translateWhereToMongo = translateWhereToMongo;
+exports.translateOrderToMongo = translateOrderToMongo;
+/**
+ * ORM where-clause translator for the MongoDB store.
+ *
+ * Turns the ORM's `where` shape (plain-object field conditions, `Op.*`
+ * comparison symbols, and `Op.and`/`Op.or`/`Op.not` logical symbols) directly
+ * into a native MongoDB query filter (`$gt`, `$in`, `$regex`, `$and`/`$or`/
+ * `$nor`, ...). This is what lets callers write standard ORM queries
+ * (`{ age: { [Op.gte]: 18 } }`) instead of hand-building Mongo filter objects.
+ */
+const operators_1 = require("../../operators");
+const index_1 = require("../../errors/index");
+/** Whether `v` is a plain object carrying `Op.*` comparison symbols. */
+function hasOpSymbols(v) {
+    return (v !== null &&
+        typeof v === 'object' &&
+        !Array.isArray(v) &&
+        Object.getOwnPropertySymbols(v).length > 0);
+}
+function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/** Translate a SQL `LIKE` pattern into a MongoDB `$regex` source string. */
+function likeToRegexSource(pattern) {
+    let out = '^';
+    for (const ch of pattern) {
+        if (ch === '%')
+            out += '.*';
+        else if (ch === '_')
+            out += '.';
+        else
+            out += escapeRegex(ch);
+    }
+    return out + '$';
+}
+/** Translate one `{ [Op.*]: value }` object into the Mongo operators for a single field. */
+function translateFieldOps(opObj) {
+    const out = {};
+    for (const op of Object.getOwnPropertySymbols(opObj)) {
+        const value = opObj[op];
+        switch (op) {
+            case operators_1.Op.eq:
+                out.$eq = value;
+                break;
+            case operators_1.Op.ne:
+                out.$ne = value;
+                break;
+            case operators_1.Op.gt:
+                out.$gt = value;
+                break;
+            case operators_1.Op.gte:
+                out.$gte = value;
+                break;
+            case operators_1.Op.lt:
+                out.$lt = value;
+                break;
+            case operators_1.Op.lte:
+                out.$lte = value;
+                break;
+            case operators_1.Op.in:
+                out.$in = value;
+                break;
+            case operators_1.Op.notIn:
+                out.$nin = value;
+                break;
+            case operators_1.Op.between: {
+                const [lo, hi] = value;
+                out.$gte = lo;
+                out.$lte = hi;
+                break;
+            }
+            case operators_1.Op.notBetween: {
+                const [lo, hi] = value;
+                out.$not = { $gte: lo, $lte: hi };
+                break;
+            }
+            case operators_1.Op.isNull:
+                out.$eq = null;
+                break;
+            case operators_1.Op.isNotNull:
+                out.$ne = null;
+                break;
+            case operators_1.Op.like:
+                out.$regex = likeToRegexSource(String(value));
+                break;
+            case operators_1.Op.iLike:
+                out.$regex = likeToRegexSource(String(value));
+                out.$options = 'i';
+                break;
+            case operators_1.Op.notLike:
+                // $not requires a BSON regex, not a { $regex } document (that throws
+                // "$not needs a regex or a document" at query time).
+                out.$not = new RegExp(likeToRegexSource(String(value)));
+                break;
+            case operators_1.Op.notILike:
+                out.$not = new RegExp(likeToRegexSource(String(value)), 'i');
+                break;
+            case operators_1.Op.startsWith:
+                out.$regex = '^' + escapeRegex(String(value));
+                break;
+            case operators_1.Op.endsWith:
+                out.$regex = escapeRegex(String(value)) + '$';
+                break;
+            case operators_1.Op.substring:
+            case operators_1.Op.contains:
+                out.$regex = escapeRegex(String(value));
+                break;
+            case operators_1.Op.regexp:
+                out.$regex = String(value);
+                break;
+            case operators_1.Op.iRegexp:
+                out.$regex = String(value);
+                out.$options = 'i';
+                break;
+            case operators_1.Op.notRegexp:
+                out.$not = new RegExp(String(value));
+                break;
+            case operators_1.Op.notIRegexp:
+                out.$not = new RegExp(String(value), 'i');
+                break;
+            default:
+                throw new index_1.DatabaseError(`MongoDB: unsupported where operator "${op.toString()}"`, {
+                    code: index_1.ErrorCodes.QUERY_ERROR,
+                });
+        }
+    }
+    return out;
+}
+/**
+ * Translate an ORM `where` object into a native MongoDB filter document.
+ * A bare `{ field: value }` maps to equality, an array value to `$in`, and
+ * `Op.and`/`Op.or`/`Op.not` to `$and`/`$or`/`$nor`.
+ */
+function translateWhereToMongo(where) {
+    if (!where)
+        return {};
+    const out = {};
+    for (const sym of Object.getOwnPropertySymbols(where)) {
+        const val = where[sym];
+        if (sym === operators_1.Op.and) {
+            out.$and = val.map(translateWhereToMongo);
+        }
+        else if (sym === operators_1.Op.or) {
+            out.$or = val.map(translateWhereToMongo);
+        }
+        else if (sym === operators_1.Op.not) {
+            out.$nor = [translateWhereToMongo(val)];
+        }
+    }
+    for (const field of Object.keys(where)) {
+        const val = where[field];
+        if (hasOpSymbols(val)) {
+            out[field] = translateFieldOps(val);
+        }
+        else if (Array.isArray(val)) {
+            out[field] = { $in: val };
+        }
+        else {
+            out[field] = val;
+        }
+    }
+    return out;
+}
+/** Build a MongoDB `sort` document from ORM ordering terms. */
+function translateOrderToMongo(order) {
+    if (order === undefined)
+        return undefined;
+    const single = Array.isArray(order) && order.length === 2 && typeof order[0] === 'string' && (order[1] === 'ASC' || order[1] === 'DESC');
+    const terms = (Array.isArray(order) && !single ? order : [order]);
+    const sort = {};
+    for (const term of terms) {
+        if (typeof term === 'string')
+            sort[term] = 1;
+        else
+            sort[term[0]] = term[1] === 'DESC' ? -1 : 1;
+    }
+    return sort;
+}

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

@@ -0,0 +1,139 @@
+/**
+ * NATS store implementation.
+ *
+ * NATS is a lightweight publish/subscribe and request/reply messaging system.
+ * Its JetStream layer adds persistence, including a key/value (KV) store built
+ * on top of streams. NATS has no query language and does not fit the
+ * SQL-shaped `Dialect` interface, so this class implements the minimal
+ * `NoSqlStore` marker interface and exposes NATS's real operations
+ * (core pub/sub, request/reply, and JetStream KV) instead of forcing
+ * everything into a `query(sql)` shape.
+ *
+ * Uses the `nats` driver (`nats.js`). The driver is lazy-loaded inside
+ * `connect()` via `require('nats')` so that importing this module never
+ * pulls in the driver unless a connection is actually opened; tests inject a
+ * pre-built connection through the `client` option and never touch the real
+ * driver or the network.
+ *
+ * Encoding: NATS messages are byte payloads (`Uint8Array`). `publish()` and
+ * `request()` accept either a `string` (UTF-8 encoded via `TextEncoder`) or a
+ * `Uint8Array` (passed through unchanged). `subscribe()` handlers and
+ * `request()` replies deliver the raw `Uint8Array` payload; decode with
+ * `TextDecoder` (or the message's own `.string()`/`.json()` helpers when using
+ * the real driver) as needed. JetStream KV values are encoded the same way on
+ * write, and `kvGet()` returns the entry's raw `Uint8Array` value (or `null`
+ * when the key is absent).
+ */
+import { NoSqlStore } from '../store';
+/**
+ * A NATS message payload accepted by `publish()`/`request()`/`kvPut()`.
+ * Strings are UTF-8 encoded; `Uint8Array` values are sent as-is.
+ */
+export type NatsPayload = string | Uint8Array;
+/**
+ * A minimal structural view of the pieces of a `nats` `NatsConnection` this
+ * store uses. Kept intentionally loose (`any`-returning) because the real
+ * driver's types are not available at build time (the package is optional).
+ */
+export interface NatsConnectionLike {
+    publish(subject: string, data?: Uint8Array, opts?: unknown): void;
+    subscribe(subject: string, opts?: unknown): unknown;
+    request(subject: string, data?: Uint8Array, opts?: unknown): Promise<unknown>;
+    jetstream(opts?: unknown): {
+        views: {
+            kv(bucket: string, opts?: unknown): Promise<NatsKvLike>;
+        };
+    };
+    drain?(): Promise<void>;
+    close?(): Promise<void>;
+}
+/** A minimal structural view of a JetStream KV bucket view. */
+export interface NatsKvLike {
+    put(key: string, value: Uint8Array): Promise<number>;
+    get(key: string): Promise<{
+        value: Uint8Array;
+    } | null>;
+    delete(key: string): Promise<void>;
+}
+/** A handler invoked for each message delivered to a `subscribe()` subject. */
+export type NatsMessageHandler = (err: Error | null, msg: unknown) => void;
+/** Connection options for `NatsStore`. */
+export interface NatsStoreOptions {
+    /**
+     * One or more NATS server URLs (e.g. `nats://localhost:4222`). Passed
+     * straight through to the driver's `connect({ servers })`.
+     */
+    servers?: string | string[];
+    /** Token auth. */
+    token?: string;
+    /** Username for user/password auth. */
+    user?: string;
+    /** Password for user/password auth. */
+    pass?: string;
+    /**
+     * A pre-built `NatsConnection`. When provided, `connect()` adopts it
+     * directly and never calls `require('nats')` — this is how tests inject a
+     * mock connection without the real driver or a network.
+     */
+    client?: NatsConnectionLike;
+}
+/**
+ * `NatsStore` wraps a `nats` `NatsConnection` and exposes NATS's core
+ * publish/subscribe and request/reply operations plus JetStream KV
+ * (`kvPut`/`kvGet`/`kvDelete`) as a typed, promise-based API.
+ */
+export declare class NatsStore implements NoSqlStore {
+    readonly name = "nats";
+    readonly library = "nats";
+    private readonly options;
+    private connection;
+    private connected;
+    /** Cached JetStream KV bucket views, keyed by bucket name. */
+    private readonly kvCache;
+    constructor(options?: NatsStoreOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /** Returns the underlying `nats` connection for anything not wrapped here. */
+    getClient(): NatsConnectionLike;
+    private requireConnection;
+    /**
+     * Publish `data` to `subject`. The payload is encoded per the module's
+     * encoding rules (string → UTF-8, `Uint8Array` → as-is).
+     */
+    publish(subject: string, data: NatsPayload): void;
+    /**
+     * Subscribe to `subject`, invoking `handler` for each message via the
+     * driver's callback option (`subscribe(subject, { callback })`). Returns the
+     * driver's `Subscription` (call `.unsubscribe()` / `.drain()` on it to stop).
+     * The callback style is chosen over the async-iterator style so a handler
+     * can be registered without spawning a consuming loop.
+     */
+    subscribe(subject: string, handler: NatsMessageHandler): unknown;
+    /**
+     * Send a request to `subject` and await a single reply. `opts` is passed
+     * straight through to the driver (e.g. `{ timeout }`). Resolves with the
+     * driver's reply `Msg`; read `.data` / `.string()` / `.json()` off it.
+     */
+    request(subject: string, data: NatsPayload, opts?: unknown): Promise<unknown>;
+    /**
+     * Lazily resolve (and cache) the JetStream KV bucket view for `bucket` via
+     * `connection.jetstream().views.kv(bucket)`. Subsequent calls for the same
+     * bucket return the cached view.
+     */
+    kv(bucket: string): Promise<NatsKvLike>;
+    /**
+     * Put `value` at `key` in `bucket`'s KV store (encoded per the module's
+     * encoding rules). Returns the revision number assigned by JetStream.
+     */
+    kvPut(bucket: string, key: string, value: NatsPayload): Promise<number>;
+    /**
+     * Get the raw value stored at `key` in `bucket`, or `null` if the key is
+     * absent (or holds a deleted/purged entry). Returns the entry's
+     * `Uint8Array` value; decode with `TextDecoder` as needed.
+     */
+    kvGet(bucket: string, key: string): Promise<Uint8Array | null>;
+    /** Delete `key` from `bucket`'s KV store. */
+    kvDelete(bucket: string, key: string): Promise<void>;
+}
+export default NatsStore;

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

@@ -0,0 +1,79 @@
+import type { NoSqlStore } from '../store';
+/** A single entry in a `batch()` write: a `put` (with document value) or a `del`. */
+export type NedbBatchOp = {
+    type: 'put';
+    key: string;
+    value: Record<string, unknown>;
+} | {
+    type: 'del';
+    key: string;
+};
+/** A NeDB document: an arbitrary record that carries an `_id`. */
+export type NedbDoc = Record<string, unknown> & {
+    _id?: string;
+};
+type NodeCallback<T> = (err: Error | null, result?: T) => void;
+/**
+ * Minimal structural type for the pieces of a `nedb` `Datastore` this store
+ * uses. Kept local (rather than importing from `nedb`) so this module
+ * type-checks without the optional driver installed.
+ */
+export interface NedbClientLike {
+    insert(doc: NedbDoc, cb: NodeCallback<NedbDoc>): void;
+    findOne(query: Record<string, unknown>, cb: NodeCallback<NedbDoc | null>): void;
+    find(query: Record<string, unknown>, cb: NodeCallback<NedbDoc[]>): void;
+    remove(query: Record<string, unknown>, options: Record<string, unknown>, cb: NodeCallback<number>): void;
+}
+/** Connection options for `NedbStore`. */
+export interface NedbStoreOptions {
+    /**
+     * Filesystem path for the NeDB datafile. Omit for a purely in-memory store.
+     */
+    filename?: string;
+    /**
+     * A pre-built `nedb` `Datastore` (or a compatible mock). When provided,
+     * `connect()` uses it directly and skips `require('nedb')` entirely — this
+     * is how tests inject a mock without the real driver installed.
+     */
+    client?: NedbClientLike;
+}
+/**
+ * `NedbStore` wraps a `nedb` `Datastore` and exposes both a common KV surface
+ * — `put`/`get`/`del` keyed on `_id`, `batch`, `list` — and NeDB's native
+ * document operations `insert`/`find`.
+ */
+export declare class NedbStore implements NoSqlStore {
+    readonly name = "nedb";
+    readonly library = "nedb";
+    private readonly options;
+    private client;
+    private connected;
+    constructor(options?: NedbStoreOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /** Returns the underlying `nedb` `Datastore` for anything not wrapped here. */
+    getClient(): NedbClientLike;
+    private requireClient;
+    private wrapError;
+    /** Wrap a callback-style NeDB call into a Promise. */
+    private promisify;
+    /**
+     * Writes a document keyed by `_id = key`. Maps onto NeDB's `insert`, merging
+     * `key` into the document as its `_id`.
+     */
+    put(key: string, value: Record<string, unknown>): Promise<NedbDoc>;
+    /** Reads a document by `_id` (NeDB `findOne({ _id })`). Returns `null` if absent. */
+    get(key: string): Promise<NedbDoc | null>;
+    /** Deletes a document by `_id` (NeDB `remove({ _id })`). Returns the number removed. */
+    del(key: string): Promise<number>;
+    /** Native `insert`: adds a document (NeDB assigns an `_id` if omitted). */
+    insert(doc: NedbDoc): Promise<NedbDoc>;
+    /** Native `find`: returns every document matching the Mongo-style `query`. */
+    find(query?: Record<string, unknown>): Promise<NedbDoc[]>;
+    /** Applies a list of `put`/`del` operations sequentially. */
+    batch(ops: NedbBatchOp[]): Promise<void>;
+    /** Lists all document `_id`s (via `find({})`). */
+    list(): Promise<string[]>;
+}
+export default NedbStore;

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

@@ -0,0 +1,217 @@
+/**
+ * Neo4j store implementation.
+ *
+ * Neo4j is a graph database: data is modeled as labeled nodes and typed
+ * relationships (both carrying arbitrary properties) instead of rows in
+ * tables, and queried with Cypher instead of SQL. It has no `Dialect`-shaped
+ * `query(sql)`/identifier-escaping/DDL surface, so this class implements the
+ * minimal `NoSqlStore` marker interface and exposes Neo4j's real primitives
+ * — sessions, (managed and explicit) transactions, and raw parameterized
+ * Cypher — plus a thin layer of Cypher-generating convenience helpers for
+ * common node/relationship CRUD, rather than forcing a graph database into
+ * a `query(sql)` shape.
+ *
+ * Uses the official `neo4j-driver` (Bolt protocol) driver.
+ */
+import type { Driver, Session, ManagedTransaction, Config as Neo4jDriverConfig, AuthToken, Integer } from 'neo4j-driver';
+import { NoSqlStore } from '../store';
+/**
+ * Connection options for `Neo4jStore`.
+ *
+ * Accepts either a pre-built `AuthToken` (e.g. from `neo4j.auth.kerberos()`/
+ * `neo4j.auth.bearer()`) or a plain `username`/`password` pair, which is
+ * turned into a basic auth token. Any other `neo4j-driver` `Config` fields
+ * (`maxConnectionPoolSize`, `connectionTimeout`, `encrypted`, etc) are
+ * passed straight through via `config`.
+ */
+export interface Neo4jStoreOptions {
+    /** Bolt/neo4j connection URI, e.g. `'neo4j://localhost:7687'` or `'bolt://localhost:7687'`. */
+    uri: string;
+    /** Basic-auth username. Ignored if `auth` is provided. */
+    username?: string;
+    /** Basic-auth password. Ignored if `auth` is provided. */
+    password?: string;
+    /** A pre-built auth token (`neo4j.auth.basic/kerberos/bearer/custom`). Overrides `username`/`password`. */
+    auth?: AuthToken;
+    /** Default database to run sessions/queries against (Neo4j 4.0+ multi-database). */
+    database?: string;
+    /** Any other `neo4j-driver` `Config` fields, passed straight through to `neo4j.driver()`. */
+    config?: Neo4jDriverConfig;
+}
+/** Parameters for a parameterized Cypher query. */
+export type CypherParams = Record<string, unknown>;
+/** Session-level options shared by `session()`, `run()`, `executeRead()`/`executeWrite()`, and `beginTransaction()`. */
+export interface SessionOptions {
+    /** Database to run against; falls back to `Neo4jStoreOptions.database`, then the server default. */
+    database?: string;
+    /** `'READ'` or `'WRITE'` — determines routing in a cluster and eligibility for read-replica routing. */
+    defaultAccessMode?: 'READ' | 'WRITE';
+}
+/** A subset of `ResultSummary.counters` surfaced as plain numbers. */
+export interface CypherSummary {
+    queryType: string;
+    nodesCreated: number;
+    nodesDeleted: number;
+    relationshipsCreated: number;
+    relationshipsDeleted: number;
+    propertiesSet: number;
+    labelsAdded: number;
+    labelsRemoved: number;
+}
+/** The result of running a Cypher query: mapped plain-object records plus a summary. */
+export interface CypherResult<T = Record<string, unknown>> {
+    records: T[];
+    /** Field names present on each record, in order. */
+    keys: string[];
+    summary: CypherSummary;
+}
+/** A Neo4j node, mapped to a plain object (see "Result mapping" in the README). */
+export interface GraphNode<P = Record<string, unknown>> {
+    elementId: string;
+    /** Legacy numeric ID (unwrapped from Neo4j's `Integer` type - see `intToNumber`/README "Known limitations"). */
+    identity: number;
+    labels: string[];
+    properties: P;
+}
+/** A Neo4j relationship, mapped to a plain object. */
+export interface GraphRelationship<P = Record<string, unknown>> {
+    elementId: string;
+    identity: number;
+    type: string;
+    startElementId: string;
+    endElementId: string;
+    start: number;
+    end: number;
+    properties: P;
+}
+/** Pagination options for `findNodes()`/`findRelationships()`. */
+export interface FindOptions {
+    skip?: number;
+    limit?: number;
+}
+/** Options for `deleteNode()`. */
+export interface DeleteNodeOptions {
+    /** Also delete any relationships attached to the node (Cypher `DETACH DELETE`). Without this, deleting a node with existing relationships fails. */
+    detach?: boolean;
+}
+/**
+ * A handle to an explicit (begin/commit/rollback) transaction, returned by
+ * `beginTransaction()`. Unlike `executeRead()`/`executeWrite()`, this is not
+ * automatically retried on transient errors - the caller drives commit/
+ * rollback explicitly.
+ */
+export interface Neo4jTransaction {
+    run<T = Record<string, unknown>>(cypher: string, params?: CypherParams): Promise<CypherResult<T>>;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+    /** `true` until `commit()`/`rollback()` has completed. */
+    isOpen(): boolean;
+}
+/**
+ * Unwrap a single Neo4j `Integer` (its 64-bit integer type, used for
+ * identities, counts, and any Cypher `INTEGER` value) into a JS `number`.
+ * Values outside `Number.MAX_SAFE_INTEGER` lose precision on this
+ * conversion - see "Known limitations" in the README for the lossless
+ * alternative (`neo4j-driver`'s `disableLosslessIntegers`/`useBigInt`
+ * config, passed through via `Neo4jStoreOptions.config`).
+ */
+export declare function intToNumber(value: Integer): number;
+/**
+ * `Neo4jStore` wraps a `neo4j-driver` `Driver` and exposes:
+ *  - raw parameterized Cypher (`run()`) - the general escape hatch,
+ *  - session management (`session()`),
+ *  - transaction functions with automatic retry (`executeRead()`/`executeWrite()`),
+ *  - explicit begin/commit/rollback transactions (`beginTransaction()`),
+ *  - and Cypher-generating node/relationship CRUD convenience helpers
+ *    (`createNode()`, `findNodes()`, `createRelationship()`, etc) built on
+ *    top of `run()` - these are thin Cypher generators, not a separate
+ *    query engine, so anything they don't cover is one `run()` call away.
+ */
+export declare class Neo4jStore implements NoSqlStore {
+    readonly name = "neo4j";
+    readonly library = "neo4j-driver";
+    private readonly options;
+    private driverInstance;
+    private connected;
+    constructor(options: Neo4jStoreOptions);
+    private resolveAuth;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /** Returns the underlying `neo4j-driver` `Driver` for anything not wrapped here. */
+    getClient(): Driver;
+    private requireDriver;
+    /**
+     * Open a new `Session`. Sessions are lightweight and disposable - open
+     * one per logical unit of work and close it when done (`run()`,
+     * `executeRead()`/`executeWrite()`, and `beginTransaction()` all do this
+     * for you; call this directly only if you need the raw `Session`, e.g.
+     * for `session.run()`'s streaming `subscribe()` API).
+     */
+    session(options?: SessionOptions): Session;
+    /**
+     * Run a single parameterized Cypher statement as an auto-commit query,
+     * on a session opened and closed for just this call. Always parameterize
+     * user-supplied values (`$name`, not string concatenation) - the driver
+     * sends `params` separately from the query text, the same protection
+     * bind parameters give you against SQL injection.
+     */
+    run<T = Record<string, unknown>>(cypher: string, params?: CypherParams, options?: SessionOptions): Promise<CypherResult<T>>;
+    /**
+     * Run `work` inside a managed read transaction. The driver automatically
+     * retries `work` on transient errors (e.g. deadlocks, leader switches in
+     * a cluster) - `work` may run more than once, so it must be idempotent
+     * and side-effect-free outside of the transaction it's given.
+     */
+    executeRead<T>(work: (tx: ManagedTransaction) => Promise<T> | T, options?: SessionOptions): Promise<T>;
+    /** Like `executeRead()`, but for a managed write transaction (`defaultAccessMode: 'WRITE'`). */
+    executeWrite<T>(work: (tx: ManagedTransaction) => Promise<T> | T, options?: SessionOptions): Promise<T>;
+    /**
+     * Begin an explicit transaction spanning multiple `run()` calls, on a
+     * session held open until `commit()`/`rollback()`. Unlike
+     * `executeRead()`/`executeWrite()`, this is never retried automatically
+     * - use it when you need multiple round trips with logic in between, or
+     * full manual control over commit/rollback.
+     */
+    beginTransaction(options?: SessionOptions): Promise<Neo4jTransaction>;
+    /** `CREATE (n:Label1:Label2) SET n = $properties RETURN n` */
+    createNode<P extends Record<string, unknown> = Record<string, unknown>>(labels: string | string[], properties?: P): Promise<GraphNode<P>>;
+    /** `MATCH (n) WHERE elementId(n) = $elementId RETURN n` */
+    getNodeByElementId<P extends Record<string, unknown> = Record<string, unknown>>(elementId: string): Promise<GraphNode<P> | null>;
+    /**
+     * `MATCH (n:Label) WHERE n.k1 = $k1 AND ... RETURN n [SKIP $skip] [LIMIT $limit]`
+     *
+     * `where` is an equality-only match on node properties (no operators,
+     * ranges, or `OR`) - use `run()` directly for anything more expressive.
+     */
+    findNodes<P extends Record<string, unknown> = Record<string, unknown>>(labels?: string | string[], where?: Record<string, unknown>, options?: FindOptions): Promise<GraphNode<P>[]>;
+    /** `MATCH (n) WHERE elementId(n) = $elementId SET n += $properties RETURN n` (merges, does not replace, existing properties) */
+    updateNode<P extends Record<string, unknown> = Record<string, unknown>>(elementId: string, properties: Partial<P>): Promise<GraphNode<P> | null>;
+    /**
+     * `MATCH (n) WHERE elementId(n) = $elementId [DETACH] DELETE n`
+     *
+     * Without `options.detach`, deleting a node that still has relationships
+     * fails (Neo4j refuses to leave dangling relationships) - the underlying
+     * error surfaces as a `DatabaseError`. Returns whether a node was
+     * actually deleted (based on the query's `nodesDeleted` counter).
+     */
+    deleteNode(elementId: string, options?: DeleteNodeOptions): Promise<boolean>;
+    /** `MATCH (n:Label) WHERE ... RETURN count(n) AS count` */
+    countNodes(labels?: string | string[], where?: Record<string, unknown>): Promise<number>;
+    /**
+     * `MATCH (a), (b) WHERE elementId(a) = $fromElementId AND elementId(b) = $toElementId`
+     * `CREATE (a)-[r:TYPE]->(b) SET r = $properties RETURN r`
+     */
+    createRelationship<P extends Record<string, unknown> = Record<string, unknown>>(fromElementId: string, toElementId: string, type: string, properties?: P): Promise<GraphRelationship<P>>;
+    /** `MATCH ()-[r]->() WHERE elementId(r) = $elementId RETURN r` */
+    getRelationshipByElementId<P extends Record<string, unknown> = Record<string, unknown>>(elementId: string): Promise<GraphRelationship<P> | null>;
+    /**
+     * `MATCH (a)-[r:TYPE]->(b) WHERE r.k1 = $k1 AND ... RETURN r [SKIP $skip] [LIMIT $limit]`
+     *
+     * Omit `type` to match relationships of any type.
+     */
+    findRelationships<P extends Record<string, unknown> = Record<string, unknown>>(type?: string, where?: Record<string, unknown>, options?: FindOptions): Promise<GraphRelationship<P>[]>;
+    /** `MATCH (a)-[r]->(b) WHERE elementId(r) = $elementId DELETE r` - returns whether a relationship was actually deleted. */
+    deleteRelationship(elementId: string): Promise<boolean>;
+}
+export default Neo4jStore;