kysely 0.23.3 → 0.23.5

package/README.md

@@ -78,6 +78,8 @@ for [3rd party dialects](https://koskimas.github.io/kysely/interfaces/Dialect.ht
  - [SingleStore Data API](https://github.com/igalklebanov/kysely-singlestore)
  - [D1](https://github.com/aidenwallis/kysely-d1)
  - [SurrealDB](https://github.com/igalklebanov/kysely-surrealdb)
+ - [sqld](https://github.com/libsql/kysely-libsql)
+ - [Neon](https://github.com/seveibar/kysely-neon)
 
 # Minimal example
 
@@ -183,7 +185,7 @@ type UpdateablePerson = Updateable<PersonTable>
 
 # Playground
 
-[@wirekang](https://github.com/wirekang) has created a [playground for Kysely](https://wirekang.github.io/kysely-playground/#eyJkaWFsZWN0IjoibXlzcWwiLCJ0cyI6ImludGVyZmFjZSBEQiB7XG4gIHVzZXI6IFVzZXJUYWJsZVxufVxuXG5pbnRlcmZhY2UgVXNlclRhYmxlIHtcbiAgaWQ6IEdlbmVyYXRlZDxzdHJpbmc+XG4gIGZpcnN0X25hbWU6IHN0cmluZyB8IG51bGxcbiAgbGFzdF9uYW1lOiBzdHJpbmcgfCBudWxsXG4gIGNyZWF0ZWRfYXQ6IEdlbmVyYXRlZDxEYXRlPlxufVxuXG5yZXN1bHQgPSBreXNlbHlcbiAgLnNlbGVjdEZyb20oXCJ1c2VyXCIpXG4gIC5zZWxlY3RBbGwoKVxuICAub3JkZXJCeShcImNyZWF0ZWRfYXRcIikifQ==). You can use to quickly test stuff out and for creating code examples for your issues, PRs and discord messages.
+[@wirekang](https://github.com/wirekang) has created a [playground for Kysely](https://wirekang.github.io/kysely-playground/?p=f&i=-NLp3n_P5fyeQKMQda8n). You can use to quickly test stuff out and for creating code examples for your issues, PRs and discord messages.
 
 # Generating types
 
@@ -207,37 +209,34 @@ among other places.
 import { Pool } from 'pg'
 // or `import * as Cursor from 'pg-cursor'` depending on your tsconfig
 import Cursor from 'pg-cursor'
-import {
-    Kysely,
-    PostgresDialect,
-} from 'kysely'
+import { Kysely, PostgresDialect } from 'kysely'
 
 const db = new Kysely<Database>({
-    // PostgresDialect requires the Cursor dependency
-    dialect: new PostgresDialect({
-        pool: new Pool({
-            host: 'localhost',
-            database: 'kysely_test'
-        }),
-        cursor: Cursor
+  // PostgresDialect requires the Cursor dependency
+  dialect: new PostgresDialect({
+    pool: new Pool({
+      host: 'localhost',
+      database: 'kysely_test'
     }),
-
-    // MysqlDialect doesn't require any special configuration
+    cursor: Cursor
+  }),
+  // MysqlDialect doesn't require any special configuration
 })
 
 async function demo() {
-    for await (const male of db.selectFrom("person")
-        .selectAll()
-        .where("person.gender", "=", "male")
-        .stream()) {
-        console.log(`Hello mr. ${male.first_name}!`)
-
-        if (male.first_name === "John") {
-          // After this line the db connection is released and no more 
-          // rows are streamed from the database to the client
-          break;
-        }
+  for await (const adult of db.selectFrom('person')
+    .selectAll()
+    .where('age', '>', 18)
+    .stream()
+  ) {
+    console.log(`Hello ${adult.first_name}!`)
+
+    if (adult.first_name === 'John') {
+      // After this line the db connection is released and no more
+      // rows are streamed from the database to the client
+      break;
     }
+  }
 }
 ```
 
@@ -268,6 +267,7 @@ or "recipes" for common use cases.
 * [Extending kysely](https://github.com/koskimas/kysely/tree/master/recipes/extending-kysely.md)
 * [Raw SQL](https://github.com/koskimas/kysely/tree/master/recipes/raw-sql.md)
 * [Schemas](https://github.com/koskimas/kysely/tree/master/recipes/schemas.md)
+* [Dealing with the `Type instantiation is excessively deep and possibly infinite` error](https://github.com/koskimas/kysely/tree/master/recipes/excessively-deep-types.md)
 
 # Migrations
 

package/dist/cjs/dialect/database-introspector.d.ts

@@ -7,7 +7,7 @@ export interface DatabaseIntrospector {
      */
     getSchemas(): Promise<SchemaMetadata[]>;
     /**
-     * Get table metadata.
+     * Get tables and views metadata.
      */
     getTables(options?: DatabaseMetadataOptions): Promise<TableMetadata[]>;
     /**
@@ -29,12 +29,14 @@ export interface SchemaMetadata {
 }
 export interface DatabaseMetadata {
     /**
-     * The tables found in the database.
+     * The tables and views found in the database.
+  *  * The propery isView can be used to tell them apart.
      */
     readonly tables: TableMetadata[];
 }
 export interface TableMetadata {
     readonly name: string;
+    readonly isView: boolean;
     readonly columns: ColumnMetadata[];
     readonly schema?: string;
 }

package/dist/cjs/dialect/dialect-adapter-base.d.ts

@@ -25,12 +25,38 @@ export declare abstract class DialectAdapterBase implements DialectAdapter {
      * Most dialects have explicit locks that can be used, like advisory locks
      * in PostgreSQL and the get_lock function in MySQL.
      *
-     * If the dialect doesn't have explicit locks the {@link MIGRATION_LOCK_TABLE}
-     * created by Kysely can be used instead. {@link MIGRATION_LOCK_TABLE}
-     * has two columns `id` and `is_locked` and there's only one row in the
-     * table whose id is {@link MIGRATION_LOCK_ID}. `is_locked` is an integer.
-     * Kysely takes care of creating the lock table and inserting the one single
-     * row to it before this method is executed.
+     * If the dialect doesn't have explicit locks the {@link MigrationLockOptions.lockTable}
+     * created by Kysely can be used instead. You can access it through the `options` object.
+     * The lock table has two columns `id` and `is_locked` and there's only one row in the table
+     * whose id is {@link MigrationLockOptions.lockRowId}. `is_locked` is an integer. Kysely
+     * takes care of creating the lock table and inserting the one single row to it before this
+     * method is executed. If the dialect supports schemas and the user has specified a custom
+     * schema in their migration settings, the options object also contains the schema name in
+     * {@link MigrationLockOptions.lockTableSchema}.
+     *
+     * Here's an example of how you might implement this method for a dialect that doesn't
+     * have explicit locks but supports `FOR UPDATE` row locks and transactional DDL:
+     *
+     * ```ts
+     * {
+     *   async acquireMigrationLock(db, options): Promise<void> {
+     *     const queryDb = options.lockTableSchema
+     *       ? db.withSchema(options.lockTableSchema)
+     *       : db
+     *
+     *     // Since our imaginary dialect supports transactional DDL and has
+     *     // row locks, we can simply take a row lock here and it will guarantee
+     *     // all subsequent calls to this method from other transactions will
+     *     // wait until this transaction finishes.
+     *     await queryDb
+     *       .selectFrom(options.lockTable)
+     *       .selectAll()
+     *       .where('id', '=', options.lockRowId)
+     *       .forUpdate()
+     *       .execute()
+     *   }
+     * }
+     * ```
      *
      * If `supportsTransactionalDdl` is `true` then the `db` passed to this method
      * is a transaction inside which the migrations will be executed. Otherwise

package/dist/cjs/dialect/dialect-adapter.d.ts

@@ -26,19 +26,45 @@ export interface DialectAdapter {
      * Most dialects have explicit locks that can be used, like advisory locks
      * in PostgreSQL and the get_lock function in MySQL.
      *
-     * If the dialect doesn't have explicit locks the {@link MIGRATION_LOCK_TABLE}
-     * created by Kysely can be used instead. {@link MIGRATION_LOCK_TABLE}
-     * has two columns `id` and `is_locked` and there's only one row in the
-     * table whose id is {@link MIGRATION_LOCK_ID}. `is_locked` is an integer.
-     * Kysely takes care of creating the lock table and inserting the one single
-     * row to it before this method is executed.
+     * If the dialect doesn't have explicit locks the {@link MigrationLockOptions.lockTable}
+     * created by Kysely can be used instead. You can access it through the `options` object.
+     * The lock table has two columns `id` and `is_locked` and there's only one row in the table
+     * whose id is {@link MigrationLockOptions.lockRowId}. `is_locked` is an integer. Kysely
+     * takes care of creating the lock table and inserting the one single row to it before this
+     * method is executed. If the dialect supports schemas and the user has specified a custom
+     * schema in their migration settings, the options object also contains the schema name in
+     * {@link MigrationLockOptions.lockTableSchema}.
+     *
+     * Here's an example of how you might implement this method for a dialect that doesn't
+     * have explicit locks but supports `FOR UPDATE` row locks and transactional DDL:
+     *
+     * ```ts
+     * {
+     *   async acquireMigrationLock(db, options): Promise<void> {
+     *     const queryDb = options.lockTableSchema
+     *       ? db.withSchema(options.lockTableSchema)
+     *       : db
+     *
+     *     // Since our imaginary dialect supports transactional DDL and has
+     *     // row locks, we can simply take a row lock here and it will guarantee
+     *     // all subsequent calls to this method from other transactions will
+     *     // wait until this transaction finishes.
+     *     await queryDb
+     *       .selectFrom(options.lockTable)
+     *       .selectAll()
+     *       .where('id', '=', options.lockRowId)
+     *       .forUpdate()
+     *       .execute()
+     *   }
+     * }
+     * ```
      *
      * If `supportsTransactionalDdl` is `true` then the `db` passed to this method
      * is a transaction inside which the migrations will be executed. Otherwise
      * `db` is a single connection (session) that will be used to execute the
      * migrations.
      */
-    acquireMigrationLock(db: Kysely<any>): Promise<void>;
+    acquireMigrationLock(db: Kysely<any>, options: MigrationLockOptions): Promise<void>;
     /**
      * Releases the migration lock. See {@link acquireMigrationLock}.
      *
@@ -47,5 +73,21 @@ export interface DialectAdapter {
      * is a single connection (session) that was used to execute the migrations
      * and the `acquireMigrationLock` call.
      */
-    releaseMigrationLock(db: Kysely<any>): Promise<void>;
+    releaseMigrationLock(db: Kysely<any>, options: MigrationLockOptions): Promise<void>;
+}
+export interface MigrationLockOptions {
+    /**
+     * The name of the migration lock table.
+     */
+    readonly lockTable: string;
+    /**
+     * The id of the only row in the migration lock table.
+     */
+    readonly lockRowId: string;
+    /**
+     * The schema in which the migration lock table lives. This is only
+     * defined if the user has specified a custom schema in the migration
+     * settings.
+     */
+    readonly lockTableSchema?: string;
 }

package/dist/cjs/dialect/mysql/mysql-adapter.d.ts

@@ -19,12 +19,38 @@ export declare class MysqlAdapter extends DialectAdapterBase {
      * Most dialects have explicit locks that can be used, like advisory locks
      * in PostgreSQL and the get_lock function in MySQL.
      *
-     * If the dialect doesn't have explicit locks the {@link MIGRATION_LOCK_TABLE}
-     * created by Kysely can be used instead. {@link MIGRATION_LOCK_TABLE}
-     * has two columns `id` and `is_locked` and there's only one row in the
-     * table whose id is {@link MIGRATION_LOCK_ID}. `is_locked` is an integer.
-     * Kysely takes care of creating the lock table and inserting the one single
-     * row to it before this method is executed.
+     * If the dialect doesn't have explicit locks the {@link MigrationLockOptions.lockTable}
+     * created by Kysely can be used instead. You can access it through the `options` object.
+     * The lock table has two columns `id` and `is_locked` and there's only one row in the table
+     * whose id is {@link MigrationLockOptions.lockRowId}. `is_locked` is an integer. Kysely
+     * takes care of creating the lock table and inserting the one single row to it before this
+     * method is executed. If the dialect supports schemas and the user has specified a custom
+     * schema in their migration settings, the options object also contains the schema name in
+     * {@link MigrationLockOptions.lockTableSchema}.
+     *
+     * Here's an example of how you might implement this method for a dialect that doesn't
+     * have explicit locks but supports `FOR UPDATE` row locks and transactional DDL:
+     *
+     * ```ts
+     * {
+     *   async acquireMigrationLock(db, options): Promise<void> {
+     *     const queryDb = options.lockTableSchema
+     *       ? db.withSchema(options.lockTableSchema)
+     *       : db
+     *
+     *     // Since our imaginary dialect supports transactional DDL and has
+     *     // row locks, we can simply take a row lock here and it will guarantee
+     *     // all subsequent calls to this method from other transactions will
+     *     // wait until this transaction finishes.
+     *     await queryDb
+     *       .selectFrom(options.lockTable)
+     *       .selectAll()
+     *       .where('id', '=', options.lockRowId)
+     *       .forUpdate()
+     *       .execute()
+     *   }
+     * }
+     * ```
      *
      * If `supportsTransactionalDdl` is `true` then the `db` passed to this method
      * is a transaction inside which the migrations will be executed. Otherwise

package/dist/cjs/dialect/mysql/mysql-introspector.d.ts

@@ -8,7 +8,7 @@ export declare class MysqlIntrospector implements DatabaseIntrospector {
      */
     getSchemas(): Promise<SchemaMetadata[]>;
     /**
-     * Get table metadata.
+     * Get tables and views metadata.
      */
     getTables(options?: DatabaseMetadataOptions): Promise<TableMetadata[]>;
     /**

package/dist/cjs/dialect/mysql/mysql-introspector.js

@@ -13,30 +13,35 @@ class MysqlIntrospector {
         let rawSchemas = await this.#db
             .selectFrom('information_schema.schemata')
             .select('schema_name')
-            .castTo()
+            .$castTo()
             .execute();
         return rawSchemas.map((it) => ({ name: it.SCHEMA_NAME }));
     }
     async getTables(options = { withInternalKyselyTables: false }) {
         let query = this.#db
-            .selectFrom('information_schema.columns')
+            .selectFrom('information_schema.columns as columns')
+            .innerJoin('information_schema.tables as tables', (b) => b
+            .onRef('columns.TABLE_CATALOG', '=', 'tables.TABLE_CATALOG')
+            .onRef('columns.TABLE_SCHEMA', '=', 'tables.TABLE_SCHEMA')
+            .onRef('columns.TABLE_NAME', '=', 'tables.TABLE_NAME'))
             .select([
-            'COLUMN_NAME',
-            'COLUMN_DEFAULT',
-            'TABLE_NAME',
-            'TABLE_SCHEMA',
-            'IS_NULLABLE',
-            'DATA_TYPE',
-            'EXTRA',
+            'columns.COLUMN_NAME',
+            'columns.COLUMN_DEFAULT',
+            'columns.TABLE_NAME',
+            'columns.TABLE_SCHEMA',
+            'tables.TABLE_TYPE',
+            'columns.IS_NULLABLE',
+            'columns.DATA_TYPE',
+            'columns.EXTRA',
         ])
-            .where('table_schema', '=', (0, sql_js_1.sql) `database()`)
-            .orderBy('table_name')
-            .orderBy('ordinal_position')
-            .castTo();
+            .where('columns.TABLE_SCHEMA', '=', (0, sql_js_1.sql) `database()`)
+            .orderBy('columns.TABLE_NAME')
+            .orderBy('columns.ORDINAL_POSITION')
+            .$castTo();
         if (!options.withInternalKyselyTables) {
             query = query
-                .where('table_name', '!=', migrator_js_1.DEFAULT_MIGRATION_TABLE)
-                .where('table_name', '!=', migrator_js_1.DEFAULT_MIGRATION_LOCK_TABLE);
+                .where('columns.TABLE_NAME', '!=', migrator_js_1.DEFAULT_MIGRATION_TABLE)
+                .where('columns.TABLE_NAME', '!=', migrator_js_1.DEFAULT_MIGRATION_LOCK_TABLE);
         }
         const rawColumns = await query.execute();
         return this.#parseTableMetadata(rawColumns);
@@ -52,6 +57,7 @@ class MysqlIntrospector {
             if (!table) {
                 table = (0, object_utils_js_1.freeze)({
                     name: it.TABLE_NAME,
+                    isView: it.TABLE_TYPE === 'VIEW',
                     schema: it.TABLE_SCHEMA,
                     columns: [],
                 });

package/dist/cjs/dialect/postgres/postgres-adapter.d.ts

@@ -19,12 +19,38 @@ export declare class PostgresAdapter extends DialectAdapterBase {
      * Most dialects have explicit locks that can be used, like advisory locks
      * in PostgreSQL and the get_lock function in MySQL.
      *
-     * If the dialect doesn't have explicit locks the {@link MIGRATION_LOCK_TABLE}
-     * created by Kysely can be used instead. {@link MIGRATION_LOCK_TABLE}
-     * has two columns `id` and `is_locked` and there's only one row in the
-     * table whose id is {@link MIGRATION_LOCK_ID}. `is_locked` is an integer.
-     * Kysely takes care of creating the lock table and inserting the one single
-     * row to it before this method is executed.
+     * If the dialect doesn't have explicit locks the {@link MigrationLockOptions.lockTable}
+     * created by Kysely can be used instead. You can access it through the `options` object.
+     * The lock table has two columns `id` and `is_locked` and there's only one row in the table
+     * whose id is {@link MigrationLockOptions.lockRowId}. `is_locked` is an integer. Kysely
+     * takes care of creating the lock table and inserting the one single row to it before this
+     * method is executed. If the dialect supports schemas and the user has specified a custom
+     * schema in their migration settings, the options object also contains the schema name in
+     * {@link MigrationLockOptions.lockTableSchema}.
+     *
+     * Here's an example of how you might implement this method for a dialect that doesn't
+     * have explicit locks but supports `FOR UPDATE` row locks and transactional DDL:
+     *
+     * ```ts
+     * {
+     *   async acquireMigrationLock(db, options): Promise<void> {
+     *     const queryDb = options.lockTableSchema
+     *       ? db.withSchema(options.lockTableSchema)
+     *       : db
+     *
+     *     // Since our imaginary dialect supports transactional DDL and has
+     *     // row locks, we can simply take a row lock here and it will guarantee
+     *     // all subsequent calls to this method from other transactions will
+     *     // wait until this transaction finishes.
+     *     await queryDb
+     *       .selectFrom(options.lockTable)
+     *       .selectAll()
+     *       .where('id', '=', options.lockRowId)
+     *       .forUpdate()
+     *       .execute()
+     *   }
+     * }
+     * ```
      *
      * If `supportsTransactionalDdl` is `true` then the `db` passed to this method
      * is a transaction inside which the migrations will be executed. Otherwise

package/dist/cjs/dialect/postgres/postgres-introspector.d.ts

@@ -8,7 +8,7 @@ export declare class PostgresIntrospector implements DatabaseIntrospector {
      */
     getSchemas(): Promise<SchemaMetadata[]>;
     /**
-     * Get table metadata.
+     * Get tables and views metadata.
      */
     getTables(options?: DatabaseMetadataOptions): Promise<TableMetadata[]>;
     /**

package/dist/cjs/dialect/postgres/postgres-introspector.js

@@ -13,7 +13,7 @@ class PostgresIntrospector {
         let rawSchemas = await this.#db
             .selectFrom('pg_catalog.pg_namespace')
             .select('nspname')
-            .castTo()
+            .$castTo()
             .execute();
         return rawSchemas.map((it) => ({ name: it.nspname }));
     }
@@ -34,6 +34,7 @@ class PostgresIntrospector {
             'a.attnotnull as not_null',
             'a.atthasdef as has_default',
             'c.relname as table',
+            'c.relkind as table_type',
             'ns.nspname as schema',
             'typ.typname as type',
             'dtns.nspname as type_schema',
@@ -49,7 +50,7 @@ class PostgresIntrospector {
                 .as('auto_incrementing'),
         ])
             // r == normal table
-            .where('c.relkind', '=', 'r')
+            .where('c.relkind', 'in', ['r', 'v'])
             .where('ns.nspname', '!~', '^pg_')
             .where('ns.nspname', '!=', 'information_schema')
             // No system columns
@@ -58,7 +59,7 @@ class PostgresIntrospector {
             .orderBy('ns.nspname')
             .orderBy('c.relname')
             .orderBy('a.attnum')
-            .castTo();
+            .$castTo();
         if (!options.withInternalKyselyTables) {
             query = query
                 .where('c.relname', '!=', migrator_js_1.DEFAULT_MIGRATION_TABLE)
@@ -78,6 +79,7 @@ class PostgresIntrospector {
             if (!table) {
                 table = (0, object_utils_js_1.freeze)({
                     name: it.table,
+                    isView: it.table_type === 'v',
                     schema: it.schema,
                     columns: [],
                 });

package/dist/cjs/dialect/sqlite/sqlite-adapter.d.ts

@@ -18,12 +18,38 @@ export declare class SqliteAdapter implements DialectAdapterBase {
      * Most dialects have explicit locks that can be used, like advisory locks
      * in PostgreSQL and the get_lock function in MySQL.
      *
-     * If the dialect doesn't have explicit locks the {@link MIGRATION_LOCK_TABLE}
-     * created by Kysely can be used instead. {@link MIGRATION_LOCK_TABLE}
-     * has two columns `id` and `is_locked` and there's only one row in the
-     * table whose id is {@link MIGRATION_LOCK_ID}. `is_locked` is an integer.
-     * Kysely takes care of creating the lock table and inserting the one single
-     * row to it before this method is executed.
+     * If the dialect doesn't have explicit locks the {@link MigrationLockOptions.lockTable}
+     * created by Kysely can be used instead. You can access it through the `options` object.
+     * The lock table has two columns `id` and `is_locked` and there's only one row in the table
+     * whose id is {@link MigrationLockOptions.lockRowId}. `is_locked` is an integer. Kysely
+     * takes care of creating the lock table and inserting the one single row to it before this
+     * method is executed. If the dialect supports schemas and the user has specified a custom
+     * schema in their migration settings, the options object also contains the schema name in
+     * {@link MigrationLockOptions.lockTableSchema}.
+     *
+     * Here's an example of how you might implement this method for a dialect that doesn't
+     * have explicit locks but supports `FOR UPDATE` row locks and transactional DDL:
+     *
+     * ```ts
+     * {
+     *   async acquireMigrationLock(db, options): Promise<void> {
+     *     const queryDb = options.lockTableSchema
+     *       ? db.withSchema(options.lockTableSchema)
+     *       : db
+     *
+     *     // Since our imaginary dialect supports transactional DDL and has
+     *     // row locks, we can simply take a row lock here and it will guarantee
+     *     // all subsequent calls to this method from other transactions will
+     *     // wait until this transaction finishes.
+     *     await queryDb
+     *       .selectFrom(options.lockTable)
+     *       .selectAll()
+     *       .where('id', '=', options.lockRowId)
+     *       .forUpdate()
+     *       .execute()
+     *   }
+     * }
+     * ```
      *
      * If `supportsTransactionalDdl` is `true` then the `db` passed to this method
      * is a transaction inside which the migrations will be executed. Otherwise

package/dist/cjs/dialect/sqlite/sqlite-introspector.d.ts

@@ -8,7 +8,7 @@ export declare class SqliteIntrospector implements DatabaseIntrospector {
      */
     getSchemas(): Promise<SchemaMetadata[]>;
     /**
-     * Get table metadata.
+     * Get tables and views metadata.
      */
     getTables(options?: DatabaseMetadataOptions): Promise<TableMetadata[]>;
     /**

package/dist/cjs/dialect/sqlite/sqlite-introspector.js

@@ -15,11 +15,11 @@ class SqliteIntrospector {
     async getTables(options = { withInternalKyselyTables: false }) {
         let query = this.#db
             .selectFrom('sqlite_schema')
-            .where('type', '=', 'table')
+            .where('type', 'in', ['table', 'view'])
             .where('name', 'not like', 'sqlite_%')
             .select('name')
             .orderBy('name')
-            .castTo();
+            .$castTo();
         if (!options.withInternalKyselyTables) {
             query = query
                 .where('name', '!=', migrator_js_1.DEFAULT_MIGRATION_TABLE)
@@ -36,14 +36,14 @@ class SqliteIntrospector {
     async #getTableMetadata(table) {
         const db = this.#db;
         // Get the SQL that was used to create the table.
-        const createSql = await db
+        const tableDefinition = await db
             .selectFrom('sqlite_master')
             .where('name', '=', table)
-            .select('sql')
-            .castTo()
-            .execute();
+            .select(['sql', 'type'])
+            .$castTo()
+            .executeTakeFirstOrThrow();
         // Try to find the name of the column that has `autoincrement` 🤦
-        const autoIncrementCol = createSql[0]?.sql
+        const autoIncrementCol = tableDefinition.sql
             ?.split(/[\(\),]/)
             ?.find((it) => it.toLowerCase().includes('autoincrement'))
             ?.trimStart()
@@ -56,6 +56,7 @@ class SqliteIntrospector {
             .execute();
         return {
             name: table,
+            isView: tableDefinition.type === 'view',
             columns: columns.map((col) => ({
                 name: col.name,
                 dataType: col.type,

package/dist/cjs/index.d.ts

@@ -159,6 +159,7 @@ export * from './operation-node/partition-by-item-node.js';
 export * from './operation-node/set-operation-node.js';
 export * from './operation-node/binary-operation-node.js';
 export * from './operation-node/unary-operation-node.js';
+export * from './operation-node/using-node.js';
 export * from './util/column-type.js';
 export * from './util/compilable.js';
 export * from './util/explainable.js';

package/dist/cjs/index.js

@@ -176,6 +176,7 @@ __exportStar(require("./operation-node/partition-by-item-node.js"), exports);
 __exportStar(require("./operation-node/set-operation-node.js"), exports);
 __exportStar(require("./operation-node/binary-operation-node.js"), exports);
 __exportStar(require("./operation-node/unary-operation-node.js"), exports);
+__exportStar(require("./operation-node/using-node.js"), exports);
 __exportStar(require("./util/column-type.js"), exports);
 __exportStar(require("./util/compilable.js"), exports);
 __exportStar(require("./util/explainable.js"), exports);

package/dist/cjs/migration/migrator.d.ts

@@ -24,12 +24,17 @@ export interface Migration {
  * other way.
  *
  * ```ts
+ * import { promises as fs } from 'fs'
+ * import path from 'path'
+ *
  * const migrator = new Migrator({
  *   db,
- *   provider: new FileMigrationProvider(
+ *   provider: new FileMigrationProvider({
+ *     fs,
+ *     path,
  *     // Path to the folder that contains all your migrations.
- *     'some/path/to/migrations'
- *   )
+ *     migrationFolder: 'some/path/to/migrations'
+ *   })
  * })
  * ```
  */

package/dist/cjs/migration/migrator.js

@@ -19,12 +19,17 @@ exports.NO_MIGRATIONS = (0, object_utils_js_1.freeze)({ __noMigrations__: true }
  * other way.
  *
  * ```ts
+ * import { promises as fs } from 'fs'
+ * import path from 'path'
+ *
  * const migrator = new Migrator({
  *   db,
- *   provider: new FileMigrationProvider(
+ *   provider: new FileMigrationProvider({
+ *     fs,
+ *     path,
  *     // Path to the folder that contains all your migrations.
- *     'some/path/to/migrations'
- *   )
+ *     migrationFolder: 'some/path/to/migrations'
+ *   })
  * })
  * ```
  */
@@ -318,9 +323,14 @@ class Migrator {
     }
     async #runMigrations(getTargetMigrationIndex) {
         const adapter = this.#props.db.getExecutor().adapter;
+        const lockOptions = (0, object_utils_js_1.freeze)({
+            lockTable: this.#props.migrationLockTableName ?? exports.DEFAULT_MIGRATION_LOCK_TABLE,
+            lockRowId: exports.MIGRATION_LOCK_ID,
+            lockTableSchema: this.#props.migrationTableSchema,
+        });
         const run = async (db) => {
             try {
-                await adapter.acquireMigrationLock(db);
+                await adapter.acquireMigrationLock(db, lockOptions);
                 const state = await this.#getState(db);
                 if (state.migrations.length === 0) {
                     return { results: [] };
@@ -338,7 +348,7 @@ class Migrator {
                 return { results: [] };
             }
             finally {
-                await adapter.releaseMigrationLock(db);
+                await adapter.releaseMigrationLock(db, lockOptions);
             }
         };
         if (adapter.supportsTransactionalDdl) {