kysely 0.19.12 → 0.21.0

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

@@ -28,6 +28,8 @@ export class MysqlIntrospector {
             'extra',
         ])
             .where('table_schema', '=', sql `database()`)
+            .orderBy('table_name')
+            .orderBy('column_name')
             .castTo();
         if (!options.withInternalKyselyTables) {
             query = query

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

@@ -1,6 +1,11 @@
 import { DefaultQueryCompiler } from '../../query-compiler/default-query-compiler.js';
 export declare class MysqlQueryCompiler extends DefaultQueryCompiler {
     protected getCurrentParameterPlaceholder(): string;
+    protected getLeftExplainOptionsWrapper(): string;
+    protected getExplainOptionAssignment(): string;
+    protected getExplainOptionsDelimiter(): string;
+    protected getRightExplainOptionsWrapper(): string;
     protected getLeftIdentifierWrapper(): string;
     protected getRightIdentifierWrapper(): string;
+    protected sanitizeIdentifier(identifier: string): string;
 }

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

@@ -1,13 +1,29 @@
 /// <reference types="./mysql-query-compiler.d.ts" />
 import { DefaultQueryCompiler } from '../../query-compiler/default-query-compiler.js';
+const ID_WRAP_REGEX = /`/g;
 export class MysqlQueryCompiler extends DefaultQueryCompiler {
     getCurrentParameterPlaceholder() {
         return '?';
     }
+    getLeftExplainOptionsWrapper() {
+        return '';
+    }
+    getExplainOptionAssignment() {
+        return '=';
+    }
+    getExplainOptionsDelimiter() {
+        return ' ';
+    }
+    getRightExplainOptionsWrapper() {
+        return '';
+    }
     getLeftIdentifierWrapper() {
         return '`';
     }
     getRightIdentifierWrapper() {
         return '`';
     }
+    sanitizeIdentifier(identifier) {
+        return identifier.replace(ID_WRAP_REGEX, '``');
+    }
 }

package/dist/esm/dialect/postgres/postgres-dialect-config.d.ts

@@ -1,14 +1,4 @@
 import { DatabaseConnection } from '../../driver/database-connection.js';
-export declare type PostgresCursorConstructor = new <T>(sql: string, parameters: readonly unknown[]) => PostgresCursor<T>;
-export declare type PostgresCursor<T> = {
-    state: 'initialized' | 'idle' | 'submitted' | 'busy';
-    read: (rowsCount: number) => Promise<T[]>;
-} | {
-    state: 'done';
-} | {
-    state: 'error';
-    _error: Error;
-};
 /**
  * Config for the PostgreSQL dialect.
  */
@@ -56,13 +46,16 @@ export interface PostgresPoolClient {
     query<R>(cursor: PostgresCursor<R>): PostgresCursor<R>;
     release(): void;
 }
+export interface PostgresCursor<T> {
+    read(rowsCount: number): Promise<T[]>;
+    close(): Promise<void>;
+}
+export declare type PostgresCursorConstructor = new <T>(sql: string, parameters: unknown[]) => PostgresCursor<T>;
 export interface PostgresQueryResult<R> {
     command: 'UPDATE' | 'DELETE' | 'INSERT' | 'SELECT';
     rowCount: number;
     rows: R[];
 }
-export interface PostgresStreamOptions {
-}
 export interface PostgresStream<T> {
     [Symbol.asyncIterator](): AsyncIterableIterator<T>;
 }

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

@@ -87,18 +87,23 @@ class PostgresConnection {
         if (!this.#options.cursor) {
             throw new Error("'cursor' is not present in your postgres dialect config. It's required to make streaming work in postgres.");
         }
-        const cursor = this.#client.query(new this.#options.cursor(compiledQuery.sql, compiledQuery.parameters));
-        while (true) {
-            if (cursor.state === 'done') {
-                break;
-            }
-            if (cursor.state === 'error') {
-                throw cursor._error;
+        if (!Number.isInteger(chunkSize) || chunkSize <= 0) {
+            throw new Error('chunkSize must be a positive integer');
+        }
+        const cursor = this.#client.query(new this.#options.cursor(compiledQuery.sql, compiledQuery.parameters.slice()));
+        try {
+            while (true) {
+                const rows = await cursor.read(chunkSize);
+                if (rows.length === 0) {
+                    break;
+                }
+                yield {
+                    rows,
+                };
             }
-            const rows = await cursor.read(chunkSize);
-            yield {
-                rows,
-            };
+        }
+        finally {
+            await cursor.close();
         }
     }
     [PRIVATE_RELEASE_METHOD]() {

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

@@ -19,33 +19,41 @@ export class PostgresIntrospector {
         let query = this.#db
             .selectFrom('pg_catalog.pg_attribute as a')
             .innerJoin('pg_catalog.pg_class as c', 'a.attrelid', 'c.oid')
-            .innerJoin('pg_catalog.pg_tables as t', 't.tablename', 'c.relname')
+            .innerJoin('pg_catalog.pg_namespace as ns', 'c.relnamespace', 'ns.oid')
             .innerJoin('pg_catalog.pg_type as typ', 'a.atttypid', 'typ.oid')
             .select([
             'a.attname as column',
             'a.attnotnull as not_null',
             'a.atthasdef as has_default',
-            't.tablename as table',
-            't.schemaname as schema',
+            'c.relname as table',
+            'ns.nspname as schema',
             'typ.typname as type',
             // Detect if the column is auto incrementing by finding the sequence
             // that is created for `serial` and `bigserial` columns.
             this.#db
                 .selectFrom('pg_class')
                 .select(sql `true`.as('auto_incrementing'))
+                // Make sure the sequence is in the same schema as the table.
+                .whereRef('relnamespace', '=', 'c.relnamespace')
                 .where('relkind', '=', 'S')
-                .where('relname', '=', sql `t.tablename || '_' || a.attname || '_seq'`)
+                .where('relname', '=', sql `c.relname || '_' || a.attname || '_seq'`)
                 .as('auto_incrementing'),
         ])
-            .where('t.schemaname', '!~', '^pg_')
-            .where('t.schemaname', '!=', 'information_schema')
-            .where('a.attnum', '>=', 0) // No system columns
+            // r == normal table
+            .where('c.relkind', '=', 'r')
+            .where('ns.nspname', '!~', '^pg_')
+            .where('ns.nspname', '!=', 'information_schema')
+            // No system columns
+            .where('a.attnum', '>=', 0)
             .where('a.attisdropped', '!=', true)
+            .orderBy('ns.nspname')
+            .orderBy('c.relname')
+            .orderBy('a.attname')
             .castTo();
         if (!options.withInternalKyselyTables) {
             query = query
-                .where('t.tablename', '!=', DEFAULT_MIGRATION_TABLE)
-                .where('t.tablename', '!=', DEFAULT_MIGRATION_LOCK_TABLE);
+                .where('c.relname', '!=', DEFAULT_MIGRATION_TABLE)
+                .where('c.relname', '!=', DEFAULT_MIGRATION_LOCK_TABLE);
         }
         const rawColumns = await query.execute();
         return this.#parseTableMetadata(rawColumns);

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

@@ -1,6 +1,4 @@
 import { DefaultQueryCompiler } from '../../query-compiler/default-query-compiler.js';
 export declare class PostgresQueryCompiler extends DefaultQueryCompiler {
-    protected getCurrentParameterPlaceholder(): string;
-    protected getLeftIdentifierWrapper(): string;
-    protected getRightIdentifierWrapper(): string;
+    protected sanitizeIdentifier(identifier: string): string;
 }

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

@@ -1,13 +1,8 @@
 /// <reference types="./postgres-query-compiler.d.ts" />
 import { DefaultQueryCompiler } from '../../query-compiler/default-query-compiler.js';
+const ID_WRAP_REGEX = /"/g;
 export class PostgresQueryCompiler extends DefaultQueryCompiler {
-    getCurrentParameterPlaceholder() {
-        return '$' + this.numParameters;
-    }
-    getLeftIdentifierWrapper() {
-        return '"';
-    }
-    getRightIdentifierWrapper() {
-        return '"';
+    sanitizeIdentifier(identifier) {
+        return identifier.replace(ID_WRAP_REGEX, '""');
     }
 }

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

@@ -16,6 +16,7 @@ export class SqliteIntrospector {
             .where('type', '=', 'table')
             .where('name', 'not like', 'sqlite_%')
             .select('name')
+            .orderBy('name')
             .castTo();
         if (!options.withInternalKyselyTables) {
             query = query
@@ -48,6 +49,7 @@ export class SqliteIntrospector {
         const columns = await db
             .selectFrom(sql `pragma_table_info(${table})`.as('table_info'))
             .select(['name', 'type', 'notnull', 'dflt_value'])
+            .orderBy('name')
             .execute();
         return {
             name: table,

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

@@ -1,7 +1,10 @@
 import { DefaultQueryCompiler } from '../../query-compiler/default-query-compiler.js';
 export declare class SqliteQueryCompiler extends DefaultQueryCompiler {
     protected getCurrentParameterPlaceholder(): string;
+    protected getLeftExplainOptionsWrapper(): string;
+    protected getRightExplainOptionsWrapper(): string;
     protected getLeftIdentifierWrapper(): string;
     protected getRightIdentifierWrapper(): string;
     protected getAutoIncrement(): string;
+    protected sanitizeIdentifier(identifier: string): string;
 }

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

@@ -1,9 +1,16 @@
 /// <reference types="./sqlite-query-compiler.d.ts" />
 import { DefaultQueryCompiler } from '../../query-compiler/default-query-compiler.js';
+const ID_WRAP_REGEX = /"/g;
 export class SqliteQueryCompiler extends DefaultQueryCompiler {
     getCurrentParameterPlaceholder() {
         return '?';
     }
+    getLeftExplainOptionsWrapper() {
+        return '';
+    }
+    getRightExplainOptionsWrapper() {
+        return '';
+    }
     getLeftIdentifierWrapper() {
         return '"';
     }
@@ -13,4 +20,7 @@ export class SqliteQueryCompiler extends DefaultQueryCompiler {
     getAutoIncrement() {
         return 'autoincrement';
     }
+    sanitizeIdentifier(identifier) {
+        return identifier.replace(ID_WRAP_REGEX, '""');
+    }
 }

package/dist/esm/index.d.ts

@@ -73,6 +73,7 @@ export * from './migration/file-migration-provider.js';
 export * from './plugin/kysely-plugin.js';
 export * from './plugin/camel-case/camel-case-plugin.js';
 export * from './plugin/deduplicate-joins/deduplicate-joins-plugin.js';
+export * from './plugin/with-schema/with-schema-plugin.js';
 export * from './operation-node/add-column-node.js';
 export * from './operation-node/add-constraint-node.js';
 export * from './operation-node/alias-node.js';
@@ -149,8 +150,10 @@ export * from './operation-node/value-node.js';
 export * from './operation-node/values-node.js';
 export * from './operation-node/where-node.js';
 export * from './operation-node/with-node.js';
+export * from './operation-node/explain-node.js';
 export * from './util/column-type.js';
 export * from './util/compilable.js';
+export * from './util/explainable.js';
 export * from './util/log.js';
 export { AnyColumn, UnknownRow, AnySelectQueryBuilder, } from './util/type-utils.js';
 export { SelectExpression, SelectExpressionOrList, Selection, } from './parser/select-parser.js';

package/dist/esm/index.js

@@ -74,6 +74,7 @@ export * from './migration/file-migration-provider.js';
 export * from './plugin/kysely-plugin.js';
 export * from './plugin/camel-case/camel-case-plugin.js';
 export * from './plugin/deduplicate-joins/deduplicate-joins-plugin.js';
+export * from './plugin/with-schema/with-schema-plugin.js';
 export * from './operation-node/add-column-node.js';
 export * from './operation-node/add-constraint-node.js';
 export * from './operation-node/alias-node.js';
@@ -150,6 +151,8 @@ export * from './operation-node/value-node.js';
 export * from './operation-node/values-node.js';
 export * from './operation-node/where-node.js';
 export * from './operation-node/with-node.js';
+export * from './operation-node/explain-node.js';
 export * from './util/column-type.js';
 export * from './util/compilable.js';
+export * from './util/explainable.js';
 export * from './util/log.js';

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

@@ -3,9 +3,10 @@ import { TableNode } from './table-node.js';
 import { ConstraintNode } from './constraint-node.js';
 import { ColumnDefinitionNode } from './column-definition-node.js';
 import { ArrayItemType } from '../util/type-utils.js';
+import { RawNode } from './raw-node.js';
 export declare const ON_COMMIT_ACTIONS: string[];
 export declare type OnCommitAction = ArrayItemType<typeof ON_COMMIT_ACTIONS>;
-export declare type CreateTableNodeParams = Omit<CreateTableNode, 'kind' | 'table' | 'columns' | 'constraints'>;
+export declare type CreateTableNodeParams = Omit<CreateTableNode, 'kind' | 'table' | 'columns' | 'constraints' | 'frontModifiers' | 'endModifiers'>;
 export interface CreateTableNode extends OperationNode {
     readonly kind: 'CreateTableNode';
     readonly table: TableNode;
@@ -14,6 +15,8 @@ export interface CreateTableNode extends OperationNode {
     readonly temporary?: boolean;
     readonly ifNotExists?: boolean;
     readonly onCommit?: OnCommitAction;
+    readonly frontModifiers?: ReadonlyArray<RawNode>;
+    readonly endModifiers?: ReadonlyArray<RawNode>;
 }
 /**
  * @internal
@@ -23,5 +26,7 @@ export declare const CreateTableNode: Readonly<{
     create(table: TableNode): CreateTableNode;
     cloneWithColumn(createTable: CreateTableNode, column: ColumnDefinitionNode): CreateTableNode;
     cloneWithConstraint(createTable: CreateTableNode, constraint: ConstraintNode): CreateTableNode;
+    cloneWithFrontModifier(createTable: CreateTableNode, modifier: RawNode): CreateTableNode;
+    cloneWithEndModifier(createTable: CreateTableNode, modifier: RawNode): CreateTableNode;
     cloneWith(createTable: CreateTableNode, params: CreateTableNodeParams): CreateTableNode;
 }>;

package/dist/esm/operation-node/create-table-node.js

@@ -29,6 +29,22 @@ export const CreateTableNode = freeze({
                 : freeze([constraint]),
         });
     },
+    cloneWithFrontModifier(createTable, modifier) {
+        return freeze({
+            ...createTable,
+            frontModifiers: createTable.frontModifiers
+                ? freeze([...createTable.frontModifiers, modifier])
+                : freeze([modifier]),
+        });
+    },
+    cloneWithEndModifier(createTable, modifier) {
+        return freeze({
+            ...createTable,
+            endModifiers: createTable.endModifiers
+                ? freeze([...createTable.endModifiers, modifier])
+                : freeze([modifier]),
+        });
+    },
     cloneWith(createTable, params) {
         return freeze({
             ...createTable,

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

@@ -1,10 +1,10 @@
-import { IdentifierNode } from './identifier-node.js';
 import { OperationNode } from './operation-node.js';
+import { SchemableIdentifierNode } from './schemable-identifier-node.js';
 import { ValueListNode } from './value-list-node.js';
 export declare type CreateTypeNodeParams = Omit<Partial<CreateTypeNode>, 'kind'>;
 export interface CreateTypeNode extends OperationNode {
     readonly kind: 'CreateTypeNode';
-    readonly name: IdentifierNode;
+    readonly name: SchemableIdentifierNode;
     readonly enum?: ValueListNode;
 }
 /**

package/dist/esm/operation-node/create-type-node.js

@@ -1,6 +1,6 @@
 /// <reference types="./create-type-node.d.ts" />
 import { freeze } from '../util/object-utils.js';
-import { IdentifierNode } from './identifier-node.js';
+import { SchemableIdentifierNode } from './schemable-identifier-node.js';
 import { ValueListNode } from './value-list-node.js';
 import { ValueNode } from './value-node.js';
 /**
@@ -13,7 +13,7 @@ export const CreateTypeNode = freeze({
     create(name) {
         return freeze({
             kind: 'CreateTypeNode',
-            name: IdentifierNode.create(name),
+            name: SchemableIdentifierNode.create(name),
         });
     },
     cloneWithEnum(createType, values) {

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

@@ -1,12 +1,12 @@
 import { ColumnNode } from './column-node.js';
-import { IdentifierNode } from './identifier-node.js';
 import { OperationNode } from './operation-node.js';
 import { RawNode } from './raw-node.js';
+import { SchemableIdentifierNode } from './schemable-identifier-node.js';
 import { SelectQueryNode } from './select-query-node.js';
 export declare type CreateViewNodeParams = Omit<Partial<CreateViewNode>, 'kind' | 'name'>;
 export interface CreateViewNode extends OperationNode {
     readonly kind: 'CreateViewNode';
-    readonly name: IdentifierNode;
+    readonly name: SchemableIdentifierNode;
     readonly temporary?: boolean;
     readonly materialized?: boolean;
     readonly orReplace?: boolean;

package/dist/esm/operation-node/create-view-node.js

@@ -1,6 +1,6 @@
 /// <reference types="./create-view-node.d.ts" />
 import { freeze } from '../util/object-utils.js';
-import { IdentifierNode } from './identifier-node.js';
+import { SchemableIdentifierNode } from './schemable-identifier-node.js';
 /**
  * @internal
  */
@@ -11,7 +11,7 @@ export const CreateViewNode = freeze({
     create(name) {
         return freeze({
             kind: 'CreateViewNode',
-            name: IdentifierNode.create(name),
+            name: SchemableIdentifierNode.create(name),
         });
     },
     cloneWith(createView, params) {

package/dist/esm/operation-node/delete-query-node.d.ts

@@ -8,6 +8,7 @@ import { WithNode } from './with-node.js';
 import { LimitNode } from './limit-node.js';
 import { OrderByNode } from './order-by-node.js';
 import { OrderByItemNode } from './order-by-item-node.js';
+import { ExplainNode } from './explain-node.js';
 export interface DeleteQueryNode extends OperationNode {
     readonly kind: 'DeleteQueryNode';
     readonly from: FromNode;
@@ -17,6 +18,7 @@ export interface DeleteQueryNode extends OperationNode {
     readonly with?: WithNode;
     readonly orderBy?: OrderByNode;
     readonly limit?: LimitNode;
+    readonly explain?: ExplainNode;
 }
 /**
  * @internal
@@ -26,4 +28,5 @@ export declare const DeleteQueryNode: Readonly<{
     create(fromItem: TableExpressionNode, withNode?: WithNode): DeleteQueryNode;
     cloneWithOrderByItem(deleteNode: DeleteQueryNode, item: OrderByItemNode): DeleteQueryNode;
     cloneWithLimit(deleteNode: DeleteQueryNode, limit: LimitNode): DeleteQueryNode;
+    cloneWithExplain(deleteNode: DeleteQueryNode, explain: ExplainNode): DeleteQueryNode;
 }>;

package/dist/esm/operation-node/delete-query-node.js

@@ -30,4 +30,10 @@ export const DeleteQueryNode = freeze({
             limit,
         });
     },
+    cloneWithExplain(deleteNode, explain) {
+        return freeze({
+            ...deleteNode,
+            explain,
+        });
+    },
 });

package/dist/esm/operation-node/drop-index-node.d.ts

@@ -1,10 +1,10 @@
-import { IdentifierNode } from './identifier-node.js';
 import { OperationNode } from './operation-node.js';
+import { SchemableIdentifierNode } from './schemable-identifier-node.js';
 import { TableNode } from './table-node.js';
 export declare type DropIndexNodeProps = Omit<DropIndexNode, 'kind' | 'name'>;
 export interface DropIndexNode extends OperationNode {
     readonly kind: 'DropIndexNode';
-    readonly name: IdentifierNode;
+    readonly name: SchemableIdentifierNode;
     readonly table?: TableNode;
     readonly ifExists?: boolean;
 }

package/dist/esm/operation-node/drop-index-node.js

@@ -1,6 +1,6 @@
 /// <reference types="./drop-index-node.d.ts" />
 import { freeze } from '../util/object-utils.js';
-import { IdentifierNode } from './identifier-node.js';
+import { SchemableIdentifierNode } from './schemable-identifier-node.js';
 /**
  * @internal
  */
@@ -11,7 +11,7 @@ export const DropIndexNode = freeze({
     create(name, params) {
         return freeze({
             kind: 'DropIndexNode',
-            name: IdentifierNode.create(name),
+            name: SchemableIdentifierNode.create(name),
             ...params,
         });
     },

package/dist/esm/operation-node/drop-type-node.d.ts

@@ -1,9 +1,9 @@
-import { IdentifierNode } from './identifier-node.js';
 import { OperationNode } from './operation-node.js';
+import { SchemableIdentifierNode } from './schemable-identifier-node.js';
 export declare type DropTypeNodeParams = Omit<Partial<DropTypeNode>, 'kind' | 'name'>;
 export interface DropTypeNode extends OperationNode {
     readonly kind: 'DropTypeNode';
-    readonly name: IdentifierNode;
+    readonly name: SchemableIdentifierNode;
     readonly ifExists?: boolean;
 }
 /**

package/dist/esm/operation-node/drop-type-node.js

@@ -1,6 +1,6 @@
 /// <reference types="./drop-type-node.d.ts" />
 import { freeze } from '../util/object-utils.js';
-import { IdentifierNode } from './identifier-node.js';
+import { SchemableIdentifierNode } from './schemable-identifier-node.js';
 /**
  * @internal
  */
@@ -11,7 +11,7 @@ export const DropTypeNode = freeze({
     create(name) {
         return freeze({
             kind: 'DropTypeNode',
-            name: IdentifierNode.create(name),
+            name: SchemableIdentifierNode.create(name),
         });
     },
     cloneWith(dropType, params) {

package/dist/esm/operation-node/drop-view-node.d.ts

@@ -1,9 +1,9 @@
-import { IdentifierNode } from './identifier-node.js';
 import { OperationNode } from './operation-node.js';
+import { SchemableIdentifierNode } from './schemable-identifier-node.js';
 export declare type DropViewNodeParams = Omit<Partial<DropViewNode>, 'kind' | 'name'>;
 export interface DropViewNode extends OperationNode {
     readonly kind: 'DropViewNode';
-    readonly name: IdentifierNode;
+    readonly name: SchemableIdentifierNode;
     readonly ifExists?: boolean;
     readonly materialized?: boolean;
 }

package/dist/esm/operation-node/drop-view-node.js

@@ -1,6 +1,6 @@
 /// <reference types="./drop-view-node.d.ts" />
 import { freeze } from '../util/object-utils.js';
-import { IdentifierNode } from './identifier-node.js';
+import { SchemableIdentifierNode } from './schemable-identifier-node.js';
 /**
  * @internal
  */
@@ -11,7 +11,7 @@ export const DropViewNode = freeze({
     create(name) {
         return freeze({
             kind: 'DropViewNode',
-            name: IdentifierNode.create(name),
+            name: SchemableIdentifierNode.create(name),
         });
     },
     cloneWith(dropView, params) {

package/dist/esm/operation-node/explain-node.d.ts

@@ -0,0 +1,16 @@
+import { ExplainFormat } from '../util/explainable.js';
+import { AnyRawBuilder } from '../util/type-utils.js';
+import { OperationNode } from './operation-node.js';
+import { RawNode } from './raw-node.js';
+export interface ExplainNode extends OperationNode {
+    readonly kind: 'ExplainNode';
+    readonly format?: ExplainFormat;
+    readonly options?: RawNode;
+}
+/**
+ * @internal
+ */
+export declare const ExplainNode: Readonly<{
+    is(node: OperationNode): node is ExplainNode;
+    create(format?: ExplainFormat, options?: AnyRawBuilder): ExplainNode;
+}>;

package/dist/esm/operation-node/explain-node.js

@@ -0,0 +1,17 @@
+/// <reference types="./explain-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+/**
+ * @internal
+ */
+export const ExplainNode = freeze({
+    is(node) {
+        return node.kind === 'ExplainNode';
+    },
+    create(format, options) {
+        return freeze({
+            kind: 'ExplainNode',
+            format,
+            options: options?.toOperationNode(),
+        });
+    },
+});

package/dist/esm/operation-node/identifier-node.d.ts

@@ -1,12 +1,12 @@
 import { OperationNode } from './operation-node.js';
 export interface IdentifierNode extends OperationNode {
     readonly kind: 'IdentifierNode';
-    readonly identifier: string;
+    readonly name: string;
 }
 /**
  * @internal
  */
 export declare const IdentifierNode: Readonly<{
     is(node: OperationNode): node is IdentifierNode;
-    create(identifier: string): IdentifierNode;
+    create(name: string): IdentifierNode;
 }>;

package/dist/esm/operation-node/identifier-node.js

@@ -7,10 +7,10 @@ export const IdentifierNode = freeze({
     is(node) {
         return node.kind === 'IdentifierNode';
     },
-    create(identifier) {
+    create(name) {
         return freeze({
             kind: 'IdentifierNode',
-            identifier,
+            name,
         });
     },
 });

package/dist/esm/operation-node/insert-query-node.d.ts

@@ -1,4 +1,5 @@
 import { ColumnNode } from './column-node.js';
+import { ExplainNode } from './explain-node.js';
 import { OnConflictNode } from './on-conflict-node.js';
 import { OnDuplicateKeyNode } from './on-duplicate-key-node.js';
 import { OperationNode } from './operation-node.js';
@@ -20,6 +21,7 @@ export interface InsertQueryNode extends OperationNode {
     readonly with?: WithNode;
     readonly ignore?: boolean;
     readonly replace?: boolean;
+    readonly explain?: ExplainNode;
 }
 /**
  * @internal