kysely 0.23.4 → 0.24.0

package/dist/cjs/helpers/postgres.d.ts

@@ -0,0 +1,133 @@
+import { Expression } from '../expression/expression.js';
+import { RawBuilder } from '../raw-builder/raw-builder.js';
+import { Simplify } from '../util/type-utils.js';
+/**
+ * A postgres helper for aggregating a subquery (or other expression) into a JSONB array.
+ *
+ * NOTE: This helper is only guaranteed to fully work with the built-in `PostgresDialect`.
+ * While the produced SQL is compatibe with all PostgreSQL databases, some 3rd party dialects
+ * may not parse the nested results into arrays.
+ *
+ * ### Examples
+ *
+ * ```ts
+ * const result = await db
+ *   .selectFrom('person')
+ *   .select((eb) => [
+ *     'id',
+ *     jsonArrayFrom(
+ *       eb.selectFrom('pet')
+ *         .select(['pet.id as pet_id', 'pet.name'])
+ *         .where('pet.owner_id', '=', 'person.id')
+ *         .orderBy('pet.name')
+ *     ).as('pets')
+ *   ])
+ *   .execute()
+ *
+ * result[0].id
+ * result[0].pets[0].pet_id
+ * result[0].pets[0].name
+ * ```
+ *
+ * The generated SQL (PostgreSQL):
+ *
+ * ```sql
+ * select "id", (
+ *   select coalesce(jsonb_agg(agg), '[]') from (
+ *     select "pet"."id" as "pet_id", "pet"."name"
+ *     from "pet"
+ *     where "pet"."owner_id" = "person"."id"
+ *     order by "pet"."name"
+ *   ) as agg
+ * ) as "pets"
+ * from "person"
+ * ```
+ */
+export declare function jsonArrayFrom<O>(expr: Expression<O>): RawBuilder<Simplify<O>[]>;
+/**
+ * A postgres helper for turning a subquery (or other expression) into a JSONB object.
+ *
+ * The subquery must only return one row.
+ *
+ * NOTE: This helper is only guaranteed to fully work with the built-in `PostgresDialect`.
+ * While the produced SQL is compatibe with all PostgreSQL databases, some 3rd party dialects
+ * may not parse the nested results into objects.
+ *
+ * ### Examples
+ *
+ * ```ts
+ * const result = await db
+ *   .selectFrom('person')
+ *   .select((eb) => [
+ *     'id',
+ *     jsonObjectFrom(
+ *       eb.selectFrom('pet')
+ *         .select(['pet.id as pet_id', 'pet.name'])
+ *         .where('pet.owner_id', '=', 'person.id')
+ *         .where('pet.is_favorite', '=', true)
+ *     ).as('favorite_pet')
+ *   ])
+ *   .execute()
+ *
+ * result[0].id
+ * result[0].favorite_pet.pet_id
+ * result[0].favorite_pet.name
+ * ```
+ *
+ * The generated SQL (PostgreSQL):
+ *
+ * ```sql
+ * select "id", (
+ *   select to_jsonb(obj) from (
+ *     select "pet"."id" as "pet_id", "pet"."name"
+ *     from "pet"
+ *     where "pet"."owner_id" = "person"."id"
+ *     and "pet"."is_favorite" = $1
+ *   ) as obj
+ * ) as "favorite_pet"
+ * from "person"
+ * ```
+ */
+export declare function jsonObjectFrom<O>(expr: Expression<O>): RawBuilder<Simplify<O>>;
+/**
+ * The PostgreSQL `jsonb_build_object` function.
+ *
+ * NOTE: This helper is only guaranteed to fully work with the built-in `PostgresDialect`.
+ * While the produced SQL is compatibe with all PostgreSQL databases, some 3rd party dialects
+ * may not parse the nested results into objects.
+ *
+ * ### Examples
+ *
+ * ```ts
+ * const result = await db
+ *   .selectFrom('person')
+ *   .select((eb) => [
+ *     'id',
+ *     jsonbBuildObject({
+ *       first: eb.ref('first_name'),
+ *       last: eb.ref('last_name'),
+ *       full: sql<string>`first_name || ' ' || last_name`
+ *     }).as('name')
+ *   ])
+ *   .execute()
+ *
+ * result[0].id
+ * result[0].name.first
+ * result[0].name.last
+ * result[0].name.full
+ * ```
+ *
+ * The generated SQL (PostgreSQL):
+ *
+ * ```sql
+ * select "id", jsonb_build_object(
+ *   'first', first_name,
+ *   'last', last_name,
+ *   'full', first_name || ' ' || last_name
+ * ) as "name"
+ * from "person"
+ * ```
+ */
+export declare function jsonbBuildObject<O extends Record<string, Expression<unknown>>>(obj: O): RawBuilder<Simplify<{
+    [K in keyof O]: O[K] extends Expression<infer V> ? V : never;
+}>>;

package/dist/cjs/helpers/postgres.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jsonbBuildObject = exports.jsonObjectFrom = exports.jsonArrayFrom = void 0;
+const sql_js_1 = require("../raw-builder/sql.js");
+/**
+ * A postgres helper for aggregating a subquery (or other expression) into a JSONB array.
+ *
+ * NOTE: This helper is only guaranteed to fully work with the built-in `PostgresDialect`.
+ * While the produced SQL is compatibe with all PostgreSQL databases, some 3rd party dialects
+ * may not parse the nested results into arrays.
+ *
+ * ### Examples
+ *
+ * ```ts
+ * const result = await db
+ *   .selectFrom('person')
+ *   .select((eb) => [
+ *     'id',
+ *     jsonArrayFrom(
+ *       eb.selectFrom('pet')
+ *         .select(['pet.id as pet_id', 'pet.name'])
+ *         .where('pet.owner_id', '=', 'person.id')
+ *         .orderBy('pet.name')
+ *     ).as('pets')
+ *   ])
+ *   .execute()
+ *
+ * result[0].id
+ * result[0].pets[0].pet_id
+ * result[0].pets[0].name
+ * ```
+ *
+ * The generated SQL (PostgreSQL):
+ *
+ * ```sql
+ * select "id", (
+ *   select coalesce(jsonb_agg(agg), '[]') from (
+ *     select "pet"."id" as "pet_id", "pet"."name"
+ *     from "pet"
+ *     where "pet"."owner_id" = "person"."id"
+ *     order by "pet"."name"
+ *   ) as agg
+ * ) as "pets"
+ * from "person"
+ * ```
+ */
+function jsonArrayFrom(expr) {
+    return (0, sql_js_1.sql) `(select coalesce(jsonb_agg(agg), '[]') from ${expr} as agg)`;
+}
+exports.jsonArrayFrom = jsonArrayFrom;
+/**
+ * A postgres helper for turning a subquery (or other expression) into a JSONB object.
+ *
+ * The subquery must only return one row.
+ *
+ * NOTE: This helper is only guaranteed to fully work with the built-in `PostgresDialect`.
+ * While the produced SQL is compatibe with all PostgreSQL databases, some 3rd party dialects
+ * may not parse the nested results into objects.
+ *
+ * ### Examples
+ *
+ * ```ts
+ * const result = await db
+ *   .selectFrom('person')
+ *   .select((eb) => [
+ *     'id',
+ *     jsonObjectFrom(
+ *       eb.selectFrom('pet')
+ *         .select(['pet.id as pet_id', 'pet.name'])
+ *         .where('pet.owner_id', '=', 'person.id')
+ *         .where('pet.is_favorite', '=', true)
+ *     ).as('favorite_pet')
+ *   ])
+ *   .execute()
+ *
+ * result[0].id
+ * result[0].favorite_pet.pet_id
+ * result[0].favorite_pet.name
+ * ```
+ *
+ * The generated SQL (PostgreSQL):
+ *
+ * ```sql
+ * select "id", (
+ *   select to_jsonb(obj) from (
+ *     select "pet"."id" as "pet_id", "pet"."name"
+ *     from "pet"
+ *     where "pet"."owner_id" = "person"."id"
+ *     and "pet"."is_favorite" = $1
+ *   ) as obj
+ * ) as "favorite_pet"
+ * from "person"
+ * ```
+ */
+function jsonObjectFrom(expr) {
+    return (0, sql_js_1.sql) `(select to_jsonb(obj) from ${expr} as obj)`;
+}
+exports.jsonObjectFrom = jsonObjectFrom;
+/**
+ * The PostgreSQL `jsonb_build_object` function.
+ *
+ * NOTE: This helper is only guaranteed to fully work with the built-in `PostgresDialect`.
+ * While the produced SQL is compatibe with all PostgreSQL databases, some 3rd party dialects
+ * may not parse the nested results into objects.
+ *
+ * ### Examples
+ *
+ * ```ts
+ * const result = await db
+ *   .selectFrom('person')
+ *   .select((eb) => [
+ *     'id',
+ *     jsonbBuildObject({
+ *       first: eb.ref('first_name'),
+ *       last: eb.ref('last_name'),
+ *       full: sql<string>`first_name || ' ' || last_name`
+ *     }).as('name')
+ *   ])
+ *   .execute()
+ *
+ * result[0].id
+ * result[0].name.first
+ * result[0].name.last
+ * result[0].name.full
+ * ```
+ *
+ * The generated SQL (PostgreSQL):
+ *
+ * ```sql
+ * select "id", jsonb_build_object(
+ *   'first', first_name,
+ *   'last', last_name,
+ *   'full', first_name || ' ' || last_name
+ * ) as "name"
+ * from "person"
+ * ```
+ */
+function jsonbBuildObject(obj) {
+    return (0, sql_js_1.sql) `jsonb_build_object(${sql_js_1.sql.join(Object.keys(obj).flatMap((k) => [sql_js_1.sql.lit(k), obj[k]]))})`;
+}
+exports.jsonbBuildObject = jsonbBuildObject;

package/dist/cjs/index.d.ts

@@ -1,6 +1,7 @@
 export * from './kysely.js';
 export * from './query-creator.js';
 export * from './expression/expression.js';
+export { ExpressionBuilder, expressionBuilder, } from './expression/expression-builder.js';
 export * from './query-builder/where-interface.js';
 export * from './query-builder/returning-interface.js';
 export * from './query-builder/having-interface.js';
@@ -10,7 +11,6 @@ export * from './query-builder/update-query-builder.js';
 export * from './query-builder/delete-query-builder.js';
 export * from './query-builder/no-result-error.js';
 export * from './query-builder/join-builder.js';
-export * from './query-builder/expression-builder.js';
 export * from './query-builder/function-module.js';
 export * from './query-builder/insert-result.js';
 export * from './query-builder/delete-result.js';
@@ -163,11 +163,12 @@ export * from './operation-node/using-node.js';
 export * from './util/column-type.js';
 export * from './util/compilable.js';
 export * from './util/explainable.js';
+export * from './util/streamable.js';
 export * from './util/log.js';
-export { AnyAliasedColumn, AnyAliasedColumnWithTable, AnyColumn, AnyColumnWithTable, AnySelectQueryBuilder, Equals, UnknownRow, } from './util/type-utils.js';
+export { AnyAliasedColumn, AnyAliasedColumnWithTable, AnyColumn, AnyColumnWithTable, AnySelectQueryBuilder, Equals, UnknownRow, Simplify, SqlBool, } from './util/type-utils.js';
 export * from './util/infer-result.js';
 export { logOnce } from './util/log-once.js';
-export { SelectExpression, SelectExpressionOrList, Selection, } from './parser/select-parser.js';
+export { SelectExpression, SelectArg, Selection, } from './parser/select-parser.js';
 export { ReferenceExpression, ReferenceExpressionOrList, SimpleReferenceExpression, StringReference, ExtractTypeFromStringReference, ExtractTypeFromReferenceExpression, } from './parser/reference-parser.js';
 export { ValueExpression, ValueExpressionOrList, } from './parser/value-parser.js';
 export { TableExpression, TableExpressionOrList, } from './parser/table-parser.js';

package/dist/cjs/index.js

@@ -14,10 +14,12 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.logOnce = void 0;
+exports.logOnce = exports.expressionBuilder = void 0;
 __exportStar(require("./kysely.js"), exports);
 __exportStar(require("./query-creator.js"), exports);
 __exportStar(require("./expression/expression.js"), exports);
+var expression_builder_js_1 = require("./expression/expression-builder.js");
+Object.defineProperty(exports, "expressionBuilder", { enumerable: true, get: function () { return expression_builder_js_1.expressionBuilder; } });
 __exportStar(require("./query-builder/where-interface.js"), exports);
 __exportStar(require("./query-builder/returning-interface.js"), exports);
 __exportStar(require("./query-builder/having-interface.js"), exports);
@@ -27,7 +29,6 @@ __exportStar(require("./query-builder/update-query-builder.js"), exports);
 __exportStar(require("./query-builder/delete-query-builder.js"), exports);
 __exportStar(require("./query-builder/no-result-error.js"), exports);
 __exportStar(require("./query-builder/join-builder.js"), exports);
-__exportStar(require("./query-builder/expression-builder.js"), exports);
 __exportStar(require("./query-builder/function-module.js"), exports);
 __exportStar(require("./query-builder/insert-result.js"), exports);
 __exportStar(require("./query-builder/delete-result.js"), exports);
@@ -180,6 +181,7 @@ __exportStar(require("./operation-node/using-node.js"), exports);
 __exportStar(require("./util/column-type.js"), exports);
 __exportStar(require("./util/compilable.js"), exports);
 __exportStar(require("./util/explainable.js"), exports);
+__exportStar(require("./util/streamable.js"), exports);
 __exportStar(require("./util/log.js"), exports);
 __exportStar(require("./util/infer-result.js"), exports);
 var log_once_js_1 = require("./util/log-once.js");

package/dist/cjs/kysely.d.ts

@@ -9,6 +9,10 @@ import { Driver, IsolationLevel } 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';
 /**
  * The main Kysely class.
  *
@@ -225,6 +229,12 @@ export declare class Kysely<DB> extends QueryCreator<DB> implements QueryExecuto
      * @private
      */
     getExecutor(): QueryExecutor;
+    /**
+     * Executes a given compiled query or query builder.
+     *
+     * See {@link https://github.com/koskimas/kysely/blob/master/site/docs/recipes/splitting-build-compile-and-execute-code.md#execute-compiled-queries splitting build, compile and execute code recipe} for more information.
+     */
+    executeQuery<R>(query: CompiledQuery<R> | Compilable<R>, queryId?: QueryId): Promise<QueryResult<R>>;
 }
 export declare class Transaction<DB> extends Kysely<DB> {
     #private;

package/dist/cjs/kysely.js

@@ -13,6 +13,8 @@ const driver_js_1 = require("./driver/driver.js");
 const prevent_await_js_1 = require("./util/prevent-await.js");
 const function_module_js_1 = require("./query-builder/function-module.js");
 const log_js_1 = require("./util/log.js");
+const query_id_js_1 = require("./util/query-id.js");
+const compilable_js_1 = require("./util/compilable.js");
 /**
  * The main Kysely class.
  *
@@ -135,7 +137,7 @@ class Kysely extends query_creator_js_1.QueryCreator {
      * ```
      */
     get fn() {
-        return new function_module_js_1.FunctionModule();
+        return (0, function_module_js_1.createFunctionModule)();
     }
     /**
      * Creates a {@link TransactionBuilder} that can be used to run queries inside a transaction.
@@ -284,6 +286,15 @@ class Kysely extends query_creator_js_1.QueryCreator {
     getExecutor() {
         return this.#props.executor;
     }
+    /**
+     * Executes a given compiled query or query builder.
+     *
+     * See {@link https://github.com/koskimas/kysely/blob/master/site/docs/recipes/splitting-build-compile-and-execute-code.md#execute-compiled-queries splitting build, compile and execute code recipe} for more information.
+     */
+    executeQuery(query, queryId = (0, query_id_js_1.createQueryId)()) {
+        const compiledQuery = (0, compilable_js_1.isCompilable)(query) ? query.compile() : query;
+        return this.getExecutor().executeQuery(compiledQuery, queryId);
+    }
 }
 exports.Kysely = Kysely;
 class Transaction extends Kysely {

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

@@ -22,8 +22,11 @@ export declare class FileMigrationProvider implements MigrationProvider {
      * Returns all migrations, old and new.
      *
      * For example if you have your migrations in a folder as separate files,
-     * you can use the {@link FileMigrationProvider} that implements this
-     * method to return all migrations in a folder.
+     * you can implement this method to return all migration in that folder
+     * as {@link Migration} objects.
+     *
+     * Kysely already has a built-in {@link FileMigrationProvider} for node.js
+     * that does exactly that.
      *
      * The keys of the returned object are migration names and values are the
      * migrations. The order of the migrations is determined by the alphabetical

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

@@ -258,8 +258,11 @@ export interface MigrationProvider {
      * Returns all migrations, old and new.
      *
      * For example if you have your migrations in a folder as separate files,
-     * you can use the {@link FileMigrationProvider} that implements this
-     * method to return all migrations in a folder.
+     * you can implement this method to return all migration in that folder
+     * as {@link Migration} objects.
+     *
+     * Kysely already has a built-in {@link FileMigrationProvider} for node.js
+     * that does exactly that.
      *
      * The keys of the returned object are migration names and values are the
      * migrations. The order of the migrations is determined by the alphabetical

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

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

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

@@ -10,11 +10,11 @@ exports.AggregateFunctionNode = (0, object_utils_js_1.freeze)({
     is(node) {
         return node.kind === 'AggregateFunctionNode';
     },
-    create(aggregateFunction, column) {
+    create(aggregateFunction, aggregated) {
         return (0, object_utils_js_1.freeze)({
             kind: 'AggregateFunctionNode',
             func: aggregateFunction,
-            column,
+            aggregated,
         });
     },
     cloneWithDistinct(aggregateFunctionNode) {

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

@@ -2,6 +2,7 @@ import { IdentifierNode } from './identifier-node.js';
 import { OperationNode } from './operation-node.js';
 import { RawNode } from './raw-node.js';
 import { TableNode } from './table-node.js';
+import { WhereNode } from './where-node.js';
 export declare type CreateIndexNodeProps = Omit<CreateIndexNode, 'kind' | 'name'>;
 export declare type IndexType = 'btree' | 'hash' | 'gist' | 'gin';
 export interface CreateIndexNode extends OperationNode {
@@ -12,6 +13,7 @@ export interface CreateIndexNode extends OperationNode {
     readonly unique?: boolean;
     readonly using?: RawNode;
     readonly ifNotExists?: boolean;
+    readonly where?: WhereNode;
 }
 /**
  * @internal

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

@@ -26,9 +26,8 @@ export interface DeleteQueryNode extends OperationNode {
  */
 export declare const DeleteQueryNode: Readonly<{
     is(node: OperationNode): node is DeleteQueryNode;
-    create(fromItem: OperationNode, withNode?: WithNode): DeleteQueryNode;
+    create(fromItems: OperationNode[], withNode?: WithNode): DeleteQueryNode;
     cloneWithOrderByItem(deleteNode: DeleteQueryNode, item: OrderByItemNode): DeleteQueryNode;
     cloneWithLimit(deleteNode: DeleteQueryNode, limit: LimitNode): DeleteQueryNode;
-    cloneWithExplain(deleteNode: DeleteQueryNode, explain: ExplainNode): DeleteQueryNode;
     cloneWithUsing(deleteNode: DeleteQueryNode, tables: OperationNode[]): DeleteQueryNode;
 }>;

package/dist/cjs/operation-node/delete-query-node.js

@@ -12,10 +12,10 @@ exports.DeleteQueryNode = (0, object_utils_js_1.freeze)({
     is(node) {
         return node.kind === 'DeleteQueryNode';
     },
-    create(fromItem, withNode) {
+    create(fromItems, withNode) {
         return (0, object_utils_js_1.freeze)({
             kind: 'DeleteQueryNode',
-            from: from_node_js_1.FromNode.create([fromItem]),
+            from: from_node_js_1.FromNode.create(fromItems),
             ...(withNode && { with: withNode }),
         });
     },
@@ -33,12 +33,6 @@ exports.DeleteQueryNode = (0, object_utils_js_1.freeze)({
             limit,
         });
     },
-    cloneWithExplain(deleteNode, explain) {
-        return (0, object_utils_js_1.freeze)({
-            ...deleteNode,
-            explain,
-        });
-    },
     cloneWithUsing(deleteNode, tables) {
         return (0, object_utils_js_1.freeze)({
             ...deleteNode,

package/dist/cjs/operation-node/function-node.d.ts

@@ -0,0 +1,13 @@
+import { OperationNode } from './operation-node.js';
+export interface FunctionNode extends OperationNode {
+    readonly kind: 'FunctionNode';
+    readonly func: string;
+    readonly arguments: ReadonlyArray<OperationNode>;
+}
+/**
+ * @internal
+ */
+export declare const FunctionNode: Readonly<{
+    is(node: OperationNode): node is FunctionNode;
+    create(func: string, args: ReadonlyArray<OperationNode>): FunctionNode;
+}>;

package/dist/cjs/operation-node/function-node.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FunctionNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+/**
+ * @internal
+ */
+exports.FunctionNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'FunctionNode';
+    },
+    create(func, args) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'FunctionNode',
+            func,
+            arguments: args,
+        });
+    },
+});

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

@@ -77,6 +77,7 @@ import { SetOperationNode } from './set-operation-node.js';
 import { BinaryOperationNode } from './binary-operation-node.js';
 import { UnaryOperationNode } from './unary-operation-node.js';
 import { UsingNode } from './using-node.js';
+import { FunctionNode } from './function-node.js';
 /**
  * Transforms an operation node tree into another one.
  *
@@ -183,6 +184,7 @@ export declare class OperationNodeTransformer {
     protected transformBinaryOperation(node: BinaryOperationNode): BinaryOperationNode;
     protected transformUnaryOperation(node: UnaryOperationNode): UnaryOperationNode;
     protected transformUsing(node: UsingNode): UsingNode;
+    protected transformFunction(node: FunctionNode): FunctionNode;
     protected transformDataType(node: DataTypeNode): DataTypeNode;
     protected transformSelectAll(node: SelectAllNode): SelectAllNode;
     protected transformIdentifier(node: IdentifierNode): IdentifierNode;

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

@@ -113,6 +113,7 @@ class OperationNodeTransformer {
         BinaryOperationNode: this.transformBinaryOperation.bind(this),
         UnaryOperationNode: this.transformUnaryOperation.bind(this),
         UsingNode: this.transformUsing.bind(this),
+        FunctionNode: this.transformFunction.bind(this),
     });
     transformNode(node) {
         if (!node) {
@@ -407,6 +408,7 @@ class OperationNodeTransformer {
             unique: node.unique,
             using: this.transformNode(node.using),
             ifNotExists: node.ifNotExists,
+            where: this.transformNode(node.where),
         });
     }
     transformList(node) {
@@ -651,7 +653,7 @@ class OperationNodeTransformer {
     transformAggregateFunction(node) {
         return (0, require_all_props_js_1.requireAllProps)({
             kind: 'AggregateFunctionNode',
-            column: this.transformNode(node.column),
+            aggregated: this.transformNode(node.aggregated),
             distinct: node.distinct,
             filter: this.transformNode(node.filter),
             func: node.func,
@@ -695,7 +697,14 @@ class OperationNodeTransformer {
     transformUsing(node) {
         return (0, require_all_props_js_1.requireAllProps)({
             kind: 'UsingNode',
-            tables: node.tables,
+            tables: this.transformNodeList(node.tables),
+        });
+    }
+    transformFunction(node) {
+        return (0, require_all_props_js_1.requireAllProps)({
+            kind: 'FunctionNode',
+            func: node.func,
+            arguments: this.transformNodeList(node.arguments),
         });
     }
     transformDataType(node) {

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

@@ -77,6 +77,7 @@ import { SetOperationNode } from './set-operation-node.js';
 import { BinaryOperationNode } from './binary-operation-node.js';
 import { UnaryOperationNode } from './unary-operation-node.js';
 import { UsingNode } from './using-node.js';
+import { FunctionNode } from './function-node.js';
 export declare abstract class OperationNodeVisitor {
     #private;
     protected readonly nodeStack: OperationNode[];
@@ -160,4 +161,5 @@ export declare abstract class OperationNodeVisitor {
     protected abstract visitBinaryOperation(node: BinaryOperationNode): void;
     protected abstract visitUnaryOperation(node: UnaryOperationNode): void;
     protected abstract visitUsing(node: UsingNode): void;
+    protected abstract visitFunction(node: FunctionNode): void;
 }

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

@@ -86,6 +86,7 @@ class OperationNodeVisitor {
         BinaryOperationNode: this.visitBinaryOperation.bind(this),
         UnaryOperationNode: this.visitUnaryOperation.bind(this),
         UsingNode: this.visitUsing.bind(this),
+        FunctionNode: this.visitFunction.bind(this),
     });
     visitNode = (node) => {
         this.nodeStack.push(node);

package/dist/cjs/operation-node/operation-node.d.ts

@@ -1,4 +1,4 @@
-export declare type OperationNodeKind = 'IdentifierNode' | 'SchemableIdentifierNode' | 'RawNode' | 'SelectQueryNode' | 'SelectionNode' | 'ReferenceNode' | 'ColumnNode' | 'TableNode' | 'AliasNode' | 'FromNode' | 'SelectAllNode' | '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' | 'CreateViewNode' | 'DropViewNode' | 'GeneratedNode' | 'DefaultValueNode' | 'OnNode' | 'ValuesNode' | 'CommonTableExpressionNameNode' | 'SelectModifierNode' | 'CreateTypeNode' | 'DropTypeNode' | 'ExplainNode' | 'DefaultInsertValueNode' | 'AggregateFunctionNode' | 'OverNode' | 'PartitionByNode' | 'PartitionByItemNode' | 'SetOperationNode' | 'BinaryOperationNode' | 'UnaryOperationNode' | 'UsingNode';
+export declare type OperationNodeKind = 'IdentifierNode' | 'SchemableIdentifierNode' | 'RawNode' | 'SelectQueryNode' | 'SelectionNode' | 'ReferenceNode' | 'ColumnNode' | 'TableNode' | 'AliasNode' | 'FromNode' | 'SelectAllNode' | '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' | 'CreateViewNode' | 'DropViewNode' | 'GeneratedNode' | 'DefaultValueNode' | 'OnNode' | 'ValuesNode' | 'CommonTableExpressionNameNode' | 'SelectModifierNode' | 'CreateTypeNode' | 'DropTypeNode' | 'ExplainNode' | 'DefaultInsertValueNode' | 'AggregateFunctionNode' | 'OverNode' | 'PartitionByNode' | 'PartitionByItemNode' | 'SetOperationNode' | 'BinaryOperationNode' | 'UnaryOperationNode' | 'UsingNode' | 'FunctionNode';
 export interface OperationNode {
     readonly kind: OperationNodeKind;
 }