kysely 0.19.11 → 0.20.1

package/README.md

@@ -21,7 +21,7 @@ column names, aliases and types from selected subqueries, joined subqueries, `wi
 much anything you can think of.
 
 Of course there are cases where things cannot be typed at compile time, and Kysely offers escape
-hatches for these situations. See the [sql template tag](https://koskimas.github.io/kysely/modules.html#sql) 
+hatches for these situations. See the [sql template tag](https://koskimas.github.io/kysely/functions/sql.html) 
 and the [DynamicModule](https://koskimas.github.io/kysely/classes/DynamicModule.html#ref) for more info.
 
 If you start using Kysely and can't find something you'd want to use, please open an issue or join our

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

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

package/dist/cjs/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/cjs/dialect/mysql/mysql-query-compiler.js

@@ -2,15 +2,31 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MysqlQueryCompiler = void 0;
 const default_query_compiler_js_1 = require("../../query-compiler/default-query-compiler.js");
+const ID_WRAP_REGEX = /`/g;
 class MysqlQueryCompiler extends default_query_compiler_js_1.DefaultQueryCompiler {
     getCurrentParameterPlaceholder() {
         return '?';
     }
+    getLeftExplainOptionsWrapper() {
+        return '';
+    }
+    getExplainOptionAssignment() {
+        return '=';
+    }
+    getExplainOptionsDelimiter() {
+        return ' ';
+    }
+    getRightExplainOptionsWrapper() {
+        return '';
+    }
     getLeftIdentifierWrapper() {
         return '`';
     }
     getRightIdentifierWrapper() {
         return '`';
     }
+    sanitizeIdentifier(identifier) {
+        return identifier.replace(ID_WRAP_REGEX, '``');
+    }
 }
 exports.MysqlQueryCompiler = MysqlQueryCompiler;

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

@@ -21,33 +21,41 @@ 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((0, sql_js_1.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', '=', (0, sql_js_1.sql) `t.tablename || '_' || a.attname || '_seq'`)
+                .where('relname', '=', (0, sql_js_1.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', '!=', migrator_js_1.DEFAULT_MIGRATION_TABLE)
-                .where('t.tablename', '!=', migrator_js_1.DEFAULT_MIGRATION_LOCK_TABLE);
+                .where('c.relname', '!=', migrator_js_1.DEFAULT_MIGRATION_TABLE)
+                .where('c.relname', '!=', migrator_js_1.DEFAULT_MIGRATION_LOCK_TABLE);
         }
         const rawColumns = await query.execute();
         return this.#parseTableMetadata(rawColumns);

package/dist/cjs/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/cjs/dialect/postgres/postgres-query-compiler.js

@@ -2,15 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PostgresQueryCompiler = void 0;
 const default_query_compiler_js_1 = require("../../query-compiler/default-query-compiler.js");
+const ID_WRAP_REGEX = /"/g;
 class PostgresQueryCompiler extends default_query_compiler_js_1.DefaultQueryCompiler {
-    getCurrentParameterPlaceholder() {
-        return '$' + this.numParameters;
-    }
-    getLeftIdentifierWrapper() {
-        return '"';
-    }
-    getRightIdentifierWrapper() {
-        return '"';
+    sanitizeIdentifier(identifier) {
+        return identifier.replace(ID_WRAP_REGEX, '""');
     }
 }
 exports.PostgresQueryCompiler = PostgresQueryCompiler;

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

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

package/dist/cjs/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/cjs/dialect/sqlite/sqlite-query-compiler.js

@@ -2,10 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SqliteQueryCompiler = void 0;
 const default_query_compiler_js_1 = require("../../query-compiler/default-query-compiler.js");
+const ID_WRAP_REGEX = /"/g;
 class SqliteQueryCompiler extends default_query_compiler_js_1.DefaultQueryCompiler {
     getCurrentParameterPlaceholder() {
         return '?';
     }
+    getLeftExplainOptionsWrapper() {
+        return '';
+    }
+    getRightExplainOptionsWrapper() {
+        return '';
+    }
     getLeftIdentifierWrapper() {
         return '"';
     }
@@ -15,5 +22,8 @@ class SqliteQueryCompiler extends default_query_compiler_js_1.DefaultQueryCompil
     getAutoIncrement() {
         return 'autoincrement';
     }
+    sanitizeIdentifier(identifier) {
+        return identifier.replace(ID_WRAP_REGEX, '""');
+    }
 }
 exports.SqliteQueryCompiler = SqliteQueryCompiler;

package/dist/cjs/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/cjs/index.js

@@ -89,6 +89,7 @@ __exportStar(require("./migration/file-migration-provider.js"), exports);
 __exportStar(require("./plugin/kysely-plugin.js"), exports);
 __exportStar(require("./plugin/camel-case/camel-case-plugin.js"), exports);
 __exportStar(require("./plugin/deduplicate-joins/deduplicate-joins-plugin.js"), exports);
+__exportStar(require("./plugin/with-schema/with-schema-plugin.js"), exports);
 __exportStar(require("./operation-node/add-column-node.js"), exports);
 __exportStar(require("./operation-node/add-constraint-node.js"), exports);
 __exportStar(require("./operation-node/alias-node.js"), exports);
@@ -165,6 +166,8 @@ __exportStar(require("./operation-node/value-node.js"), exports);
 __exportStar(require("./operation-node/values-node.js"), exports);
 __exportStar(require("./operation-node/where-node.js"), exports);
 __exportStar(require("./operation-node/with-node.js"), exports);
+__exportStar(require("./operation-node/explain-node.js"), exports);
 __exportStar(require("./util/column-type.js"), exports);
 __exportStar(require("./util/compilable.js"), exports);
+__exportStar(require("./util/explainable.js"), exports);
 __exportStar(require("./util/log.js"), exports);

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

@@ -2,8 +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 OnCommitAction = 'preserve rows' | 'delete rows' | 'drop';
-export declare type CreateTableNodeParams = Omit<CreateTableNode, 'kind' | 'table' | 'columns' | 'constraints'>;
+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' | 'frontModifiers' | 'endModifiers'>;
 export interface CreateTableNode extends OperationNode {
     readonly kind: 'CreateTableNode';
     readonly table: TableNode;
@@ -12,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
@@ -21,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/cjs/operation-node/create-table-node.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CreateTableNode = void 0;
+exports.CreateTableNode = exports.ON_COMMIT_ACTIONS = void 0;
 const object_utils_js_1 = require("../util/object-utils.js");
+exports.ON_COMMIT_ACTIONS = ['preserve rows', 'delete rows', 'drop'];
 /**
  * @internal
  */
@@ -30,6 +31,22 @@ exports.CreateTableNode = (0, object_utils_js_1.freeze)({
                 : (0, object_utils_js_1.freeze)([constraint]),
         });
     },
+    cloneWithFrontModifier(createTable, modifier) {
+        return (0, object_utils_js_1.freeze)({
+            ...createTable,
+            frontModifiers: createTable.frontModifiers
+                ? (0, object_utils_js_1.freeze)([...createTable.frontModifiers, modifier])
+                : (0, object_utils_js_1.freeze)([modifier]),
+        });
+    },
+    cloneWithEndModifier(createTable, modifier) {
+        return (0, object_utils_js_1.freeze)({
+            ...createTable,
+            endModifiers: createTable.endModifiers
+                ? (0, object_utils_js_1.freeze)([...createTable.endModifiers, modifier])
+                : (0, object_utils_js_1.freeze)([modifier]),
+        });
+    },
     cloneWith(createTable, params) {
         return (0, object_utils_js_1.freeze)({
             ...createTable,

package/dist/cjs/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/cjs/operation-node/delete-query-node.js

@@ -32,4 +32,10 @@ exports.DeleteQueryNode = (0, object_utils_js_1.freeze)({
             limit,
         });
     },
+    cloneWithExplain(deleteNode, explain) {
+        return (0, object_utils_js_1.freeze)({
+            ...deleteNode,
+            explain,
+        });
+    },
 });

package/dist/cjs/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/cjs/operation-node/explain-node.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExplainNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+/**
+ * @internal
+ */
+exports.ExplainNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'ExplainNode';
+    },
+    create(format, options) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'ExplainNode',
+            format,
+            options: options?.toOperationNode(),
+        });
+    },
+});

package/dist/cjs/operation-node/foreign-key-constraint-node.d.ts

@@ -20,8 +20,8 @@ export declare const ForeignKeyConstraintNode: Readonly<{
     create(sourceColumns: ReadonlyArray<ColumnNode>, targetTable: TableNode, targetColumns: ReadonlyArray<ColumnNode>, constraintName?: string): ForeignKeyConstraintNode;
     cloneWith(node: ForeignKeyConstraintNode, props: ForeignKeyConstraintNodeProps): Readonly<{
         name?: IdentifierNode | undefined;
-        onDelete?: OnModifyForeignAction | undefined;
-        onUpdate?: OnModifyForeignAction | undefined;
+        onDelete?: "no action" | "restrict" | "cascade" | "set null" | "set default" | undefined;
+        onUpdate?: "no action" | "restrict" | "cascade" | "set null" | "set default" | undefined;
         kind: 'ForeignKeyConstraintNode';
         columns: ReadonlyArray<ColumnNode>;
         references: ReferencesNode;

package/dist/cjs/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

package/dist/cjs/operation-node/operation-node-transformer.d.ts

@@ -68,6 +68,7 @@ import { ValuesNode } from './values-node.js';
 import { SelectModifierNode } from './select-modifier-node.js';
 import { CreateTypeNode } from './create-type-node.js';
 import { DropTypeNode } from './drop-type-node.js';
+import { ExplainNode } from './explain-node.js';
 /**
  * Transforms an operation node tree into another one.
  *
@@ -172,4 +173,5 @@ export declare class OperationNodeTransformer {
     protected transformValue(node: ValueNode): ValueNode;
     protected transformPrimitiveValueList(node: PrimitiveValueListNode): PrimitiveValueListNode;
     protected transformOperator(node: OperatorNode): OperatorNode;
+    protected transformExplain(node: ExplainNode): ExplainNode;
 }

package/dist/cjs/operation-node/operation-node-transformer.js

@@ -104,6 +104,7 @@ class OperationNodeTransformer {
         SelectModifierNode: this.transformSelectModifier.bind(this),
         CreateTypeNode: this.transformCreateType.bind(this),
         DropTypeNode: this.transformDropType.bind(this),
+        ExplainNode: this.transformExplain.bind(this),
     });
     transformNode = (node) => {
         if (!node) {
@@ -137,6 +138,7 @@ class OperationNodeTransformer {
             with: this.transformNode(node.with),
             having: this.transformNode(node.having),
             union: this.transformNodeList(node.union),
+            explain: this.transformNode(node.explain),
         });
     }
     transformSelection(node) {
@@ -245,6 +247,7 @@ class OperationNodeTransformer {
             with: this.transformNode(node.with),
             ignore: node.ignore,
             replace: node.replace,
+            explain: this.transformNode(node.explain),
         });
     }
     transformValues(node) {
@@ -263,6 +266,7 @@ class OperationNodeTransformer {
             with: this.transformNode(node.with),
             orderBy: this.transformNode(node.orderBy),
             limit: this.transformNode(node.limit),
+            explain: this.transformNode(node.explain),
         });
     }
     transformReturning(node) {
@@ -280,6 +284,8 @@ class OperationNodeTransformer {
             temporary: node.temporary,
             ifNotExists: node.ifNotExists,
             onCommit: node.onCommit,
+            frontModifiers: this.transformNodeList(node.frontModifiers),
+            endModifiers: this.transformNodeList(node.endModifiers),
         });
     }
     transformColumnDefinition(node) {
@@ -346,6 +352,7 @@ class OperationNodeTransformer {
             updates: this.transformNodeList(node.updates),
             returning: this.transformNode(node.returning),
             with: this.transformNode(node.with),
+            explain: this.transformNode(node.explain),
         });
     }
     transformColumnUpdate(node) {
@@ -644,5 +651,12 @@ class OperationNodeTransformer {
         // An Object.freezed leaf node. No need to clone.
         return node;
     }
+    transformExplain(node) {
+        return (0, require_all_props_js_1.requireAllProps)({
+            kind: 'ExplainNode',
+            format: node.format,
+            options: this.transformNode(node.options),
+        });
+    }
 }
 exports.OperationNodeTransformer = OperationNodeTransformer;

package/dist/cjs/operation-node/operation-node-visitor.d.ts

@@ -68,6 +68,7 @@ import { ValuesNode } from './values-node.js';
 import { SelectModifierNode } from './select-modifier-node.js';
 import { CreateTypeNode } from './create-type-node.js';
 import { DropTypeNode } from './drop-type-node.js';
+import { ExplainNode } from './explain-node.js';
 export declare abstract class OperationNodeVisitor {
     #private;
     protected readonly nodeStack: OperationNode[];
@@ -142,4 +143,5 @@ export declare abstract class OperationNodeVisitor {
     protected abstract visitSelectModifier(node: SelectModifierNode): void;
     protected abstract visitCreateType(node: CreateTypeNode): void;
     protected abstract visitDropType(node: DropTypeNode): void;
+    protected abstract visitExplain(node: ExplainNode): void;
 }

package/dist/cjs/operation-node/operation-node-visitor.js

@@ -77,6 +77,7 @@ class OperationNodeVisitor {
         SelectModifierNode: this.visitSelectModifier.bind(this),
         CreateTypeNode: this.visitCreateType.bind(this),
         DropTypeNode: this.visitDropType.bind(this),
+        ExplainNode: this.visitExplain.bind(this),
     });
     visitNode = (node) => {
         this.nodeStack.push(node);

package/dist/cjs/operation-node/operation-node.d.ts

@@ -1,4 +1,4 @@
-export declare type OperationNodeKind = 'IdentifierNode' | 'RawNode' | 'SelectQueryNode' | 'SelectionNode' | 'ReferenceNode' | 'ColumnNode' | 'TableNode' | 'AliasNode' | 'FromNode' | 'SelectAllNode' | 'FilterNode' | 'AndNode' | 'OrNode' | 'ParensNode' | 'ValueNode' | 'ValueListNode' | 'PrimitiveValueListNode' | 'JoinNode' | 'OperatorNode' | 'WhereNode' | 'InsertQueryNode' | 'DeleteQueryNode' | 'ReturningNode' | 'CreateTableNode' | 'ColumnDefinitionNode' | 'AddColumnNode' | 'DropTableNode' | 'DataTypeNode' | 'OrderByNode' | 'OrderByItemNode' | 'GroupByNode' | 'GroupByItemNode' | 'UpdateQueryNode' | 'ColumnUpdateNode' | 'LimitNode' | 'OffsetNode' | 'OnConflictNode' | 'OnDuplicateKeyNode' | 'CreateIndexNode' | 'DropIndexNode' | 'ListNode' | 'ReferencesNode' | 'PrimaryKeyConstraintNode' | 'UniqueConstraintNode' | 'CheckConstraintNode' | 'ForeignKeyConstraintNode' | 'WithNode' | 'CommonTableExpressionNode' | 'HavingNode' | 'CreateSchemaNode' | 'DropSchemaNode' | 'AlterTableNode' | 'ModifyColumnNode' | 'DropColumnNode' | 'RenameColumnNode' | 'AlterColumnNode' | 'AddConstraintNode' | 'DropConstraintNode' | 'UnionNode' | 'CreateViewNode' | 'DropViewNode' | 'GeneratedNode' | 'DefaultValueNode' | 'OnNode' | 'ValuesNode' | 'CommonTableExpressionNameNode' | 'SelectModifierNode' | 'CreateTypeNode' | 'DropTypeNode';
+export declare type OperationNodeKind = 'IdentifierNode' | 'RawNode' | 'SelectQueryNode' | 'SelectionNode' | 'ReferenceNode' | 'ColumnNode' | 'TableNode' | 'AliasNode' | 'FromNode' | 'SelectAllNode' | 'FilterNode' | 'AndNode' | 'OrNode' | 'ParensNode' | 'ValueNode' | 'ValueListNode' | 'PrimitiveValueListNode' | 'JoinNode' | 'OperatorNode' | 'WhereNode' | 'InsertQueryNode' | 'DeleteQueryNode' | 'ReturningNode' | 'CreateTableNode' | 'ColumnDefinitionNode' | 'AddColumnNode' | 'DropTableNode' | 'DataTypeNode' | 'OrderByNode' | 'OrderByItemNode' | 'GroupByNode' | 'GroupByItemNode' | 'UpdateQueryNode' | 'ColumnUpdateNode' | 'LimitNode' | 'OffsetNode' | 'OnConflictNode' | 'OnDuplicateKeyNode' | 'CreateIndexNode' | 'DropIndexNode' | 'ListNode' | 'ReferencesNode' | 'PrimaryKeyConstraintNode' | 'UniqueConstraintNode' | 'CheckConstraintNode' | 'ForeignKeyConstraintNode' | 'WithNode' | 'CommonTableExpressionNode' | 'HavingNode' | 'CreateSchemaNode' | 'DropSchemaNode' | 'AlterTableNode' | 'ModifyColumnNode' | 'DropColumnNode' | 'RenameColumnNode' | 'AlterColumnNode' | 'AddConstraintNode' | 'DropConstraintNode' | 'UnionNode' | 'CreateViewNode' | 'DropViewNode' | 'GeneratedNode' | 'DefaultValueNode' | 'OnNode' | 'ValuesNode' | 'CommonTableExpressionNameNode' | 'SelectModifierNode' | 'CreateTypeNode' | 'DropTypeNode' | 'ExplainNode';
 export interface OperationNode {
     readonly kind: OperationNodeKind;
 }

package/dist/cjs/operation-node/reference-node.d.ts

@@ -13,5 +13,5 @@ export interface ReferenceNode extends OperationNode {
 export declare const ReferenceNode: Readonly<{
     is(node: OperationNode): node is ReferenceNode;
     create(table: TableNode, column: ColumnNode): ReferenceNode;
-    createSelectAll(table: string): ReferenceNode;
+    createSelectAll(table: TableNode): ReferenceNode;
 }>;

package/dist/cjs/operation-node/reference-node.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ReferenceNode = void 0;
-const table_node_js_1 = require("./table-node.js");
 const select_all_node_js_1 = require("./select-all-node.js");
 const object_utils_js_1 = require("../util/object-utils.js");
 /**
@@ -21,7 +20,7 @@ exports.ReferenceNode = (0, object_utils_js_1.freeze)({
     createSelectAll(table) {
         return (0, object_utils_js_1.freeze)({
             kind: 'ReferenceNode',
-            table: table_node_js_1.TableNode.create(table),
+            table,
             column: select_all_node_js_1.SelectAllNode.create(),
         });
     },

package/dist/cjs/operation-node/references-node.d.ts

@@ -1,7 +1,9 @@
 import { OperationNode } from './operation-node.js';
 import { ColumnNode } from './column-node.js';
 import { TableNode } from './table-node.js';
-export declare type OnModifyForeignAction = 'no action' | 'restrict' | 'cascade' | 'set null' | 'set default';
+import { ArrayItemType } from '../util/type-utils.js';
+export declare const ON_MODIFY_FOREIGN_ACTIONS: readonly ["no action", "restrict", "cascade", "set null", "set default"];
+export declare type OnModifyForeignAction = ArrayItemType<typeof ON_MODIFY_FOREIGN_ACTIONS>;
 export interface ReferencesNode extends OperationNode {
     readonly kind: 'ReferencesNode';
     readonly table: TableNode;

package/dist/cjs/operation-node/references-node.js

@@ -1,7 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ReferencesNode = void 0;
+exports.ReferencesNode = exports.ON_MODIFY_FOREIGN_ACTIONS = void 0;
 const object_utils_js_1 = require("../util/object-utils.js");
+exports.ON_MODIFY_FOREIGN_ACTIONS = [
+    'no action',
+    'restrict',
+    'cascade',
+    'set null',
+    'set default',
+];
 /**
  * @internal
  */

package/dist/cjs/operation-node/select-query-node.d.ts

@@ -14,6 +14,7 @@ import { WhereNode } from './where-node.js';
 import { WithNode } from './with-node.js';
 import { UnionNode } from './union-node.js';
 import { SelectModifierNode } from './select-modifier-node.js';
+import { ExplainNode } from './explain-node.js';
 export interface SelectQueryNode extends OperationNode {
     readonly kind: 'SelectQueryNode';
     readonly from: FromNode;
@@ -30,6 +31,7 @@ export interface SelectQueryNode extends OperationNode {
     readonly with?: WithNode;
     readonly having?: HavingNode;
     readonly union?: ReadonlyArray<UnionNode>;
+    readonly explain?: ExplainNode;
 }
 /**
  * @internal
@@ -48,4 +50,5 @@ export declare const SelectQueryNode: Readonly<{
     cloneWithHaving(selectNode: SelectQueryNode, filter: FilterExpressionNode): SelectQueryNode;
     cloneWithOrHaving(selectNode: SelectQueryNode, filter: FilterExpressionNode): SelectQueryNode;
     cloneWithUnion(selectNode: SelectQueryNode, union: UnionNode): SelectQueryNode;
+    cloneWithExplain(selectNode: SelectQueryNode, explain: ExplainNode): SelectQueryNode;
 }>;

package/dist/cjs/operation-node/select-query-node.js

@@ -104,4 +104,10 @@ exports.SelectQueryNode = (0, object_utils_js_1.freeze)({
                 : (0, object_utils_js_1.freeze)([union]),
         });
     },
+    cloneWithExplain(selectNode, explain) {
+        return (0, object_utils_js_1.freeze)({
+            ...selectNode,
+            explain,
+        });
+    },
 });

package/dist/cjs/operation-node/selection-node.d.ts

@@ -3,6 +3,7 @@ import { ColumnNode } from './column-node.js';
 import { OperationNode } from './operation-node.js';
 import { ReferenceNode } from './reference-node.js';
 import { SelectAllNode } from './select-all-node.js';
+import { TableNode } from './table-node.js';
 declare type SelectionNodeChild = ColumnNode | ReferenceNode | AliasNode | SelectAllNode;
 export interface SelectionNode extends OperationNode {
     readonly kind: 'SelectionNode';
@@ -15,6 +16,6 @@ export declare const SelectionNode: Readonly<{
     is(node: OperationNode): node is SelectionNode;
     create(selection: SelectionNodeChild): SelectionNode;
     createSelectAll(): SelectionNode;
-    createSelectAllFromTable(table: string): SelectionNode;
+    createSelectAllFromTable(table: TableNode): SelectionNode;
 }>;
 export {};