kysely 0.28.8 → 0.28.10

package/dist/esm/kysely.d.ts

@@ -1,23 +1,23 @@
-import { Dialect } from './dialect/dialect.js';
+import type { Dialect } from './dialect/dialect.js';
 import { SchemaModule } from './schema/schema.js';
 import { DynamicModule } from './dynamic/dynamic.js';
-import { QueryExecutor } from './query-executor/query-executor.js';
+import type { QueryExecutor } from './query-executor/query-executor.js';
 import { QueryCreator } from './query-creator.js';
-import { KyselyPlugin } from './plugin/kysely-plugin.js';
-import { DatabaseIntrospector } from './dialect/database-introspector.js';
-import { Driver, IsolationLevel, AccessMode } from './driver/driver.js';
-import { FunctionModule } from './query-builder/function-module.js';
-import { LogConfig } from './util/log.js';
-import { QueryExecutorProvider } from './query-executor/query-executor-provider.js';
-import { QueryResult } from './driver/database-connection.js';
-import { CompiledQuery } from './query-compiler/compiled-query.js';
-import { QueryId } from './util/query-id.js';
-import { Compilable } from './util/compilable.js';
+import type { KyselyPlugin } from './plugin/kysely-plugin.js';
+import type { DatabaseIntrospector } from './dialect/database-introspector.js';
+import { type Driver, type IsolationLevel, type AccessMode } from './driver/driver.js';
+import { type FunctionModule } from './query-builder/function-module.js';
+import { type LogConfig } from './util/log.js';
+import type { QueryExecutorProvider } from './query-executor/query-executor-provider.js';
+import type { QueryResult } from './driver/database-connection.js';
+import type { CompiledQuery } from './query-compiler/compiled-query.js';
+import { type QueryId } from './util/query-id.js';
+import { type Compilable } from './util/compilable.js';
 import { CaseBuilder } from './query-builder/case-builder.js';
-import { Expression } from './expression/expression.js';
-import { DrainOuterGeneric } from './util/type-utils.js';
-import { ReleaseSavepoint, RollbackToSavepoint } from './parser/savepoint-parser.js';
-import { ControlledConnection } from './util/provide-controlled-connection.js';
+import type { Expression } from './expression/expression.js';
+import type { DrainOuterGeneric } from './util/type-utils.js';
+import type { ReleaseSavepoint, RollbackToSavepoint } from './parser/savepoint-parser.js';
+import { type ControlledConnection } from './util/provide-controlled-connection.js';
 declare global {
     interface AsyncDisposable {
     }

package/dist/esm/migration/file-migration-provider.d.ts

@@ -1,4 +1,4 @@
-import { Migration, MigrationProvider } from './migrator.js';
+import type { Migration, MigrationProvider } from './migrator.js';
 /**
  * Reads all migrations from a folder in node.js.
  *

package/dist/esm/migration/migrator.d.ts

@@ -1,4 +1,4 @@
-import { Kysely } from '../kysely.js';
+import type { Kysely } from '../kysely.js';
 export declare const DEFAULT_MIGRATION_TABLE = "kysely_migration";
 export declare const DEFAULT_MIGRATION_LOCK_TABLE = "kysely_migration_lock";
 export declare const DEFAULT_ALLOW_UNORDERED_MIGRATIONS = false;
@@ -263,7 +263,7 @@ export interface MigratorProps {
      * the project, to the end of time or prepare to manually migrate the migration
      * tables.
      *
-     * This only works on postgres.
+     * This only works on postgres and mssql.
      */
     readonly migrationTableSchema?: string;
     /**

package/dist/esm/migration/migrator.js

@@ -56,7 +56,8 @@ export class Migrator {
      * The returned array is sorted by migration name.
      */
     async getMigrations() {
-        const executedMigrations = (await this.#doesTableExists(this.#migrationTable))
+        const tableExists = await this.#doesTableExist(this.#migrationTable);
+        const executedMigrations = tableExists
             ? await this.#props.db
                 .withPlugin(this.#schemaPlugin)
                 .selectFrom(this.#migrationTable)
@@ -263,7 +264,10 @@ export class Migrator {
     }
     async #migrate(getMigrationDirectionAndStep) {
         try {
-            await this.#ensureMigrationTablesExists();
+            await this.#ensureMigrationTableSchemaExists();
+            await this.#ensureMigrationTableExists();
+            await this.#ensureMigrationLockTableExists();
+            await this.#ensureLockRowExists();
             return await this.#runMigrations(getMigrationDirectionAndStep);
         }
         catch (error) {
@@ -291,95 +295,98 @@ export class Migrator {
         }
         return new NoopPlugin();
     }
-    async #ensureMigrationTablesExists() {
-        await this.#ensureMigrationTableSchemaExists();
-        await this.#ensureMigrationTableExists();
-        await this.#ensureMigrationLockTableExists();
-        await this.#ensureLockRowExists();
-    }
     async #ensureMigrationTableSchemaExists() {
         if (!this.#migrationTableSchema) {
             // Use default schema. Nothing to do.
             return;
         }
-        if (!(await this.#doesSchemaExists())) {
-            try {
-                await this.#createIfNotExists(this.#props.db.schema.createSchema(this.#migrationTableSchema));
-            }
-            catch (error) {
-                // At least on PostgreSQL, `if not exists` doesn't guarantee the `create schema`
-                // query doesn't throw if the schema already exits. That's why we check if
-                // the schema exist here and ignore the error if it does.
-                if (!(await this.#doesSchemaExists())) {
-                    throw error;
-                }
+        const schemaExists = await this.#doesSchemaExist();
+        if (schemaExists) {
+            return;
+        }
+        try {
+            await this.#createIfNotExists(this.#props.db.schema.createSchema(this.#migrationTableSchema));
+        }
+        catch (error) {
+            const schemaExists = await this.#doesSchemaExist();
+            // At least on PostgreSQL, `if not exists` doesn't guarantee the `create schema`
+            // query doesn't throw if the schema already exits. That's why we check if
+            // the schema exist here and ignore the error if it does.
+            if (!schemaExists) {
+                throw error;
             }
         }
     }
     async #ensureMigrationTableExists() {
-        if (!(await this.#doesTableExists(this.#migrationTable))) {
-            try {
-                if (this.#migrationTableSchema) {
-                    await this.#createIfNotExists(this.#props.db.schema.createSchema(this.#migrationTableSchema));
-                }
-                await this.#createIfNotExists(this.#props.db.schema
-                    .withPlugin(this.#schemaPlugin)
-                    .createTable(this.#migrationTable)
-                    .addColumn('name', 'varchar(255)', (col) => col.notNull().primaryKey())
-                    // The migration run time as ISO string. This is not a real date type as we
-                    // can't know which data type is supported by all future dialects.
-                    .addColumn('timestamp', 'varchar(255)', (col) => col.notNull()));
-            }
-            catch (error) {
-                // At least on PostgreSQL, `if not exists` doesn't guarantee the `create table`
-                // query doesn't throw if the table already exits. That's why we check if
-                // the table exist here and ignore the error if it does.
-                if (!(await this.#doesTableExists(this.#migrationTable))) {
-                    throw error;
-                }
+        const tableExists = await this.#doesTableExist(this.#migrationTable);
+        if (tableExists) {
+            return;
+        }
+        try {
+            await this.#createIfNotExists(this.#props.db.schema
+                .withPlugin(this.#schemaPlugin)
+                .createTable(this.#migrationTable)
+                .addColumn('name', 'varchar(255)', (col) => col.notNull().primaryKey())
+                // The migration run time as ISO string. This is not a real date type as we
+                // can't know which data type is supported by all future dialects.
+                .addColumn('timestamp', 'varchar(255)', (col) => col.notNull()));
+        }
+        catch (error) {
+            const tableExists = await this.#doesTableExist(this.#migrationTable);
+            // At least on PostgreSQL, `if not exists` doesn't guarantee the `create table`
+            // query doesn't throw if the table already exits. That's why we check if
+            // the table exist here and ignore the error if it does.
+            if (!tableExists) {
+                throw error;
             }
         }
     }
     async #ensureMigrationLockTableExists() {
-        if (!(await this.#doesTableExists(this.#migrationLockTable))) {
-            try {
-                await this.#createIfNotExists(this.#props.db.schema
-                    .withPlugin(this.#schemaPlugin)
-                    .createTable(this.#migrationLockTable)
-                    .addColumn('id', 'varchar(255)', (col) => col.notNull().primaryKey())
-                    .addColumn('is_locked', 'integer', (col) => col.notNull().defaultTo(0)));
-            }
-            catch (error) {
-                // At least on PostgreSQL, `if not exists` doesn't guarantee the `create table`
-                // query doesn't throw if the table already exits. That's why we check if
-                // the table exist here and ignore the error if it does.
-                if (!(await this.#doesTableExists(this.#migrationLockTable))) {
-                    throw error;
-                }
+        const tableExists = await this.#doesTableExist(this.#migrationLockTable);
+        if (tableExists) {
+            return;
+        }
+        try {
+            await this.#createIfNotExists(this.#props.db.schema
+                .withPlugin(this.#schemaPlugin)
+                .createTable(this.#migrationLockTable)
+                .addColumn('id', 'varchar(255)', (col) => col.notNull().primaryKey())
+                .addColumn('is_locked', 'integer', (col) => col.notNull().defaultTo(0)));
+        }
+        catch (error) {
+            const tableExists = await this.#doesTableExist(this.#migrationLockTable);
+            // At least on PostgreSQL, `if not exists` doesn't guarantee the `create table`
+            // query doesn't throw if the table already exits. That's why we check if
+            // the table exist here and ignore the error if it does.
+            if (!tableExists) {
+                throw error;
             }
         }
     }
     async #ensureLockRowExists() {
-        if (!(await this.#doesLockRowExists())) {
-            try {
-                await this.#props.db
-                    .withPlugin(this.#schemaPlugin)
-                    .insertInto(this.#migrationLockTable)
-                    .values({ id: MIGRATION_LOCK_ID, is_locked: 0 })
-                    .execute();
-            }
-            catch (error) {
-                if (!(await this.#doesLockRowExists())) {
-                    throw error;
-                }
+        const lockRowExists = await this.#doesLockRowExists();
+        if (lockRowExists) {
+            return;
+        }
+        try {
+            await this.#props.db
+                .withPlugin(this.#schemaPlugin)
+                .insertInto(this.#migrationLockTable)
+                .values({ id: MIGRATION_LOCK_ID, is_locked: 0 })
+                .execute();
+        }
+        catch (error) {
+            const lockRowExists = await this.#doesLockRowExists();
+            if (!lockRowExists) {
+                throw error;
             }
         }
     }
-    async #doesSchemaExists() {
+    async #doesSchemaExist() {
         const schemas = await this.#props.db.introspection.getSchemas();
         return schemas.some((it) => it.name === this.#migrationTableSchema);
     }
-    async #doesTableExists(tableName) {
+    async #doesTableExist(tableName) {
         const schema = this.#migrationTableSchema;
         const tables = await this.#props.db.introspection.getTables({
             withInternalKyselyTables: true,

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

@@ -1,13 +1,15 @@
-import { ColumnDefinitionNode } from './column-definition-node.js';
-import { OperationNode } from './operation-node.js';
+import type { ColumnDefinitionNode } from './column-definition-node.js';
+import type { OperationNode } from './operation-node.js';
 export interface AddColumnNode extends OperationNode {
     readonly kind: 'AddColumnNode';
     readonly column: ColumnDefinitionNode;
 }
+type AddColumnNodeFactory = Readonly<{
+    is(node: OperationNode): node is AddColumnNode;
+    create(column: ColumnDefinitionNode): Readonly<AddColumnNode>;
+}>;
 /**
  * @internal
  */
-export declare const AddColumnNode: Readonly<{
-    is(node: OperationNode): node is AddColumnNode;
-    create(column: ColumnDefinitionNode): AddColumnNode;
-}>;
+export declare const AddColumnNode: AddColumnNodeFactory;
+export {};

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

@@ -1,13 +1,15 @@
-import { OperationNode } from './operation-node.js';
-import { ConstraintNode } from './constraint-node.js';
+import type { OperationNode } from './operation-node.js';
+import type { ConstraintNode } from './constraint-node.js';
 export interface AddConstraintNode extends OperationNode {
     readonly kind: 'AddConstraintNode';
     readonly constraint: ConstraintNode;
 }
+type AddConstraintNodeFactory = Readonly<{
+    is(node: OperationNode): node is AddConstraintNode;
+    create(constraint: ConstraintNode): Readonly<AddConstraintNode>;
+}>;
 /**
  * @internal
  */
-export declare const AddConstraintNode: Readonly<{
-    is(node: OperationNode): node is AddConstraintNode;
-    create(constraint: ConstraintNode): AddConstraintNode;
-}>;
+export declare const AddConstraintNode: AddConstraintNodeFactory;
+export {};

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

@@ -1,6 +1,6 @@
 import { IdentifierNode } from './identifier-node.js';
-import { OperationNode } from './operation-node.js';
-import { RawNode } from './raw-node.js';
+import type { OperationNode } from './operation-node.js';
+import type { RawNode } from './raw-node.js';
 export type AddIndexNodeProps = Omit<AddIndexNode, 'kind' | 'name'>;
 export interface AddIndexNode extends OperationNode {
     readonly kind: 'AddIndexNode';
@@ -10,12 +10,14 @@ export interface AddIndexNode extends OperationNode {
     readonly using?: RawNode;
     readonly ifNotExists?: boolean;
 }
+type AddIndexNodeFactory = Readonly<{
+    is(node: OperationNode): node is AddIndexNode;
+    create(name: string): Readonly<AddIndexNode>;
+    cloneWith(node: AddIndexNode, props: Omit<AddIndexNode, 'kind' | 'name'>): Readonly<AddIndexNode>;
+    cloneWithColumns(node: AddIndexNode, columns: OperationNode[]): Readonly<AddIndexNode>;
+}>;
 /**
  * @internal
  */
-export declare const AddIndexNode: Readonly<{
-    is(node: OperationNode): node is AddIndexNode;
-    create(name: string): AddIndexNode;
-    cloneWith(node: AddIndexNode, props: AddIndexNodeProps): AddIndexNode;
-    cloneWithColumns(node: AddIndexNode, columns: OperationNode[]): AddIndexNode;
-}>;
+export declare const AddIndexNode: AddIndexNodeFactory;
+export {};

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

@@ -1,8 +1,8 @@
-import { OperationNode } from './operation-node.js';
-import { OverNode } from './over-node.js';
+import type { OperationNode } from './operation-node.js';
+import type { OverNode } from './over-node.js';
 import { WhereNode } from './where-node.js';
 import { OrderByNode } from './order-by-node.js';
-import { OrderByItemNode } from './order-by-item-node.js';
+import type { OrderByItemNode } from './order-by-item-node.js';
 export interface AggregateFunctionNode extends OperationNode {
     readonly kind: 'AggregateFunctionNode';
     readonly func: string;
@@ -13,15 +13,17 @@ export interface AggregateFunctionNode extends OperationNode {
     readonly filter?: WhereNode;
     readonly over?: OverNode;
 }
+type AggregateFunctionNodeFactory = Readonly<{
+    is(node: OperationNode): node is AggregateFunctionNode;
+    create(aggregateFunction: string, aggregated?: readonly OperationNode[]): Readonly<AggregateFunctionNode>;
+    cloneWithDistinct(aggregateFunctionNode: AggregateFunctionNode): Readonly<AggregateFunctionNode>;
+    cloneWithOrderBy(aggregateFunctionNode: AggregateFunctionNode, orderItems: ReadonlyArray<OrderByItemNode>, withinGroup?: boolean): Readonly<AggregateFunctionNode>;
+    cloneWithFilter(aggregateFunctionNode: AggregateFunctionNode, filter: OperationNode): Readonly<AggregateFunctionNode>;
+    cloneWithOrFilter(aggregateFunctionNode: AggregateFunctionNode, filter: OperationNode): Readonly<AggregateFunctionNode>;
+    cloneWithOver(aggregateFunctionNode: AggregateFunctionNode, over?: OverNode): Readonly<AggregateFunctionNode>;
+}>;
 /**
  * @internal
  */
-export declare const AggregateFunctionNode: Readonly<{
-    is(node: OperationNode): node is AggregateFunctionNode;
-    create(aggregateFunction: string, aggregated?: readonly OperationNode[]): AggregateFunctionNode;
-    cloneWithDistinct(aggregateFunctionNode: AggregateFunctionNode): AggregateFunctionNode;
-    cloneWithOrderBy(aggregateFunctionNode: AggregateFunctionNode, orderItems: ReadonlyArray<OrderByItemNode>, withinGroup?: boolean): AggregateFunctionNode;
-    cloneWithFilter(aggregateFunctionNode: AggregateFunctionNode, filter: OperationNode): AggregateFunctionNode;
-    cloneWithOrFilter(aggregateFunctionNode: AggregateFunctionNode, filter: OperationNode): AggregateFunctionNode;
-    cloneWithOver(aggregateFunctionNode: AggregateFunctionNode, over?: OverNode): AggregateFunctionNode;
-}>;
+export declare const AggregateFunctionNode: AggregateFunctionNodeFactory;
+export {};

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

@@ -1,13 +1,15 @@
-import { OperationNode } from './operation-node.js';
+import type { OperationNode } from './operation-node.js';
 export interface AliasNode extends OperationNode {
     readonly kind: 'AliasNode';
     readonly node: OperationNode;
     readonly alias: OperationNode;
 }
+type AliasNodeFactory = Readonly<{
+    is(node: OperationNode): node is AliasNode;
+    create(node: OperationNode, alias: OperationNode): Readonly<AliasNode>;
+}>;
 /**
  * @internal
  */
-export declare const AliasNode: Readonly<{
-    is(node: OperationNode): node is AliasNode;
-    create(node: OperationNode, alias: OperationNode): AliasNode;
-}>;
+export declare const AliasNode: AliasNodeFactory;
+export {};

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

@@ -1,6 +1,6 @@
-import { OperationNode } from './operation-node.js';
+import type { OperationNode } from './operation-node.js';
 import { ColumnNode } from './column-node.js';
-import { RawNode } from './raw-node.js';
+import type { RawNode } from './raw-node.js';
 export type AlterColumnNodeProps = Omit<AlterColumnNode, 'kind' | 'column'>;
 export interface AlterColumnNode extends OperationNode {
     readonly kind: 'AlterColumnNode';
@@ -12,10 +12,12 @@ export interface AlterColumnNode extends OperationNode {
     readonly setNotNull?: true;
     readonly dropNotNull?: true;
 }
+type AlterColumnNodeFactory = Readonly<{
+    is(node: OperationNode): node is AlterColumnNode;
+    create<T extends keyof AlterColumnNodeProps>(column: string, prop: T, value: Required<AlterColumnNodeProps>[T]): Readonly<AlterColumnNode>;
+}>;
 /**
  * @internal
  */
-export declare const AlterColumnNode: Readonly<{
-    is(node: OperationNode): node is AlterColumnNode;
-    create<T extends keyof AlterColumnNodeProps>(column: string, prop: T, value: Required<AlterColumnNodeProps>[T]): AlterColumnNode;
-}>;
+export declare const AlterColumnNode: AlterColumnNodeFactory;
+export {};

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

@@ -1,16 +1,16 @@
-import { OperationNode } from './operation-node.js';
-import { AddColumnNode } from './add-column-node.js';
-import { DropColumnNode } from './drop-column-node.js';
-import { TableNode } from './table-node.js';
-import { IdentifierNode } from './identifier-node.js';
-import { RenameColumnNode } from './rename-column-node.js';
-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';
-import { DropIndexNode } from './drop-index-node.js';
-import { AddIndexNode } from './add-index-node.js';
-import { RenameConstraintNode } from './rename-constraint-node.js';
+import type { OperationNode } from './operation-node.js';
+import type { AddColumnNode } from './add-column-node.js';
+import type { DropColumnNode } from './drop-column-node.js';
+import type { TableNode } from './table-node.js';
+import type { IdentifierNode } from './identifier-node.js';
+import type { RenameColumnNode } from './rename-column-node.js';
+import type { AlterColumnNode } from './alter-column-node.js';
+import type { AddConstraintNode } from './add-constraint-node.js';
+import type { DropConstraintNode } from './drop-constraint-node.js';
+import type { ModifyColumnNode } from './modify-column-node.js';
+import type { DropIndexNode } from './drop-index-node.js';
+import type { AddIndexNode } from './add-index-node.js';
+import type { RenameConstraintNode } from './rename-constraint-node.js';
 export type AlterTableNodeTableProps = Pick<AlterTableNode, 'renameTo' | 'setSchema' | 'addConstraint' | 'dropConstraint' | 'addIndex' | 'dropIndex' | 'renameConstraint'>;
 export type AlterTableColumnAlterationNode = RenameColumnNode | AddColumnNode | DropColumnNode | AlterColumnNode | ModifyColumnNode;
 export interface AlterTableNode extends OperationNode {
@@ -25,12 +25,14 @@ export interface AlterTableNode extends OperationNode {
     readonly addIndex?: AddIndexNode;
     readonly dropIndex?: DropIndexNode;
 }
+type AlterTableNodeFactory = Readonly<{
+    is(node: OperationNode): node is AlterTableNode;
+    create(table: TableNode): Readonly<AlterTableNode>;
+    cloneWithTableProps(node: AlterTableNode, props: AlterTableNodeTableProps): Readonly<AlterTableNode>;
+    cloneWithColumnAlteration(node: AlterTableNode, columnAlteration: AlterTableColumnAlterationNode): Readonly<AlterTableNode>;
+}>;
 /**
  * @internal
  */
-export declare const AlterTableNode: Readonly<{
-    is(node: OperationNode): node is AlterTableNode;
-    create(table: TableNode): AlterTableNode;
-    cloneWithTableProps(node: AlterTableNode, props: AlterTableNodeTableProps): AlterTableNode;
-    cloneWithColumnAlteration(node: AlterTableNode, columnAlteration: AlterTableColumnAlterationNode): AlterTableNode;
-}>;
+export declare const AlterTableNode: AlterTableNodeFactory;
+export {};

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

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

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

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

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

@@ -1,4 +1,4 @@
-import { OperationNode } from './operation-node.js';
+import type { OperationNode } from './operation-node.js';
 import { WhenNode } from './when-node.js';
 export interface CaseNode extends OperationNode {
     readonly kind: 'CaseNode';
@@ -7,13 +7,15 @@ export interface CaseNode extends OperationNode {
     readonly else?: OperationNode;
     readonly isStatement?: boolean;
 }
+type CaseNodeFactory = Readonly<{
+    is(node: OperationNode): node is CaseNode;
+    create(value?: OperationNode): Readonly<CaseNode>;
+    cloneWithWhen(caseNode: CaseNode, when: WhenNode): Readonly<CaseNode>;
+    cloneWithThen(caseNode: CaseNode, then: OperationNode): Readonly<CaseNode>;
+    cloneWith(caseNode: CaseNode, props: Partial<Pick<CaseNode, 'else' | 'isStatement'>>): Readonly<CaseNode>;
+}>;
 /**
  * @internal
  */
-export declare const CaseNode: Readonly<{
-    is(node: OperationNode): node is CaseNode;
-    create(value?: OperationNode): CaseNode;
-    cloneWithWhen(caseNode: CaseNode, when: WhenNode): CaseNode;
-    cloneWithThen(caseNode: CaseNode, then: OperationNode): CaseNode;
-    cloneWith(caseNode: CaseNode, props: Partial<Pick<CaseNode, "else" | "isStatement">>): CaseNode;
-}>;
+export declare const CaseNode: CaseNodeFactory;
+export {};

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

@@ -1,13 +1,15 @@
-import { OperationNode } from './operation-node.js';
+import type { OperationNode } from './operation-node.js';
 export interface CastNode extends OperationNode {
     readonly kind: 'CastNode';
     readonly expression: OperationNode;
     readonly dataType: OperationNode;
 }
+type CastNodeFactory = Readonly<{
+    is(node: OperationNode): node is CastNode;
+    create(expression: OperationNode, dataType: OperationNode): Readonly<CastNode>;
+}>;
 /**
  * @internal
  */
-export declare const CastNode: Readonly<{
-    is(node: OperationNode): node is CastNode;
-    create(expression: OperationNode, dataType: OperationNode): CastNode;
-}>;
+export declare const CastNode: CastNodeFactory;
+export {};

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

@@ -1,14 +1,16 @@
-import { OperationNode } from './operation-node.js';
+import type { OperationNode } from './operation-node.js';
 import { IdentifierNode } from './identifier-node.js';
 export interface CheckConstraintNode extends OperationNode {
     readonly kind: 'CheckConstraintNode';
     readonly expression: OperationNode;
     readonly name?: IdentifierNode;
 }
+type CheckConstraintNodeFactory = Readonly<{
+    is(node: OperationNode): node is CheckConstraintNode;
+    create(expression: OperationNode, constraintName?: string): Readonly<CheckConstraintNode>;
+}>;
 /**
  * @internal
  */
-export declare const CheckConstraintNode: Readonly<{
-    is(node: OperationNode): node is CheckConstraintNode;
-    create(expression: OperationNode, constraintName?: string): CheckConstraintNode;
-}>;
+export declare const CheckConstraintNode: CheckConstraintNodeFactory;
+export {};

package/dist/esm/operation-node/check-constraint-node.js

@@ -12,7 +12,9 @@ export const CheckConstraintNode = freeze({
         return freeze({
             kind: 'CheckConstraintNode',
             expression,
-            name: constraintName ? IdentifierNode.create(constraintName) : undefined,
+            name: constraintName
+                ? IdentifierNode.create(constraintName)
+                : undefined,
         });
     },
 });

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

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

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

@@ -4,7 +4,7 @@ import { IdentifierNode } from './identifier-node.js';
 /**
  * @internal
  */
-export const CollateNode = {
+export const CollateNode = freeze({
     is(node) {
         return node.kind === 'CollateNode';
     },
@@ -14,4 +14,4 @@ export const CollateNode = {
             collation: IdentifierNode.create(collation),
         });
     },
-};
+});