kysely 0.9.8 → 0.11.0

package/dist/esm/dialect/postgres/postgres-driver.js

@@ -1,4 +1,5 @@
-import { isFunction } from '../../util/object-utils.js';
+import { CompiledQuery } from '../../query-compiler/compiled-query.js';
+import { importNamedFunction } from '../../util/dynamic-import.js';
 const PRIVATE_RELEASE_METHOD = Symbol();
 export class PostgresDriver {
     #config;
@@ -35,20 +36,17 @@ export class PostgresDriver {
     }
     async beginTransaction(connection, settings) {
         if (settings.isolationLevel) {
-            await connection.executeQuery({
-                sql: `start transaction isolation level ${settings.isolationLevel}`,
-                parameters: [],
-            });
+            await connection.executeQuery(CompiledQuery.raw(`start transaction isolation level ${settings.isolationLevel}`));
         }
         else {
-            await connection.executeQuery({ sql: 'begin', parameters: [] });
+            await connection.executeQuery(CompiledQuery.raw('begin'));
         }
     }
     async commitTransaction(connection) {
-        await connection.executeQuery({ sql: 'commit', parameters: [] });
+        await connection.executeQuery(CompiledQuery.raw('commit'));
     }
     async rollbackTransaction(connection) {
-        await connection.executeQuery({ sql: 'rollback', parameters: [] });
+        await connection.executeQuery(CompiledQuery.raw('rollback'));
     }
     async releaseConnection(connection) {
         const pgConnection = connection;
@@ -64,16 +62,7 @@ export class PostgresDriver {
 }
 async function importPgPool() {
     try {
-        // For this to work with both esm and cjs modules we need
-        // this hacky crap here.
-        const pg = (await import('pg'));
-        if (isFunction(pg.Pool)) {
-            return pg.Pool;
-        }
-        else {
-            // With esm the imported module doesn't match the typings.
-            return pg.default.Pool;
-        }
+        return await importNamedFunction('pg', 'Pool');
     }
     catch (error) {
         throw new Error('Postgres client not installed. Please run `npm install pg`');
@@ -90,7 +79,7 @@ class PostgresConnection {
         ]);
         if (result.command === 'UPDATE' || result.command === 'DELETE') {
             return {
-                numUpdatedOrDeletedRows: result.rowCount,
+                numUpdatedOrDeletedRows: BigInt(result.rowCount),
                 rows: result.rows ?? [],
             };
         }

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

@@ -0,0 +1,7 @@
+import { DialectAdapter } from '../dialect-adapter.js';
+export declare class SqliteAdapter implements DialectAdapter {
+    get supportsTransactionalDdl(): boolean;
+    get supportsReturning(): boolean;
+    acquireMigrationLock(): Promise<void>;
+    releaseMigrationLock(): Promise<void>;
+}

package/dist/esm/dialect/sqlite/sqlite-adapter.js

@@ -0,0 +1,14 @@
+export class SqliteAdapter {
+    get supportsTransactionalDdl() {
+        return false;
+    }
+    get supportsReturning() {
+        return false;
+    }
+    async acquireMigrationLock() {
+        // Nothing to do here.
+    }
+    async releaseMigrationLock() {
+        // Nothing to do here.
+    }
+}

package/dist/esm/dialect/sqlite/sqlite-dialect.d.ts

@@ -0,0 +1,64 @@
+import { Driver } from '../../driver/driver.js';
+import { Kysely } from '../../kysely.js';
+import { QueryCompiler } from '../../query-compiler/query-compiler.js';
+import { Dialect } from '../dialect.js';
+import { DatabaseIntrospector } from '../../introspection/database-introspector.js';
+import { DialectAdapter } from '../dialect-adapter.js';
+import { DatabaseConnection } from '../../driver/database-connection.js';
+/**
+ * SQLite dialect that uses the [better-sqlite3](https://github.com/JoshuaWise/better-sqlite3) library.
+ *
+ * The {@link SqliteDialectConfig | configuration} is used to construct an instance of
+ * [Database](https://github.com/JoshuaWise/better-sqlite3/blob/master/docs/api.md#new-databasepath-options)
+ * class. The configuration values are passed directly to the `Database` constructor.
+ */
+export declare class SqliteDialect implements Dialect {
+    #private;
+    constructor(config: SqliteDialectConfig);
+    createDriver(): Driver;
+    createQueryCompiler(): QueryCompiler;
+    createAdapter(): DialectAdapter;
+    createIntrospector(db: Kysely<any>): DatabaseIntrospector;
+}
+/**
+ * Config for the SQLite dialect.
+ *
+ * This interface is equal to `better-sqlite3` library's `Databse` class's constructor parameters.
+ *
+ * https://github.com/JoshuaWise/better-sqlite3/blob/master/docs/api.md#new-databasepath-options
+ */
+export interface SqliteDialectConfig {
+    /**
+     * The database file path.
+     *
+     * This is passed as the first argument for the [Database](https://github.com/JoshuaWise/better-sqlite3/blob/master/docs/api.md#new-databasepath-options)
+     * class constructor.
+     */
+    databasePath: string;
+    /**
+     * Open the database connection in readonly mode (default: false)
+     */
+    readonly?: boolean;
+    /**
+     * If the database does not exist, an Error will be thrown instead of creating a new file.
+     * This option is ignored for in-memory, temporary, or readonly database connections
+     * (default: false)
+     */
+    fileMustExist?: boolean;
+    /**
+     * The number of milliseconds to wait when executing queries on a locked database,
+     * before throwing a SQLITE_BUSY error (default: 5000)
+     */
+    timeout?: number;
+    /**
+     * Provide a function that gets called with every SQL string executed by the database connection
+     * (default: null)
+     */
+    verbose?: (sql: string) => void;
+    /**
+     * Called once when the first query is executed.
+     *
+     * This is a Kysely specific feature and does not come from the `better-sqlite3` module.
+     */
+    onCreateConnection?: (connection: DatabaseConnection) => Promise<void>;
+}

package/dist/esm/dialect/sqlite/sqlite-dialect.js

@@ -0,0 +1,29 @@
+import { SqliteDriver } from './sqlite-driver.js';
+import { SqliteQueryCompiler } from './sqlite-query-compiler.js';
+import { SqliteIntrospector } from './sqlite-introspector.js';
+import { SqliteAdapter } from './sqlite-adapter.js';
+/**
+ * SQLite dialect that uses the [better-sqlite3](https://github.com/JoshuaWise/better-sqlite3) library.
+ *
+ * The {@link SqliteDialectConfig | configuration} is used to construct an instance of
+ * [Database](https://github.com/JoshuaWise/better-sqlite3/blob/master/docs/api.md#new-databasepath-options)
+ * class. The configuration values are passed directly to the `Database` constructor.
+ */
+export class SqliteDialect {
+    #config;
+    constructor(config) {
+        this.#config = config;
+    }
+    createDriver() {
+        return new SqliteDriver(this.#config);
+    }
+    createQueryCompiler() {
+        return new SqliteQueryCompiler();
+    }
+    createAdapter() {
+        return new SqliteAdapter();
+    }
+    createIntrospector(db) {
+        return new SqliteIntrospector(db);
+    }
+}

package/dist/esm/dialect/sqlite/sqlite-driver.d.ts

@@ -0,0 +1,14 @@
+import { DatabaseConnection } from '../../driver/database-connection.js';
+import { Driver } from '../../driver/driver.js';
+import { SqliteDialectConfig } from './sqlite-dialect.js';
+export declare class SqliteDriver implements Driver {
+    #private;
+    constructor(config: SqliteDialectConfig);
+    init(): Promise<void>;
+    acquireConnection(): Promise<DatabaseConnection>;
+    beginTransaction(connection: DatabaseConnection): Promise<void>;
+    commitTransaction(connection: DatabaseConnection): Promise<void>;
+    rollbackTransaction(connection: DatabaseConnection): Promise<void>;
+    releaseConnection(): Promise<void>;
+    destroy(): Promise<void>;
+}

package/dist/esm/dialect/sqlite/sqlite-driver.js

@@ -0,0 +1,112 @@
+import { CompiledQuery } from '../../query-compiler/compiled-query.js';
+import { importFunction } from '../../util/dynamic-import.js';
+export class SqliteDriver {
+    #config;
+    #connectionMutex = new ConnectionMutex();
+    #db;
+    #connection;
+    constructor(config) {
+        this.#config = config;
+    }
+    async init() {
+        // Import the `better-sqlite3` module here instead at the top of the file
+        // so that this file can be loaded by node without `better-sqlite3` driver
+        // installed. As you can see, there IS an import from `better-sqlite3` at
+        // the top level too, but that's only for types. It doesn't get compiled
+        // into javascript. You can check the built javascript code.
+        const DatabaseConstructor = await importBetterSqlite3Database();
+        const options = {};
+        if (typeof this.#config.readonly === 'boolean') {
+            options.readonly = this.#config.readonly;
+        }
+        if (typeof this.#config.fileMustExist === 'boolean') {
+            options.fileMustExist = this.#config.fileMustExist;
+        }
+        if (typeof this.#config.timeout === 'number') {
+            options.timeout = this.#config.timeout;
+        }
+        if (typeof this.#config.verbose === 'function') {
+            options.verbose = this.#config.verbose;
+        }
+        this.#db = new DatabaseConstructor(this.#config.databasePath, options);
+        this.#connection = new SqliteConnection(this.#db);
+        if (this.#config.onCreateConnection) {
+            await this.#config.onCreateConnection(this.#connection);
+        }
+    }
+    async acquireConnection() {
+        // sqlite effectively only has one single connection. We use a mutex
+        // here to wait until the single connection has been released.
+        await this.#connectionMutex.lock();
+        return this.#connection;
+    }
+    async beginTransaction(connection) {
+        await connection.executeQuery(CompiledQuery.raw('begin'));
+    }
+    async commitTransaction(connection) {
+        await connection.executeQuery(CompiledQuery.raw('commit'));
+    }
+    async rollbackTransaction(connection) {
+        await connection.executeQuery(CompiledQuery.raw('rollback'));
+    }
+    async releaseConnection() {
+        this.#connectionMutex.unlock();
+    }
+    async destroy() {
+        this.#db?.close();
+    }
+}
+async function importBetterSqlite3Database() {
+    try {
+        return await importFunction('better-sqlite3');
+    }
+    catch (error) {
+        console.error(error);
+        throw new Error('SQLite client not installed. Please run `npm install better-sqlite3`');
+    }
+}
+class SqliteConnection {
+    #db;
+    constructor(db) {
+        this.#db = db;
+    }
+    executeQuery(compiledQuery) {
+        const { sql, parameters } = compiledQuery;
+        const stmt = this.#db.prepare(sql);
+        if (stmt.reader) {
+            return Promise.resolve({
+                rows: stmt.all(parameters),
+            });
+        }
+        else {
+            const { changes, lastInsertRowid } = stmt.run(parameters);
+            return Promise.resolve({
+                numUpdatedOrDeletedRows: changes !== undefined && changes !== null
+                    ? BigInt(changes)
+                    : undefined,
+                insertId: lastInsertRowid !== undefined && lastInsertRowid !== null
+                    ? BigInt(lastInsertRowid)
+                    : undefined,
+                rows: [],
+            });
+        }
+    }
+}
+class ConnectionMutex {
+    #promise;
+    #resolve;
+    async lock() {
+        while (this.#promise) {
+            await this.#promise;
+        }
+        this.#promise = new Promise((resolve) => {
+            this.#resolve = resolve;
+        });
+    }
+    unlock() {
+        const resolve = this.#resolve;
+        this.#promise = undefined;
+        this.#resolve = undefined;
+        resolve?.();
+    }
+}

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

@@ -0,0 +1,7 @@
+import { DatabaseIntrospector, DatabaseMetadata, DatabaseMetadataOptions } from '../../introspection/database-introspector.js';
+import { Kysely } from '../../kysely.js';
+export declare class SqliteIntrospector implements DatabaseIntrospector {
+    #private;
+    constructor(db: Kysely<any>);
+    getMetadata(options?: DatabaseMetadataOptions): Promise<DatabaseMetadata>;
+}

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

@@ -0,0 +1,27 @@
+import { MIGRATION_LOCK_TABLE, MIGRATION_TABLE, } from '../../migration/migration.js';
+export class SqliteIntrospector {
+    #db;
+    constructor(db) {
+        this.#db = db;
+    }
+    async getMetadata(options = { withInternalKyselyTables: false }) {
+        let query = this.#db
+            .selectFrom('sqlite_schema')
+            .where('type', '=', 'table')
+            .where('name', 'not like', 'sqlite_%')
+            .select('name');
+        if (!options.withInternalKyselyTables) {
+            query = query
+                .where('name', '!=', MIGRATION_TABLE)
+                .where('name', '!=', MIGRATION_LOCK_TABLE);
+        }
+        const result = await query.execute();
+        return {
+            tables: result.map((it) => ({
+                name: it.name,
+                // TODO: Get columns somehow.
+                columns: [],
+            })),
+        };
+    }
+}

package/dist/esm/dialect/sqlite/sqlite-query-compiler.d.ts

@@ -0,0 +1,7 @@
+import { DefaultQueryCompiler } from '../../query-compiler/default-query-compiler.js';
+export declare class SqliteQueryCompiler extends DefaultQueryCompiler {
+    protected visitReturning(): void;
+    protected getSql(): string;
+    protected getCurrentParameterPlaceholder(): string;
+    protected getAutoIncrement(): string;
+}

package/dist/esm/dialect/sqlite/sqlite-query-compiler.js

@@ -0,0 +1,15 @@
+import { DefaultQueryCompiler } from '../../query-compiler/default-query-compiler.js';
+export class SqliteQueryCompiler extends DefaultQueryCompiler {
+    visitReturning() {
+        // Do nothing.
+    }
+    getSql() {
+        return super.getSql().trimEnd();
+    }
+    getCurrentParameterPlaceholder() {
+        return '?';
+    }
+    getAutoIncrement() {
+        return 'autoincrement';
+    }
+}

package/dist/esm/driver/database-connection.d.ts

@@ -12,12 +12,12 @@ export interface QueryResult<O> {
      * This is defined for update and delete queries and contains
      * the number of rows the query updated/deleted.
      */
-    readonly numUpdatedOrDeletedRows?: number;
+    readonly numUpdatedOrDeletedRows?: bigint;
     /**
      * This is defined for insert queries on dialects that return
      * the auto incrementing primary key from an insert.
      */
-    readonly insertedPrimaryKey?: number;
+    readonly insertId?: bigint;
     /**
      * The rows returned by the query. This is always defined and is
      * empty if the query returned no rows.

package/dist/esm/driver/runtime-driver.js

@@ -1,3 +1,4 @@
+import { performanceNow } from '../util/performance-now.js';
 /**
  * A small wrapper around {@link Driver} that makes sure the driver is
  * initialized before it is used, only initialized and destroyed
@@ -71,7 +72,7 @@ class RuntimeConnection {
         this.#log = log;
     }
     async executeQuery(compiledQuery) {
-        const startTime = process.hrtime.bigint();
+        const startTime = performanceNow();
         try {
             return await this.#connection.executeQuery(compiledQuery);
         }
@@ -97,8 +98,6 @@ class RuntimeConnection {
         }));
     }
     #calculateDurationMillis(startTime) {
-        const endTime = process.hrtime.bigint();
-        const durationNanos = Number(endTime - startTime);
-        return durationNanos / 1_000_000;
+        return performanceNow() - startTime;
     }
 }

package/dist/esm/index.d.ts

@@ -3,6 +3,9 @@ export * from './query-creator.js';
 export * from './query-builder/query-builder.js';
 export * from './query-builder/join-builder.js';
 export * from './query-builder/expression-builder.js';
+export * from './query-builder/insert-result.js';
+export * from './query-builder/delete-result.js';
+export * from './query-builder/update-result.js';
 export * from './raw-builder/raw-builder.js';
 export * from './query-executor/query-executor.js';
 export * from './query-executor/default-query-executor.js';
@@ -19,6 +22,8 @@ export * from './schema/drop-schema-builder.js';
 export * from './schema/column-definition-builder.js';
 export * from './schema/foreign-key-constraint-builder.js';
 export * from './schema/alter-table-builder.js';
+export * from './schema/create-view-builder.js';
+export * from './schema/drop-view-builder.js';
 export * from './dynamic/dynamic.js';
 export * from './driver/driver.js';
 export * from './driver/database-connection.js';
@@ -35,6 +40,11 @@ export * from './dialect/mysql/mysql-query-compiler.js';
 export * from './dialect/mysql/mysql-driver.js';
 export * from './dialect/mysql/mysql-introspector.js';
 export * from './dialect/mysql/mysql-adapter.js';
+export * from './dialect/sqlite/sqlite-dialect.js';
+export * from './dialect/sqlite/sqlite-query-compiler.js';
+export * from './dialect/sqlite/sqlite-driver.js';
+export * from './dialect/sqlite/sqlite-introspector.js';
+export * from './dialect/sqlite/sqlite-adapter.js';
 export * from './query-compiler/default-query-compiler.js';
 export * from './query-compiler/query-compiler.js';
 export * from './migration/migration.js';

package/dist/esm/index.js

@@ -3,6 +3,9 @@ export * from './query-creator.js';
 export * from './query-builder/query-builder.js';
 export * from './query-builder/join-builder.js';
 export * from './query-builder/expression-builder.js';
+export * from './query-builder/insert-result.js';
+export * from './query-builder/delete-result.js';
+export * from './query-builder/update-result.js';
 export * from './raw-builder/raw-builder.js';
 export * from './query-executor/query-executor.js';
 export * from './query-executor/default-query-executor.js';
@@ -19,6 +22,8 @@ export * from './schema/drop-schema-builder.js';
 export * from './schema/column-definition-builder.js';
 export * from './schema/foreign-key-constraint-builder.js';
 export * from './schema/alter-table-builder.js';
+export * from './schema/create-view-builder.js';
+export * from './schema/drop-view-builder.js';
 export * from './dynamic/dynamic.js';
 export * from './driver/driver.js';
 export * from './driver/database-connection.js';
@@ -35,6 +40,11 @@ export * from './dialect/mysql/mysql-query-compiler.js';
 export * from './dialect/mysql/mysql-driver.js';
 export * from './dialect/mysql/mysql-introspector.js';
 export * from './dialect/mysql/mysql-adapter.js';
+export * from './dialect/sqlite/sqlite-dialect.js';
+export * from './dialect/sqlite/sqlite-query-compiler.js';
+export * from './dialect/sqlite/sqlite-driver.js';
+export * from './dialect/sqlite/sqlite-introspector.js';
+export * from './dialect/sqlite/sqlite-adapter.js';
 export * from './query-compiler/default-query-compiler.js';
 export * from './query-compiler/query-compiler.js';
 export * from './migration/migration.js';

package/dist/esm/kysely.d.ts

@@ -116,7 +116,7 @@ export declare class Kysely<DB> extends QueryCreator<DB> {
      *   .execute()
      * ```
      *
-     * The generated SQL (postgresql):
+     * The generated SQL (PostgreSQL):
      *
      * ```sql
      * select "person"."id", count("pet"."id") as "pet_count"
@@ -146,17 +146,19 @@ export declare class Kysely<DB> extends QueryCreator<DB> {
      * const catto = await db.transaction().execute(async (trx) => {
      *   const jennifer = await trx.insertInto('person')
      *     .values({
+     *       id: db.generated,
      *       first_name: 'Jennifer',
-     *      last_name: 'Aniston',
+     *       last_name: 'Aniston',
      *     })
      *     .returning('id')
-     *     .executeTakeFirst()
+     *     .executeTakeFirstOrThrow()
      *
      *   await someFunction(trx, jennifer)
      *
      *   return await trx.insertInto('pet')
      *     .values({
-     *       user_id: jennifer!.id,
+     *       id: db.generated,
+     *       user_id: jennifer.id,
      *       name: 'Catto',
      *       species: 'cat'
      *     })

package/dist/esm/kysely.js

@@ -151,7 +151,7 @@ export class Kysely extends QueryCreator {
      *   .execute()
      * ```
      *
-     * The generated SQL (postgresql):
+     * The generated SQL (PostgreSQL):
      *
      * ```sql
      * select "person"."id", count("pet"."id") as "pet_count"
@@ -183,17 +183,19 @@ export class Kysely extends QueryCreator {
      * const catto = await db.transaction().execute(async (trx) => {
      *   const jennifer = await trx.insertInto('person')
      *     .values({
+     *       id: db.generated,
      *       first_name: 'Jennifer',
-     *      last_name: 'Aniston',
+     *       last_name: 'Aniston',
      *     })
      *     .returning('id')
-     *     .executeTakeFirst()
+     *     .executeTakeFirstOrThrow()
      *
      *   await someFunction(trx, jennifer)
      *
      *   return await trx.insertInto('pet')
      *     .values({
-     *       user_id: jennifer!.id,
+     *       id: db.generated,
+     *       user_id: jennifer.id,
      *       name: 'Catto',
      *       species: 'cat'
      *     })

package/dist/esm/migration/migration.d.ts

@@ -62,5 +62,5 @@ export declare class MigrationModule {
 }
 export interface Migration {
     up(db: Kysely<any>): Promise<void>;
-    down(db: Kysely<any>): Promise<void>;
+    down?(db: Kysely<any>): Promise<void>;
 }

package/dist/esm/migration/migration.js

@@ -57,7 +57,7 @@ async function ensureMigrationTableExists(db) {
                 .execute();
         }
         catch (error) {
-            // At least on postgres, `if not exists` doesn't guarantee the `create table`
+            // At least on PostgreSQL, `if not exists` doesn't guarantee the `create table`
             // query doesn't throw if the table already exits. That's why we check if
             // the table exist here and ignore the error if it does.
             if (!(await doesTableExists(db, MIGRATION_TABLE))) {
@@ -77,7 +77,7 @@ async function ensureMigrationLockTableExists(db) {
                 .execute();
         }
         catch (error) {
-            // At least on postgres, `if not exists` doesn't guarantee the `create table`
+            // At least on PostgreSQL, `if not exists` doesn't guarantee the `create table`
             // query doesn't throw if the table already exits. That's why we check if
             // the table exist here and ignore the error if it does.
             if (!(await doesTableExists(db, MIGRATION_LOCK_TABLE))) {
@@ -179,5 +179,5 @@ function ensureMigrationsAreNotCorrupted(executedMigrationNames, oldMigrationNam
     }
 }
 function isMigration(obj) {
-    return isObject(obj) && isFunction(obj.up) && isFunction(obj.down);
+    return isObject(obj) && isFunction(obj.up);
 }

package/dist/esm/operation-node/column-definition-node.d.ts

@@ -1,10 +1,11 @@
 import { CheckConstraintNode } from './check-constraint-node.js';
 import { ColumnNode } from './column-node.js';
 import { DataTypeNode } from './data-type-node.js';
+import { DefaultValueNode } from './default-value-node.js';
+import { GeneratedAlwaysAsNode } from './generated-always-as-node.js';
 import { OperationNode } from './operation-node.js';
 import { RawNode } from './raw-node.js';
 import { ReferencesNode } from './references-node.js';
-import { ValueNode } from './value-node.js';
 export declare type ColumnDefinitionNodeProps = Omit<Partial<ColumnDefinitionNode>, 'kind'>;
 export declare type ColumnDataTypeNode = DataTypeNode | RawNode;
 export interface ColumnDefinitionNode extends OperationNode {
@@ -12,12 +13,13 @@ export interface ColumnDefinitionNode extends OperationNode {
     readonly column: ColumnNode;
     readonly dataType: ColumnDataTypeNode;
     readonly references?: ReferencesNode;
-    readonly isPrimaryKey: boolean;
-    readonly isAutoIncrementing: boolean;
-    readonly isUnique: boolean;
-    readonly isNullable: boolean;
-    readonly defaultTo?: ValueNode | RawNode;
+    readonly primaryKey: boolean;
+    readonly autoIncrement: boolean;
+    readonly unique: boolean;
+    readonly nullable: boolean;
+    readonly defaultTo?: DefaultValueNode;
     readonly check?: CheckConstraintNode;
+    readonly generatedAlwaysAs?: GeneratedAlwaysAsNode;
 }
 /**
  * @internal

package/dist/esm/operation-node/column-definition-node.js

@@ -12,10 +12,10 @@ export const ColumnDefinitionNode = freeze({
             kind: 'ColumnDefinitionNode',
             column: ColumnNode.create(column),
             dataType,
-            isPrimaryKey: false,
-            isAutoIncrementing: false,
-            isUnique: false,
-            isNullable: true,
+            primaryKey: false,
+            autoIncrement: false,
+            unique: false,
+            nullable: true,
         });
     },
     cloneWith(node, props) {

package/dist/esm/operation-node/create-schema-node.d.ts

@@ -1,11 +1,10 @@
 import { IdentifierNode } from './identifier-node.js';
 import { OperationNode } from './operation-node.js';
-export declare type CreateSchemaNodeModifier = 'IfNotExists';
 export declare type CreateSchemaNodeParams = Omit<Partial<CreateSchemaNode>, 'kind' | 'schema'>;
 export interface CreateSchemaNode extends OperationNode {
     readonly kind: 'CreateSchemaNode';
     readonly schema: IdentifierNode;
-    readonly modifier?: CreateSchemaNodeModifier;
+    readonly ifNotExists?: boolean;
 }
 /**
  * @internal

package/dist/esm/operation-node/create-table-node.d.ts

@@ -2,12 +2,11 @@ import { OperationNode } from './operation-node.js';
 import { TableNode } from './table-node.js';
 import { ConstraintNode } from './constraint-node.js';
 import { ColumnDefinitionNode } from './column-definition-node.js';
-export declare type CreateTableNodeModifier = 'IfNotExists';
 export interface CreateTableNode extends OperationNode {
     readonly kind: 'CreateTableNode';
     readonly table: TableNode;
     readonly columns: ReadonlyArray<ColumnDefinitionNode>;
-    readonly modifier?: CreateTableNodeModifier;
+    readonly ifNotExists?: boolean;
     readonly constraints?: ReadonlyArray<ConstraintNode>;
 }
 /**
@@ -17,6 +16,6 @@ export declare const CreateTableNode: Readonly<{
     is(node: OperationNode): node is CreateTableNode;
     create(table: TableNode): CreateTableNode;
     cloneWithColumn(createTable: CreateTableNode, column: ColumnDefinitionNode): CreateTableNode;
-    cloneWithModifier(createTable: CreateTableNode, modifier: CreateTableNodeModifier): CreateTableNode;
+    cloneWithIfNotExists(createTable: CreateTableNode, ifNotExists: boolean): CreateTableNode;
     cloneWithConstraint(createTable: CreateTableNode, constraint: ConstraintNode): CreateTableNode;
 }>;