kysely 0.20.1 → 0.21.2

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

@@ -2,120 +2,112 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WithSchemaTransformer = void 0;
 const alias_node_js_1 = require("../../operation-node/alias-node.js");
+const identifier_node_js_1 = require("../../operation-node/identifier-node.js");
 const operation_node_transformer_js_1 = require("../../operation-node/operation-node-transformer.js");
+const schemable_identifier_node_js_1 = require("../../operation-node/schemable-identifier-node.js");
 const table_node_js_1 = require("../../operation-node/table-node.js");
+const object_utils_js_1 = require("../../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 = (0, object_utils_js_1.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,
+});
 class WithSchemaTransformer extends operation_node_transformer_js_1.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: identifier_node_js_1.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 && schemable_identifier_node_js_1.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 = table_node_js_1.TableNode.is(node)
             ? node
             : alias_node_js_1.AliasNode.is(node) && table_node_js_1.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/cjs/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/cjs/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/cjs/query-compiler/default-query-compiler.js

@@ -239,10 +239,10 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
         this.append(this.getRightIdentifierWrapper());
     }
     compileUnwrappedIdentifier(node) {
-        if (!(0, object_utils_js_1.isString)(node.identifier)) {
+        if (!(0, object_utils_js_1.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) {
@@ -318,11 +318,14 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
         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/cjs/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
      *

package/dist/cjs/schema/column-definition-builder.d.ts

@@ -16,7 +16,7 @@ export interface ColumnDefinitionBuilderInterface {
      * 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(): ColumnDefinitionBuilderInterface;
     /**
@@ -24,7 +24,7 @@ export interface ColumnDefinitionBuilderInterface {
      *
      * 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
      *
@@ -38,7 +38,7 @@ export interface ColumnDefinitionBuilderInterface {
      *
      * 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
      *
@@ -175,7 +175,7 @@ export declare class ColumnDefinitionBuilder implements ColumnDefinitionBuilderI
      * 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(): ColumnDefinitionBuilder;
     /**
@@ -183,7 +183,7 @@ export declare class ColumnDefinitionBuilder implements ColumnDefinitionBuilderI
      *
      * 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
      *
@@ -197,7 +197,7 @@ export declare class ColumnDefinitionBuilder implements ColumnDefinitionBuilderI
      *
      * 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
      *

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

@@ -19,13 +19,13 @@ export class MysqlIntrospector {
         let query = this.#db
             .selectFrom('information_schema.columns')
             .select([
-            'column_name',
-            'column_default',
-            'table_name',
-            'table_schema',
-            'is_nullable',
-            'data_type',
-            'extra',
+            'COLUMN_NAME',
+            'COLUMN_DEFAULT',
+            'TABLE_NAME',
+            'TABLE_SCHEMA',
+            'IS_NULLABLE',
+            'DATA_TYPE',
+            'EXTRA',
         ])
             .where('table_schema', '=', sql `database()`)
             .orderBy('table_name')

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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