ts-prorm-orm 1.1.0

package/dist/dialects/trino/index.js

@@ -0,0 +1,420 @@
+"use strict";
+/**
+ * Trino (formerly PrestoSQL) dialect implementation for the TypeScript ORM.
+ *
+ * Trino is a distributed, federated SQL query engine. It is *not* a storage
+ * engine of its own: it runs ANSI SQL over pluggable connectors (Hive, Iceberg,
+ * MySQL, PostgreSQL, Kafka, ...). Because its SQL surface is ANSI-flavored and
+ * it quotes identifiers with double quotes (like PostgreSQL), this dialect
+ * extends {@link PostgresDialect} and overrides only where Trino differs.
+ *
+ * Key differences from PostgreSQL that this dialect implements:
+ *
+ * - **Default port 8080.** Trino's HTTP/query port is 8080, not 5432.
+ *   The constructor injects it via `super({ port: 8080, ...config })`.
+ *
+ * - **Three-part table names: `catalog.schema.table`.** A Trino table lives in
+ *   a connector *catalog* and a *schema*. When a `catalog` is configured (and,
+ *   optionally, a default `schema`), {@link TrinoDialect.quoteTable} emits the
+ *   fully-qualified `"catalog"."schema"."table"` form. Without a catalog it
+ *   falls back to the PostgreSQL `schema.table` behavior.
+ *
+ * - **Connector table properties via `WITH (...)`.** `CREATE TABLE ... WITH
+ *   (format = 'ORC', partitioning = ARRAY['col'])` configures the underlying
+ *   connector (file format, partitioning, bucketing, ...). Exposed through
+ *   {@link TrinoTableOptions} (`format`, `partitioning`, `tableProperties`).
+ *
+ * - **`CREATE TABLE AS SELECT` (CTAS).** Trino's primary way to materialize a
+ *   table from a query. Exposed via {@link TrinoDialect.buildCreateTableAsSelectSQL}
+ *   (sync SQL builder) and {@link TrinoDialect.createTableAsSelect} (executes it).
+ *
+ * - **No PRIMARY KEY / FOREIGN KEY / UNIQUE enforcement.** Trino does not
+ *   support (or enforce) key constraints — `CREATE TABLE` here omits any
+ *   `PRIMARY KEY`, `FOREIGN KEY`, or `UNIQUE` clause entirely. Constraint
+ *   metadata on columns/tables is ignored for DDL purposes.
+ *
+ * - **No AUTO_INCREMENT / identity / sequences.** Trino has no
+ *   SERIAL/BIGSERIAL/IDENTITY. Surrogate keys are *not* auto-generated;
+ *   application code (or the source connector) must supply key values. The
+ *   `autoIncrement` column flag is ignored.
+ *
+ * - **Type mapping.** Trino uses unbounded `VARCHAR` (no length required),
+ *   `DOUBLE` (not `DOUBLE PRECISION`), `BOOLEAN`, and `TIMESTAMP`. See
+ *   {@link TrinoDialect.getDataTypeSql}.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrinoDialect = void 0;
+exports.createTrinoDialect = createTrinoDialect;
+const index_1 = require("../postgres/index");
+const prorm_1 = require("../../prorm");
+/**
+ * Trino / PrestoSQL federated query engine dialect. Extends {@link PostgresDialect}
+ * (ANSI SQL, double-quoted identifiers) and overrides Trino-specific behavior.
+ */
+class TrinoDialect extends index_1.PostgresDialect {
+    constructor(config) {
+        // Trino's default query port is 8080 (not PostgreSQL's 5432).
+        super({ port: 8080, ...config });
+        this.name = 'trino';
+        this.trinoCatalog = config.catalog;
+        this.trinoSchema = config.schema;
+    }
+    /**
+     * Quote a table name. When a connector catalog is configured, emit the Trino
+     * three-part `"catalog"."schema"."table"` form; otherwise defer to the
+     * PostgreSQL `schema.table` behavior.
+     */
+    quoteTable(tableName, schema) {
+        if (this.trinoCatalog) {
+            const effectiveSchema = schema ?? this.trinoSchema;
+            const parts = [this.escapeId(this.trinoCatalog)];
+            if (effectiveSchema) {
+                parts.push(this.escapeId(effectiveSchema));
+            }
+            parts.push(this.escapeId(tableName));
+            return parts.join('.');
+        }
+        return super.quoteTable(tableName, schema);
+    }
+    /**
+     * Map a data type to Trino SQL. Trino uses unbounded `VARCHAR`, `DOUBLE`,
+     * `BOOLEAN`, and `TIMESTAMP`, and has no SERIAL/identity types.
+     */
+    getDataTypeSql(dataType) {
+        if (typeof dataType === 'string') {
+            // The shared model-sync layer emits the cross-dialect 'DATETIME'
+            // pseudo-type for timestamp columns; Trino spells it TIMESTAMP.
+            if (/^DATETIME(\(\d+\))?$/i.test(dataType)) {
+                return dataType.replace(/^DATETIME/i, 'TIMESTAMP');
+            }
+            return dataType;
+        }
+        if (!dataType || typeof dataType !== 'object') {
+            return 'VARCHAR';
+        }
+        const dt = dataType;
+        switch (dt.key) {
+            case 'STRING':
+            case 'TEXT':
+                // Trino VARCHAR is unbounded by default — no length needed.
+                return 'VARCHAR';
+            case 'CHAR':
+                return dt.length ? `CHAR(${dt.length})` : 'CHAR';
+            case 'INTEGER':
+                // No SERIAL in Trino; auto-increment is not honored.
+                return 'INTEGER';
+            case 'BIGINT':
+                return 'BIGINT';
+            case 'FLOAT':
+                return 'REAL';
+            case 'DOUBLE':
+                return 'DOUBLE';
+            case 'DECIMAL':
+                return `DECIMAL(${dt.precision || 10}, ${dt.scale || 0})`;
+            case 'BOOLEAN':
+                return 'BOOLEAN';
+            case 'DATE':
+                return 'TIMESTAMP';
+            case 'DATEONLY':
+                return 'DATE';
+            case 'TIME':
+                return 'TIME';
+            case 'BLOB':
+                return 'VARBINARY';
+            case 'JSON':
+            case 'JSONB':
+                return 'JSON';
+            case 'UUID':
+                return 'UUID';
+            case 'ARRAY': {
+                const arrayType = dt.type || dt.subtype;
+                if (arrayType) {
+                    return `ARRAY(${this.getDataTypeSql(arrayType)})`;
+                }
+                return 'ARRAY(VARCHAR)';
+            }
+            default:
+                return 'VARCHAR';
+        }
+    }
+    /**
+     * Build a column definition fragment for Trino DDL. PRIMARY KEY, UNIQUE,
+     * FOREIGN KEY (references) and auto-increment are intentionally NOT emitted —
+     * Trino neither supports nor enforces them.
+     */
+    getTrinoColumnDefinitionSql(columnName, definition) {
+        let sql = `${this.escapeId(columnName)} ${this.getDataTypeSql(definition.type)}`;
+        if (definition.allowNull === false) {
+            sql += ' NOT NULL';
+        }
+        if (definition.comment) {
+            sql += ` COMMENT '${String(definition.comment).replace(/'/g, "''")}'`;
+        }
+        return sql;
+    }
+    /**
+     * Build the `WITH (...)` connector-properties clause (or '' when there are
+     * no properties). Handles `format`, `partitioning`, and `tableProperties`.
+     */
+    buildTablePropertiesClause(options) {
+        if (!options)
+            return '';
+        const props = [];
+        if (options.format) {
+            props.push(`format = '${String(options.format).replace(/'/g, "''")}'`);
+        }
+        if (options.partitioning && options.partitioning.length > 0) {
+            const cols = options.partitioning.map((c) => `'${String(c).replace(/'/g, "''")}'`).join(', ');
+            props.push(`partitioning = ARRAY[${cols}]`);
+        }
+        if (options.tableProperties) {
+            for (const [key, value] of Object.entries(options.tableProperties)) {
+                if (typeof value === 'string') {
+                    props.push(`${key} = '${value.replace(/'/g, "''")}'`);
+                }
+                else {
+                    props.push(`${key} = ${value}`);
+                }
+            }
+        }
+        return props.length > 0 ? `WITH (${props.join(', ')})` : '';
+    }
+    /**
+     * Build (synchronously) a Trino `CREATE TABLE` statement. Omits all key
+     * constraints (PK/FK/UNIQUE) and appends connector `WITH (...)` properties.
+     */
+    buildCreateTableSQL(tableName, columns, options) {
+        const columnDefs = Object.entries(columns)
+            .map(([name, def]) => this.getTrinoColumnDefinitionSql(name, def))
+            .filter((s) => s.trim().length > 0);
+        let sql = 'CREATE TABLE';
+        if (options?.ifNotExists) {
+            sql += ' IF NOT EXISTS';
+        }
+        sql += ` ${this.quoteTable(tableName, options?.schema)} (${columnDefs.join(', ')})`;
+        if (options?.comment) {
+            sql += ` COMMENT '${String(options.comment).replace(/'/g, "''")}'`;
+        }
+        const props = this.buildTablePropertiesClause(options);
+        if (props) {
+            sql += ` ${props}`;
+        }
+        return sql;
+    }
+    /**
+     * Build (synchronously) a Trino `CREATE TABLE ... AS SELECT` (CTAS) statement.
+     *
+     * @param tableName - Name of the table to create.
+     * @param selectQuery - The `SELECT ...` query (raw SQL) to populate it from.
+     * @param options - Connector properties and CTAS options.
+     */
+    buildCreateTableAsSelectSQL(tableName, selectQuery, options) {
+        let sql = 'CREATE TABLE';
+        if (options?.ifNotExists) {
+            sql += ' IF NOT EXISTS';
+        }
+        sql += ` ${this.quoteTable(tableName, options?.schema)}`;
+        if (options?.comment) {
+            sql += ` COMMENT '${String(options.comment).replace(/'/g, "''")}'`;
+        }
+        const props = this.buildTablePropertiesClause(options);
+        if (props) {
+            sql += ` ${props}`;
+        }
+        sql += ` AS ${selectQuery}`;
+        if (options?.withNoData) {
+            sql += ' WITH NO DATA';
+        }
+        return sql;
+    }
+    /**
+     * Create a table in Trino. Overrides the PostgreSQL implementation to omit
+     * key constraints and support connector `WITH (...)` properties.
+     */
+    async createTable(tableName, columns, options) {
+        await this.query(this.buildCreateTableSQL(tableName, columns, options));
+    }
+    /**
+     * Execute a `CREATE TABLE AS SELECT` (CTAS) statement.
+     */
+    async createTableAsSelect(tableName, selectQuery, options) {
+        await this.query(this.buildCreateTableAsSelectSQL(tableName, selectQuery, options));
+    }
+    // ==========================================================================
+    // DDL: DROP TABLE / ADD COLUMN / DROP COLUMN
+    //
+    // These override the PostgreSQL versions so they (a) use the Trino
+    // catalog.schema.table naming from quoteTable() and (b) emit only clauses
+    // Trino actually accepts. Trino has no CASCADE on DROP TABLE, and column
+    // definitions may not carry PK / UNIQUE / FOREIGN KEY / DEFAULT / SERIAL.
+    // ==========================================================================
+    /**
+     * Drop a table. Trino's `DROP TABLE` supports `IF EXISTS` but has no
+     * `CASCADE` (there are no dependent constraints to cascade).
+     */
+    async dropTable(tableName, options) {
+        let sql = 'DROP TABLE';
+        if (options?.ifExists) {
+            sql += ' IF EXISTS';
+        }
+        sql += ` ${this.quoteTable(tableName)}`;
+        await this.query(sql);
+    }
+    /**
+     * Add a column. Uses the Trino column-definition builder (no constraints /
+     * default / SERIAL) and the catalog-qualified table name.
+     */
+    async addColumn(tableName, columnName, definition) {
+        const sql = `ALTER TABLE ${this.quoteTable(tableName)} ADD COLUMN ${this.getTrinoColumnDefinitionSql(columnName, definition)}`;
+        await this.query(sql);
+    }
+    /**
+     * Remove a column. `ALTER TABLE ... DROP COLUMN` with catalog-qualified name.
+     */
+    async removeColumn(tableName, columnName) {
+        const sql = `ALTER TABLE ${this.quoteTable(tableName)} DROP COLUMN ${this.escapeId(columnName)}`;
+        await this.query(sql);
+    }
+    // ==========================================================================
+    // Pagination: Trino orders OFFSET *before* LIMIT (unlike PostgreSQL's
+    // `LIMIT n OFFSET m`), and allows a standalone OFFSET.
+    //   [ ORDER BY ... ] [ OFFSET count ] [ LIMIT count ]
+    // ==========================================================================
+    buildLimitOffset(limit, offset) {
+        let sql = '';
+        if (offset !== undefined) {
+            sql += ` OFFSET ${Number(offset)}`;
+        }
+        if (limit !== undefined) {
+            sql += ` LIMIT ${Number(limit)}`;
+        }
+        return sql;
+    }
+    // ==========================================================================
+    // CRUD builders
+    //
+    // Trino accepts standard `INSERT INTO ... VALUES`, `UPDATE ... SET ... WHERE`,
+    // and `DELETE FROM ... WHERE` (UPDATE/DELETE are connector-dependent at
+    // execution time). It has NO `RETURNING`, NO `ON CONFLICT`/upsert, and NO
+    // `LIMIT` on UPDATE/DELETE — so those clauses are never emitted. Tables are
+    // catalog-qualified via quoteTable().
+    // ==========================================================================
+    /**
+     * Build an INSERT query. Trino form: `INSERT INTO t (cols) VALUES (...)`.
+     * No `RETURNING` and no `ON CONFLICT`/upsert — requesting an upsert throws.
+     */
+    buildInsertQuery(tableName, values, options) {
+        if (options?.upsert) {
+            throw new Error('Trino does not support upsert / ON CONFLICT. Trino has no primary-key or ' +
+                'unique constraints to conflict on. Use INSERT, or MERGE (on connectors ' +
+                'that support it) issued as raw SQL.');
+        }
+        const columns = Object.keys(values);
+        const processedValues = [];
+        const placeholders = [];
+        let paramIndex = 1;
+        for (const value of Object.values(values)) {
+            if (value instanceof prorm_1.Literal) {
+                placeholders.push(value.val);
+            }
+            else {
+                placeholders.push(`$${paramIndex}`);
+                processedValues.push(value);
+                paramIndex++;
+            }
+        }
+        const sql = `INSERT INTO ${this.quoteTable(tableName, options?.schema)} (${columns
+            .map((c) => this.escapeId(c))
+            .join(', ')}) VALUES (${placeholders.join(', ')})`;
+        // Trino has no RETURNING — options.returning is intentionally ignored.
+        return { sql, values: processedValues };
+    }
+    /**
+     * Trino has no upsert. Kept explicit so callers get a clear error instead of
+     * inheriting PostgreSQL's `INSERT ... ON CONFLICT` (invalid in Trino).
+     */
+    buildUpsertQuery(_tableName, _values, _options) {
+        throw new Error('Trino does not support upsert / ON CONFLICT. Trino has no primary-key or ' +
+            'unique constraints to conflict on. Use INSERT, or MERGE (on connectors ' +
+            'that support it) issued as raw SQL.');
+    }
+    /**
+     * Build an UPDATE query. No `RETURNING`, no `LIMIT` (Trino supports neither
+     * on UPDATE). Actual UPDATE support is connector-dependent at run time.
+     */
+    buildUpdateQuery(tableName, values, where, _options) {
+        const setClauses = [];
+        const queryValues = [];
+        let paramIndex = 1;
+        for (const [key, value] of Object.entries(values)) {
+            if (value instanceof prorm_1.Literal) {
+                setClauses.push(`${this.escapeId(key)} = ${value.val}`);
+            }
+            else {
+                setClauses.push(`${this.escapeId(key)} = $${paramIndex}`);
+                queryValues.push(value);
+                paramIndex++;
+            }
+        }
+        const whereClause = this.buildWhereClause(where);
+        let sql = `UPDATE ${this.quoteTable(tableName)} SET ${setClauses.join(', ')}`;
+        if (whereClause.sql) {
+            sql += ` WHERE ${whereClause.sql}`;
+        }
+        return { sql, values: [...queryValues, ...whereClause.values] };
+    }
+    /**
+     * Build a DELETE query. No `RETURNING`, no `LIMIT`. Trino has no `TRUNCATE`,
+     * so a `truncate` request degrades to an unqualified `DELETE FROM t`. Actual
+     * DELETE support is connector-dependent at run time.
+     */
+    buildDeleteQuery(tableName, where, options) {
+        if (options?.truncate) {
+            // Trino has no TRUNCATE statement; delete every row instead.
+            return { sql: `DELETE FROM ${this.quoteTable(tableName)}`, values: [] };
+        }
+        const whereClause = this.buildWhereClause(where);
+        let sql = `DELETE FROM ${this.quoteTable(tableName)}`;
+        if (whereClause.sql) {
+            sql += ` WHERE ${whereClause.sql}`;
+        }
+        return { sql, values: whereClause.values };
+    }
+    // ==========================================================================
+    // Indexes: Trino has NO indexes. Query performance comes from the underlying
+    // connector's storage layout (partitioning / bucketing / sorting), which is
+    // configured through table `WITH (...)` properties, not `CREATE INDEX`.
+    // Every index entry point throws a clear, actionable error.
+    // ==========================================================================
+    noIndexes(method) {
+        throw new Error(`Trino does not support indexes (${method} is unavailable). Control data layout ` +
+            `and query performance with connector table properties instead — e.g. ` +
+            `CREATE TABLE ... WITH (partitioning = ARRAY[...], bucketed_by = ARRAY[...]).`);
+    }
+    async addIndex(_tableName, _indexName, _fields, _options) {
+        this.noIndexes('addIndex');
+    }
+    async createIndex(_tableName, _indexDef) {
+        this.noIndexes('createIndex');
+    }
+    async removeIndex(_tableName, _indexName) {
+        this.noIndexes('removeIndex');
+    }
+    async dropIndex(_tableName, _indexName, _options) {
+        this.noIndexes('dropIndex');
+    }
+    async createPartialIndex(_tableName, _indexName, _fields, _where, _options) {
+        this.noIndexes('createPartialIndex');
+    }
+    async createExpressionIndex(_tableName, _indexName, _expression, _options) {
+        this.noIndexes('createExpressionIndex');
+    }
+}
+exports.TrinoDialect = TrinoDialect;
+/**
+ * Create a new Trino dialect instance.
+ */
+function createTrinoDialect(options) {
+    return new TrinoDialect(options || {});
+}
+exports.default = TrinoDialect;

package/dist/dialects/turso/index.js

@@ -0,0 +1,227 @@
+"use strict";
+/**
+ * Turso / libSQL dialect implementation.
+ *
+ * Turso is a hosted libSQL service; libSQL itself is a SQLite-compatible
+ * fork, so the SQL this dialect generates (DDL, JSON helpers, upsert
+ * syntax, LIMIT/OFFSET pagination, etc.) is identical to `SQLiteDialect`'s.
+ * Rather than duplicate ~90 pure SQL-generation methods, this class
+ * extends `SQLiteDialect` and overrides only the pieces that depend on the
+ * driver: connection lifecycle, query execution, streaming, and
+ * transactions. `SQLiteDialect` reaches those through its own `private`
+ * fields, which subclasses can't touch, so this class keeps entirely
+ * separate connection/transaction state and never touches the parent's.
+ *
+ * The `@libsql/client` driver works identically for a local embedded
+ * replica (`file:` / `:memory:` URLs) and a remote Turso database
+ * (`libsql:`/`https:` URLs with an `authToken`), unlike `better-sqlite3`
+ * which is local-only — that's the whole point of this dialect existing
+ * separately from `SQLiteDialect`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TursoDialect = void 0;
+exports.createTursoDialect = createTursoDialect;
+const client_1 = require("@libsql/client");
+const index_1 = require("../sqlite/index");
+const query_stream_helper_1 = require("../query-stream-helper");
+class TursoTransaction {
+    constructor(depth, options, dialect) {
+        this.dialect = dialect;
+        this.finished = false;
+        this.parent = null;
+        this.savepoints = [];
+        this.id = `sp_${depth}_${Date.now()}`;
+        this.options = options || {};
+    }
+    async commit() {
+        if (this.finished)
+            return;
+        await this.dialect.commitTransaction(this);
+        this.finished = true;
+    }
+    async rollback() {
+        if (this.finished)
+            return;
+        await this.dialect.rollbackTransaction(this);
+        this.finished = true;
+    }
+}
+/**
+ * Turso / libSQL dialect. See the module-level doc comment for why this
+ * extends `SQLiteDialect` instead of implementing `Dialect` from scratch.
+ */
+class TursoDialect extends index_1.SQLiteDialect {
+    constructor(config) {
+        // SQLiteDialect's constructor only reads `storage` (defaulted below) and
+        // is otherwise inert until connect() is called — connect() is fully
+        // overridden here, so the better-sqlite3 codepath it would normally run
+        // never executes.
+        super({ storage: config.url || ':memory:', ...config });
+        this.name = 'turso';
+        this.library = '@libsql/client';
+        this.client = null;
+        this._tursoConnected = false;
+        this.tursoTransactionDepth = 0;
+        this.tursoConfig = { url: ':memory:', ...config };
+    }
+    async connect() {
+        try {
+            this.client = (0, client_1.createClient)({
+                url: this.tursoConfig.url,
+                authToken: this.tursoConfig.authToken,
+                encryptionKey: this.tursoConfig.encryptionKey,
+                syncUrl: this.tursoConfig.syncUrl,
+                syncInterval: this.tursoConfig.syncInterval,
+            });
+            // Verify the connection actually works instead of deferring the
+            // failure to the caller's first query.
+            await this.client.execute('SELECT 1');
+            await this.client.execute('PRAGMA foreign_keys = ON');
+            this._tursoConnected = true;
+        }
+        catch (error) {
+            throw new Error(`Failed to connect to Turso/libSQL database: ${error}`);
+        }
+    }
+    async disconnect() {
+        if (this.client) {
+            this.client.close();
+            this.client = null;
+            this._tursoConnected = false;
+        }
+    }
+    getConnection() {
+        return this.client;
+    }
+    isConnected() {
+        return this._tursoConnected && this.client !== null;
+    }
+    /**
+     * `SQLiteAdvanced` (the parent class's `.advanced` getter) drives
+     * better-sqlite3's synchronous `Database` API directly, which the
+     * `@libsql/client` connection this dialect wraps doesn't expose.
+     */
+    get advanced() {
+        throw new Error('TursoDialect does not support the .advanced SQLite extension API (it depends on a synchronous better-sqlite3 connection). Use the standard Dialect methods instead.');
+    }
+    async query(sql, options) {
+        if (!this.client) {
+            throw new Error('Not connected to database');
+        }
+        const sqlUpper = sql.trim().toUpperCase();
+        const isSelect = sqlUpper.startsWith('SELECT') || sqlUpper.startsWith('PRAGMA');
+        const params = options?.replacements ?? options?.bind ?? options?.bindings;
+        try {
+            const result = await (params === undefined
+                ? this.client.execute(sql)
+                : this.client.execute({ sql, args: this.toLibsqlArgs(params) }));
+            if (isSelect) {
+                const rows = result.rows.map((row) => this.rowToObject(row, result.columns));
+                return { rows, rowCount: rows.length, fields: [] };
+            }
+            return {
+                rows: [],
+                rowCount: result.rowsAffected,
+                fields: [],
+                lastInsertRowid: result.lastInsertRowid !== undefined ? Number(result.lastInsertRowid) : undefined,
+            };
+        }
+        catch (error) {
+            throw new Error(`Query error: ${error}`);
+        }
+    }
+    /**
+     * `@libsql/client` has no native server-side cursor — `execute()` always
+     * returns the full result set — so this uses the same generic
+     * LIMIT/OFFSET-paginated fallback the other non-cursor dialects use
+     * (`buildLimitOffset()` is inherited unchanged from `SQLiteDialect`,
+     * since libSQL's pagination syntax is identical to SQLite's).
+     */
+    queryStream(sql, options) {
+        return (0, query_stream_helper_1.createPaginatedQueryStream)(this, sql, options);
+    }
+    toLibsqlArgs(params) {
+        if (Array.isArray(params)) {
+            return params;
+        }
+        return params;
+    }
+    rowToObject(row, columns) {
+        const obj = {};
+        for (let i = 0; i < columns.length; i++) {
+            obj[columns[i]] = row[i];
+        }
+        return obj;
+    }
+    async getDatabaseVersion() {
+        const result = await this.query('SELECT sqlite_version() AS version');
+        return String(result.rows[0]?.version ?? 'unknown');
+    }
+    async attachDatabase(path, alias) {
+        const aliasId = this.quoteIdentifier(alias);
+        await this.client.execute({ sql: `ATTACH DATABASE ? AS ${aliasId}`, args: [path] });
+    }
+    async detachDatabase(alias) {
+        const aliasId = this.quoteIdentifier(alias);
+        await this.client.execute(`DETACH DATABASE ${aliasId}`);
+    }
+    async startTransaction(options) {
+        if (!this.client) {
+            throw new Error('Not connected to database');
+        }
+        const transaction = new TursoTransaction(this.tursoTransactionDepth++, options, this);
+        if (this.tursoTransactionDepth === 1) {
+            await this.client.execute('BEGIN TRANSACTION');
+        }
+        else {
+            await this.client.execute(`SAVEPOINT sp_${transaction.id}`);
+        }
+        return transaction;
+    }
+    async commitTransaction(transaction) {
+        if (!this.client) {
+            throw new Error('Not connected to database');
+        }
+        const tx = transaction;
+        if (this.tursoTransactionDepth === 1) {
+            await this.client.execute('COMMIT');
+        }
+        else {
+            await this.client.execute(`RELEASE SAVEPOINT sp_${tx.id}`);
+        }
+        this.tursoTransactionDepth--;
+    }
+    async rollbackTransaction(transaction) {
+        if (!this.client) {
+            throw new Error('Not connected to database');
+        }
+        const tx = transaction;
+        if (this.tursoTransactionDepth === 1) {
+            await this.client.execute('ROLLBACK');
+        }
+        else {
+            await this.client.execute(`ROLLBACK TO SAVEPOINT sp_${tx.id}`);
+        }
+        this.tursoTransactionDepth--;
+    }
+    /**
+     * Pull the local embedded replica up to date with its `syncUrl` remote.
+     * No-op (well, throws) if this client wasn't configured with a `syncUrl`.
+     */
+    async sync() {
+        if (!this.client) {
+            throw new Error('Not connected to database');
+        }
+        if (!this.tursoConfig.syncUrl) {
+            throw new Error('sync() requires a syncUrl to have been configured on connect');
+        }
+        await this.client.sync();
+    }
+}
+exports.TursoDialect = TursoDialect;
+/**
+ * Create a new Turso/libSQL dialect instance.
+ */
+function createTursoDialect(options) {
+    return new TursoDialect(options || {});
+}