ts-prorm-orm 1.1.0 → 1.2.0

package/dist/graph/dgraph/index.js

@@ -0,0 +1,559 @@
+"use strict";
+/**
+ * Dgraph graph dialect — DQL (GraphQL+-) queries + JSON mutations for the
+ * ORM builder API.
+ *
+ * Maps the ORM model API onto Dgraph's uid/predicate/edge model: node labels
+ * become `dgraph.type` values, finds become DQL `func: type(...)` blocks with
+ * `@filter(...)` and `expand(_all_)`, associations become edge predicates
+ * (reverse edges via `~pred` for inbound), and writes become JSON
+ * set/delete mutations (upserts resolve uids first, then mutate). Reads are
+ * parameterized with typed DQL vars (`$p0`); mutations carry structured JSON
+ * data (no string interpolation). Users never hand-write DQL/GraphQL for
+ * standard operations.
+ *
+ * Built on the optional `dgraph-js` gRPC driver, loaded lazily; a pre-built
+ * client can be injected via `options.client`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DgraphGraphDialect = void 0;
+const index_1 = require("../../errors/index");
+const types_1 = require("../../types");
+const base_graph_dialect_1 = require("../base-graph-dialect");
+const types_2 = require("../types");
+const MUT_PREFIX = '#DGRAPH-MUTATE#';
+function dqlString(value) {
+    return JSON.stringify(String(value));
+}
+function dqlLiteral(value) {
+    if (value === null || value === undefined)
+        return '""';
+    if (typeof value === 'number' || typeof value === 'boolean')
+        return String(value);
+    return dqlString(value);
+}
+function dqlType(value) {
+    if (typeof value === 'number')
+        return Number.isInteger(value) ? 'int' : 'float';
+    if (typeof value === 'boolean')
+        return 'bool';
+    return 'string';
+}
+function regexBody(value) {
+    return String(value).replace(/\//g, '\\/');
+}
+function likeToRegexBody(value) {
+    // Escape regex metacharacters AND the `/` delimiter — the result is embedded
+    // as `/${body}/` in DQL, so an unescaped `/` in a user value breaks out of the
+    // regex literal (query injection). Include `/` in the class.
+    const escaped = String(value).replace(/[.*+?^${}()|[\]\\/]/g, '\\$&');
+    return escaped.replace(/%/g, '.*').replace(/_/g, '.');
+}
+class DgraphGraphDialect extends base_graph_dialect_1.BaseGraphDialect {
+    constructor(options = {}) {
+        super(options);
+        this.name = 'dgraph';
+        this.library = 'dgraph-js';
+        this.client = null;
+        this.stub = null;
+        this.activeTxns = new Map();
+        this.currentTxnId = null;
+        this.dialectName = 'dgraph';
+    }
+    get defaultNodeVar() {
+        return 'node';
+    }
+    // -------------------------------------------------------------------
+    // 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 dgraph = require('dgraph-js');
+                const address = this.options.url || `${this.options.host || 'localhost'}:${this.options.port || 9080}`;
+                this.stub = new dgraph.DgraphClientStub(address);
+                client = new dgraph.DgraphClient(this.stub);
+            }
+            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 Dgraph', {
+                parent: error instanceof Error ? error : undefined,
+                database: this.options.database,
+            });
+        }
+    }
+    async disconnect() {
+        const stub = this.stub;
+        this.client = null;
+        this.stub = null;
+        this._connection = null;
+        this._connected = false;
+        this.activeTxns.clear();
+        this.currentTxnId = null;
+        if (stub && typeof stub.close === 'function') {
+            stub.close();
+        }
+    }
+    requireClient() {
+        if (!this.client || !this._connected) {
+            throw new index_1.ConnectionError('DgraphGraphDialect is not connected. Call connect() first.', {
+                database: this.options.database,
+            });
+        }
+        return this.client;
+    }
+    async query(statement, options) {
+        if (statement.startsWith(MUT_PREFIX)) {
+            return this.runMutation(JSON.parse(statement.slice(MUT_PREFIX.length)));
+        }
+        const client = this.requireClient();
+        const vars = this.toStringVars(options?.bind);
+        const active = this.currentTxn();
+        const txn = active || client.newTxn();
+        try {
+            const res = await txn.queryWithVars(statement, vars);
+            const data = JSON.parse(res.getJson());
+            const rows = this.extractRows(data);
+            return { rows, rowCount: rows.length, fields: [] };
+        }
+        catch (error) {
+            throw new index_1.DatabaseError('Dgraph query failed', {
+                code: 'QUERY_ERROR',
+                parent: error instanceof Error ? error : undefined,
+                original: error instanceof Error ? error.message : String(error),
+                sql: statement,
+            });
+        }
+        finally {
+            if (!active)
+                await txn.discard();
+        }
+    }
+    extractRows(data) {
+        if (!data || typeof data !== 'object')
+            return [];
+        const first = data.result ?? Object.values(data)[0];
+        if (Array.isArray(first))
+            return first;
+        return first ? [first] : [];
+    }
+    toStringVars(bind) {
+        const out = {};
+        for (const [k, v] of Object.entries(bind || {})) {
+            out[`$${k}`] = v === null || v === undefined ? '' : String(v);
+        }
+        return out;
+    }
+    async getDatabaseVersion() {
+        return 'unknown';
+    }
+    // -------------------------------------------------------------------
+    // Transactions
+    // -------------------------------------------------------------------
+    currentTxn() {
+        return this.currentTxnId ? this.activeTxns.get(this.currentTxnId) : null;
+    }
+    async startTransaction(options) {
+        const client = this.requireClient();
+        const txn = client.newTxn();
+        const transaction = new types_1.Transaction(options);
+        this.activeTxns.set(transaction.id, txn);
+        this.currentTxnId = transaction.id;
+        return transaction;
+    }
+    async commitTransaction(transaction) {
+        const txn = this.activeTxns.get(transaction.id);
+        if (!txn)
+            return;
+        try {
+            if (typeof txn.commit === 'function')
+                await txn.commit();
+        }
+        finally {
+            await txn.discard();
+            this.activeTxns.delete(transaction.id);
+            if (this.currentTxnId === transaction.id)
+                this.currentTxnId = null;
+        }
+    }
+    async rollbackTransaction(transaction) {
+        const txn = this.activeTxns.get(transaction.id);
+        if (!txn)
+            return;
+        try {
+            await txn.discard();
+        }
+        finally {
+            this.activeTxns.delete(transaction.id);
+            if (this.currentTxnId === transaction.id)
+                this.currentTxnId = null;
+        }
+    }
+    // -------------------------------------------------------------------
+    // Mutation execution (upserts resolve uids first, then mutate).
+    // -------------------------------------------------------------------
+    async mutate(mutation) {
+        const active = this.currentTxn();
+        const txn = active || this.requireClient().newTxn();
+        try {
+            return await txn.mutate({ ...mutation, commitNow: !active });
+        }
+        finally {
+            if (!active)
+                await txn.discard();
+        }
+    }
+    async resolveData(query) {
+        const client = this.requireClient();
+        const active = this.currentTxn();
+        const txn = active || client.newTxn();
+        try {
+            const res = await txn.queryWithVars(query, {});
+            return JSON.parse(res.getJson());
+        }
+        finally {
+            if (!active)
+                await txn.discard();
+        }
+    }
+    async resolveRows(query) {
+        const data = await this.resolveData(query);
+        return Array.isArray(data.q) ? data.q : [];
+    }
+    async runMutation(desc) {
+        switch (desc.op) {
+            case 'set': {
+                await this.mutate({ setJson: desc.set });
+                return { rows: desc.set || [], rowCount: (desc.set || []).length, fields: [] };
+            }
+            case 'delete': {
+                const rows = await this.resolveRows(desc.query);
+                const nodes = rows.map((r) => ({ uid: r.uid }));
+                if (nodes.length)
+                    await this.mutate({ deleteJson: nodes });
+                return { rows: nodes, rowCount: nodes.length, fields: [] };
+            }
+            case 'update': {
+                const rows = await this.resolveRows(desc.query);
+                const setNodes = rows.map((r) => ({ uid: r.uid, ...desc.set }));
+                const delNodes = [];
+                for (const r of rows) {
+                    for (const f of desc.remove || [])
+                        delNodes.push({ uid: r.uid, [f]: null });
+                }
+                if (setNodes.length && Object.keys(desc.set || {}).length) {
+                    await this.mutate({ setJson: setNodes });
+                }
+                if (delNodes.length)
+                    await this.mutate({ deleteJson: delNodes });
+                return { rows: setNodes, rowCount: setNodes.length, fields: [] };
+            }
+            case 'upsert': {
+                const rows = await this.resolveRows(desc.query);
+                const nodes = rows.length
+                    ? rows.map((r) => ({ uid: r.uid, ...desc.data }))
+                    : [{ ...desc.data }];
+                await this.mutate({ setJson: nodes });
+                return { rows: nodes, rowCount: nodes.length, fields: [] };
+            }
+            case 'increment': {
+                const rows = await this.resolveRows(desc.query);
+                const nodes = rows.map((r) => {
+                    const node = { uid: r.uid };
+                    for (const [f, amt] of Object.entries(desc.increments)) {
+                        node[f] = (Number(r[f]) || 0) + Number(amt);
+                    }
+                    return node;
+                });
+                if (nodes.length)
+                    await this.mutate({ setJson: nodes });
+                return { rows: nodes, rowCount: nodes.length, fields: [] };
+            }
+            case 'edge': {
+                const data = await this.resolveData(desc.query);
+                const froms = Array.isArray(data.from) ? data.from : [];
+                const tos = Array.isArray(data.to) ? data.to : [];
+                const nodes = froms.map((f) => ({
+                    uid: f.uid,
+                    [desc.edge]: tos.map((t) => ({ uid: t.uid, ...(desc.props || {}) })),
+                }));
+                if (nodes.length && tos.length)
+                    await this.mutate({ setJson: nodes });
+                return { rows: nodes, rowCount: nodes.length, fields: [] };
+            }
+            case 'alter': {
+                await this.requireClient().alter({ schema: desc.schema });
+                return { rows: [], rowCount: 0, fields: [] };
+            }
+            case 'noop':
+            default:
+                return { rows: [], rowCount: 0, fields: [] };
+        }
+    }
+    // -------------------------------------------------------------------
+    // Predicate rendering -> DQL @filter expression.
+    // -------------------------------------------------------------------
+    renderPredicate(pred, ctx) {
+        return this.renderDql(pred, ctx.params);
+    }
+    /** Render a predicate; with `params` uses typed DQL vars, else inlines literals. */
+    renderDql(pred, params) {
+        switch (pred.kind) {
+            case 'true':
+                return '';
+            case 'and': {
+                const parts = pred.items.map((p) => this.renderDql(p, params)).filter((s) => s);
+                return parts.length > 1 ? `(${parts.join(' AND ')})` : parts[0] || '';
+            }
+            case 'or': {
+                const parts = pred.items.map((p) => this.renderDql(p, params)).filter((s) => s);
+                return parts.length > 1 ? `(${parts.join(' OR ')})` : parts[0] || '';
+            }
+            case 'not':
+                return `NOT (${this.renderDql(pred.item, params)})`;
+            case 'cmp':
+                return this.renderComparison(pred, params);
+        }
+    }
+    renderComparison(pred, params) {
+        const field = (0, types_2.safeIdent)(pred.field);
+        const ref = (v) => (params ? `$${params.add(v)}` : dqlLiteral(v));
+        switch (pred.op) {
+            case 'eq':
+                return `eq(${field}, ${ref(pred.value)})`;
+            case 'ne':
+                return `NOT eq(${field}, ${ref(pred.value)})`;
+            case 'gt':
+                return `gt(${field}, ${ref(pred.value)})`;
+            case 'gte':
+                return `ge(${field}, ${ref(pred.value)})`;
+            case 'lt':
+                return `lt(${field}, ${ref(pred.value)})`;
+            case 'lte':
+                return `le(${field}, ${ref(pred.value)})`;
+            case 'in': {
+                const arr = Array.isArray(pred.value) ? pred.value : [pred.value];
+                return `eq(${field}, [${arr.map(dqlLiteral).join(', ')}])`;
+            }
+            case 'notIn': {
+                const arr = Array.isArray(pred.value) ? pred.value : [pred.value];
+                return `NOT eq(${field}, [${arr.map(dqlLiteral).join(', ')}])`;
+            }
+            case 'isNull':
+                return `NOT has(${field})`;
+            case 'isNotNull':
+                return `has(${field})`;
+            case 'like':
+            case 'notLike': {
+                const expr = `regexp(${field}, /${likeToRegexBody(pred.value)}/)`;
+                return pred.op === 'notLike' ? `NOT ${expr}` : expr;
+            }
+            case 'iLike':
+            case 'notILike': {
+                const expr = `regexp(${field}, /${likeToRegexBody(pred.value)}/i)`;
+                return pred.op === 'notILike' ? `NOT ${expr}` : expr;
+            }
+            case 'startsWith':
+                return `regexp(${field}, /^${likeToRegexBody(pred.value)}/)`;
+            case 'notStartsWith':
+                return `NOT regexp(${field}, /^${likeToRegexBody(pred.value)}/)`;
+            case 'endsWith':
+                return `regexp(${field}, /${likeToRegexBody(pred.value)}$/)`;
+            case 'notEndsWith':
+                return `NOT regexp(${field}, /${likeToRegexBody(pred.value)}$/)`;
+            case 'substring':
+                return `regexp(${field}, /${likeToRegexBody(pred.value)}/)`;
+            case 'notSubstring':
+                return `NOT regexp(${field}, /${likeToRegexBody(pred.value)}/)`;
+            case 'regexp':
+                return `regexp(${field}, /${regexBody(pred.value)}/)`;
+            case 'notRegexp':
+                return `NOT regexp(${field}, /${regexBody(pred.value)}/)`;
+            case 'between': {
+                const [lo, hi] = Array.isArray(pred.value) ? pred.value : [undefined, undefined];
+                return `(ge(${field}, ${ref(lo)}) AND le(${field}, ${ref(hi)}))`;
+            }
+            case 'notBetween': {
+                const [lo, hi] = Array.isArray(pred.value) ? pred.value : [undefined, undefined];
+                return `(lt(${field}, ${ref(lo)}) OR gt(${field}, ${ref(hi)}))`;
+            }
+            default:
+                return `eq(${field}, ${ref(pred.value)})`;
+        }
+    }
+    varDefs(params) {
+        const defs = Object.entries(params.params).map(([name, value]) => `$${name}: ${dqlType(value)}`);
+        return defs.join(', ');
+    }
+    // -------------------------------------------------------------------
+    // Codegen
+    // -------------------------------------------------------------------
+    compileMatch(spec) {
+        const params = new types_2.ParamBag('p');
+        const label = (0, types_2.safeIdent)(spec.label);
+        const filter = this.renderDql((0, types_2.normalizeWhere)(spec.where), params);
+        const funcArgs = [`func: type(${label})`];
+        const order = spec.order || [];
+        if (order.length) {
+            const [f, d] = order[0];
+            funcArgs.push(`${d === 'DESC' ? 'orderdesc' : 'orderasc'}: ${(0, types_2.safeIdent)(f)}`);
+        }
+        if (spec.limit !== undefined && spec.limit !== null && String(spec.limit) !== '') {
+            funcArgs.push(`first: ${Number(spec.limit)}`);
+        }
+        if (spec.offset !== undefined && spec.offset !== null && String(spec.offset) !== '') {
+            funcArgs.push(`offset: ${Number(spec.offset)}`);
+        }
+        let inner;
+        if (spec.count) {
+            inner = 'count(uid)';
+        }
+        else {
+            const attrs = Array.isArray(spec.attributes) ? spec.attributes : undefined;
+            const props = attrs && attrs.length ? attrs.map((a) => (0, types_2.safeIdent)(a)).join('\n    ') : 'expand(_all_)';
+            const includeBlocks = (spec.include || [])
+                .map((step) => {
+                const pred = step.direction === 'in' ? `~${(0, types_2.safeIdent)(step.edgeLabel)}` : (0, types_2.safeIdent)(step.edgeLabel);
+                const alias = (0, types_2.safeIdent)(step.as || step.targetLabel || step.edgeLabel);
+                const stepFilter = this.renderDql((0, types_2.normalizeWhere)(step.where), params);
+                const filterClause = stepFilter ? ` @filter(${stepFilter})` : '';
+                return `${alias}: ${pred}${filterClause} {\n      uid\n      expand(_all_)\n    }`;
+            })
+                .join('\n    ');
+            inner = `uid\n    dgraph.type\n    ${props}${includeBlocks ? '\n    ' + includeBlocks : ''}`;
+        }
+        const filterClause = filter ? ` @filter(${filter})` : '';
+        const defs = this.varDefs(params);
+        const header = defs ? `query find(${defs})` : 'query find';
+        const text = `${header} {\n  result(${funcArgs.join(', ')})${filterClause} {\n    ${inner}\n  }\n}`;
+        return { text, params: params.params };
+    }
+    compileCreateNode(label, data) {
+        const node = { uid: '_:new', 'dgraph.type': (0, types_2.safeIdent)(label) };
+        for (const [k, v] of Object.entries(data)) {
+            if (v !== undefined)
+                node[k] = v;
+        }
+        return { text: MUT_PREFIX + JSON.stringify({ op: 'set', set: [node] }), params: {} };
+    }
+    compileUpdateNodes(label, where, values) {
+        const query = this.uidQuery(label, where);
+        const set = {};
+        const remove = [];
+        for (const [k, v] of Object.entries(values)) {
+            if (v === undefined)
+                remove.push((0, types_2.safeIdent)(k));
+            else
+                set[k] = v;
+        }
+        return {
+            text: MUT_PREFIX + JSON.stringify({ op: 'update', query, set, remove }),
+            params: {},
+        };
+    }
+    compileDeleteNodes(label, where, _detach) {
+        return {
+            text: MUT_PREFIX + JSON.stringify({ op: 'delete', query: this.uidQuery(label, where) }),
+            params: {},
+        };
+    }
+    compileUpsertNode(label, data, conflictKeys) {
+        const keys = conflictKeys.length ? conflictKeys : ['id'];
+        const preds = keys.map((k) => `eq(${(0, types_2.safeIdent)(k)}, ${dqlLiteral(data[k])})`);
+        const query = `{ q(func: type(${(0, types_2.safeIdent)(label)})) @filter(${preds.join(' AND ')}) { uid } }`;
+        const node = { 'dgraph.type': (0, types_2.safeIdent)(label) };
+        for (const [k, v] of Object.entries(data)) {
+            if (v !== undefined)
+                node[k] = v;
+        }
+        return { text: MUT_PREFIX + JSON.stringify({ op: 'upsert', query, data: node }), params: {} };
+    }
+    compileIncrement(label, fields, where, by) {
+        const map = typeof fields === 'string'
+            ? { [fields]: by }
+            : Array.isArray(fields)
+                ? Object.fromEntries(fields.map((f) => [f, by]))
+                : fields;
+        const selectFields = Object.keys(map).map((f) => (0, types_2.safeIdent)(f)).join('\n    ');
+        const filter = this.renderDql((0, types_2.normalizeWhere)(where));
+        const filterClause = filter ? ` @filter(${filter})` : '';
+        const query = `{ q(func: type(${(0, types_2.safeIdent)(label)}))${filterClause} {\n    uid\n    ${selectFields}\n  } }`;
+        return {
+            text: MUT_PREFIX + JSON.stringify({ op: 'increment', query, increments: map }),
+            params: {},
+        };
+    }
+    compileCreateEdge(spec) {
+        // Resolve both endpoints, then connect the source to the target via the
+        // edge predicate (a facet-less uid link). Reverse lookups are handled by
+        // Dgraph's `~pred` at query time.
+        const fromFilter = this.renderDql((0, types_2.normalizeWhere)(spec.fromWhere));
+        const toFilter = this.renderDql((0, types_2.normalizeWhere)(spec.toWhere));
+        const query = `{ ` +
+            `from(func: type(${(0, types_2.safeIdent)(spec.fromLabel)}))${fromFilter ? ` @filter(${fromFilter})` : ''} { uid } ` +
+            `to(func: type(${(0, types_2.safeIdent)(spec.toLabel)}))${toFilter ? ` @filter(${toFilter})` : ''} { uid } ` +
+            `}`;
+        return {
+            text: MUT_PREFIX +
+                JSON.stringify({ op: 'edge', query, edge: (0, types_2.safeIdent)(spec.edgeLabel), props: spec.props || {} }),
+            params: {},
+        };
+    }
+    compileTraverse(spec) {
+        const params = new types_2.ParamBag('p');
+        const label = (0, types_2.safeIdent)(spec.label);
+        const startFilter = this.renderDql((0, types_2.normalizeWhere)(spec.where), params);
+        const pred = spec.direction === 'in' ? `~${(0, types_2.safeIdent)(spec.edgeLabel || 'edge')}` : (0, types_2.safeIdent)(spec.edgeLabel || 'edge');
+        const targetFilter = this.renderDql((0, types_2.normalizeWhere)(spec.targetWhere), params);
+        const targetFilterClause = targetFilter ? ` @filter(${targetFilter})` : '';
+        const first = spec.limit !== undefined ? `, first: ${Number(spec.limit)}` : '';
+        const defs = this.varDefs(params);
+        const header = defs ? `query traverse(${defs})` : 'query traverse';
+        const startClause = startFilter ? ` @filter(${startFilter})` : '';
+        const text = `${header} {\n` +
+            `  result(func: type(${label})${first})${startClause} {\n` +
+            `    uid\n` +
+            `    ${pred}${targetFilterClause} {\n      uid\n      expand(_all_)\n    }\n` +
+            `  }\n}`;
+        return { text, params: params.params };
+    }
+    uidQuery(label, where) {
+        const filter = this.renderDql((0, types_2.normalizeWhere)(where));
+        const filterClause = filter ? ` @filter(${filter})` : '';
+        return `{ q(func: type(${(0, types_2.safeIdent)(label)}))${filterClause} { uid } }`;
+    }
+    // Dgraph schema (types/predicate indexes) is managed via the `alter` API.
+    compileCreateConstraint(label, fields, _kind, _name) {
+        // Model a uniqueness/index hint as a predicate index alteration.
+        const schema = fields.map((f) => `${(0, types_2.safeIdent)(f)}: string @index(exact) .`).join('\n');
+        return {
+            text: MUT_PREFIX + JSON.stringify({ op: 'alter', schema, label: (0, types_2.safeIdent)(label) }),
+            params: {},
+        };
+    }
+    compileDropConstraint(_label, _name) {
+        return { text: MUT_PREFIX + JSON.stringify({ op: 'noop' }), params: {} };
+    }
+    compileCreateIndex(_label, fields, _name) {
+        const schema = fields.map((f) => `${(0, types_2.safeIdent)(f)}: string @index(term) .`).join('\n');
+        return { text: MUT_PREFIX + JSON.stringify({ op: 'alter', schema }), params: {} };
+    }
+    compileDropIndex(_label, _name) {
+        return { text: MUT_PREFIX + JSON.stringify({ op: 'noop' }), params: {} };
+    }
+    compileShowLabels() {
+        return { text: 'query labels { result(func: has(dgraph.type)) { dgraph.type } }', params: {} };
+    }
+}
+exports.DgraphGraphDialect = DgraphGraphDialect;
+exports.default = DgraphGraphDialect;

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

@@ -0,0 +1,59 @@
+/**
+ * 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}.
+ */
+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 GremlinGraphDialect extends BaseGraphDialect {
+    readonly name = "gremlin";
+    readonly library = "gremlin";
+    private client;
+    constructor(options?: GraphConnectionOptions);
+    protected get defaultNodeVar(): string;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    private requireClient;
+    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;
+    /** Strip SQL LIKE wildcards for TextP.containing (which does substring match). */
+    private likeText;
+    private filterChain;
+    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 GremlinGraphDialect;