ts-prorm-orm 1.1.0 → 1.2.1

package/dist/graph/gremlin/index.js

@@ -0,0 +1,378 @@
+"use strict";
+/**
+ * Gremlin graph dialect — Apache TinkerPop / Amazon Neptune traversal
+ * generation for the ORM builder API.
+ *
+ * Maps the ORM model API onto Gremlin traversals: `g.V().hasLabel(...)` for
+ * finds, `addV`/`addE` for node/edge writes, `.has(field, P.gte(x))` for
+ * `where` operators, `out`/`in`/`repeat().times()` for association
+ * traversals. Values are passed as Gremlin bindings (`b0`, `b1`, ...), never
+ * interpolated. Users never hand-write Gremlin for standard operations.
+ *
+ * The `gremlin` package is loaded lazily; a pre-built client can be injected
+ * via `options.client`.
+ *
+ * Notes on genuinely-unsupported features:
+ *  - TinkerPop has no portable schema DDL, so index/constraint creation
+ *    compiles to a harmless no-op traversal (real schema management is
+ *    backend-specific: JanusGraph management API, Neptune auto-indexing).
+ *  - Interactive multi-statement transactions are not portable across
+ *    Gremlin servers (Neptune in particular), so `startTransaction` throws a
+ *    typed {@link GraphCapabilityError}.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GremlinGraphDialect = void 0;
+const index_1 = require("../../errors/index");
+const base_graph_dialect_1 = require("../base-graph-dialect");
+const types_1 = require("../types");
+function gremlinStr(s) {
+    return `'${String(s).replace(/\\/g, '\\\\').replace(/'/g, "\\'")}'`;
+}
+class GremlinGraphDialect extends base_graph_dialect_1.BaseGraphDialect {
+    constructor(options = {}) {
+        super(options);
+        this.name = 'gremlin';
+        this.library = 'gremlin';
+        this.client = null;
+        this.dialectName = 'gremlin';
+    }
+    get defaultNodeVar() {
+        return 'it';
+    }
+    // -------------------------------------------------------------------
+    // Connection lifecycle
+    // -------------------------------------------------------------------
+    async connect() {
+        if (this._connected && this.client)
+            return;
+        try {
+            let client = this.options.client;
+            if (!client) {
+                // eslint-disable-next-line @typescript-eslint/no-var-requires
+                const gremlin = require('gremlin');
+                const url = this.options.url || `ws://${this.options.host || 'localhost'}:${this.options.port || 8182}/gremlin`;
+                client = new gremlin.driver.Client(url, {
+                    traversalSource: 'g',
+                    ...this.options.driverOptions,
+                });
+            }
+            if (typeof client.open === 'function') {
+                await client.open();
+            }
+            this.client = client;
+            this._connection = client;
+            this._connected = true;
+        }
+        catch (error) {
+            this.client = null;
+            this._connection = null;
+            this._connected = false;
+            throw new index_1.ConnectionError('Failed to connect to Gremlin server', {
+                parent: error instanceof Error ? error : undefined,
+                database: this.options.database,
+            });
+        }
+    }
+    async disconnect() {
+        const client = this.client;
+        this.client = null;
+        this._connection = null;
+        this._connected = false;
+        if (client && typeof client.close === 'function') {
+            await client.close();
+        }
+    }
+    requireClient() {
+        if (!this.client || !this._connected) {
+            throw new index_1.ConnectionError('GremlinGraphDialect is not connected. Call connect() first.', {
+                database: this.options.database,
+            });
+        }
+        return this.client;
+    }
+    async query(statement, options) {
+        const client = this.requireClient();
+        const bindings = options?.bind || {};
+        try {
+            const result = await client.submit(statement, bindings);
+            const rows = typeof result?.toArray === 'function' ? result.toArray() : result?._items || [];
+            return { rows, rowCount: rows.length, fields: [] };
+        }
+        catch (error) {
+            throw new index_1.DatabaseError('Gremlin traversal failed', {
+                code: 'QUERY_ERROR',
+                parent: error instanceof Error ? error : undefined,
+                original: error instanceof Error ? error.message : String(error),
+                sql: statement,
+            });
+        }
+    }
+    async getDatabaseVersion() {
+        return 'unknown';
+    }
+    // -------------------------------------------------------------------
+    // Transactions — not portable across Gremlin servers.
+    // -------------------------------------------------------------------
+    async startTransaction(_options) {
+        throw new types_1.GraphCapabilityError('interactive transactions', this.name);
+    }
+    async commitTransaction(_transaction) {
+        throw new types_1.GraphCapabilityError('interactive transactions', this.name);
+    }
+    async rollbackTransaction(_transaction) {
+        throw new types_1.GraphCapabilityError('interactive transactions', this.name);
+    }
+    // -------------------------------------------------------------------
+    // Predicate rendering -> `.has(...)` step chain.
+    // -------------------------------------------------------------------
+    renderPredicate(pred, ctx) {
+        switch (pred.kind) {
+            case 'true':
+                return '';
+            case 'and':
+                return pred.items.map((p) => this.renderPredicate(p, ctx)).join('');
+            case 'or': {
+                const anon = pred.items
+                    .map((p) => `__${this.renderPredicate(p, ctx)}`)
+                    .filter((s) => s !== '__');
+                return anon.length ? `.or(${anon.join(', ')})` : '';
+            }
+            case 'not':
+                return `.not(__${this.renderPredicate(pred.item, ctx)})`;
+            case 'cmp':
+                return this.renderComparison(pred, ctx);
+        }
+    }
+    renderComparison(pred, ctx) {
+        const field = gremlinStr(pred.field);
+        const p = (v) => ctx.params.add(v);
+        switch (pred.op) {
+            case 'eq':
+                return `.has(${field}, eq(${p(pred.value)}))`;
+            case 'ne':
+                return `.has(${field}, neq(${p(pred.value)}))`;
+            case 'gt':
+                return `.has(${field}, gt(${p(pred.value)}))`;
+            case 'gte':
+                return `.has(${field}, gte(${p(pred.value)}))`;
+            case 'lt':
+                return `.has(${field}, lt(${p(pred.value)}))`;
+            case 'lte':
+                return `.has(${field}, lte(${p(pred.value)}))`;
+            case 'in':
+                return `.has(${field}, within(${p(pred.value)}))`;
+            case 'notIn':
+                return `.has(${field}, without(${p(pred.value)}))`;
+            case 'isNull':
+                return `.hasNot(${field})`;
+            case 'isNotNull':
+                return `.has(${field})`;
+            case 'startsWith':
+                return `.has(${field}, TextP.startingWith(${p(pred.value)}))`;
+            case 'notStartsWith':
+                return `.has(${field}, TextP.notStartingWith(${p(pred.value)}))`;
+            case 'endsWith':
+                return `.has(${field}, TextP.endingWith(${p(pred.value)}))`;
+            case 'notEndsWith':
+                return `.has(${field}, TextP.notEndingWith(${p(pred.value)}))`;
+            case 'substring':
+            case 'like':
+            case 'iLike':
+                return `.has(${field}, TextP.containing(${p(this.likeText(pred.value))}))`;
+            case 'notSubstring':
+            case 'notLike':
+            case 'notILike':
+                return `.has(${field}, TextP.notContaining(${p(this.likeText(pred.value))}))`;
+            case 'regexp':
+                return `.has(${field}, TextP.regex(${p(pred.value)}))`;
+            case 'notRegexp':
+                return `.has(${field}, TextP.notRegex(${p(pred.value)}))`;
+            case 'between': {
+                const [lo, hi] = Array.isArray(pred.value) ? pred.value : [undefined, undefined];
+                return `.has(${field}, between(${p(lo)}, ${p(hi)}))`;
+            }
+            case 'notBetween': {
+                const [lo, hi] = Array.isArray(pred.value) ? pred.value : [undefined, undefined];
+                return `.has(${field}, outside(${p(lo)}, ${p(hi)}))`;
+            }
+            default:
+                return `.has(${field}, eq(${p(pred.value)}))`;
+        }
+    }
+    /** Strip SQL LIKE wildcards for TextP.containing (which does substring match). */
+    likeText(value) {
+        return String(value).replace(/[%_]/g, '');
+    }
+    filterChain(where, params) {
+        return this.renderPredicate((0, types_1.normalizeWhere)(where), { nodeVar: this.defaultNodeVar, params });
+    }
+    // -------------------------------------------------------------------
+    // Codegen
+    // -------------------------------------------------------------------
+    compileMatch(spec) {
+        const params = new types_1.ParamBag('b');
+        let text = `g.V().hasLabel(${gremlinStr(spec.label)})`;
+        text += this.filterChain(spec.where, params);
+        if (spec.count) {
+            return { text: `${text}.count()`, params: params.params };
+        }
+        const order = spec.order || [];
+        if (order.length) {
+            text += '.order()';
+            for (const [f, d] of order) {
+                text += `.by(${gremlinStr(f)}, ${d === 'DESC' ? 'desc' : 'asc'})`;
+            }
+        }
+        const offset = spec.offset !== undefined && spec.offset !== null ? Number(spec.offset) : 0;
+        const limit = spec.limit !== undefined && spec.limit !== null ? Number(spec.limit) : undefined;
+        if (offset > 0 || limit !== undefined) {
+            const to = limit !== undefined ? offset + limit : -1;
+            text += `.range(${offset}, ${to})`;
+        }
+        if (spec.include && spec.include.length) {
+            const keys = ['self', ...spec.include.map((s) => s.as || s.targetLabel || s.edgeLabel)];
+            text += `.project(${keys.map((k) => gremlinStr(k)).join(', ')})`;
+            text += '.by(elementMap())';
+            for (const step of spec.include) {
+                const stepFn = step.direction === 'in' ? 'in' : step.direction === 'both' ? 'both' : 'out';
+                let by = `__.${stepFn}(${gremlinStr(step.edgeLabel)})`;
+                if (step.targetLabel)
+                    by += `.hasLabel(${gremlinStr(step.targetLabel)})`;
+                by += '.elementMap().fold()';
+                text += `.by(${by})`;
+            }
+        }
+        else {
+            text += '.elementMap()';
+        }
+        return { text, params: params.params };
+    }
+    compileCreateNode(label, data) {
+        const params = new types_1.ParamBag('b');
+        let text = `g.addV(${gremlinStr(label)})`;
+        for (const [k, v] of Object.entries(data)) {
+            if (v === undefined)
+                continue;
+            text += `.property(${gremlinStr(k)}, ${params.add(v)})`;
+        }
+        text += '.elementMap()';
+        return { text, params: params.params };
+    }
+    compileUpdateNodes(label, where, values) {
+        const params = new types_1.ParamBag('b');
+        let text = `g.V().hasLabel(${gremlinStr(label)})`;
+        text += this.filterChain(where, params);
+        for (const [k, v] of Object.entries(values)) {
+            if (v === undefined) {
+                text += `.sideEffect(__.properties(${gremlinStr(k)}).drop())`;
+            }
+            else {
+                text += `.property(single, ${gremlinStr(k)}, ${params.add(v)})`;
+            }
+        }
+        text += '.elementMap()';
+        return { text, params: params.params };
+    }
+    compileDeleteNodes(label, where, _detach) {
+        const params = new types_1.ParamBag('b');
+        let text = `g.V().hasLabel(${gremlinStr(label)})`;
+        text += this.filterChain(where, params);
+        text += '.drop()';
+        return { text, params: params.params };
+    }
+    compileUpsertNode(label, data, conflictKeys) {
+        const params = new types_1.ParamBag('b');
+        const keys = conflictKeys.length ? conflictKeys : ['id'];
+        let match = `g.V().hasLabel(${gremlinStr(label)})`;
+        for (const k of keys) {
+            match += `.has(${gremlinStr(k)}, ${params.add(data[k])})`;
+        }
+        let addV = `__.addV(${gremlinStr(label)})`;
+        for (const k of keys) {
+            addV += `.property(${gremlinStr(k)}, ${params.add(data[k])})`;
+        }
+        let text = `${match}.fold().coalesce(__.unfold(), ${addV})`;
+        for (const [k, v] of Object.entries(data)) {
+            if (v === undefined || keys.includes(k))
+                continue;
+            text += `.property(single, ${gremlinStr(k)}, ${params.add(v)})`;
+        }
+        text += '.elementMap()';
+        return { text, params: params.params };
+    }
+    compileIncrement(label, fields, where, by) {
+        const params = new types_1.ParamBag('b');
+        let text = `g.V().hasLabel(${gremlinStr(label)})`;
+        text += this.filterChain(where, params);
+        const map = typeof fields === 'string'
+            ? { [fields]: by }
+            : Array.isArray(fields)
+                ? Object.fromEntries(fields.map((f) => [f, by]))
+                : fields;
+        for (const [f, amt] of Object.entries(map)) {
+            text += `.property(single, ${gremlinStr(f)}, __.coalesce(__.values(${gremlinStr(f)}), __.constant(0)).math('_ + ${Number(amt)}'))`;
+        }
+        text += '.elementMap()';
+        return { text, params: params.params };
+    }
+    compileCreateEdge(spec) {
+        const params = new types_1.ParamBag('b');
+        let text = `g.V().hasLabel(${gremlinStr(spec.fromLabel)})`;
+        text += this.filterChain(spec.fromWhere, params);
+        text += `.as('a').V().hasLabel(${gremlinStr(spec.toLabel)})`;
+        text += this.filterChain(spec.toWhere, params);
+        text += `.addE(${gremlinStr(spec.edgeLabel)}).from('a')`;
+        if (spec.props) {
+            for (const [k, v] of Object.entries(spec.props)) {
+                if (v === undefined)
+                    continue;
+                text += `.property(${gremlinStr(k)}, ${params.add(v)})`;
+            }
+        }
+        text += '.elementMap()';
+        return { text, params: params.params };
+    }
+    compileTraverse(spec) {
+        const params = new types_1.ParamBag('b');
+        let text = `g.V().hasLabel(${gremlinStr(spec.label)})`;
+        text += this.filterChain(spec.where, params);
+        const stepFn = spec.direction === 'in' ? 'in' : spec.direction === 'both' ? 'both' : 'out';
+        const edgeArg = spec.edgeLabel ? gremlinStr(spec.edgeLabel) : '';
+        const min = spec.minDepth ?? 1;
+        const max = spec.maxDepth ?? 1;
+        if (min === 1 && max === 1) {
+            text += `.${stepFn}(${edgeArg})`;
+        }
+        else {
+            text += `.repeat(__.${stepFn}(${edgeArg})).times(${max})`;
+            if (min <= 1)
+                text += '.emit()';
+        }
+        if (spec.targetLabel)
+            text += `.hasLabel(${gremlinStr(spec.targetLabel)})`;
+        text += this.filterChain(spec.targetWhere, params);
+        text += '.dedup()';
+        if (spec.limit !== undefined)
+            text += `.limit(${Number(spec.limit)})`;
+        text += '.elementMap()';
+        return { text, params: params.params };
+    }
+    // TinkerPop has no portable schema DDL — compile to a harmless no-op.
+    compileCreateConstraint(_label, _fields, _kind, _name) {
+        return { text: 'g.inject(true)', params: {} };
+    }
+    compileDropConstraint(_label, _name) {
+        return { text: 'g.inject(true)', params: {} };
+    }
+    compileCreateIndex(_label, _fields, _name) {
+        return { text: 'g.inject(true)', params: {} };
+    }
+    compileDropIndex(_label, _name) {
+        return { text: 'g.inject(true)', params: {} };
+    }
+    compileShowLabels() {
+        return { text: 'g.V().label().dedup()', params: {} };
+    }
+}
+exports.GremlinGraphDialect = GremlinGraphDialect;
+exports.default = GremlinGraphDialect;

package/dist/graph/index.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Graph / object-database dialects for the ORM.
+ *
+ * Unlike the NoSQL stores (src/nosql/**), which each expose their engine's
+ * own native API surface, these graph dialects implement the same SQL-shaped
+ * `Dialect` contract used by the SQL dialects — so the ORM's `Model` builder
+ * API (create/find/update/destroy, `where` operators, associations,
+ * `include`) drives graph databases directly, generating Cypher / Gremlin /
+ * DQL under the hood. Users never hand-write graph queries for standard
+ * operations.
+ *
+ *   - {@link Neo4jGraphDialect}   -> Cypher (MATCH/CREATE/MERGE/SET/DELETE)
+ *   - {@link GremlinGraphDialect} -> Apache TinkerPop / Amazon Neptune Gremlin
+ *   - {@link DgraphGraphDialect}  -> Dgraph DQL + JSON mutations
+ *
+ * Associations map to graph edges (`hasMany`/`hasOne` -> outbound edge,
+ * `belongsTo` -> inbound edge), and `include`/traversal becomes a graph walk.
+ * Genuinely relational-only features (partitions, materialized views, RLS,
+ * stored procedures, foreign-data wrappers, arbitrary SQL joins) throw a
+ * typed {@link GraphCapabilityError}.
+ */
+import { Neo4jGraphDialect } from './neo4j';
+import { GremlinGraphDialect } from './gremlin';
+import { DgraphGraphDialect } from './dgraph';
+export { BaseGraphDialect } from './base-graph-dialect';
+export type { WhereRenderContext, EdgeCreateSpec, NodeConstraintKind, } from './base-graph-dialect';
+export { Neo4jGraphDialect } from './neo4j';
+export { GremlinGraphDialect } from './gremlin';
+export { DgraphGraphDialect } from './dgraph';
+export { GraphCapabilityError, ParamBag, normalizeWhere, deriveAssociationEdge, defaultEdgeLabel, safeIdent, } from './types';
+export type { GraphConnectionOptions, GraphStatement, GraphPredicate, CanonOp, GraphAssociationType, GraphAssociationSpec, GraphPropertyDefinition, NodeModelDefinition, EdgeModelDefinition, GraphTraversalDirection, GraphTraversalStep, GraphTraversalSpec, NodeMatchSpec, } from './types';
+/** The graph dialects keyed by the name they should register under. */
+export declare const GRAPH_DIALECTS: {
+    readonly neo4j: typeof Neo4jGraphDialect;
+    readonly gremlin: typeof GremlinGraphDialect;
+    readonly neptune: typeof GremlinGraphDialect;
+    readonly dgraph: typeof DgraphGraphDialect;
+};
+/**
+ * Minimal shape of the ORM's dialect registry (from
+ * `src/dialects/dialect.ts` — `DialectRegistry`). Declared locally so this
+ * module doesn't import/modify the shared registry; the caller passes the
+ * real `DialectRegistry` in.
+ */
+export interface DialectRegistryLike {
+    register(name: string, factory: new (options: any) => any): void;
+}
+/**
+ * Register all graph dialects into the ORM's `DialectRegistry`.
+ *
+ * Wiring (one line, added by whoever owns the registry/bootstrap — NOT done
+ * here to avoid editing shared files):
+ *
+ * ```ts
+ * import { DialectRegistry } from './dialects/dialect';
+ * import { registerGraphDialects } from './graph';
+ * registerGraphDialects(DialectRegistry);
+ * ```
+ */
+export declare function registerGraphDialects(registry: DialectRegistryLike): void;

package/dist/graph/index.js

@@ -0,0 +1,67 @@
+"use strict";
+/**
+ * Graph / object-database dialects for the ORM.
+ *
+ * Unlike the NoSQL stores (src/nosql/**), which each expose their engine's
+ * own native API surface, these graph dialects implement the same SQL-shaped
+ * `Dialect` contract used by the SQL dialects — so the ORM's `Model` builder
+ * API (create/find/update/destroy, `where` operators, associations,
+ * `include`) drives graph databases directly, generating Cypher / Gremlin /
+ * DQL under the hood. Users never hand-write graph queries for standard
+ * operations.
+ *
+ *   - {@link Neo4jGraphDialect}   -> Cypher (MATCH/CREATE/MERGE/SET/DELETE)
+ *   - {@link GremlinGraphDialect} -> Apache TinkerPop / Amazon Neptune Gremlin
+ *   - {@link DgraphGraphDialect}  -> Dgraph DQL + JSON mutations
+ *
+ * Associations map to graph edges (`hasMany`/`hasOne` -> outbound edge,
+ * `belongsTo` -> inbound edge), and `include`/traversal becomes a graph walk.
+ * Genuinely relational-only features (partitions, materialized views, RLS,
+ * stored procedures, foreign-data wrappers, arbitrary SQL joins) throw a
+ * typed {@link GraphCapabilityError}.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GRAPH_DIALECTS = exports.safeIdent = exports.defaultEdgeLabel = exports.deriveAssociationEdge = exports.normalizeWhere = exports.ParamBag = exports.GraphCapabilityError = exports.DgraphGraphDialect = exports.GremlinGraphDialect = exports.Neo4jGraphDialect = exports.BaseGraphDialect = void 0;
+exports.registerGraphDialects = registerGraphDialects;
+const neo4j_1 = require("./neo4j");
+const gremlin_1 = require("./gremlin");
+const dgraph_1 = require("./dgraph");
+var base_graph_dialect_1 = require("./base-graph-dialect");
+Object.defineProperty(exports, "BaseGraphDialect", { enumerable: true, get: function () { return base_graph_dialect_1.BaseGraphDialect; } });
+var neo4j_2 = require("./neo4j");
+Object.defineProperty(exports, "Neo4jGraphDialect", { enumerable: true, get: function () { return neo4j_2.Neo4jGraphDialect; } });
+var gremlin_2 = require("./gremlin");
+Object.defineProperty(exports, "GremlinGraphDialect", { enumerable: true, get: function () { return gremlin_2.GremlinGraphDialect; } });
+var dgraph_2 = require("./dgraph");
+Object.defineProperty(exports, "DgraphGraphDialect", { enumerable: true, get: function () { return dgraph_2.DgraphGraphDialect; } });
+var types_1 = require("./types");
+Object.defineProperty(exports, "GraphCapabilityError", { enumerable: true, get: function () { return types_1.GraphCapabilityError; } });
+Object.defineProperty(exports, "ParamBag", { enumerable: true, get: function () { return types_1.ParamBag; } });
+Object.defineProperty(exports, "normalizeWhere", { enumerable: true, get: function () { return types_1.normalizeWhere; } });
+Object.defineProperty(exports, "deriveAssociationEdge", { enumerable: true, get: function () { return types_1.deriveAssociationEdge; } });
+Object.defineProperty(exports, "defaultEdgeLabel", { enumerable: true, get: function () { return types_1.defaultEdgeLabel; } });
+Object.defineProperty(exports, "safeIdent", { enumerable: true, get: function () { return types_1.safeIdent; } });
+/** The graph dialects keyed by the name they should register under. */
+exports.GRAPH_DIALECTS = {
+    neo4j: neo4j_1.Neo4jGraphDialect,
+    gremlin: gremlin_1.GremlinGraphDialect,
+    neptune: gremlin_1.GremlinGraphDialect, // Amazon Neptune speaks Gremlin
+    dgraph: dgraph_1.DgraphGraphDialect,
+};
+/**
+ * Register all graph dialects into the ORM's `DialectRegistry`.
+ *
+ * Wiring (one line, added by whoever owns the registry/bootstrap — NOT done
+ * here to avoid editing shared files):
+ *
+ * ```ts
+ * import { DialectRegistry } from './dialects/dialect';
+ * import { registerGraphDialects } from './graph';
+ * registerGraphDialects(DialectRegistry);
+ * ```
+ */
+function registerGraphDialects(registry) {
+    for (const [name, factory] of Object.entries(exports.GRAPH_DIALECTS)) {
+        registry.register(name, factory);
+    }
+}

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

@@ -0,0 +1,50 @@
+/**
+ * Neo4j graph dialect — Cypher generation for the ORM builder API.
+ *
+ * Maps the ORM model API onto Cypher: node labels for tables, `MATCH`/
+ * `CREATE`/`MERGE`/`SET`/`DELETE` for CRUD, relationships for associations,
+ * and variable-length patterns for traversals. Everything is parameterized
+ * (`$p0`, `$props`, ...). Users never hand-write Cypher for standard
+ * operations.
+ *
+ * The `neo4j-driver` package is loaded lazily so importing this module never
+ * forces the optional dependency; a pre-built driver can be injected via
+ * `options.client` for tests/connection reuse.
+ */
+import { Transaction } from '../../types';
+import type { QueryOptions, QueryResult, TransactionOptions } from '../../types';
+import { BaseGraphDialect, type EdgeCreateSpec, type NodeConstraintKind, type WhereRenderContext } from '../base-graph-dialect';
+import { type GraphConnectionOptions, type GraphPredicate, type GraphStatement, type GraphTraversalSpec, type NodeMatchSpec } from '../types';
+export declare class Neo4jGraphDialect extends BaseGraphDialect {
+    readonly name = "neo4j";
+    readonly library = "neo4j-driver";
+    private driver;
+    private readonly txns;
+    constructor(options?: GraphConnectionOptions);
+    protected get defaultNodeVar(): string;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    private requireDriver;
+    query(statement: string, options?: QueryOptions): Promise<QueryResult>;
+    getDatabaseVersion(): Promise<string>;
+    startTransaction(options?: TransactionOptions): Promise<Transaction>;
+    commitTransaction(transaction: Transaction): Promise<void>;
+    rollbackTransaction(transaction: Transaction): Promise<void>;
+    renderPredicate(pred: GraphPredicate, ctx: WhereRenderContext): string;
+    private renderComparison;
+    private where;
+    compileMatch(spec: NodeMatchSpec): GraphStatement;
+    compileCreateNode(label: string, data: Record<string, unknown>): GraphStatement;
+    compileUpdateNodes(label: string, where: import('../../types').WhereOptions | undefined, values: Record<string, unknown>): GraphStatement;
+    compileDeleteNodes(label: string, where: import('../../types').WhereOptions | undefined, detach: boolean): GraphStatement;
+    compileUpsertNode(label: string, data: Record<string, unknown>, conflictKeys: string[]): GraphStatement;
+    compileIncrement(label: string, fields: string | string[] | Record<string, number>, where: import('../../types').WhereOptions | undefined, by: number): GraphStatement;
+    compileCreateEdge(spec: EdgeCreateSpec): GraphStatement;
+    compileTraverse(spec: GraphTraversalSpec): GraphStatement;
+    compileCreateConstraint(label: string, fields: string[], kind: NodeConstraintKind, name?: string): GraphStatement;
+    compileDropConstraint(_label: string, name: string): GraphStatement;
+    compileCreateIndex(label: string, fields: string[], name?: string): GraphStatement;
+    compileDropIndex(_label: string, name: string): GraphStatement;
+    compileShowLabels(): GraphStatement;
+}
+export default Neo4jGraphDialect;