ts-prorm-orm 1.1.0 → 1.2.1

package/dist/external-fields/runtime.js

@@ -0,0 +1,221 @@
+"use strict";
+/**
+ * Runtime for `@ExternalField`: the store registry, and the per-instance
+ * accessors that keep a row's key column and the stored payload in step.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExternalStoreRegistry = void 0;
+exports.attachExternalFields = attachExternalFields;
+const adapters_1 = require("./adapters");
+const decorator_1 = require("./decorator");
+/** Registry of stores, keyed by the name given to `registerStore()`. */
+class ExternalStoreRegistry {
+    constructor() {
+        this.stores = new Map();
+    }
+    register(name, store, options = {}) {
+        this.stores.set(name, {
+            name,
+            adapter: (0, adapters_1.toExternalStoreAdapter)(store),
+            defaultBucket: options.defaultBucket,
+        });
+    }
+    get(name) {
+        const found = this.stores.get(name);
+        if (!found) {
+            const known = Array.from(this.stores.keys());
+            throw new adapters_1.ExternalStoreError(`No store registered as '${name}'.` +
+                (known.length
+                    ? ` Registered: ${known.join(', ')}.`
+                    : ` Register one with prorm.registerStore('${name}', store).`));
+        }
+        return found;
+    }
+    has(name) {
+        return this.stores.has(name);
+    }
+    clear() {
+        this.stores.clear();
+    }
+}
+exports.ExternalStoreRegistry = ExternalStoreRegistry;
+/** Capitalize for method naming (`avatar` -> `Avatar`). */
+function capitalize(s) {
+    return s.charAt(0).toUpperCase() + s.slice(1);
+}
+/** Encode a value for storage according to the field's encoding. */
+function encode(value, meta) {
+    if (value === null || value === undefined) {
+        throw new adapters_1.ExternalStoreError(`Cannot write null to external field '${meta.field}'. ` +
+            `Use delete${capitalize(meta.field)}() to remove it.`);
+    }
+    switch (meta.encoding) {
+        case 'json':
+            return Buffer.from(JSON.stringify(value), 'utf8');
+        case 'utf8':
+            return Buffer.from(String(value), 'utf8');
+        default:
+            if (Buffer.isBuffer(value))
+                return value;
+            if (value instanceof Uint8Array)
+                return Buffer.from(value);
+            if (typeof value === 'string')
+                return Buffer.from(value);
+            throw new adapters_1.ExternalStoreError(`External field '${meta.field}' is encoded as 'buffer' but got ` +
+                `${typeof value}. Pass a Buffer/Uint8Array/string, or set ` +
+                `encoding: 'json' on the field.`);
+    }
+}
+/** Materialize a stored payload according to the field's encoding. */
+function decode(buf, meta) {
+    if (buf === null)
+        return null;
+    switch (meta.encoding) {
+        case 'json':
+            return JSON.parse(buf.toString('utf8'));
+        case 'utf8':
+            return buf.toString('utf8');
+        default:
+            return buf;
+    }
+}
+/** Build the object key for a field on a given row. */
+function buildKey(meta, tableName, pk) {
+    const id = pk === undefined || pk === null ? Date.now().toString(36) : String(pk);
+    return `${meta.keyPrefix}${tableName}-${id}`;
+}
+/**
+ * Attach external-field accessors to a row instance.
+ *
+ * Each field `avatar` gets:
+ *   - `avatar`            a non-enumerable accessor holding the materialized value
+ *   - `loadAvatar()`      read from the store into `avatar`
+ *   - `saveAvatar(value)` write to the store and persist the key column
+ *   - `deleteAvatar()`    remove from the store and null the key column
+ *
+ * The accessor is deliberately **non-enumerable** so `save()`'s sweep over the
+ * instance's own keys doesn't try to persist a Buffer into a column that
+ * doesn't exist. Assigning to it records a pending write, which the wrapped
+ * `save()` flushes before the row is written.
+ */
+function attachExternalFields(rowInstance, dataValues, modelName, tableName, registry) {
+    const fields = (0, decorator_1.getExternalFields)(modelName);
+    if (fields.length === 0)
+        return;
+    // Advertise the external field names so the instance proxy and save() can
+    // keep these payloads out of dataValues and out of the generated UPDATE.
+    Object.defineProperty(rowInstance, '__externalFields', {
+        value: new Set(fields.map((f) => f.field)),
+        enumerable: false,
+        configurable: true,
+    });
+    // field -> value pending upload on the next save()
+    const pending = new Map();
+    // field -> last materialized value
+    const materialized = new Map();
+    const resolve = (meta) => {
+        const store = registry.get(meta.store);
+        const bucket = meta.bucket ?? store.defaultBucket;
+        return { store, bucket };
+    };
+    for (const meta of fields) {
+        const { field, keyColumn } = meta;
+        Object.defineProperty(rowInstance, field, {
+            enumerable: false,
+            configurable: true,
+            get() {
+                return pending.has(field) ? pending.get(field) : materialized.get(field) ?? null;
+            },
+            set(value) {
+                pending.set(field, value);
+            },
+        });
+        rowInstance[`load${capitalize(field)}`] = async () => {
+            const key = dataValues[keyColumn];
+            if (!key) {
+                materialized.set(field, null);
+                return null;
+            }
+            const { store, bucket } = resolve(meta);
+            const value = decode(await store.adapter.get(bucket, key), meta);
+            materialized.set(field, value);
+            pending.delete(field);
+            return value;
+        };
+        rowInstance[`save${capitalize(field)}`] = async (value, options = {}) => {
+            const toWrite = value !== undefined ? value : pending.get(field);
+            const { store, bucket } = resolve(meta);
+            const key = dataValues[keyColumn] || buildKey(meta, tableName, dataValues.id);
+            await store.adapter.put(bucket, key, encode(toWrite, meta), {
+                contentType: meta.contentType,
+            });
+            dataValues[keyColumn] = key;
+            rowInstance[keyColumn] = key;
+            materialized.set(field, toWrite);
+            pending.delete(field);
+            // Persist the key so a later fetch of this row can find the object.
+            // Skipped when called from the wrapped save() below, which is about to
+            // write the row anyway.
+            if (options.persist !== false && dataValues.id !== undefined) {
+                await rowInstance.update({ [keyColumn]: key });
+            }
+            return toWrite;
+        };
+        rowInstance[`delete${capitalize(field)}`] = async () => {
+            const key = dataValues[keyColumn];
+            if (key) {
+                const { store, bucket } = resolve(meta);
+                await store.adapter.delete(bucket, key);
+            }
+            dataValues[keyColumn] = null;
+            rowInstance[keyColumn] = null;
+            materialized.set(field, null);
+            pending.delete(field);
+            if (dataValues.id !== undefined) {
+                await rowInstance.update({ [keyColumn]: null });
+            }
+        };
+        rowInstance[`has${capitalize(field)}`] = async () => {
+            const key = dataValues[keyColumn];
+            if (!key)
+                return false;
+            const { store, bucket } = resolve(meta);
+            return store.adapter.exists(bucket, key);
+        };
+    }
+    // Flush pending payloads before the row is written, so that
+    // `user.avatar = buf; await user.save()` uploads and records the key.
+    const originalSave = rowInstance.save;
+    if (typeof originalSave === 'function') {
+        rowInstance.save = async (...args) => {
+            for (const meta of fields) {
+                if (pending.has(meta.field)) {
+                    // persist: false - the save() we are wrapping writes the row next,
+                    // so the key column goes out with it rather than in its own UPDATE.
+                    await rowInstance[`save${capitalize(meta.field)}`](undefined, { persist: false });
+                }
+            }
+            return originalSave.apply(rowInstance, args);
+        };
+    }
+    // Removing the row should not orphan its objects.
+    const originalDestroy = rowInstance.destroy;
+    if (typeof originalDestroy === 'function') {
+        rowInstance.destroy = async (...args) => {
+            for (const meta of fields) {
+                const key = dataValues[meta.keyColumn];
+                if (!key)
+                    continue;
+                try {
+                    const { store, bucket } = resolve(meta);
+                    await store.adapter.delete(bucket, key);
+                }
+                catch {
+                    // A store that is unreachable must not block deleting the row; the
+                    // object is orphaned rather than the delete failing halfway.
+                }
+            }
+            return originalDestroy.apply(rowInstance, args);
+        };
+    }
+}

package/dist/foreign-data.d.ts

@@ -0,0 +1,168 @@
+/**
+ * Foreign Data Wrapper (FDW) support for PostgreSQL
+ *
+ * Provides management of:
+ *  - Foreign servers  (CREATE/ALTER/DROP FOREIGN SERVER)
+ *  - User mappings    (CREATE/ALTER/DROP USER MAPPING)
+ *  - Foreign tables   (CREATE/DROP FOREIGN TABLE, IMPORT FOREIGN SCHEMA)
+ *
+ * FDW is a PostgreSQL-only feature; attempting to use these APIs with SQLite
+ * or MySQL will throw a DatabaseError.
+ */
+/**
+ * Catalog of well-known Foreign Data Wrapper extension names.
+ */
+export declare const KNOWN_FDWS: {
+    readonly POSTGRES: "postgres_fdw";
+    readonly MYSQL: "mysql_fdw";
+    readonly REDIS: "redis_fdw";
+    readonly MONGO: "mongo_fdw";
+    readonly FILE: "file_fdw";
+    readonly S3: "parquet_s3_fdw";
+    readonly SQLITE: "sqlite_fdw";
+    readonly ORACLE: "oracle_fdw";
+    readonly ODBC: "odbc_fdw";
+    readonly TDS: "tds_fdw";
+    readonly CSTORE: "cstore_fdw";
+    readonly MULTICORN: "multicorn";
+};
+/** Options for CREATE FOREIGN SERVER */
+export interface ForeignServerOptions {
+    /** The FDW name, e.g. 'postgres_fdw', 'redis_fdw', 'file_fdw' */
+    fdw: string;
+    /** Server-level OPTIONS key/value pairs */
+    options?: Record<string, string>;
+    /** Optional server version string */
+    version?: string;
+    /** Use CREATE FOREIGN SERVER IF NOT EXISTS */
+    ifNotExists?: boolean;
+}
+/** Options for ALTER FOREIGN SERVER */
+export interface AlterForeignServerOptions {
+    /** Replace all options (OPTIONS (...)) */
+    options?: Record<string, string>;
+    /** Add new options (OPTIONS (ADD key 'value')) */
+    addOptions?: Record<string, string>;
+    /** Change existing options (OPTIONS (SET key 'value')) */
+    setOptions?: Record<string, string>;
+    /** Drop options by key name (OPTIONS (DROP key)) */
+    dropOptions?: string[];
+    /** Change the server version */
+    version?: string;
+}
+/** Options for CREATE USER MAPPING */
+export interface UserMappingOptions {
+    /** Name of the foreign server */
+    serverName: string;
+    /** Local user: a role name, 'CURRENT_USER', or 'PUBLIC' */
+    user: string;
+    /** Mapping OPTIONS, e.g. { user: 'remoteuser', password: 'remotepass' } */
+    options?: Record<string, string>;
+    /** Use CREATE USER MAPPING IF NOT EXISTS */
+    ifNotExists?: boolean;
+}
+/** Column definition for a foreign table */
+export interface ForeignTableColumnDef {
+    /** SQL type as a raw string, e.g. 'INTEGER', 'TEXT', 'VARCHAR(255)' */
+    type: string;
+    /** Optional per-column OPTIONS clause, e.g. 'OPTIONS (column_name "remote_col")' */
+    options?: string;
+}
+/** Options for CREATE FOREIGN TABLE */
+export interface ForeignTableOptions {
+    /** The foreign server that provides this table */
+    serverName: string;
+    /** Optional local schema to create the table in */
+    schema?: string;
+    /** Column definitions keyed by column name */
+    columns: Record<string, ForeignTableColumnDef>;
+    /** Table-level OPTIONS */
+    options?: Record<string, string>;
+    /** Use CREATE FOREIGN TABLE IF NOT EXISTS */
+    ifNotExists?: boolean;
+}
+/** Options for IMPORT FOREIGN SCHEMA */
+export interface ImportForeignSchemaOptions {
+    /** Local schema to import tables into (defaults to 'public') */
+    localSchema?: string;
+    /** LIMIT TO – only import these remote tables */
+    limitTo?: string[];
+    /** EXCEPT – import all remote tables except these */
+    except?: string[];
+    /** IMPORT FOREIGN SCHEMA level OPTIONS */
+    options?: Record<string, string>;
+}
+/** Row returned by getServers() */
+export interface ServerInfo {
+    name: string;
+    fdw: string;
+    options: Record<string, string>;
+}
+/**
+ * Manages Foreign Data Wrapper objects (servers, user mappings, foreign tables)
+ * for a Prorm instance.
+ *
+ * All operations delegate SQL generation to the underlying dialect so that
+ * non-PostgreSQL dialects can throw meaningful errors at a single point.
+ */
+export declare class ForeignDataManager {
+    private readonly prorm;
+    constructor(prorm: any);
+    /**
+     * CREATE FOREIGN SERVER
+     */
+    createServer(name: string, opts: ForeignServerOptions): Promise<void>;
+    /**
+     * ALTER FOREIGN SERVER
+     */
+    alterServer(name: string, opts: AlterForeignServerOptions): Promise<void>;
+    /**
+     * DROP FOREIGN SERVER
+     */
+    dropServer(name: string, opts?: {
+        ifExists?: boolean;
+        cascade?: boolean;
+    }): Promise<void>;
+    /**
+     * List all foreign servers visible in the current database.
+     */
+    getServers(): Promise<ServerInfo[]>;
+    /**
+     * Return true if a foreign server with the given name exists.
+     */
+    serverExists(name: string): Promise<boolean>;
+    /**
+     * CREATE USER MAPPING
+     */
+    createUserMapping(opts: UserMappingOptions): Promise<void>;
+    /**
+     * ALTER USER MAPPING (re-uses the same SQL builder as CREATE with altered keywords)
+     */
+    alterUserMapping(opts: UserMappingOptions): Promise<void>;
+    /**
+     * DROP USER MAPPING
+     */
+    dropUserMapping(serverName: string, user?: string, opts?: {
+        ifExists?: boolean;
+    }): Promise<void>;
+    /**
+     * CREATE FOREIGN TABLE
+     */
+    createForeignTable(tableName: string, opts: ForeignTableOptions): Promise<void>;
+    /**
+     * DROP FOREIGN TABLE
+     */
+    dropForeignTable(tableName: string, opts?: {
+        ifExists?: boolean;
+        cascade?: boolean;
+    }): Promise<void>;
+    /**
+     * IMPORT FOREIGN SCHEMA
+     */
+    importForeignSchema(remoteSchema: string, serverName: string, opts?: ImportForeignSchemaOptions): Promise<void>;
+}
+/**
+ * Build a PostgreSQL OPTIONS (...) clause from a plain object.
+ * Each value is single-quoted and existing single quotes are escaped.
+ */
+export declare function buildOptionsClause(opts: Record<string, string>): string;

package/dist/graph/base-graph-dialect.d.ts

@@ -0,0 +1,250 @@
+/**
+ * BaseGraphDialect — shared implementation of the SQL-shaped `Dialect`
+ * contract for graph/object databases.
+ *
+ * The ORM's `Model` layer talks to every backend through the `Dialect`
+ * interface (connect/query/transaction + `build*Query` codegen + DDL). This
+ * class implements that whole surface **once** for graph stores, translating:
+ *
+ *   - a table            -> a node label (vertex type)
+ *   - a row              -> a node
+ *   - an INSERT          -> CREATE node
+ *   - a SELECT           -> MATCH node (+ traversals for `include`)
+ *   - a WHERE            -> a graph predicate (via {@link normalizeWhere})
+ *   - an association     -> a graph edge/relationship
+ *   - an `include`       -> a graph walk over that edge
+ *   - "DDL"              -> node-label / edge-type / index / constraint mgmt
+ *
+ * Each concrete dialect (Neo4j / Gremlin / Dgraph) only implements the
+ * connection lifecycle and a small set of language-specific `compile*`
+ * codegen primitives; everything else is centralized here. Genuinely
+ * relational-only features (partitions, materialized views, RLS, stored
+ * procedures, foreign-data wrappers, arbitrary SQL joins) throw a typed
+ * {@link GraphCapabilityError} rather than silently doing the wrong thing.
+ */
+import { Readable } from 'stream';
+import { BaseDialect, type ColumnDefinition, type ConstraintDefinition, type DropConstraintOptions, type DropIndexOptions, type DropSchemaOptions, type DropTableOptions, type DropViewOptions, type IndexDefinition, type IndexOptions, type InsertOptions, type TableDescription, type TableOptions, type UpdateOptions, type DeleteOptions, type SelectOptions, type UpsertQueryOptions, type ViewOptions, type BuildOptions } from '../dialects/dialect';
+import type { DataType, Order, QueryOptions, QueryResult, StreamOptions, Transaction, TransactionOptions, WhereOptions, MaterializedViewOptions, RefreshOptions, DropMaterializedViewOptions, StoredProcedureOptions, DropStoredProcedureOptions, ExecuteStoredProcedureOptions, TriggerOptions, DropTriggerOptions, SequenceOptions, DropSequenceOptions, PolicyOptions, DropPolicyOptions, CreatePartitionOptions, AttachPartitionOptions, DetachPartitionOptions } from '../types';
+import { ParamBag, type GraphConnectionOptions, type GraphPredicate, type GraphStatement, type GraphTraversalSpec, type GraphTraversalStep, type NodeMatchSpec, type NodeModelDefinition, type EdgeModelDefinition } from './types';
+/** Context passed to {@link BaseGraphDialect.renderPredicate}. */
+export interface WhereRenderContext {
+    /** Variable the predicate's properties are addressed through (e.g. `n`). */
+    nodeVar: string;
+    /** Bag collecting parameter bindings produced while rendering. */
+    params: ParamBag;
+}
+/** Fully-resolved spec for creating an edge between matched endpoints. */
+export interface EdgeCreateSpec {
+    fromLabel: string;
+    fromWhere?: WhereOptions;
+    edgeLabel: string;
+    toLabel: string;
+    toWhere?: WhereOptions;
+    props?: Record<string, unknown>;
+}
+/** Kind of node constraint the graph DDL layer can create. */
+export type NodeConstraintKind = 'unique' | 'exists' | 'key';
+export declare abstract class BaseGraphDialect extends BaseDialect {
+    protected readonly options: GraphConnectionOptions;
+    /** In-memory registry of node/edge models defined through the builder. */
+    protected readonly nodeModels: Map<string, NodeModelDefinition>;
+    protected readonly edgeModels: Map<string, EdgeModelDefinition>;
+    constructor(options?: GraphConnectionOptions);
+    abstract readonly name: string;
+    abstract readonly library: string;
+    abstract connect(): Promise<void>;
+    abstract disconnect(): Promise<void>;
+    abstract query(statement: string, options?: QueryOptions): Promise<QueryResult>;
+    abstract getDatabaseVersion(): Promise<string>;
+    abstract startTransaction(options?: TransactionOptions): Promise<Transaction>;
+    abstract commitTransaction(transaction: Transaction): Promise<void>;
+    abstract rollbackTransaction(transaction: Transaction): Promise<void>;
+    /** Variable name node properties are addressed through in generated queries. */
+    protected abstract get defaultNodeVar(): string;
+    /** Render a normalized predicate tree into this dialect's filter syntax. */
+    abstract renderPredicate(pred: GraphPredicate, ctx: WhereRenderContext): string;
+    /** Compile a node find/match (+ `include` traversals) into a graph query. */
+    abstract compileMatch(spec: NodeMatchSpec): GraphStatement;
+    /** Compile a node create (INSERT-equivalent). */
+    abstract compileCreateNode(label: string, data: Record<string, unknown>): GraphStatement;
+    /** Compile a node update (SET-equivalent) over a filter. */
+    abstract compileUpdateNodes(label: string, where: WhereOptions | undefined, values: Record<string, unknown>): GraphStatement;
+    /** Compile a node delete over a filter (`detach` also removes its edges). */
+    abstract compileDeleteNodes(label: string, where: WhereOptions | undefined, detach: boolean): GraphStatement;
+    /** Compile an upsert (MERGE-equivalent) keyed on `conflictKeys`. */
+    abstract compileUpsertNode(label: string, data: Record<string, unknown>, conflictKeys: string[]): GraphStatement;
+    /** Compile a numeric increment of one or more properties. */
+    abstract compileIncrement(label: string, fields: string | string[] | Record<string, number>, where: WhereOptions | undefined, by: number): GraphStatement;
+    /** Compile edge creation between two matched endpoints (association write). */
+    abstract compileCreateEdge(spec: EdgeCreateSpec): GraphStatement;
+    /** Compile a (possibly variable-length) traversal from a start node. */
+    abstract compileTraverse(spec: GraphTraversalSpec): GraphStatement;
+    /** Compile creation of a node-label constraint (unique / exists / key). */
+    abstract compileCreateConstraint(label: string, fields: string[], kind: NodeConstraintKind, name?: string): GraphStatement;
+    /** Compile dropping a named node-label constraint. */
+    abstract compileDropConstraint(label: string, name: string): GraphStatement;
+    /** Compile creation of an index over node-label properties. */
+    abstract compileCreateIndex(label: string, fields: string[], name?: string): GraphStatement;
+    /** Compile dropping a named index. */
+    abstract compileDropIndex(label: string, name: string): GraphStatement;
+    /** Compile a query listing all node labels in the store. */
+    abstract compileShowLabels(): GraphStatement;
+    getConnection(): any;
+    isConnected(): boolean;
+    /**
+     * Object-mode streaming: runs the query and pushes one row (or mapped
+     * model instance) per chunk. Graph drivers don't share a common cursor
+     * API, so this buffers the driver result and re-emits it — correct and
+     * dialect-agnostic, matching the `Model.findAllStream()` contract.
+     */
+    queryStream(statement: string, options?: StreamOptions): Readable;
+    private streamGen;
+    /** Values are parameterized, so `escape` is only a defensive fallback. */
+    escape(value: any): string;
+    escapeId(identifier: string): string;
+    quoteIdentifier(identifier: string): string;
+    quoteTable(tableName: string, _schema?: string): string;
+    /** Coarse property-type name; graph stores are largely schemaless. */
+    getDataTypeSql(dataType: DataType): string;
+    /** Run a compiled statement, forwarding its params as query bindings. */
+    protected run(stmt: GraphStatement, options?: QueryOptions): Promise<QueryResult>;
+    /** Positional param array for the SQL-shaped `{ sql, values }` contract. */
+    protected paramValues(stmt: GraphStatement): unknown[];
+    /** Tolerant `Order` -> `[field, dir][]` normalizer. */
+    protected normalizeOrder(order?: Order): Array<[string, 'ASC' | 'DESC']>;
+    /** Map ORM `include` entries into graph traversal steps. */
+    protected mapIncludes(include?: any[]): GraphTraversalStep[];
+    buildWhereClause(where: WhereOptions, _options?: BuildOptions): {
+        sql: string;
+        values: any[];
+    };
+    buildOrderClause(order: Order, _options?: BuildOptions): string;
+    buildLimitOffset(limit?: number | string, offset?: number | string): string;
+    buildInsertQuery(tableName: string, values: Record<string, any>, _options?: InsertOptions): {
+        sql: string;
+        values: any[];
+    };
+    buildUpdateQuery(tableName: string, values: Record<string, any>, where: WhereOptions, _options?: UpdateOptions): {
+        sql: string;
+        values: any[];
+    };
+    buildDeleteQuery(tableName: string, where: WhereOptions, options?: DeleteOptions): {
+        sql: string;
+        values: any[];
+    };
+    buildSelectQuery(options: SelectOptions): {
+        sql: string;
+        values: any[];
+    };
+    buildUpsertQuery(tableName: string, values: Record<string, any>, options?: UpsertQueryOptions): {
+        sql: string;
+        values: any[];
+    };
+    buildIncrementQuery(tableName: string, fields: string | string[] | Record<string, number>, where: WhereOptions, options?: {
+        by?: number;
+    }): {
+        sql: string;
+        values: any[];
+    };
+    /** Identity property/properties for a label (defaults to `id`). */
+    protected identityKeys(label: string): string[];
+    /**
+     * "CREATE TABLE" for a graph store = declare a node label and materialize
+     * its schema hints: unique/primary-key columns become uniqueness
+     * constraints, `references` columns become association edges, and indexed
+     * columns become property indexes. Nodes themselves stay schemaless.
+     */
+    createTable(tableName: string, columns: Record<string, ColumnDefinition>, _options?: TableOptions): Promise<void>;
+    dropTable(tableName: string, _options?: DropTableOptions): Promise<void>;
+    addIndex(tableName: string, indexName: string, fields: string[], _options?: IndexOptions): Promise<void>;
+    createIndex(tableName: string, indexDef: IndexDefinition): Promise<void>;
+    removeIndex(tableName: string, indexName: string): Promise<void>;
+    dropIndex(tableName: string, indexName: string, _options?: DropIndexOptions): Promise<void>;
+    createConstraint(tableName: string, constraintDef: ConstraintDefinition): Promise<void>;
+    dropConstraint(tableName: string, constraintName: string, _options?: DropConstraintOptions): Promise<void>;
+    addConstraint(tableName: string, options: {
+        type: 'UNIQUE' | 'CHECK' | 'PRIMARY KEY' | 'FOREIGN KEY';
+        fields: string[];
+        name?: string;
+        references?: {
+            table: string;
+            fields: string[];
+        };
+        check?: string;
+    }): Promise<void>;
+    removeConstraint(tableName: string, constraintName: string): Promise<void>;
+    showTables(): Promise<string[]>;
+    showViews(): Promise<string[]>;
+    showMaterializedViews(): Promise<string[]>;
+    showConstraints(_tableName: string): Promise<any[]>;
+    showIndexes(_tableName: string): Promise<any[]>;
+    describeTable(_tableName: string): Promise<TableDescription>;
+    createSchema(_schema: string): Promise<void>;
+    dropSchema(_schema: string, _options?: DropSchemaOptions): Promise<void>;
+    showAllSchemas(): Promise<string[]>;
+    addColumn(_tableName: string, _columnName: string, _definition: ColumnDefinition): Promise<void>;
+    removeColumn(tableName: string, columnName: string): Promise<void>;
+    changeColumn(_tableName: string, _columnName: string, _definition: ColumnDefinition): Promise<void>;
+    commentTable(_tableName: string, _comment: string): Promise<void>;
+    commentColumn(_tableName: string, _columnName: string, _comment: string): Promise<void>;
+    /** Register a node model (label + property schema + associations). */
+    defineNode(def: NodeModelDefinition): void;
+    /** Register an edge/relationship model between two node labels. */
+    defineEdge(def: EdgeModelDefinition): void;
+    /** Create a node and return the driver result. */
+    createNode(label: string, data: Record<string, unknown>): Promise<QueryResult>;
+    /** Find nodes matching a spec, returning the driver rows. */
+    findNodes(spec: NodeMatchSpec): Promise<any[]>;
+    /** Update nodes matching a filter. */
+    updateNodes(label: string, where: WhereOptions | undefined, values: Record<string, unknown>): Promise<QueryResult>;
+    /** Delete nodes matching a filter (detaching their edges). */
+    destroyNodes(label: string, where?: WhereOptions): Promise<QueryResult>;
+    /**
+     * Materialize an ORM association write as a graph edge: matches the two
+     * endpoints by filter and connects them with the association's edge label.
+     */
+    relate(spec: EdgeCreateSpec): Promise<QueryResult>;
+    /** Walk an association/edge from matching start node(s) — an `include`/join as a graph traversal. */
+    traverse(spec: GraphTraversalSpec): Promise<any[]>;
+    private unsupported;
+    createPartitionedTable(): Promise<void>;
+    createPartition(_options: CreatePartitionOptions): Promise<void>;
+    attachPartition(_options: AttachPartitionOptions): Promise<void>;
+    detachPartition(_options: DetachPartitionOptions): Promise<void>;
+    dropPartition(): Promise<void>;
+    createView(_viewName: string, _query: string, _options?: ViewOptions): Promise<void>;
+    dropView(_viewName: string, _options?: DropViewOptions): Promise<void>;
+    createMaterializedView(_options: MaterializedViewOptions): Promise<void>;
+    refreshMaterializedView(_viewName: string, _options?: RefreshOptions): Promise<void>;
+    dropMaterializedView(_viewName: string, _options?: DropMaterializedViewOptions): Promise<void>;
+    hasMaterializedView(_viewName: string): Promise<boolean>;
+    createStoredProcedure(_options: StoredProcedureOptions): Promise<void>;
+    dropStoredProcedure(_procedureName: string, _options?: DropStoredProcedureOptions): Promise<void>;
+    executeStoredProcedure(_options: ExecuteStoredProcedureOptions): Promise<QueryResult>;
+    hasStoredProcedure(_procedureName: string, _schema?: string): Promise<boolean>;
+    createTrigger(_options: TriggerOptions): Promise<void>;
+    dropTrigger(_triggerName: string, _tableName: string, _options?: DropTriggerOptions): Promise<void>;
+    hasTrigger(_triggerName: string, _tableName: string): Promise<boolean>;
+    createSequence(_options: SequenceOptions): Promise<void>;
+    dropSequence(_sequenceName: string, _options?: DropSequenceOptions): Promise<void>;
+    nextSequenceValue(_sequenceName: string): Promise<number>;
+    hasSequence(_sequenceName: string): Promise<boolean>;
+    createPolicy(_options: PolicyOptions): Promise<void>;
+    dropPolicy(_policyName: string, _tableName: string, _options?: DropPolicyOptions): Promise<void>;
+    enableRLS(_tableName: string, _schema?: string): Promise<void>;
+    disableRLS(_tableName: string, _schema?: string): Promise<void>;
+    hasPolicy(_policyName: string, _tableName: string): Promise<boolean>;
+    createPartialIndex(): Promise<void>;
+    createExpressionIndex(): Promise<void>;
+    createIdentityColumn(): Promise<void>;
+    createComputedColumn(): Promise<void>;
+    renameTable(_oldName: string, _newName: string): Promise<void>;
+    changeOwner(_newOwner: string, _tableName: string): Promise<void>;
+    createForeignDataWrapper(): Promise<void>;
+    dropForeignDataWrapper(): Promise<void>;
+    createForeignServer(): Promise<void>;
+    dropForeignServer(): Promise<void>;
+    createForeignTable(): Promise<void>;
+    createSecurityPolicy(): Promise<void>;
+    dropSecurityPolicy(): Promise<void>;
+}