kysely 0.22.0 → 0.23.0

package/dist/esm/index.js

@@ -1,6 +1,7 @@
 /// <reference types="./index.d.ts" />
 export * from './kysely.js';
 export * from './query-creator.js';
+export * from './expression/expression.js';
 export * from './query-builder/where-interface.js';
 export * from './query-builder/returning-interface.js';
 export * from './query-builder/having-interface.js';
@@ -39,6 +40,7 @@ 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 './schema/alter-column-builder.js';
 export * from './dynamic/dynamic.js';
 export * from './driver/driver.js';
 export * from './driver/database-connection.js';
@@ -104,7 +106,6 @@ export * from './operation-node/drop-schema-node.js';
 export * from './operation-node/drop-table-node.js';
 export * from './operation-node/drop-type-node.js';
 export * from './operation-node/drop-view-node.js';
-export * from './operation-node/filter-node.js';
 export * from './operation-node/foreign-key-constraint-node.js';
 export * from './operation-node/from-node.js';
 export * from './operation-node/generated-node.js';
@@ -123,7 +124,6 @@ export * from './operation-node/on-duplicate-key-node.js';
 export * from './operation-node/on-node.js';
 export * from './operation-node/operation-node-source.js';
 export * from './operation-node/operation-node-transformer.js';
-export * from './operation-node/operation-node-utils.js';
 export * from './operation-node/operation-node-visitor.js';
 export * from './operation-node/operation-node.js';
 export * from './operation-node/operator-node.js';
@@ -158,7 +158,11 @@ export * from './operation-node/over-node.js';
 export * from './operation-node/partition-by-node.js';
 export * from './operation-node/partition-by-item-node.js';
 export * from './operation-node/set-operation-node.js';
+export * from './operation-node/binary-operation-node.js';
+export * from './operation-node/unary-operation-node.js';
 export * from './util/column-type.js';
 export * from './util/compilable.js';
 export * from './util/explainable.js';
 export * from './util/log.js';
+export * from './util/infer-result.js';
+export { logOnce } from './util/log-once.js';

package/dist/esm/migration/file-migration-provider.js

@@ -25,11 +25,13 @@ export class FileMigrationProvider {
         const migrations = {};
         const files = await this.#props.fs.readdir(this.#props.migrationFolder);
         for (const fileName of files) {
-            if ((fileName.endsWith('.js') || fileName.endsWith('.ts') || fileName.endsWith('.mjs')) &&
-                !fileName.endsWith('.d.ts')) {
+            if (fileName.endsWith('.js') ||
+                (fileName.endsWith('.ts') && !fileName.endsWith('.d.ts')) ||
+                fileName.endsWith('.mjs') ||
+                (fileName.endsWith('.mts') && !fileName.endsWith('.d.mts'))) {
                 const migration = await import(
                 /* webpackIgnore: true */ this.#props.path.join(this.#props.migrationFolder, fileName));
-                const migrationKey = fileName.substring(0, fileName.length - 3);
+                const migrationKey = fileName.substring(0, fileName.lastIndexOf('.'));
                 // Handle esModuleInterop export's `default` prop...
                 if (isMigration(migration?.default)) {
                     migrations[migrationKey] = migration.default;

package/dist/esm/operation-node/aggregate-function-node.d.ts

@@ -1,13 +1,14 @@
-import { ColumnNode } from './column-node.js';
 import { OperationNode } from './operation-node.js';
 import { OverNode } from './over-node.js';
-import { ReferenceNode } from './reference-node.js';
+import { SimpleReferenceExpressionNode } from './simple-reference-expression-node.js';
+import { WhereNode } from './where-node.js';
 declare type AggregateFunction = 'avg' | 'count' | 'max' | 'min' | 'sum';
 export interface AggregateFunctionNode extends OperationNode {
     readonly kind: 'AggregateFunctionNode';
     readonly func: AggregateFunction;
-    readonly column: ColumnNode | ReferenceNode;
+    readonly column: SimpleReferenceExpressionNode;
     readonly distinct?: boolean;
+    readonly filter?: WhereNode;
     readonly over?: OverNode;
 }
 /**
@@ -15,8 +16,10 @@ export interface AggregateFunctionNode extends OperationNode {
  */
 export declare const AggregateFunctionNode: Readonly<{
     is(node: OperationNode): node is AggregateFunctionNode;
-    create(aggregateFunction: AggregateFunction, column: ColumnNode | ReferenceNode): AggregateFunctionNode;
+    create(aggregateFunction: AggregateFunction, column: SimpleReferenceExpressionNode): AggregateFunctionNode;
     cloneWithDistinct(aggregateFunctionNode: AggregateFunctionNode): AggregateFunctionNode;
+    cloneWithFilter(aggregateFunctionNode: AggregateFunctionNode, filter: OperationNode): AggregateFunctionNode;
+    cloneWithOrFilter(aggregateFunctionNode: AggregateFunctionNode, filter: OperationNode): AggregateFunctionNode;
     cloneWithOver(aggregateFunctionNode: AggregateFunctionNode, over?: OverNode): AggregateFunctionNode;
 }>;
 export {};

package/dist/esm/operation-node/aggregate-function-node.js

@@ -1,5 +1,6 @@
 /// <reference types="./aggregate-function-node.d.ts" />
 import { freeze } from '../util/object-utils.js';
+import { WhereNode } from './where-node.js';
 /**
  * @internal
  */
@@ -20,6 +21,22 @@ export const AggregateFunctionNode = freeze({
             distinct: true,
         });
     },
+    cloneWithFilter(aggregateFunctionNode, filter) {
+        return freeze({
+            ...aggregateFunctionNode,
+            filter: aggregateFunctionNode.filter
+                ? WhereNode.cloneWithOperation(aggregateFunctionNode.filter, 'And', filter)
+                : WhereNode.create(filter),
+        });
+    },
+    cloneWithOrFilter(aggregateFunctionNode, filter) {
+        return freeze({
+            ...aggregateFunctionNode,
+            filter: aggregateFunctionNode.filter
+                ? WhereNode.cloneWithOperation(aggregateFunctionNode.filter, 'Or', filter)
+                : WhereNode.create(filter),
+        });
+    },
     cloneWithOver(aggregateFunctionNode, over) {
         return freeze({
             ...aggregateFunctionNode,

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

@@ -1,21 +1,13 @@
-import { AggregateFunctionNode } from './aggregate-function-node.js';
-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 { ReferenceNode } from './reference-node.js';
-import { SelectQueryNode } from './select-query-node.js';
-import { TableNode } from './table-node.js';
-export declare type AliasNodeChild = ColumnNode | ReferenceNode | TableNode | SelectQueryNode | RawNode | AggregateFunctionNode;
 export interface AliasNode extends OperationNode {
     readonly kind: 'AliasNode';
-    readonly node: AliasNodeChild;
-    readonly alias: IdentifierNode | RawNode;
+    readonly node: OperationNode;
+    readonly alias: OperationNode;
 }
 /**
  * @internal
  */
 export declare const AliasNode: Readonly<{
     is(node: OperationNode): node is AliasNode;
-    create(node: AliasNodeChild, alias: IdentifierNode | RawNode): AliasNode;
+    create(node: OperationNode, alias: OperationNode): AliasNode;
 }>;

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

@@ -1,7 +1,6 @@
 import { OperationNode } from './operation-node.js';
 import { ColumnNode } from './column-node.js';
 import { DataTypeNode } from './data-type-node.js';
-import { ValueNode } from './value-node.js';
 import { RawNode } from './raw-node.js';
 export declare type AlterColumnNodeProps = Omit<AlterColumnNode, 'kind' | 'column'>;
 export interface AlterColumnNode extends OperationNode {
@@ -9,7 +8,7 @@ export interface AlterColumnNode extends OperationNode {
     readonly column: ColumnNode;
     readonly dataType?: DataTypeNode;
     readonly dataTypeExpression?: RawNode;
-    readonly setDefault?: ValueNode | RawNode;
+    readonly setDefault?: OperationNode;
     readonly dropDefault?: true;
     readonly setNotNull?: true;
     readonly dropNotNull?: true;

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

@@ -8,17 +8,14 @@ import { AlterColumnNode } from './alter-column-node.js';
 import { AddConstraintNode } from './add-constraint-node.js';
 import { DropConstraintNode } from './drop-constraint-node.js';
 import { ModifyColumnNode } from './modify-column-node.js';
-export declare type AlterTableNodeProps = Omit<AlterTableNode, 'kind' | 'table'>;
+export declare type AlterTableNodeTableProps = Pick<AlterTableNode, 'renameTo' | 'setSchema' | 'addConstraint' | 'dropConstraint'>;
+export declare type AlterTableColumnAlterationNode = RenameColumnNode | AddColumnNode | DropColumnNode | AlterColumnNode | ModifyColumnNode;
 export interface AlterTableNode extends OperationNode {
     readonly kind: 'AlterTableNode';
     readonly table: TableNode;
     readonly renameTo?: TableNode;
     readonly setSchema?: IdentifierNode;
-    readonly renameColumn?: RenameColumnNode;
-    readonly addColumn?: AddColumnNode;
-    readonly dropColumn?: DropColumnNode;
-    readonly alterColumn?: AlterColumnNode;
-    readonly modifyColumn?: ModifyColumnNode;
+    readonly columnAlterations?: ReadonlyArray<AlterTableColumnAlterationNode>;
     readonly addConstraint?: AddConstraintNode;
     readonly dropConstraint?: DropConstraintNode;
 }
@@ -28,5 +25,6 @@ export interface AlterTableNode extends OperationNode {
 export declare const AlterTableNode: Readonly<{
     is(node: OperationNode): node is AlterTableNode;
     create(table: string): AlterTableNode;
-    cloneWith(node: AlterTableNode, props: AlterTableNodeProps): AlterTableNode;
+    cloneWithTableProps(node: AlterTableNode, props: AlterTableNodeTableProps): AlterTableNode;
+    cloneWithColumnAlteration(node: AlterTableNode, columnAlteration: AlterTableColumnAlterationNode): AlterTableNode;
 }>;

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

@@ -14,10 +14,18 @@ export const AlterTableNode = freeze({
             table: TableNode.create(table),
         });
     },
-    cloneWith(node, props) {
+    cloneWithTableProps(node, props) {
         return freeze({
             ...node,
             ...props,
         });
     },
+    cloneWithColumnAlteration(node, columnAlteration) {
+        return freeze({
+            ...node,
+            columnAlterations: node.columnAlterations
+                ? [...node.columnAlterations, columnAlteration]
+                : [columnAlteration],
+        });
+    },
 });

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

@@ -1,14 +1,13 @@
 import { OperationNode } from './operation-node.js';
-import { FilterExpressionNode } from './operation-node-utils.js';
 export interface AndNode extends OperationNode {
     readonly kind: 'AndNode';
-    readonly left: FilterExpressionNode;
-    readonly right: FilterExpressionNode;
+    readonly left: OperationNode;
+    readonly right: OperationNode;
 }
 /**
  * @internal
  */
 export declare const AndNode: Readonly<{
     is(node: OperationNode): node is AndNode;
-    create(left: FilterExpressionNode, right: FilterExpressionNode): AndNode;
+    create(left: OperationNode, right: OperationNode): AndNode;
 }>;

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

@@ -0,0 +1,14 @@
+import { OperationNode } from './operation-node.js';
+export interface BinaryOperationNode extends OperationNode {
+    readonly kind: 'BinaryOperationNode';
+    readonly leftOperand: OperationNode;
+    readonly operator: OperationNode;
+    readonly rightOperand: OperationNode;
+}
+/**
+ * @internal
+ */
+export declare const BinaryOperationNode: Readonly<{
+    is(node: OperationNode): node is BinaryOperationNode;
+    create(leftOperand: OperationNode, operator: OperationNode, rightOperand: OperationNode): BinaryOperationNode;
+}>;

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

@@ -0,0 +1,18 @@
+/// <reference types="./binary-operation-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+/**
+ * @internal
+ */
+export const BinaryOperationNode = freeze({
+    is(node) {
+        return node.kind === 'BinaryOperationNode';
+    },
+    create(leftOperand, operator, rightOperand) {
+        return freeze({
+            kind: 'BinaryOperationNode',
+            leftOperand,
+            operator,
+            rightOperand,
+        });
+    },
+});

package/dist/esm/operation-node/check-constraint-node.d.ts

@@ -1,9 +1,8 @@
 import { OperationNode } from './operation-node.js';
-import { RawNode } from './raw-node.js';
 import { IdentifierNode } from './identifier-node.js';
 export interface CheckConstraintNode extends OperationNode {
     readonly kind: 'CheckConstraintNode';
-    readonly expression: RawNode;
+    readonly expression: OperationNode;
     readonly name?: IdentifierNode;
 }
 /**
@@ -11,5 +10,5 @@ export interface CheckConstraintNode extends OperationNode {
  */
 export declare const CheckConstraintNode: Readonly<{
     is(node: OperationNode): node is CheckConstraintNode;
-    create(expression: RawNode, constraintName?: string): CheckConstraintNode;
+    create(expression: OperationNode, constraintName?: string): CheckConstraintNode;
 }>;

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

@@ -1,17 +1,14 @@
 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 { GeneratedNode } from './generated-node.js';
 import { OperationNode } from './operation-node.js';
-import { RawNode } from './raw-node.js';
 import { ReferencesNode } from './references-node.js';
 export declare type ColumnDefinitionNodeProps = Omit<Partial<ColumnDefinitionNode>, 'kind' | 'dataType'>;
-export declare type ColumnDataTypeNode = DataTypeNode | RawNode;
 export interface ColumnDefinitionNode extends OperationNode {
     readonly kind: 'ColumnDefinitionNode';
     readonly column: ColumnNode;
-    readonly dataType: ColumnDataTypeNode;
+    readonly dataType: OperationNode;
     readonly references?: ReferencesNode;
     readonly primaryKey?: boolean;
     readonly autoIncrement?: boolean;
@@ -21,12 +18,16 @@ export interface ColumnDefinitionNode extends OperationNode {
     readonly check?: CheckConstraintNode;
     readonly generated?: GeneratedNode;
     readonly unsigned?: boolean;
+    readonly frontModifiers?: ReadonlyArray<OperationNode>;
+    readonly endModifiers?: ReadonlyArray<OperationNode>;
 }
 /**
  * @internal
  */
 export declare const ColumnDefinitionNode: Readonly<{
     is(node: OperationNode): node is ColumnDefinitionNode;
-    create(column: string, dataType: ColumnDataTypeNode): ColumnDefinitionNode;
+    create(column: string, dataType: OperationNode): ColumnDefinitionNode;
+    cloneWithFrontModifier(node: ColumnDefinitionNode, modifier: OperationNode): ColumnDefinitionNode;
+    cloneWithEndModifier(node: ColumnDefinitionNode, modifier: OperationNode): ColumnDefinitionNode;
     cloneWith(node: ColumnDefinitionNode, props: ColumnDefinitionNodeProps): ColumnDefinitionNode;
 }>;

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

@@ -15,6 +15,22 @@ export const ColumnDefinitionNode = freeze({
             dataType,
         });
     },
+    cloneWithFrontModifier(node, modifier) {
+        return freeze({
+            ...node,
+            frontModifiers: node.frontModifiers
+                ? freeze([...node.frontModifiers, modifier])
+                : [modifier],
+        });
+    },
+    cloneWithEndModifier(node, modifier) {
+        return freeze({
+            ...node,
+            endModifiers: node.endModifiers
+                ? freeze([...node.endModifiers, modifier])
+                : [modifier],
+        });
+    },
     cloneWith(node, props) {
         return freeze({
             ...node,

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

@@ -1,15 +1,14 @@
 import { ColumnNode } from './column-node.js';
 import { OperationNode } from './operation-node.js';
-import { ValueExpressionNode } from './operation-node-utils.js';
 export interface ColumnUpdateNode extends OperationNode {
     readonly kind: 'ColumnUpdateNode';
     readonly column: ColumnNode;
-    readonly value: ValueExpressionNode;
+    readonly value: OperationNode;
 }
 /**
  * @internal
  */
 export declare const ColumnUpdateNode: Readonly<{
     is(node: OperationNode): node is ColumnUpdateNode;
-    create(column: ColumnNode, value: ValueExpressionNode): ColumnUpdateNode;
+    create(column: ColumnNode, value: OperationNode): ColumnUpdateNode;
 }>;

package/dist/esm/operation-node/common-table-expression-node.d.ts

@@ -1,16 +1,14 @@
 import { CommonTableExpressionNameNode } from './common-table-expression-name-node.js';
 import { OperationNode } from './operation-node.js';
-import { QueryNode } from './query-node.js';
-import { RawNode } from './raw-node.js';
 export interface CommonTableExpressionNode extends OperationNode {
     readonly kind: 'CommonTableExpressionNode';
     readonly name: CommonTableExpressionNameNode;
-    readonly expression: QueryNode | RawNode;
+    readonly expression: OperationNode;
 }
 /**
  * @internal
  */
 export declare const CommonTableExpressionNode: Readonly<{
     is(node: OperationNode): node is CommonTableExpressionNode;
-    create(name: CommonTableExpressionNameNode, expression: QueryNode | RawNode): CommonTableExpressionNode;
+    create(name: CommonTableExpressionNameNode, expression: OperationNode): CommonTableExpressionNode;
 }>;

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

@@ -1,6 +1,4 @@
-import { ColumnNode } from './column-node.js';
 import { IdentifierNode } from './identifier-node.js';
-import { ListNode } from './list-node.js';
 import { OperationNode } from './operation-node.js';
 import { RawNode } from './raw-node.js';
 import { TableNode } from './table-node.js';
@@ -10,7 +8,7 @@ export interface CreateIndexNode extends OperationNode {
     readonly kind: 'CreateIndexNode';
     readonly name: IdentifierNode;
     readonly table?: TableNode;
-    readonly expression?: ColumnNode | ListNode | RawNode;
+    readonly expression?: OperationNode;
     readonly unique?: boolean;
     readonly using?: RawNode;
 }

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

@@ -3,7 +3,6 @@ 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' | 'frontModifiers' | 'endModifiers'>;
@@ -15,8 +14,8 @@ export interface CreateTableNode extends OperationNode {
     readonly temporary?: boolean;
     readonly ifNotExists?: boolean;
     readonly onCommit?: OnCommitAction;
-    readonly frontModifiers?: ReadonlyArray<RawNode>;
-    readonly endModifiers?: ReadonlyArray<RawNode>;
+    readonly frontModifiers?: ReadonlyArray<OperationNode>;
+    readonly endModifiers?: ReadonlyArray<OperationNode>;
 }
 /**
  * @internal
@@ -26,7 +25,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;
+    cloneWithFrontModifier(createTable: CreateTableNode, modifier: OperationNode): CreateTableNode;
+    cloneWithEndModifier(createTable: CreateTableNode, modifier: OperationNode): CreateTableNode;
     cloneWith(createTable: CreateTableNode, params: CreateTableNodeParams): CreateTableNode;
 }>;

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

@@ -12,6 +12,6 @@ export interface CreateTypeNode extends OperationNode {
  */
 export declare const CreateTypeNode: Readonly<{
     is(node: OperationNode): node is CreateTypeNode;
-    create(name: string): CreateTypeNode;
+    create(name: SchemableIdentifierNode): CreateTypeNode;
     cloneWithEnum(createType: CreateTypeNode, values: string[]): CreateTypeNode;
 }>;

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

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

package/dist/esm/operation-node/default-value-node.d.ts

@@ -1,14 +1,12 @@
 import { OperationNode } from './operation-node.js';
-import { RawNode } from './raw-node.js';
-import { ValueNode } from './value-node.js';
 export interface DefaultValueNode extends OperationNode {
     readonly kind: 'DefaultValueNode';
-    readonly defaultValue: ValueNode | RawNode;
+    readonly defaultValue: OperationNode;
 }
 /**
  * @internal
  */
 export declare const DefaultValueNode: Readonly<{
     is(node: OperationNode): node is DefaultValueNode;
-    create(defaultValue: ValueNode | RawNode): DefaultValueNode;
+    create(defaultValue: OperationNode): DefaultValueNode;
 }>;

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

@@ -1,7 +1,6 @@
 import { FromNode } from './from-node.js';
 import { JoinNode } from './join-node.js';
 import { OperationNode } from './operation-node.js';
-import { TableExpressionNode } from './operation-node-utils.js';
 import { ReturningNode } from './returning-node.js';
 import { WhereNode } from './where-node.js';
 import { WithNode } from './with-node.js';
@@ -25,7 +24,7 @@ export interface DeleteQueryNode extends OperationNode {
  */
 export declare const DeleteQueryNode: Readonly<{
     is(node: OperationNode): node is DeleteQueryNode;
-    create(fromItem: TableExpressionNode, withNode?: WithNode): DeleteQueryNode;
+    create(fromItem: OperationNode, 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/drop-type-node.d.ts

@@ -11,6 +11,6 @@ export interface DropTypeNode extends OperationNode {
  */
 export declare const DropTypeNode: Readonly<{
     is(node: OperationNode): node is DropTypeNode;
-    create(name: string): DropTypeNode;
+    create(name: SchemableIdentifierNode): DropTypeNode;
     cloneWith(dropType: DropTypeNode, params: DropTypeNodeParams): DropTypeNode;
 }>;

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

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

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

@@ -1,16 +1,14 @@
 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;
+    readonly options?: OperationNode;
 }
 /**
  * @internal
  */
 export declare const ExplainNode: Readonly<{
     is(node: OperationNode): node is ExplainNode;
-    create(format?: ExplainFormat, options?: AnyRawBuilder): ExplainNode;
+    create(format?: ExplainFormat, options?: OperationNode): ExplainNode;
 }>;

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

@@ -11,7 +11,7 @@ export const ExplainNode = freeze({
         return freeze({
             kind: 'ExplainNode',
             format,
-            options: options?.toOperationNode(),
+            options,
         });
     },
 });

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

@@ -1,14 +1,13 @@
 import { OperationNode } from './operation-node.js';
-import { TableExpressionNode } from './operation-node-utils.js';
 export interface FromNode extends OperationNode {
     readonly kind: 'FromNode';
-    readonly froms: ReadonlyArray<TableExpressionNode>;
+    readonly froms: ReadonlyArray<OperationNode>;
 }
 /**
  * @internal
  */
 export declare const FromNode: Readonly<{
     is(node: OperationNode): node is FromNode;
-    create(froms: ReadonlyArray<TableExpressionNode>): FromNode;
-    cloneWithFroms(from: FromNode, froms: ReadonlyArray<TableExpressionNode>): FromNode;
+    create(froms: ReadonlyArray<OperationNode>): FromNode;
+    cloneWithFroms(from: FromNode, froms: ReadonlyArray<OperationNode>): FromNode;
 }>;

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

@@ -1,5 +1,4 @@
 import { OperationNode } from './operation-node.js';
-import { RawNode } from './raw-node.js';
 export declare type GeneratedNodeParams = Omit<GeneratedNode, 'kind' | 'expression'>;
 export interface GeneratedNode extends OperationNode {
     readonly kind: 'GeneratedNode';
@@ -7,7 +6,7 @@ export interface GeneratedNode extends OperationNode {
     readonly always?: boolean;
     readonly identity?: boolean;
     readonly stored?: boolean;
-    readonly expression?: RawNode;
+    readonly expression?: OperationNode;
 }
 /**
  * @internal
@@ -15,6 +14,6 @@ export interface GeneratedNode extends OperationNode {
 export declare const GeneratedNode: Readonly<{
     is(node: OperationNode): node is GeneratedNode;
     create(params: GeneratedNodeParams): GeneratedNode;
-    createWithExpression(expression: RawNode): GeneratedNode;
+    createWithExpression(expression: OperationNode): GeneratedNode;
     cloneWith(node: GeneratedNode, params: GeneratedNodeParams): GeneratedNode;
 }>;

package/dist/esm/operation-node/group-by-item-node.d.ts

@@ -1,13 +1,12 @@
 import { OperationNode } from './operation-node.js';
-import { ReferenceExpressionNode } from './operation-node-utils.js';
 export interface GroupByItemNode extends OperationNode {
     readonly kind: 'GroupByItemNode';
-    readonly groupBy: ReferenceExpressionNode;
+    readonly groupBy: OperationNode;
 }
 /**
  * @internal
  */
 export declare const GroupByItemNode: Readonly<{
     is(node: OperationNode): node is GroupByItemNode;
-    create(groupBy: ReferenceExpressionNode): GroupByItemNode;
+    create(groupBy: OperationNode): GroupByItemNode;
 }>;

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

@@ -1,14 +1,13 @@
-import { FilterExpressionNode } from './operation-node-utils.js';
 import { OperationNode } from './operation-node.js';
 export interface HavingNode extends OperationNode {
     readonly kind: 'HavingNode';
-    readonly having: FilterExpressionNode;
+    readonly having: OperationNode;
 }
 /**
  * @internal
  */
 export declare const HavingNode: Readonly<{
     is(node: OperationNode): node is HavingNode;
-    create(filter: FilterExpressionNode): HavingNode;
-    cloneWithFilter(havingNode: HavingNode, op: 'And' | 'Or', filter: FilterExpressionNode): HavingNode;
+    create(filter: OperationNode): HavingNode;
+    cloneWithOperation(havingNode: HavingNode, operator: 'And' | 'Or', operation: OperationNode): HavingNode;
 }>;