kysely 0.20.1 → 0.21.2

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

@@ -69,6 +69,7 @@ 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';
+import { SchemableIdentifierNode } from './schemable-identifier-node.js';
 /**
  * Transforms an operation node tree into another one.
  *
@@ -89,7 +90,7 @@ import { ExplainNode } from './explain-node.js';
  *
  *     return {
  *       ...node,
- *       identifier: snakeCase(node.identifier),
+ *       name: snakeCase(node.name),
  *     }
  *   }
  * }
@@ -101,9 +102,9 @@ import { ExplainNode } from './explain-node.js';
 export declare class OperationNodeTransformer {
     #private;
     protected readonly nodeStack: OperationNode[];
-    readonly transformNode: <T extends OperationNode | undefined, U extends T | undefined = T>(node: U) => T;
-    protected transformNodeList<T extends OperationNode, U extends T = T>(list: readonly U[]): readonly T[];
-    protected transformNodeList<T extends OperationNode, U extends T = T>(list: readonly U[] | undefined): readonly T[] | undefined;
+    transformNode<T extends OperationNode | undefined>(node: T): T;
+    protected transformNodeImpl<T extends OperationNode>(node: T): T;
+    protected transformNodeList<T extends ReadonlyArray<OperationNode> | undefined>(list: T): T;
     protected transformSelectQuery(node: SelectQueryNode): SelectQueryNode;
     protected transformSelection(node: SelectionNode): SelectionNode;
     protected transformColumn(node: ColumnNode): ColumnNode;
@@ -167,11 +168,12 @@ export declare class OperationNodeTransformer {
     protected transformSelectModifier(node: SelectModifierNode): SelectModifierNode;
     protected transformCreateType(node: CreateTypeNode): CreateTypeNode;
     protected transformDropType(node: DropTypeNode): DropTypeNode;
+    protected transformExplain(node: ExplainNode): ExplainNode;
+    protected transformSchemableIdentifier(node: SchemableIdentifierNode): SchemableIdentifierNode;
     protected transformDataType(node: DataTypeNode): DataTypeNode;
     protected transformSelectAll(node: SelectAllNode): SelectAllNode;
     protected transformIdentifier(node: IdentifierNode): IdentifierNode;
     protected transformValue(node: ValueNode): ValueNode;
     protected transformPrimitiveValueList(node: PrimitiveValueListNode): PrimitiveValueListNode;
     protected transformOperator(node: OperatorNode): OperatorNode;
-    protected transformExplain(node: ExplainNode): ExplainNode;
 }

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

@@ -21,7 +21,7 @@ import { requireAllProps } from '../util/require-all-props.js';
  *
  *     return {
  *       ...node,
- *       identifier: snakeCase(node.identifier),
+ *       name: snakeCase(node.name),
  *     }
  *   }
  * }
@@ -36,6 +36,7 @@ export class OperationNodeTransformer {
         AliasNode: this.transformAlias.bind(this),
         ColumnNode: this.transformColumn.bind(this),
         IdentifierNode: this.transformIdentifier.bind(this),
+        SchemableIdentifierNode: this.transformSchemableIdentifier.bind(this),
         RawNode: this.transformRaw.bind(this),
         ReferenceNode: this.transformReference.bind(this),
         SelectQueryNode: this.transformSelectQuery.bind(this),
@@ -104,20 +105,23 @@ export class OperationNodeTransformer {
         DropTypeNode: this.transformDropType.bind(this),
         ExplainNode: this.transformExplain.bind(this),
     });
-    transformNode = (node) => {
+    transformNode(node) {
         if (!node) {
-            return undefined;
+            return node;
         }
         this.nodeStack.push(node);
-        const out = this.#transformers[node.kind](node);
+        const out = this.transformNodeImpl(node);
         this.nodeStack.pop();
         return freeze(out);
-    };
+    }
+    transformNodeImpl(node) {
+        return this.#transformers[node.kind](node);
+    }
     transformNodeList(list) {
         if (!list) {
             return list;
         }
-        return freeze(list.map(this.transformNode));
+        return freeze(list.map((node) => this.transformNode(node)));
     }
     transformSelectQuery(node) {
         return requireAllProps({
@@ -161,7 +165,6 @@ export class OperationNodeTransformer {
     transformTable(node) {
         return requireAllProps({
             kind: 'TableNode',
-            schema: this.transformNode(node.schema),
             table: this.transformNode(node.table),
         });
     }
@@ -625,6 +628,20 @@ export class OperationNodeTransformer {
             ifExists: node.ifExists,
         });
     }
+    transformExplain(node) {
+        return requireAllProps({
+            kind: 'ExplainNode',
+            format: node.format,
+            options: this.transformNode(node.options),
+        });
+    }
+    transformSchemableIdentifier(node) {
+        return requireAllProps({
+            kind: 'SchemableIdentifierNode',
+            schema: this.transformNode(node.schema),
+            identifier: this.transformNode(node.identifier),
+        });
+    }
     transformDataType(node) {
         // An Object.freezed leaf node. No need to clone.
         return node;
@@ -649,11 +666,4 @@ export class OperationNodeTransformer {
         // An Object.freezed leaf node. No need to clone.
         return node;
     }
-    transformExplain(node) {
-        return requireAllProps({
-            kind: 'ExplainNode',
-            format: node.format,
-            options: this.transformNode(node.options),
-        });
-    }
 }

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

@@ -69,6 +69,7 @@ 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';
+import { SchemableIdentifierNode } from './schemable-identifier-node.js';
 export declare abstract class OperationNodeVisitor {
     #private;
     protected readonly nodeStack: OperationNode[];
@@ -129,10 +130,11 @@ export declare abstract class OperationNodeVisitor {
     protected abstract visitForeignKeyConstraint(node: ForeignKeyConstraintNode): void;
     protected abstract visitUnion(node: UnionNode): void;
     protected abstract visitDataType(node: DataTypeNode): void;
-    protected abstract visitSelectAll(_: SelectAllNode): void;
-    protected abstract visitIdentifier(_: IdentifierNode): void;
-    protected abstract visitValue(_: ValueNode): void;
-    protected abstract visitPrimitiveValueList(_: PrimitiveValueListNode): void;
+    protected abstract visitSelectAll(node: SelectAllNode): void;
+    protected abstract visitIdentifier(node: IdentifierNode): void;
+    protected abstract visitSchemableIdentifier(node: SchemableIdentifierNode): void;
+    protected abstract visitValue(node: ValueNode): void;
+    protected abstract visitPrimitiveValueList(node: PrimitiveValueListNode): void;
     protected abstract visitOperator(node: OperatorNode): void;
     protected abstract visitCreateView(node: CreateViewNode): void;
     protected abstract visitDropView(node: DropViewNode): void;

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

@@ -9,6 +9,7 @@ export class OperationNodeVisitor {
         AliasNode: this.visitAlias.bind(this),
         ColumnNode: this.visitColumn.bind(this),
         IdentifierNode: this.visitIdentifier.bind(this),
+        SchemableIdentifierNode: this.visitSchemableIdentifier.bind(this),
         RawNode: this.visitRaw.bind(this),
         ReferenceNode: this.visitReference.bind(this),
         SelectQueryNode: this.visitSelectQuery.bind(this),

package/dist/esm/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' | 'ExplainNode';
+export declare type OperationNodeKind = 'IdentifierNode' | 'SchemableIdentifierNode' | '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/esm/operation-node/schemable-identifier-node.d.ts

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

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

@@ -0,0 +1,24 @@
+/// <reference types="./schemable-identifier-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+import { IdentifierNode } from './identifier-node.js';
+/**
+ * @internal
+ */
+export const SchemableIdentifierNode = freeze({
+    is(node) {
+        return node.kind === 'SchemableIdentifierNode';
+    },
+    create(identifier) {
+        return freeze({
+            kind: 'SchemableIdentifierNode',
+            identifier: IdentifierNode.create(identifier),
+        });
+    },
+    createWithSchema(schema, identifier) {
+        return freeze({
+            kind: 'SchemableIdentifierNode',
+            schema: IdentifierNode.create(schema),
+            identifier: IdentifierNode.create(identifier),
+        });
+    },
+});

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

@@ -1,9 +1,8 @@
-import { IdentifierNode } from './identifier-node.js';
 import { OperationNode } from './operation-node.js';
+import { SchemableIdentifierNode } from './schemable-identifier-node.js';
 export interface TableNode extends OperationNode {
     readonly kind: 'TableNode';
-    readonly schema?: IdentifierNode;
-    readonly table: IdentifierNode;
+    readonly table: SchemableIdentifierNode;
 }
 /**
  * @internal

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

@@ -1,6 +1,6 @@
 /// <reference types="./table-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,14 +11,13 @@ export const TableNode = freeze({
     create(table) {
         return freeze({
             kind: 'TableNode',
-            table: IdentifierNode.create(table),
+            table: SchemableIdentifierNode.create(table),
         });
     },
     createWithSchema(schema, table) {
         return freeze({
             kind: 'TableNode',
-            schema: IdentifierNode.create(schema),
-            table: IdentifierNode.create(table),
+            table: SchemableIdentifierNode.createWithSchema(schema, table),
         });
     },
 });

package/dist/esm/parser/group-by-parser.d.ts

@@ -1,3 +1,5 @@
 import { GroupByItemNode } from '../operation-node/group-by-item-node.js';
-import { ReferenceExpressionOrList } from './reference-parser.js';
-export declare function parseGroupBy(orderBy: ReferenceExpressionOrList<any, any>): GroupByItemNode[];
+import { ReferenceExpression } from './reference-parser.js';
+export declare type GroupByExpression<DB, TB extends keyof DB, O> = ReferenceExpression<DB, TB> | (keyof O & string);
+export declare type GroupByExpressionOrList<DB, TB extends keyof DB, O> = ReadonlyArray<GroupByExpression<DB, TB, O>> | GroupByExpression<DB, TB, O>;
+export declare function parseGroupBy(orderBy: GroupByExpressionOrList<any, any, any>): GroupByItemNode[];

package/dist/esm/plugin/camel-case/camel-case-transformer.js

@@ -10,7 +10,7 @@ export class SnakeCaseTransformer extends OperationNodeTransformer {
         node = super.transformIdentifier(node);
         return {
             ...node,
-            identifier: this.#snakeCase(node.identifier),
+            name: this.#snakeCase(node.name),
         };
     }
 }

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

@@ -1,33 +1,9 @@
-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 { CreateTypeNode } from '../../operation-node/create-type-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 { DropTypeNode } from '../../operation-node/drop-type-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';
-import { TableNode } from '../../operation-node/table-node.js';
-import { UpdateQueryNode } from '../../operation-node/update-query-node.js';
+import { OperationNode } from '../../operation-node/operation-node.js';
+import { SchemableIdentifierNode } from '../../operation-node/schemable-identifier-node.js';
 export declare class WithSchemaTransformer extends OperationNodeTransformer {
     #private;
     constructor(schema: string);
-    protected transformSelectQuery(node: SelectQueryNode): SelectQueryNode;
-    protected transformInsertQuery(node: InsertQueryNode): InsertQueryNode;
-    protected transformUpdateQuery(node: UpdateQueryNode): UpdateQueryNode;
-    protected transformDeleteQuery(node: DeleteQueryNode): DeleteQueryNode;
-    protected transformCreateTable(node: CreateTableNode): CreateTableNode;
-    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 transformCreateType(node: CreateTypeNode): CreateTypeNode;
-    protected transformDropType(node: DropTypeNode): DropTypeNode;
-    protected transformAlterTable(node: AlterTableNode): AlterTableNode;
-    protected transformTable(node: TableNode): TableNode;
+    protected transformNodeImpl<T extends OperationNode>(node: T): T;
+    protected transformSchemableIdentifier(node: SchemableIdentifierNode): SchemableIdentifierNode;
 }

package/dist/esm/plugin/with-schema/with-schema-transformer.js

@@ -1,119 +1,111 @@
 /// <reference types="./with-schema-transformer.d.ts" />
 import { AliasNode } from '../../operation-node/alias-node.js';
+import { IdentifierNode } from '../../operation-node/identifier-node.js';
 import { OperationNodeTransformer } from '../../operation-node/operation-node-transformer.js';
+import { SchemableIdentifierNode } from '../../operation-node/schemable-identifier-node.js';
 import { TableNode } from '../../operation-node/table-node.js';
+import { freeze } from '../../util/object-utils.js';
+// This object exist only so that we get a type error when a new RootOperationNode
+// is added. If you get a type error here, make sure to add the new root node and
+// handle it correctly in the transformer.
+//
+// DO NOT REFACTOR THIS EVEN IF IT SEEMS USELESS TO YOU!
+const ROOT_OPERATION_NODES = freeze({
+    AlterTableNode: true,
+    CreateIndexNode: true,
+    CreateSchemaNode: true,
+    CreateTableNode: true,
+    CreateTypeNode: true,
+    CreateViewNode: true,
+    DeleteQueryNode: true,
+    DropIndexNode: true,
+    DropSchemaNode: true,
+    DropTableNode: true,
+    DropTypeNode: true,
+    DropViewNode: true,
+    InsertQueryNode: true,
+    RawNode: true,
+    SelectQueryNode: true,
+    UpdateQueryNode: true,
+});
 export class WithSchemaTransformer extends OperationNodeTransformer {
     #schema;
-    #tables = new Set();
+    #schemableIds = new Set();
     constructor(schema) {
         super();
         this.#schema = schema;
     }
-    transformSelectQuery(node) {
-        return this.#transformRoot(node, (node) => super.transformSelectQuery(node));
-    }
-    transformInsertQuery(node) {
-        return this.#transformRoot(node, (node) => super.transformInsertQuery(node));
-    }
-    transformUpdateQuery(node) {
-        return this.#transformRoot(node, (node) => super.transformUpdateQuery(node));
-    }
-    transformDeleteQuery(node) {
-        return this.#transformRoot(node, (node) => super.transformDeleteQuery(node));
-    }
-    transformCreateTable(node) {
-        return this.#transformRoot(node, (node) => super.transformCreateTable(node));
-    }
-    transformDropTable(node) {
-        return this.#transformRoot(node, (node) => super.transformDropTable(node));
-    }
-    transformCreateIndex(node) {
-        return this.#transformRoot(node, (node) => super.transformCreateIndex(node));
-    }
-    transformDropIndex(node) {
-        return this.#transformRoot(node, (node) => super.transformDropIndex(node));
-    }
-    transformCreateView(node) {
-        return this.#transformRoot(node, (node) => super.transformCreateView(node));
-    }
-    transformDropView(node) {
-        return this.#transformRoot(node, (node) => super.transformDropView(node));
-    }
-    transformCreateType(node) {
-        return this.#transformRoot(node, (node) => super.transformCreateType(node));
-    }
-    transformDropType(node) {
-        return this.#transformRoot(node, (node) => super.transformDropType(node));
-    }
-    transformAlterTable(node) {
-        return this.#transformRoot(node, (node) => super.transformAlterTable(node));
+    transformNodeImpl(node) {
+        if (!this.#isRootOperationNode(node)) {
+            return super.transformNodeImpl(node);
+        }
+        const tables = this.#collectSchemableIds(node);
+        for (const table of tables) {
+            this.#schemableIds.add(table);
+        }
+        const transformed = super.transformNodeImpl(node);
+        for (const table of tables) {
+            this.#schemableIds.delete(table);
+        }
+        return transformed;
     }
-    transformTable(node) {
-        const transformed = super.transformTable(node);
-        if (transformed.schema || !this.#tables.has(node.table.identifier)) {
+    transformSchemableIdentifier(node) {
+        const transformed = super.transformSchemableIdentifier(node);
+        if (transformed.schema || !this.#schemableIds.has(node.identifier.name)) {
             return transformed;
         }
         return {
             ...transformed,
-            schema: {
-                kind: 'IdentifierNode',
-                identifier: this.#schema,
-            },
+            schema: IdentifierNode.create(this.#schema),
         };
     }
-    #transformRoot(node, transform) {
-        const tables = this.#collectTables(node);
-        for (const table of tables) {
-            this.#tables.add(table);
-        }
-        const transformed = transform(node);
-        for (const table of tables) {
-            this.#tables.delete(table);
-        }
-        return transformed;
+    #isRootOperationNode(node) {
+        return node.kind in ROOT_OPERATION_NODES;
     }
-    #collectTables(node) {
-        const tables = new Set();
+    #collectSchemableIds(node) {
+        const schemableIds = new Set();
+        if ('name' in node && node.name && SchemableIdentifierNode.is(node.name)) {
+            this.#collectSchemableId(node.name, schemableIds);
+        }
         if ('from' in node && node.from) {
-            this.#collectTablesFromTableExpressionNodes(node.from.froms, tables);
+            for (const from of node.from.froms) {
+                this.#collectSchemableIdsFromTableExpr(from, schemableIds);
+            }
         }
         if ('into' in node && node.into) {
-            this.#collectTablesFromTableExpressionNode(node.into, tables);
+            this.#collectSchemableIdsFromTableExpr(node.into, schemableIds);
         }
         if ('table' in node && node.table) {
-            this.#collectTablesFromTableExpressionNode(node.table, tables);
+            this.#collectSchemableIdsFromTableExpr(node.table, schemableIds);
         }
         if ('joins' in node && node.joins) {
-            this.#collectTablesFromJoins(node.joins, tables);
+            for (const join of node.joins) {
+                this.#collectSchemableIdsFromTableExpr(join.table, schemableIds);
+            }
         }
         if ('with' in node && node.with) {
-            this.#removeCommonTableExpressionTables(node.with, tables);
-        }
-        return tables;
-    }
-    #collectTablesFromTableExpressionNodes(nodes, tables) {
-        for (const node of nodes) {
-            this.#collectTablesFromTableExpressionNode(node, tables);
+            this.#removeCommonTableExpressionTables(node.with, schemableIds);
         }
+        return schemableIds;
     }
-    #collectTablesFromJoins(nodes, tables) {
-        for (const node of nodes) {
-            this.#collectTablesFromTableExpressionNode(node.table, tables);
-        }
-    }
-    #collectTablesFromTableExpressionNode(node, tables) {
+    #collectSchemableIdsFromTableExpr(node, schemableIds) {
         const table = TableNode.is(node)
             ? node
             : AliasNode.is(node) && TableNode.is(node.node)
                 ? node.node
                 : null;
-        if (table && !this.#tables.has(table.table.identifier)) {
-            tables.add(table.table.identifier);
+        if (table) {
+            this.#collectSchemableId(table.table, schemableIds);
+        }
+    }
+    #collectSchemableId(node, schemableIds) {
+        if (!this.#schemableIds.has(node.identifier.name)) {
+            schemableIds.add(node.identifier.name);
         }
     }
-    #removeCommonTableExpressionTables(node, tables) {
+    #removeCommonTableExpressionTables(node, schemableIds) {
         for (const expr of node.expressions) {
-            tables.delete(expr.name.table.table.identifier);
+            schemableIds.delete(expr.name.table.table.identifier.name);
         }
     }
 }

package/dist/esm/query-builder/select-query-builder.d.ts

@@ -12,6 +12,7 @@ import { OrderByDirectionExpression, OrderByExpression } from '../parser/order-b
 import { Compilable } from '../util/compilable.js';
 import { QueryExecutor } from '../query-executor/query-executor.js';
 import { QueryId } from '../util/query-id.js';
+import { GroupByExpression } from '../parser/group-by-parser.js';
 import { UnionExpression } from '../parser/union-parser.js';
 import { KyselyPlugin } from '../plugin/kysely-plugin.js';
 import { WhereInterface } from './where-interface.js';
@@ -1144,8 +1145,8 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      * group by "first_name"
      * ```
      */
-    groupBy(groupBy: ReadonlyArray<ReferenceExpression<DB, TB>>): SelectQueryBuilder<DB, TB, O>;
-    groupBy(groupBy: ReferenceExpression<DB, TB>): SelectQueryBuilder<DB, TB, O>;
+    groupBy(groupBy: ReadonlyArray<GroupByExpression<DB, TB, O>>): SelectQueryBuilder<DB, TB, O>;
+    groupBy(groupBy: GroupByExpression<DB, TB, O>): SelectQueryBuilder<DB, TB, O>;
     /**
      * Adds a limit clause to the query.
      *

package/dist/esm/query-builder/select-query-builder.js

@@ -11,7 +11,7 @@ import { preventAwait } from '../util/prevent-await.js';
 import { LimitNode } from '../operation-node/limit-node.js';
 import { OffsetNode } from '../operation-node/offset-node.js';
 import { freeze } from '../util/object-utils.js';
-import { parseGroupBy } from '../parser/group-by-parser.js';
+import { parseGroupBy, } from '../parser/group-by-parser.js';
 import { parseUnion } from '../parser/union-parser.js';
 import { NoResultError } from './no-result-error.js';
 import { IdentifierNode } from '../operation-node/identifier-node.js';

package/dist/esm/query-compiler/default-query-compiler.d.ts

@@ -72,6 +72,7 @@ import { SelectModifierNode } from '../operation-node/select-modifier-node.js';
 import { CreateTypeNode } from '../operation-node/create-type-node.js';
 import { DropTypeNode } from '../operation-node/drop-type-node.js';
 import { ExplainNode } from '../operation-node/explain-node.js';
+import { SchemableIdentifierNode } from '../operation-node/schemable-identifier-node.js';
 export declare class DefaultQueryCompiler extends OperationNodeVisitor implements QueryCompiler {
     #private;
     protected get numParameters(): number;
@@ -106,6 +107,7 @@ export declare class DefaultQueryCompiler extends OperationNodeVisitor implement
     protected visitRaw(node: RawNode): void;
     protected visitOperator(node: OperatorNode): void;
     protected visitTable(node: TableNode): void;
+    protected visitSchemableIdentifier(node: SchemableIdentifierNode): void;
     protected visitCreateTable(node: CreateTableNode): void;
     protected visitColumnDefinition(node: ColumnDefinitionNode): void;
     protected getAutoIncrement(): string;

package/dist/esm/query-compiler/default-query-compiler.js

@@ -237,10 +237,10 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
         this.append(this.getRightIdentifierWrapper());
     }
     compileUnwrappedIdentifier(node) {
-        if (!isString(node.identifier)) {
+        if (!isString(node.name)) {
             throw new Error('a non-string identifier was passed to compileUnwrappedIdentifier.');
         }
-        this.append(this.sanitizeIdentifier(node.identifier));
+        this.append(this.sanitizeIdentifier(node.name));
     }
     visitFilter(node) {
         if (node.left) {
@@ -316,11 +316,14 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
         this.append(node.operator);
     }
     visitTable(node) {
+        this.visitNode(node.table);
+    }
+    visitSchemableIdentifier(node) {
         if (node.schema) {
             this.visitNode(node.schema);
             this.append('.');
         }
-        this.visitNode(node.table);
+        this.visitNode(node.identifier);
     }
     visitCreateTable(node) {
         this.append('create ');

package/dist/esm/schema/alter-table-builder.d.ts

@@ -92,7 +92,7 @@ export declare class AlterTableAddColumnBuilder implements ColumnDefinitionBuild
      * Makes the column the primary key.
      *
      * If you want to specify a composite primary key use the
-     * {@link TableBuilder.addPrimaryKeyConstraint} method.
+     * {@link CreateTableBuilder.addPrimaryKeyConstraint} method.
      */
     primaryKey(): AlterTableAddColumnBuilder;
     /**
@@ -100,7 +100,7 @@ export declare class AlterTableAddColumnBuilder implements ColumnDefinitionBuild
      *
      * If your database engine doesn't support foreign key constraints in the
      * column definition (like MySQL 5) you need to call the table level
-     * {@link TableBuilder.addForeignKeyConstraint} method instead.
+     * {@link CreateTableBuilder.addForeignKeyConstraint} method instead.
      *
      * ### Examples
      *
@@ -114,7 +114,7 @@ export declare class AlterTableAddColumnBuilder implements ColumnDefinitionBuild
      *
      * If your database engine doesn't support foreign key constraints in the
      * column definition (like MySQL 5) you need to call the table level
-     * {@link TableBuilder.addForeignKeyConstraint} method instead.
+     * {@link CreateTableBuilder.addForeignKeyConstraint} method instead.
      *
      * ### Examples
      *
@@ -258,7 +258,7 @@ export declare class AlterTableModifyColumnBuilder implements ColumnDefinitionBu
      * Makes the column the primary key.
      *
      * If you want to specify a composite primary key use the
-     * {@link TableBuilder.addPrimaryKeyConstraint} method.
+     * {@link CreateTableBuilder.addPrimaryKeyConstraint} method.
      */
     primaryKey(): AlterTableModifyColumnBuilder;
     /**
@@ -266,7 +266,7 @@ export declare class AlterTableModifyColumnBuilder implements ColumnDefinitionBu
      *
      * If your database engine doesn't support foreign key constraints in the
      * column definition (like MySQL 5) you need to call the table level
-     * {@link TableBuilder.addForeignKeyConstraint} method instead.
+     * {@link CreateTableBuilder.addForeignKeyConstraint} method instead.
      *
      * ### Examples
      *
@@ -280,7 +280,7 @@ export declare class AlterTableModifyColumnBuilder implements ColumnDefinitionBu
      *
      * If your database engine doesn't support foreign key constraints in the
      * column definition (like MySQL 5) you need to call the table level
-     * {@link TableBuilder.addForeignKeyConstraint} method instead.
+     * {@link CreateTableBuilder.addForeignKeyConstraint} method instead.
      *
      * ### Examples
      *