kysely 0.9.6 → 0.10.0

package/README.md

@@ -67,7 +67,9 @@ import { Kysely, PostgresDialect } from 'kysely'
 interface Person {
   id: number
   first_name: string
-  last_name: string
+  // If the column is nullable in the db, make its type nullable.
+  // Don't use optional properties.
+  last_name: string | null
   gender: 'male' | 'female' | 'other'
 }
 
@@ -172,9 +174,9 @@ export async function up(db: Kysely<any>): Promise<void> {
   await db.schema
     .createTable('person')
     .addColumn('id', 'serial', (col) => col.primaryKey())
-    .addColumn('first_name', 'varchar')
+    .addColumn('first_name', 'varchar', (col) => col.notNull())
     .addColumn('last_name', 'varchar')
-    .addColumn('gender', 'varchar(50)')
+    .addColumn('gender', 'varchar(50)', (col) => col.notNull())
     .execute()
 
   await db.schema
@@ -182,9 +184,9 @@ export async function up(db: Kysely<any>): Promise<void> {
     .addColumn('id', 'serial', (col) => col.primaryKey())
     .addColumn('name', 'varchar', (col) => col.notNull().unique())
     .addColumn('owner_id', 'integer', (col) =>
-      col.references('person.id').onDelete('cascade')
+      col.references('person.id').onDelete('cascade').notNull()
     )
-    .addColumn('species', 'varchar')
+    .addColumn('species', 'varchar', (col) => col.notNull())
     .execute()
 
   await db.schema
@@ -208,18 +210,18 @@ import { Kysely } from 'kysely'
 export async function up(db: Kysely<any>): Promise<void> {
   await db.schema
     .createTable('person')
-    .addColumn('id', 'integer', (col) => col.increments().primaryKey())
-    .addColumn('first_name', 'varchar')
-    .addColumn('last_name', 'varchar')
-    .addColumn('gender', 'varchar(50)')
+    .addColumn('id', 'integer', (col) => col.autoIncrement().primaryKey())
+    .addColumn('first_name', 'varchar(255)', (col) => col.notNull())
+    .addColumn('last_name', 'varchar(255)')
+    .addColumn('gender', 'varchar(50)', (col) => col.notNull())
     .execute()
 
   await db.schema
     .createTable('pet')
-    .addColumn('id', 'integer', (col) => col.increments().primaryKey())
-    .addColumn('name', 'varchar', (col) => col.notNull().unique())
-    .addColumn('owner_id', 'integer')
-    .addColumn('species', 'varchar')
+    .addColumn('id', 'integer', (col) => col.autoIncrement().primaryKey())
+    .addColumn('name', 'varchar(255)', (col) => col.notNull().unique())
+    .addColumn('owner_id', 'integer', (col) => col.notNull())
+    .addColumn('species', 'varchar(255)', (col) => col.notNull())
     .addForeignKeyConstraint(
       'pet_owner_id_fk', ['owner_id'], 'person', ['id'],
       (cb) => cb.onDelete('cascade')

package/dist/cjs/index.d.ts

@@ -19,6 +19,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';

package/dist/cjs/index.js

@@ -31,6 +31,8 @@ __exportStar(require("./schema/drop-schema-builder.js"), exports);
 __exportStar(require("./schema/column-definition-builder.js"), exports);
 __exportStar(require("./schema/foreign-key-constraint-builder.js"), exports);
 __exportStar(require("./schema/alter-table-builder.js"), exports);
+__exportStar(require("./schema/create-view-builder.js"), exports);
+__exportStar(require("./schema/drop-view-builder.js"), exports);
 __exportStar(require("./dynamic/dynamic.js"), exports);
 __exportStar(require("./driver/driver.js"), exports);
 __exportStar(require("./driver/database-connection.js"), exports);

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

@@ -12,10 +12,10 @@ 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 primaryKey: boolean;
+    readonly autoIncrement: boolean;
+    readonly unique: boolean;
+    readonly nullable: boolean;
     readonly defaultTo?: ValueNode | RawNode;
     readonly check?: CheckConstraintNode;
 }

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

@@ -15,10 +15,10 @@ exports.ColumnDefinitionNode = (0, object_utils_js_1.freeze)({
             kind: 'ColumnDefinitionNode',
             column: column_node_js_1.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/cjs/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/cjs/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;
 }>;

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

@@ -22,10 +22,10 @@ exports.CreateTableNode = (0, object_utils_js_1.freeze)({
             columns: (0, object_utils_js_1.freeze)([...createTable.columns, column]),
         });
     },
-    cloneWithModifier(createTable, modifier) {
+    cloneWithIfNotExists(createTable, ifNotExists) {
         return (0, object_utils_js_1.freeze)({
             ...createTable,
-            modifier,
+            ifNotExists,
         });
     },
     cloneWithConstraint(createTable, constraint) {

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

@@ -0,0 +1,22 @@
+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 { 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 materialized?: boolean;
+    readonly orReplace?: boolean;
+    readonly columns?: ReadonlyArray<ColumnNode>;
+    readonly as?: SelectQueryNode | RawNode;
+}
+/**
+ * @internal
+ */
+export declare const CreateViewNode: Readonly<{
+    is(node: OperationNode): node is CreateViewNode;
+    create(name: string): CreateViewNode;
+    cloneWith(createView: CreateViewNode, params: CreateViewNodeParams): CreateViewNode;
+}>;

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateViewNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+const identifier_node_js_1 = require("./identifier-node.js");
+/**
+ * @internal
+ */
+exports.CreateViewNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'CreateViewNode';
+    },
+    create(name) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'CreateViewNode',
+            name: identifier_node_js_1.IdentifierNode.create(name),
+        });
+    },
+    cloneWith(createView, params) {
+        return (0, object_utils_js_1.freeze)({
+            ...createView,
+            ...params,
+        });
+    },
+});

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

@@ -2,12 +2,11 @@ import { IdentifierNode } from './identifier-node.js';
 import { OperationNode } from './operation-node.js';
 import { TableNode } from './table-node.js';
 export declare type DropIndexNodeProps = Omit<DropIndexNode, 'kind' | 'name'>;
-export declare type DropIndexNodeModifier = 'IfExists';
 export interface DropIndexNode extends OperationNode {
     readonly kind: 'DropIndexNode';
     readonly name: IdentifierNode;
     readonly table?: TableNode;
-    readonly modifier?: DropIndexNodeModifier;
+    readonly ifExists?: boolean;
 }
 /**
  * @internal

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

@@ -1,11 +1,10 @@
 import { IdentifierNode } from './identifier-node.js';
 import { OperationNode } from './operation-node.js';
-export declare type DropSchemaNodeModifier = 'IfExists';
 export declare type DropSchemaNodeParams = Omit<Partial<DropSchemaNode>, 'kind' | 'schema'>;
 export interface DropSchemaNode extends OperationNode {
     readonly kind: 'DropSchemaNode';
     readonly schema: IdentifierNode;
-    readonly modifier?: DropSchemaNodeModifier;
+    readonly ifExists?: boolean;
 }
 /**
  * @internal
@@ -13,5 +12,5 @@ export interface DropSchemaNode extends OperationNode {
 export declare const DropSchemaNode: Readonly<{
     is(node: OperationNode): node is DropSchemaNode;
     create(schema: string, params?: DropSchemaNodeParams | undefined): DropSchemaNode;
-    cloneWithModifier(createSchema: DropSchemaNode, modifier: DropSchemaNodeModifier): DropSchemaNode;
+    cloneWith(dropSchema: DropSchemaNode, params: DropSchemaNodeParams): DropSchemaNode;
 }>;

package/dist/cjs/operation-node/drop-schema-node.js

@@ -17,10 +17,10 @@ exports.DropSchemaNode = (0, object_utils_js_1.freeze)({
             ...params,
         });
     },
-    cloneWithModifier(createSchema, modifier) {
+    cloneWith(dropSchema, params) {
         return (0, object_utils_js_1.freeze)({
-            ...createSchema,
-            modifier,
+            ...dropSchema,
+            ...params,
         });
     },
 });

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

@@ -1,11 +1,10 @@
 import { OperationNode } from './operation-node.js';
 import { TableNode } from './table-node.js';
 export declare type DropTablexNodeParams = Omit<Partial<DropTableNode>, 'kind' | 'table'>;
-export declare type DropTableNodeModifier = 'IfExists';
 export interface DropTableNode extends OperationNode {
     readonly kind: 'DropTableNode';
     readonly table: TableNode;
-    readonly modifier?: DropTableNodeModifier;
+    readonly ifExists?: boolean;
 }
 /**
  * @internal
@@ -13,5 +12,5 @@ export interface DropTableNode extends OperationNode {
 export declare const DropTableNode: Readonly<{
     is(node: OperationNode): node is DropTableNode;
     create(table: TableNode, params?: DropTablexNodeParams | undefined): DropTableNode;
-    cloneWithModifier(dropIndex: DropTableNode, modifier: DropTableNodeModifier): DropTableNode;
+    cloneWith(dropIndex: DropTableNode, params: DropTablexNodeParams): DropTableNode;
 }>;

package/dist/cjs/operation-node/drop-table-node.js

@@ -16,10 +16,10 @@ exports.DropTableNode = (0, object_utils_js_1.freeze)({
             ...params,
         });
     },
-    cloneWithModifier(dropIndex, modifier) {
+    cloneWith(dropIndex, params) {
         return (0, object_utils_js_1.freeze)({
             ...dropIndex,
-            modifier,
+            ...params,
         });
     },
 });

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

@@ -0,0 +1,17 @@
+import { IdentifierNode } from './identifier-node.js';
+import { OperationNode } from './operation-node.js';
+export declare type DropViewNodeParams = Omit<Partial<DropViewNode>, 'kind' | 'name'>;
+export interface DropViewNode extends OperationNode {
+    readonly kind: 'DropViewNode';
+    readonly name: IdentifierNode;
+    readonly ifExists?: boolean;
+    readonly materialized?: boolean;
+}
+/**
+ * @internal
+ */
+export declare const DropViewNode: Readonly<{
+    is(node: OperationNode): node is DropViewNode;
+    create(name: string): DropViewNode;
+    cloneWith(dropView: DropViewNode, params: DropViewNodeParams): DropViewNode;
+}>;

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DropViewNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+const identifier_node_js_1 = require("./identifier-node.js");
+/**
+ * @internal
+ */
+exports.DropViewNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'DropViewNode';
+    },
+    create(name) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'DropViewNode',
+            name: identifier_node_js_1.IdentifierNode.create(name),
+        });
+    },
+    cloneWith(dropView, params) {
+        return (0, object_utils_js_1.freeze)({
+            ...dropView,
+            ...params,
+        });
+    },
+});

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

@@ -58,6 +58,8 @@ import { ColumnDefinitionNode } from './column-definition-node.js';
 import { ModifyColumnNode } from './modify-column-node.js';
 import { OnDuplicateKeyNode } from './on-duplicate-key-node.js';
 import { UnionNode } from './union-node.js';
+import { CreateViewNode } from './create-view-node.js';
+import { DropViewNode } from './drop-view-node.js';
 /**
  * Transforms an operation node tree into another one.
  *
@@ -145,6 +147,8 @@ export declare class OperationNodeTransformer {
     protected transformModifyColumn(node: ModifyColumnNode): ModifyColumnNode;
     protected transformAddConstraint(node: AddConstraintNode): AddConstraintNode;
     protected transformDropConstraint(node: DropConstraintNode): DropConstraintNode;
+    protected transformCreateView(node: CreateViewNode): CreateViewNode;
+    protected transformDropView(node: DropViewNode): DropViewNode;
     protected transformDataType(node: DataTypeNode): DataTypeNode;
     protected transformSelectAll(node: SelectAllNode): SelectAllNode;
     protected transformIdentifier(node: IdentifierNode): IdentifierNode;

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

@@ -93,6 +93,8 @@ class OperationNodeTransformer {
         DropConstraintNode: this.transformDropConstraint.bind(this),
         ForeignKeyConstraintNode: this.transformForeignKeyConstraint.bind(this),
         UnionNode: this.transformUnion.bind(this),
+        CreateViewNode: this.transformCreateView.bind(this),
+        DropViewNode: this.transformDropView.bind(this),
     };
     transformNode = (node) => {
         if (!node) {
@@ -115,7 +117,7 @@ class OperationNodeTransformer {
             from: this.transformNode(node.from),
             selections: this.transformNodeList(node.selections),
             distinctOnSelections: this.transformNodeList(node.distinctOnSelections),
-            isDistinct: node.isDistinct,
+            distinct: node.distinct,
             joins: this.transformNodeList(node.joins),
             groupBy: this.transformNode(node.groupBy),
             orderBy: this.transformNode(node.orderBy),
@@ -257,7 +259,7 @@ class OperationNodeTransformer {
             table: this.transformNode(node.table),
             columns: this.transformNodeList(node.columns),
             constraints: this.transformNodeList(node.constraints),
-            modifier: node.modifier,
+            ifNotExists: node.ifNotExists,
         };
     }
     transformColumnDefinition(node) {
@@ -266,10 +268,10 @@ class OperationNodeTransformer {
             column: this.transformNode(node.column),
             dataType: this.transformNode(node.dataType),
             references: this.transformNode(node.references),
-            isPrimaryKey: node.isPrimaryKey,
-            isAutoIncrementing: node.isAutoIncrementing,
-            isUnique: node.isUnique,
-            isNullable: node.isNullable,
+            primaryKey: node.primaryKey,
+            autoIncrement: node.autoIncrement,
+            unique: node.unique,
+            nullable: node.nullable,
             defaultTo: this.transformNode(node.defaultTo),
             check: this.transformNode(node.check),
         };
@@ -284,7 +286,7 @@ class OperationNodeTransformer {
         return {
             kind: 'DropTableNode',
             table: this.transformNode(node.table),
-            modifier: node.modifier,
+            ifExists: node.ifExists,
         };
     }
     transformOrderBy(node) {
@@ -378,7 +380,7 @@ class OperationNodeTransformer {
             kind: 'DropIndexNode',
             name: this.transformNode(node.name),
             table: this.transformNode(node.table),
-            modifier: node.modifier,
+            ifExists: node.ifExists,
         };
     }
     transformPrimaryKeyConstraint(node) {
@@ -457,7 +459,7 @@ class OperationNodeTransformer {
         return {
             kind: 'DropSchemaNode',
             schema: this.transformNode(node.schema),
-            modifier: node.modifier,
+            ifExists: node.ifExists,
         };
     }
     transformAlterTable(node) {
@@ -518,6 +520,24 @@ class OperationNodeTransformer {
             constraintName: this.transformNode(node.constraintName),
         };
     }
+    transformCreateView(node) {
+        return {
+            kind: 'CreateViewNode',
+            name: this.transformNode(node.name),
+            orReplace: node.orReplace,
+            materialized: node.materialized,
+            columns: this.transformNodeList(node.columns),
+            as: this.transformNode(node.as),
+        };
+    }
+    transformDropView(node) {
+        return {
+            kind: 'DropViewNode',
+            name: this.transformNode(node.name),
+            ifExists: node.ifExists,
+            materialized: node.materialized,
+        };
+    }
     transformDataType(node) {
         // An Object.freezed leaf node. No need to clone.
         return node;

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

@@ -58,6 +58,8 @@ import { ColumnDefinitionNode } from './column-definition-node.js';
 import { ModifyColumnNode } from './modify-column-node.js';
 import { OnDuplicateKeyNode } from './on-duplicate-key-node.js';
 import { UnionNode } from './union-node.js';
+import { CreateViewNode } from './create-view-node.js';
+import { DropViewNode } from './drop-view-node.js';
 export declare abstract class OperationNodeVisitor {
     #private;
     protected readonly nodeStack: OperationNode[];
@@ -121,4 +123,6 @@ export declare abstract class OperationNodeVisitor {
     protected abstract visitValue(_: ValueNode): void;
     protected abstract visitPrimitiveValueList(_: PrimitiveValueListNode): void;
     protected abstract visitOperator(node: OperatorNode): void;
+    protected abstract visitCreateView(node: CreateViewNode): void;
+    protected abstract visitDropView(node: DropViewNode): void;
 }

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

@@ -63,6 +63,8 @@ class OperationNodeVisitor {
         DropConstraintNode: this.visitDropConstraint.bind(this),
         ForeignKeyConstraintNode: this.visitForeignKeyConstraint.bind(this),
         UnionNode: this.visitUnion.bind(this),
+        CreateViewNode: this.visitCreateView.bind(this),
+        DropViewNode: this.visitDropView.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';
+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';
 export interface OperationNode {
     readonly kind: OperationNodeKind;
 }

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

@@ -1,6 +1,6 @@
 import { ArrayItemType } from '../util/type-utils.js';
 import { OperationNode } from './operation-node.js';
-export declare const OPERATORS: readonly ["=", "==", "!=", "<>", ">", ">=", "<", "<=", "in", "not in", "is", "is not", "like", "not like", "ilike", "not ilike", "@>", "<@", "?", "?", "?&", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "exists", "not exists", "&&"];
+export declare const OPERATORS: readonly ["=", "==", "!=", "<>", ">", ">=", "<", "<=", "in", "not in", "is", "is not", "like", "not like", "ilike", "not ilike", "@>", "<@", "?", "?", "?&", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "exists", "not exists", "&&", "||", "@@", "@@@", "!!", "<->"];
 export declare type Operator = ArrayItemType<typeof OPERATORS>;
 export interface OperatorNode extends OperationNode {
     readonly kind: 'OperatorNode';

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

@@ -34,6 +34,11 @@ exports.OPERATORS = [
     'exists',
     'not exists',
     '&&',
+    '||',
+    '@@',
+    '@@@',
+    '!!',
+    '<->',
 ];
 /**
  * @internal

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

@@ -19,7 +19,7 @@ export interface SelectQueryNode extends OperationNode {
     readonly from: FromNode;
     readonly selections?: ReadonlyArray<SelectionNode>;
     readonly distinctOnSelections?: ReadonlyArray<SelectionNode>;
-    readonly isDistinct?: boolean;
+    readonly distinct?: boolean;
     readonly joins?: ReadonlyArray<JoinNode>;
     readonly groupBy?: GroupByNode;
     readonly orderBy?: OrderByNode;

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

@@ -91,7 +91,7 @@ exports.SelectQueryNode = (0, object_utils_js_1.freeze)({
     cloneWithDistinct(selectNode) {
         return (0, object_utils_js_1.freeze)({
             ...selectNode,
-            isDistinct: true,
+            distinct: true,
         });
     },
     cloneWithUnion(selectNode, union) {

package/dist/cjs/plugin/immediate-value.ts/immediate-value-plugin.d.ts

@@ -0,0 +1,17 @@
+import { QueryResult } from '../../driver/database-connection.js';
+import { UnknownRow } from '../../index.js';
+import { RootOperationNode } from '../../query-compiler/query-compiler.js';
+import { KyselyPlugin, PluginTransformQueryArgs, PluginTransformResultArgs } from '../kysely-plugin.js';
+/**
+ * Transforms all ValueNodes to immediate.
+ *
+ * WARNING! This should never be part of the public API. Users should never use this.
+ * This is an internal helper.
+ *
+ * @internal
+ */
+export declare class ImmediateValuePlugin implements KyselyPlugin {
+    #private;
+    transformQuery(args: PluginTransformQueryArgs): RootOperationNode;
+    transformResult(args: PluginTransformResultArgs): Promise<QueryResult<UnknownRow>>;
+}

package/dist/cjs/plugin/immediate-value.ts/immediate-value-plugin.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImmediateValuePlugin = void 0;
+const immediate_value_transformer_js_1 = require("./immediate-value-transformer.js");
+/**
+ * Transforms all ValueNodes to immediate.
+ *
+ * WARNING! This should never be part of the public API. Users should never use this.
+ * This is an internal helper.
+ *
+ * @internal
+ */
+class ImmediateValuePlugin {
+    #transformer = new immediate_value_transformer_js_1.ImmediateValueTransformer();
+    transformQuery(args) {
+        return this.#transformer.transformNode(args.node);
+    }
+    async transformResult(args) {
+        return args.result;
+    }
+}
+exports.ImmediateValuePlugin = ImmediateValuePlugin;

package/dist/cjs/plugin/immediate-value.ts/immediate-value-transformer.d.ts

@@ -0,0 +1,13 @@
+import { OperationNodeTransformer } from '../../operation-node/operation-node-transformer.js';
+import { ValueNode } from '../../operation-node/value-node.js';
+/**
+ * Transforms all ValueNodes to immediate.
+ *
+ * WARNING! This should never be part of the public API. Users should never use this.
+ * This is an internal helper.
+ *
+ * @internal
+ */
+export declare class ImmediateValueTransformer extends OperationNodeTransformer {
+    transformValue(node: ValueNode): ValueNode;
+}

package/dist/cjs/plugin/immediate-value.ts/immediate-value-transformer.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImmediateValueTransformer = void 0;
+const operation_node_transformer_js_1 = require("../../operation-node/operation-node-transformer.js");
+/**
+ * Transforms all ValueNodes to immediate.
+ *
+ * WARNING! This should never be part of the public API. Users should never use this.
+ * This is an internal helper.
+ *
+ * @internal
+ */
+class ImmediateValueTransformer extends operation_node_transformer_js_1.OperationNodeTransformer {
+    transformValue(node) {
+        return {
+            ...super.transformValue(node),
+            immediate: true,
+        };
+    }
+}
+exports.ImmediateValueTransformer = ImmediateValueTransformer;

package/dist/cjs/plugin/with-schema/with-schema-transformer.d.ts

@@ -1,9 +1,11 @@
 import { AlterTableNode } from '../../operation-node/alter-table-node.js';
 import { CreateIndexNode } from '../../operation-node/create-index-node.js';
 import { CreateTableNode } from '../../operation-node/create-table-node.js';
+import { CreateViewNode } from '../../operation-node/create-view-node.js';
 import { DeleteQueryNode } from '../../operation-node/delete-query-node.js';
 import { DropIndexNode } from '../../operation-node/drop-index-node.js';
 import { DropTableNode } from '../../operation-node/drop-table-node.js';
+import { DropViewNode } from '../../operation-node/drop-view-node.js';
 import { InsertQueryNode } from '../../operation-node/insert-query-node.js';
 import { OperationNodeTransformer } from '../../operation-node/operation-node-transformer.js';
 import { SelectQueryNode } from '../../operation-node/select-query-node.js';
@@ -20,6 +22,8 @@ export declare class WithSchemaTransformer extends OperationNodeTransformer {
     protected transformDropTable(node: DropTableNode): DropTableNode;
     protected transformCreateIndex(node: CreateIndexNode): CreateIndexNode;
     protected transformDropIndex(node: DropIndexNode): DropIndexNode;
+    protected transformCreateView(node: CreateViewNode): CreateViewNode;
+    protected transformDropView(node: DropViewNode): DropViewNode;
     protected transformAlterTable(node: AlterTableNode): AlterTableNode;
     protected transformTable(node: TableNode): TableNode;
 }