kysely 0.7.2 → 0.7.6

package/dist/cjs/schema/drop-index-builder.js

@@ -4,14 +4,11 @@ exports.DropIndexBuilder = void 0;
 const drop_index_node_js_1 = require("../operation-node/drop-index-node.js");
 const prevent_await_js_1 = require("../util/prevent-await.js");
 const table_parser_js_1 = require("../parser/table-parser.js");
+const object_utils_js_1 = require("../util/object-utils.js");
 class DropIndexBuilder {
-    #queryId;
-    #dropIndexNode;
-    #executor;
-    constructor(args) {
-        this.#queryId = args.queryId;
-        this.#dropIndexNode = args.dropIndexNode;
-        this.#executor = args.executor;
+    #props;
+    constructor(props) {
+        this.#props = (0, object_utils_js_1.freeze)(props);
     }
     /**
      * Specifies the table the index was created for. This is not needed
@@ -19,30 +16,28 @@ class DropIndexBuilder {
      */
     on(table) {
         return new DropIndexBuilder({
-            queryId: this.#queryId,
-            executor: this.#executor,
-            dropIndexNode: drop_index_node_js_1.DropIndexNode.cloneWith(this.#dropIndexNode, {
+            ...this.#props,
+            dropIndexNode: drop_index_node_js_1.DropIndexNode.cloneWith(this.#props.dropIndexNode, {
                 table: (0, table_parser_js_1.parseTable)(table),
             }),
         });
     }
     ifExists() {
         return new DropIndexBuilder({
-            queryId: this.#queryId,
-            executor: this.#executor,
-            dropIndexNode: drop_index_node_js_1.DropIndexNode.cloneWith(this.#dropIndexNode, {
+            ...this.#props,
+            dropIndexNode: drop_index_node_js_1.DropIndexNode.cloneWith(this.#props.dropIndexNode, {
                 modifier: 'IfExists',
             }),
         });
     }
     toOperationNode() {
-        return this.#executor.transformQuery(this.#dropIndexNode, this.#queryId);
+        return this.#props.executor.transformQuery(this.#props.dropIndexNode, this.#props.queryId);
     }
     compile() {
-        return this.#executor.compileQuery(this.toOperationNode(), this.#queryId);
+        return this.#props.executor.compileQuery(this.toOperationNode(), this.#props.queryId);
     }
     async execute() {
-        await this.#executor.executeQuery(this.compile(), this.#queryId);
+        await this.#props.executor.executeQuery(this.compile(), this.#props.queryId);
     }
 }
 exports.DropIndexBuilder = DropIndexBuilder;

package/dist/cjs/schema/drop-schema-builder.d.ts

@@ -6,14 +6,14 @@ import { QueryExecutor } from '../query-executor/query-executor.js';
 import { QueryId } from '../util/query-id.js';
 export declare class DropSchemaBuilder implements OperationNodeSource, Compilable {
     #private;
-    constructor(args: DropSchemaBuilderConstructorArgs);
+    constructor(props: DropSchemaBuilderProps);
     ifExists(): DropSchemaBuilder;
     toOperationNode(): DropSchemaNode;
     compile(): CompiledQuery;
     execute(): Promise<void>;
 }
-export interface DropSchemaBuilderConstructorArgs {
-    queryId: QueryId;
-    dropSchemaNode: DropSchemaNode;
-    executor: QueryExecutor;
+export interface DropSchemaBuilderProps {
+    readonly queryId: QueryId;
+    readonly executor: QueryExecutor;
+    readonly dropSchemaNode: DropSchemaNode;
 }

package/dist/cjs/schema/drop-schema-builder.js

@@ -3,30 +3,26 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DropSchemaBuilder = void 0;
 const drop_schema_node_js_1 = require("../operation-node/drop-schema-node.js");
 const prevent_await_js_1 = require("../util/prevent-await.js");
+const object_utils_js_1 = require("../util/object-utils.js");
 class DropSchemaBuilder {
-    #queryId;
-    #dropSchemaNode;
-    #executor;
-    constructor(args) {
-        this.#queryId = args.queryId;
-        this.#dropSchemaNode = args.dropSchemaNode;
-        this.#executor = args.executor;
+    #props;
+    constructor(props) {
+        this.#props = (0, object_utils_js_1.freeze)(props);
     }
     ifExists() {
         return new DropSchemaBuilder({
-            queryId: this.#queryId,
-            executor: this.#executor,
-            dropSchemaNode: drop_schema_node_js_1.DropSchemaNode.cloneWithModifier(this.#dropSchemaNode, 'IfExists'),
+            ...this.#props,
+            dropSchemaNode: drop_schema_node_js_1.DropSchemaNode.cloneWithModifier(this.#props.dropSchemaNode, 'IfExists'),
         });
     }
     toOperationNode() {
-        return this.#executor.transformQuery(this.#dropSchemaNode, this.#queryId);
+        return this.#props.executor.transformQuery(this.#props.dropSchemaNode, this.#props.queryId);
     }
     compile() {
-        return this.#executor.compileQuery(this.toOperationNode(), this.#queryId);
+        return this.#props.executor.compileQuery(this.toOperationNode(), this.#props.queryId);
     }
     async execute() {
-        await this.#executor.executeQuery(this.compile(), this.#queryId);
+        await this.#props.executor.executeQuery(this.compile(), this.#props.queryId);
     }
 }
 exports.DropSchemaBuilder = DropSchemaBuilder;

package/dist/cjs/schema/drop-table-builder.d.ts

@@ -6,14 +6,14 @@ import { QueryExecutor } from '../query-executor/query-executor.js';
 import { QueryId } from '../util/query-id.js';
 export declare class DropTableBuilder implements OperationNodeSource, Compilable {
     #private;
-    constructor(args: DropTableBuilderConstructorArgs);
+    constructor(props: DropTableBuilderProps);
     ifExists(): DropTableBuilder;
     toOperationNode(): DropTableNode;
     compile(): CompiledQuery;
     execute(): Promise<void>;
 }
-export interface DropTableBuilderConstructorArgs {
-    queryId: QueryId;
-    dropTableNode: DropTableNode;
-    executor: QueryExecutor;
+export interface DropTableBuilderProps {
+    readonly queryId: QueryId;
+    readonly executor: QueryExecutor;
+    readonly dropTableNode: DropTableNode;
 }

package/dist/cjs/schema/drop-table-builder.js

@@ -3,30 +3,26 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DropTableBuilder = void 0;
 const drop_table_node_js_1 = require("../operation-node/drop-table-node.js");
 const prevent_await_js_1 = require("../util/prevent-await.js");
+const object_utils_js_1 = require("../util/object-utils.js");
 class DropTableBuilder {
-    #queryId;
-    #dropTableNode;
-    #executor;
-    constructor(args) {
-        this.#queryId = args.queryId;
-        this.#dropTableNode = args.dropTableNode;
-        this.#executor = args.executor;
+    #props;
+    constructor(props) {
+        this.#props = (0, object_utils_js_1.freeze)(props);
     }
     ifExists() {
         return new DropTableBuilder({
-            queryId: this.#queryId,
-            executor: this.#executor,
-            dropTableNode: drop_table_node_js_1.DropTableNode.cloneWithModifier(this.#dropTableNode, 'IfExists'),
+            ...this.#props,
+            dropTableNode: drop_table_node_js_1.DropTableNode.cloneWithModifier(this.#props.dropTableNode, 'IfExists'),
         });
     }
     toOperationNode() {
-        return this.#executor.transformQuery(this.#dropTableNode, this.#queryId);
+        return this.#props.executor.transformQuery(this.#props.dropTableNode, this.#props.queryId);
     }
     compile() {
-        return this.#executor.compileQuery(this.toOperationNode(), this.#queryId);
+        return this.#props.executor.compileQuery(this.toOperationNode(), this.#props.queryId);
     }
     async execute() {
-        await this.#executor.executeQuery(this.compile(), this.#queryId);
+        await this.#props.executor.executeQuery(this.compile(), this.#props.queryId);
     }
 }
 exports.DropTableBuilder = DropTableBuilder;

package/dist/cjs/schema/foreign-key-constraint-builder.d.ts

@@ -0,0 +1,14 @@
+import { ForeignKeyConstraintNode } from '../operation-node/foreign-key-constraint-node.js';
+import { OperationNodeSource } from '../operation-node/operation-node-source.js';
+import { OnModifyForeignAction } from '../operation-node/references-node.js';
+export interface ForeignKeyConstraintBuilderInterface<R> {
+    onDelete(onDelete: OnModifyForeignAction): R;
+    onUpdate(onUpdate: OnModifyForeignAction): R;
+}
+export declare class ForeignKeyConstraintBuilder implements ForeignKeyConstraintBuilderInterface<ForeignKeyConstraintBuilder>, OperationNodeSource {
+    #private;
+    constructor(node: ForeignKeyConstraintNode);
+    onDelete(onDelete: OnModifyForeignAction): ForeignKeyConstraintBuilder;
+    onUpdate(onUpdate: OnModifyForeignAction): ForeignKeyConstraintBuilder;
+    toOperationNode(): ForeignKeyConstraintNode;
+}

package/dist/cjs/schema/foreign-key-constraint-builder.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ForeignKeyConstraintBuilder = void 0;
+const foreign_key_constraint_node_js_1 = require("../operation-node/foreign-key-constraint-node.js");
+const prevent_await_js_1 = require("../util/prevent-await.js");
+class ForeignKeyConstraintBuilder {
+    #node;
+    constructor(node) {
+        this.#node = node;
+    }
+    onDelete(onDelete) {
+        return new ForeignKeyConstraintBuilder(foreign_key_constraint_node_js_1.ForeignKeyConstraintNode.cloneWith(this.#node, {
+            onDelete,
+        }));
+    }
+    onUpdate(onUpdate) {
+        return new ForeignKeyConstraintBuilder(foreign_key_constraint_node_js_1.ForeignKeyConstraintNode.cloneWith(this.#node, {
+            onUpdate,
+        }));
+    }
+    toOperationNode() {
+        return this.#node;
+    }
+}
+exports.ForeignKeyConstraintBuilder = ForeignKeyConstraintBuilder;
+(0, prevent_await_js_1.preventAwait)(ForeignKeyConstraintBuilder, "don't await ForeignKeyConstraintBuilder instances directly.");

package/dist/esm/dialect/dialect-adapter.d.ts

@@ -1,13 +1,5 @@
 import { Kysely } from '../kysely.js';
-/**
- * The `DialectAdapter` encapsulates all differences between dialects outside
- * the `Driver` and `QueryCompiler`.
- *
- * For example, some databases support transactional DDL and therefore we want
- * to run migrations inside a transaction, while other databases don't support
- * it. For that there's a `supportsTransactionalDdl` boolean in this interface.
- */
-export interface DialectAdapter {
+export interface DialectSupports {
     /**
      * Whether or not this dialect supports transactional DDL.
      *
@@ -19,6 +11,16 @@ export interface DialectAdapter {
      * upates and deletes.
      */
     readonly supportsReturning: boolean;
+}
+/**
+ * The `DialectAdapter` encapsulates all differences between dialects outside
+ * the `Driver` and `QueryCompiler`.
+ *
+ * For example, some databases support transactional DDL and therefore we want
+ * to run migrations inside a transaction, while other databases don't support
+ * it. For that there's a `supportsTransactionalDdl` boolean in this interface.
+ */
+export interface DialectAdapter extends DialectSupports {
     /**
      * This method is used to acquire a lock for the migrations so that
      * it's not possible for two migration processes to run in parallel.

package/dist/esm/index.d.ts

@@ -2,7 +2,7 @@ export * from './kysely.js';
 export * from './query-creator.js';
 export * from './query-builder/query-builder.js';
 export * from './query-builder/join-builder.js';
-export * from './query-builder/sub-query-builder.js';
+export * from './query-builder/expression-builder.js';
 export * from './raw-builder/raw-builder.js';
 export * from './query-executor/query-executor.js';
 export * from './query-executor/default-query-executor.js';
@@ -17,6 +17,7 @@ export * from './schema/drop-index-builder.js';
 export * from './schema/create-schema-builder.js';
 export * from './schema/drop-schema-builder.js';
 export * from './schema/column-definition-builder.js';
+export * from './schema/foreign-key-constraint-builder.js';
 export * from './schema/alter-table-builder.js';
 export * from './dynamic/dynamic.js';
 export * from './driver/driver.js';

package/dist/esm/index.js

@@ -2,7 +2,7 @@ export * from './kysely.js';
 export * from './query-creator.js';
 export * from './query-builder/query-builder.js';
 export * from './query-builder/join-builder.js';
-export * from './query-builder/sub-query-builder.js';
+export * from './query-builder/expression-builder.js';
 export * from './raw-builder/raw-builder.js';
 export * from './query-executor/query-executor.js';
 export * from './query-executor/default-query-executor.js';
@@ -17,6 +17,7 @@ export * from './schema/drop-index-builder.js';
 export * from './schema/create-schema-builder.js';
 export * from './schema/drop-schema-builder.js';
 export * from './schema/column-definition-builder.js';
+export * from './schema/foreign-key-constraint-builder.js';
 export * from './schema/alter-table-builder.js';
 export * from './dynamic/dynamic.js';
 export * from './driver/driver.js';

package/dist/esm/kysely.d.ts

@@ -8,7 +8,7 @@ import { KyselyPlugin } from './plugin/kysely-plugin.js';
 import { GeneratedPlaceholder } from './query-builder/type-utils.js';
 import { DatabaseIntrospector } from './introspection/database-introspector.js';
 import { Driver, IsolationLevel } from './driver/driver.js';
-import { DialectAdapter } from './dialect/dialect-adapter.js';
+import { ParseContext } from './parser/parse-context.js';
 /**
  * The main Kysely class.
  *
@@ -186,7 +186,7 @@ export interface KyselyProps {
     readonly driver: Driver;
     readonly executor: QueryExecutor;
     readonly dialect: Dialect;
-    readonly adapter: DialectAdapter;
+    readonly parseContext: ParseContext;
 }
 export declare function isKyselyProps(obj: unknown): obj is KyselyProps;
 export interface KyselyConfig {

package/dist/esm/kysely.js

@@ -10,6 +10,7 @@ import { RuntimeDriver } from './driver/runtime-driver.js';
 import { SingleConnectionProvider } from './driver/single-connection-provider.js';
 import { TRANSACTION_ISOLATION_LEVELS, } from './driver/driver.js';
 import { preventAwait } from './util/prevent-await.js';
+import { DefaultParseContext } from './parser/parse-context.js';
 /**
  * The main Kysely class.
  *
@@ -54,7 +55,7 @@ export class Kysely extends QueryCreator {
     #props;
     constructor(args) {
         if (isKyselyProps(args)) {
-            super({ executor: args.executor, adapter: args.adapter });
+            super({ executor: args.executor, parseContext: args.parseContext });
             this.#props = freeze(args);
         }
         else {
@@ -62,16 +63,17 @@ export class Kysely extends QueryCreator {
             const driver = dialect.createDriver();
             const compiler = dialect.createQueryCompiler();
             const adapter = dialect.createAdapter();
+            const parseContext = new DefaultParseContext(adapter);
             const runtimeDriver = new RuntimeDriver(driver);
             const connectionProvider = new DefaultConnectionProvider(runtimeDriver);
             const executor = new DefaultQueryExecutor(compiler, connectionProvider, args.plugins ?? []);
-            super({ executor, adapter });
+            super({ executor, parseContext });
             this.#props = freeze({
                 config: args,
                 executor,
-                adapter,
                 dialect,
-                driver,
+                driver: runtimeDriver,
+                parseContext,
             });
         }
     }
@@ -85,7 +87,7 @@ export class Kysely extends QueryCreator {
      * Returns the {@link MigrationModule} module for managing and running migrations.
      */
     get migration() {
-        return new MigrationModule(this, this.#props.adapter);
+        return new MigrationModule(this, this.#props.parseContext.adapter);
     }
     /**
      * Returns a the {@link DynamicModule} module.
@@ -243,7 +245,7 @@ export function isKyselyProps(obj) {
         isObject(obj.driver) &&
         isObject(obj.executor) &&
         isObject(obj.dialect) &&
-        isObject(obj.adapter));
+        isObject(obj.parseContext));
 }
 export class ConnectionBuilder {
     #props;
@@ -269,7 +271,7 @@ preventAwait(ConnectionBuilder, "don't await ConnectionBuilder instances directl
 export class TransactionBuilder {
     #props;
     constructor(props) {
-        this.#props = props;
+        this.#props = freeze(props);
     }
     setIsolationLevel(isolationLevel) {
         return new TransactionBuilder({

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

@@ -1,5 +1,6 @@
 import { OperationNode } from './operation-node.js';
 import { TableNode } from './table-node.js';
+import { ForeignKeyConstraintNode } from './foreign-key-constraint-node.js';
 import { ConstraintNode } from './constraint-node.js';
 import { ColumnDefinitionNode } from './column-definition-node.js';
 export declare type CreateTableNodeModifier = 'IfNotExists';
@@ -21,5 +22,5 @@ export declare const CreateTableNode: Readonly<{
     cloneWithPrimaryKeyConstraint(createTable: CreateTableNode, constraintName: string, columns: string[]): CreateTableNode;
     cloneWithUniqueConstraint(createTable: CreateTableNode, constraintName: string, columns: string[]): CreateTableNode;
     cloneWithCheckConstraint(createTable: CreateTableNode, constraintName: string, sql: string): CreateTableNode;
-    cloneWithForeignKeyConstraint(createTable: CreateTableNode, constraintName: string, sourceColumns: string[], targetTable: string, targetColumns: string[]): CreateTableNode;
+    cloneWithForeignKeyConstraint(createTable: CreateTableNode, constraint: ForeignKeyConstraintNode): CreateTableNode;
 }>;

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

@@ -1,10 +1,7 @@
 import { freeze } from '../util/object-utils.js';
 import { CheckConstraintNode } from './check-constraint-node.js';
-import { TableNode } from './table-node.js';
 import { PrimaryConstraintNode } from './primary-constraint-node.js';
 import { UniqueConstraintNode } from './unique-constraint-node.js';
-import { ForeignKeyConstraintNode } from './foreign-key-constraint-node.js';
-import { ColumnNode } from './column-node.js';
 /**
  * @internal
  */
@@ -58,8 +55,7 @@ export const CreateTableNode = freeze({
                 : freeze([constraint]),
         });
     },
-    cloneWithForeignKeyConstraint(createTable, constraintName, sourceColumns, targetTable, targetColumns) {
-        const constraint = ForeignKeyConstraintNode.create(sourceColumns.map(ColumnNode.create), TableNode.create(targetTable), targetColumns.map(ColumnNode.create), constraintName);
+    cloneWithForeignKeyConstraint(createTable, constraint) {
         return freeze({
             ...createTable,
             constraints: createTable.constraints

package/dist/esm/operation-node/foreign-key-constraint-node.d.ts

@@ -1,12 +1,15 @@
 import { ColumnNode } from './column-node.js';
 import { IdentifierNode } from './identifier-node.js';
 import { OperationNode } from './operation-node.js';
-import { ReferencesNode } from './references-node.js';
+import { OnModifyForeignAction, ReferencesNode } from './references-node.js';
 import { TableNode } from './table-node.js';
+export declare type ForeignKeyConstraintNodeProps = Omit<ForeignKeyConstraintNode, 'kind' | 'columns' | 'references'>;
 export interface ForeignKeyConstraintNode extends OperationNode {
     readonly kind: 'ForeignKeyConstraintNode';
     readonly columns: ReadonlyArray<ColumnNode>;
     readonly references: ReferencesNode;
+    readonly onDelete?: OnModifyForeignAction;
+    readonly onUpdate?: OnModifyForeignAction;
     readonly name?: IdentifierNode;
 }
 /**
@@ -15,4 +18,12 @@ export interface ForeignKeyConstraintNode extends OperationNode {
 export declare const ForeignKeyConstraintNode: Readonly<{
     is(node: OperationNode): node is ForeignKeyConstraintNode;
     create(sourceColumns: ReadonlyArray<ColumnNode>, targetTable: TableNode, targetColumns: ReadonlyArray<ColumnNode>, constraintName?: string | undefined): ForeignKeyConstraintNode;
+    cloneWith(node: ForeignKeyConstraintNode, props: ForeignKeyConstraintNodeProps): Readonly<{
+        name?: IdentifierNode | undefined;
+        onDelete?: OnModifyForeignAction | undefined;
+        onUpdate?: OnModifyForeignAction | undefined;
+        kind: 'ForeignKeyConstraintNode';
+        columns: ReadonlyArray<ColumnNode>;
+        references: ReferencesNode;
+    }>;
 }>;

package/dist/esm/operation-node/foreign-key-constraint-node.js

@@ -16,4 +16,10 @@ export const ForeignKeyConstraintNode = freeze({
             name: constraintName ? IdentifierNode.create(constraintName) : undefined,
         });
     },
+    cloneWith(node, props) {
+        return freeze({
+            ...node,
+            ...props,
+        });
+    },
 });

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

@@ -20,5 +20,6 @@ export interface JoinNode extends OperationNode {
 export declare const JoinNode: Readonly<{
     is(node: OperationNode): node is JoinNode;
     create(joinType: JoinType, table: JoinTableNode): JoinNode;
+    createWithOn(joinType: JoinType, table: JoinTableNode, on: JoinNodeOnNode): JoinNode;
     cloneWithOn(joinNode: JoinNode, op: 'And' | 'Or', on: JoinNodeOnNode): JoinNode;
 }>;

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

@@ -16,6 +16,14 @@ export const JoinNode = freeze({
             on: undefined,
         });
     },
+    createWithOn(joinType, table, on) {
+        return freeze({
+            kind: 'JoinNode',
+            joinType,
+            table,
+            on,
+        });
+    },
     cloneWithOn(joinNode, op, on) {
         return freeze({
             ...joinNode,

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

@@ -396,6 +396,8 @@ export class OperationNodeTransformer {
             columns: this.transformNodeList(node.columns),
             references: this.transformNode(node.references),
             name: this.transformNode(node.name),
+            onDelete: node.onDelete,
+            onUpdate: node.onUpdate,
         };
     }
     transformReferences(node) {
@@ -404,6 +406,7 @@ export class OperationNodeTransformer {
             table: this.transformNode(node.table),
             columns: this.transformNodeList(node.columns),
             onDelete: node.onDelete,
+            onUpdate: node.onUpdate,
         };
     }
     transformCheckConstraint(node) {

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

@@ -1,12 +1,13 @@
 import { OperationNode } from './operation-node.js';
 import { ColumnNode } from './column-node.js';
 import { TableNode } from './table-node.js';
-export declare type OnDelete = 'cascade' | 'set null';
+export declare type OnModifyForeignAction = 'no action' | 'restrict' | 'cascade' | 'set null' | 'set default';
 export interface ReferencesNode extends OperationNode {
     readonly kind: 'ReferencesNode';
     readonly table: TableNode;
     readonly columns: ReadonlyArray<ColumnNode>;
-    readonly onDelete?: OnDelete;
+    readonly onDelete?: OnModifyForeignAction;
+    readonly onUpdate?: OnModifyForeignAction;
 }
 /**
  * @internal
@@ -14,5 +15,6 @@ export interface ReferencesNode extends OperationNode {
 export declare const ReferencesNode: Readonly<{
     is(node: OperationNode): node is ReferencesNode;
     create(table: TableNode, columns: ReadonlyArray<ColumnNode>): ReferencesNode;
-    cloneWithOnDelete(references: ReferencesNode, onDelete: OnDelete): ReferencesNode;
+    cloneWithOnDelete(references: ReferencesNode, onDelete: OnModifyForeignAction): ReferencesNode;
+    cloneWithOnUpdate(references: ReferencesNode, onUpdate: OnModifyForeignAction): ReferencesNode;
 }>;

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

@@ -19,4 +19,10 @@ export const ReferencesNode = freeze({
             onDelete,
         });
     },
+    cloneWithOnUpdate(references, onUpdate) {
+        return freeze({
+            ...references,
+            onUpdate,
+        });
+    },
 });

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

@@ -8,10 +8,10 @@ export const TableNode = freeze({
         return node.kind === 'TableNode';
     },
     create(table) {
-        return {
+        return freeze({
             kind: 'TableNode',
             table: IdentifierNode.create(table),
-        };
+        });
     },
     createWithSchema(schema, table) {
         return freeze({

package/dist/esm/parser/data-type-parser.d.ts

@@ -0,0 +1,5 @@
+import { ColumnDataType, DataTypeNode } from '../operation-node/data-type-node.js';
+import { RawNode } from '../operation-node/raw-node.js';
+import { AnyRawBuilder } from '../query-builder/type-utils.js';
+export declare type DataTypeExpression = ColumnDataType | AnyRawBuilder;
+export declare function parseDataTypeExpression(dataType: DataTypeExpression): DataTypeNode | RawNode;

package/dist/esm/parser/data-type-parser.js

@@ -0,0 +1,7 @@
+import { DataTypeNode, } from '../operation-node/data-type-node.js';
+import { isOperationNodeSource } from '../operation-node/operation-node-source.js';
+export function parseDataTypeExpression(dataType) {
+    return isOperationNodeSource(dataType)
+        ? dataType.toOperationNode()
+        : DataTypeNode.create(dataType);
+}

package/dist/esm/parser/default-value-parser.d.ts

@@ -0,0 +1,6 @@
+import { RawNode } from '../operation-node/raw-node.js';
+import { ValueNode } from '../operation-node/value-node.js';
+import { AnyRawBuilder } from '../query-builder/type-utils.js';
+import { PrimitiveValue } from '../util/object-utils.js';
+export declare type DefaultValueExpression = PrimitiveValue | AnyRawBuilder;
+export declare function parseDefaultValueExpression(value: DefaultValueExpression): ValueNode | RawNode;

package/dist/esm/parser/default-value-parser.js

@@ -0,0 +1,7 @@
+import { isOperationNodeSource } from '../operation-node/operation-node-source.js';
+import { ValueNode } from '../operation-node/value-node.js';
+export function parseDefaultValueExpression(value) {
+    return isOperationNodeSource(value)
+        ? value.toOperationNode()
+        : ValueNode.createImmediate(value);
+}

package/dist/esm/parser/filter-parser.d.ts

@@ -10,5 +10,5 @@ export declare function parseWhereFilter(ctx: ParseContext, args: any[]): Filter
 export declare function parseHavingFilter(ctx: ParseContext, args: any[]): FilterExpressionNode;
 export declare function parseOnFilter(ctx: ParseContext, args: any[]): FilterExpressionNode;
 export declare function parseReferenceFilter(ctx: ParseContext, lhs: ReferenceExpression<any, any>, op: FilterOperator, rhs: ReferenceExpression<any, any>): FilterNode;
-export declare function parseExistExpression(ctx: ParseContext, arg: ExistsExpression<any, any>): FilterNode;
-export declare function parseNotExistExpression(ctx: ParseContext, arg: ExistsExpression<any, any>): FilterNode;
+export declare function parseExistFilter(ctx: ParseContext, arg: ExistsExpression<any, any>): FilterNode;
+export declare function parseNotExistFilter(ctx: ParseContext, arg: ExistsExpression<any, any>): FilterNode;