kysely 0.21.6 → 0.23.0

package/dist/esm/schema/create-table-builder.js

@@ -214,7 +214,7 @@ export class CreateTableBuilder {
      * ```ts
      * db.schema.createTable('person')
      *   .modifyFront(sql`global temporary`)
-     *   .addColumn('id', 'integer', col => col => primaryKey())
+     *   .addColumn('id', 'integer', col => col.primaryKey())
      *   .addColumn('first_name', 'varchar(64)', col => col.notNull())
      *   .addColumn('last_name', 'varchar(64), col => col.notNull())
      *   .execute()
@@ -268,6 +268,41 @@ export class CreateTableBuilder {
             createTableNode: CreateTableNode.cloneWithEndModifier(this.#props.createTableNode, modifier.toOperationNode()),
         });
     }
+    /**
+     * Calls the given function passing `this` as the only argument.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.schema
+     *   .createTable('test')
+     *   .call((builder) => builder.addColumn('id', 'integer'))
+     *   .execute()
+     * ```
+     *
+     * ```ts
+     * const addDefaultColumns = <T extends string, C extends string = never>(
+     *   builder: CreateTableBuilder<T, C>
+     * ) => {
+     *   return builder
+     *     .addColumn('id', 'integer', (col) => col.notNull())
+     *     .addColumn('created_at', 'date', (col) =>
+     *       col.notNull().defaultTo(sql`now()`)
+     *     )
+     *     .addColumn('updated_at', 'date', (col) =>
+     *       col.notNull().defaultTo(sql`now()`)
+     *     )
+     * }
+     *
+     * db.schema
+     *   .createTable('test')
+     *   .call(addDefaultColumns)
+     *   .execute()
+     * ```
+     */
+    call(func) {
+        return func(this);
+    }
     toOperationNode() {
         return this.#props.executor.transformQuery(this.#props.createTableNode, this.#props.queryId);
     }

package/dist/esm/schema/create-view-builder.d.ts

@@ -4,7 +4,8 @@ import { Compilable } from '../util/compilable.js';
 import { QueryExecutor } from '../query-executor/query-executor.js';
 import { QueryId } from '../util/query-id.js';
 import { CreateViewNode } from '../operation-node/create-view-node.js';
-import { AnyRawBuilder, AnySelectQueryBuilder } from '../util/type-utils.js';
+import { AnySelectQueryBuilder } from '../util/type-utils.js';
+import { RawBuilder } from '../raw-builder/raw-builder.js';
 export declare class CreateViewBuilder implements OperationNodeSource, Compilable {
     #private;
     constructor(props: CreateViewBuilderProps);
@@ -30,7 +31,7 @@ export declare class CreateViewBuilder implements OperationNodeSource, Compilabl
      * string opening an SQL injection vulnerability. DO NOT pass unchecked user input
      * into the query or raw expression passed to this method!
      */
-    as(query: AnySelectQueryBuilder | AnyRawBuilder): CreateViewBuilder;
+    as(query: AnySelectQueryBuilder | RawBuilder<any>): CreateViewBuilder;
     toOperationNode(): CreateViewNode;
     compile(): CompiledQuery;
     execute(): Promise<void>;

package/dist/esm/schema/schema.d.ts

@@ -186,7 +186,7 @@ export declare class SchemaModule {
      *   .execute()
      * ```
      */
-    createType(viewName: string): CreateTypeBuilder;
+    createType(typeName: string): CreateTypeBuilder;
     /**
      * Drop a type.
      *
@@ -201,7 +201,7 @@ export declare class SchemaModule {
      *   .execute()
      * ```
      */
-    dropType(viewName: string): DropTypeBuilder;
+    dropType(typeName: string): DropTypeBuilder;
     /**
      * Returns a copy of this schema module with the given plugin installed.
      */

package/dist/esm/schema/schema.js

@@ -24,6 +24,7 @@ import { CreateTypeBuilder } from './create-type-builder.js';
 import { DropTypeBuilder } from './drop-type-builder.js';
 import { CreateTypeNode } from '../operation-node/create-type-node.js';
 import { DropTypeNode } from '../operation-node/drop-type-node.js';
+import { parseSchemableIdentifier } from '../parser/identifier-parser.js';
 /**
  * Provides methods for building database schema.
  */
@@ -199,7 +200,7 @@ export class SchemaModule {
         return new AlterTableBuilder({
             queryId: createQueryId(),
             executor: this.#executor,
-            alterTableNode: AlterTableNode.create(table),
+            node: AlterTableNode.create(table),
         });
     }
     /**
@@ -255,11 +256,11 @@ export class SchemaModule {
      *   .execute()
      * ```
      */
-    createType(viewName) {
+    createType(typeName) {
         return new CreateTypeBuilder({
             queryId: createQueryId(),
             executor: this.#executor,
-            createTypeNode: CreateTypeNode.create(viewName),
+            createTypeNode: CreateTypeNode.create(parseSchemableIdentifier(typeName)),
         });
     }
     /**
@@ -276,11 +277,11 @@ export class SchemaModule {
      *   .execute()
      * ```
      */
-    dropType(viewName) {
+    dropType(typeName) {
         return new DropTypeBuilder({
             queryId: createQueryId(),
             executor: this.#executor,
-            dropTypeNode: DropTypeNode.create(viewName),
+            dropTypeNode: DropTypeNode.create(parseSchemableIdentifier(typeName)),
         });
     }
     /**

package/dist/esm/util/compilable.d.ts

@@ -1,4 +1,4 @@
 import { CompiledQuery } from '../query-compiler/compiled-query.js';
-export interface Compilable {
-    compile(): CompiledQuery;
+export interface Compilable<O = unknown> {
+    compile(): CompiledQuery<O>;
 }

package/dist/esm/util/explainable.d.ts

@@ -1,5 +1,5 @@
-import { AnyRawBuilder } from './type-utils.js';
+import { Expression } from '../expression/expression.js';
 export declare type ExplainFormat = 'text' | 'xml' | 'json' | 'yaml' | 'traditional' | 'tree';
 export interface Explainable {
-    explain<O extends Record<string, any> = Record<string, any>>(format?: ExplainFormat, options?: AnyRawBuilder): Promise<O[]>;
+    explain<O extends Record<string, any> = Record<string, any>>(format?: ExplainFormat, options?: Expression<any>): Promise<O[]>;
 }

package/dist/esm/util/infer-result.d.ts

@@ -0,0 +1,46 @@
+import { DeleteResult } from '../query-builder/delete-result.js';
+import { InsertResult } from '../query-builder/insert-result.js';
+import { UpdateResult } from '../query-builder/update-result.js';
+import { CompiledQuery } from '../query-compiler/compiled-query.js';
+import { Compilable } from './compilable.js';
+/**
+ * A helper type that allows inferring a select/insert/update/delete query's result
+ * type from a query builder or compiled query.
+ *
+ * ### Examples
+ *
+ * Infer a query builder's result type:
+ *
+ * ```ts
+ * import { InferResult } from 'kysely'
+ *
+ * const query = db
+ *   .selectFrom('person')
+ *   .innerJoin('pet', 'pet.owner_id', 'person.id')
+ *   .select(['person.first_name', 'pet.name'])
+ *
+ * type QueryResult = InferResult<typeof query> // { first_name: string; name: string; }[]
+ * ```
+ *
+ * Infer a compiled query's result type:
+ *
+ * ```ts
+ * import { InferResult } from 'kysely'
+ *
+ * const compiledQuery = db
+ *   .insertInto('person')
+ *   .values({
+ *     first_name: 'Foo',
+ *     last_name: 'Barson',
+ *     gender: 'other',
+ *     age: 15,
+ *   })
+ *   .returningAll()
+ *   .compile()
+ *
+ * type QueryResult = InferResult<typeof compiledQuery> // Selectable<Person>[]
+ * ```
+ */
+export declare type InferResult<C extends Compilable<any> | CompiledQuery<any>> = C extends Compilable<infer O> ? ResolveResult<O> : C extends CompiledQuery<infer O> ? ResolveResult<O> : never;
+declare type ResolveResult<O> = O extends InsertResult | UpdateResult | DeleteResult ? O : O[];
+export {};

package/dist/esm/util/infer-result.js

@@ -0,0 +1,2 @@
+/// <reference types="./infer-result.d.ts" />
+export {};

package/dist/esm/util/log-once.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Use for system-level logging, such as deprecation messages.
+ * Logs a message and ensures it won't be logged again.
+ */
+export declare function logOnce(message: string): void;

package/dist/esm/util/log-once.js

@@ -0,0 +1,13 @@
+/// <reference types="./log-once.d.ts" />
+const LOGGED_MESSAGES = new Set();
+/**
+ * Use for system-level logging, such as deprecation messages.
+ * Logs a message and ensures it won't be logged again.
+ */
+export function logOnce(message) {
+    if (LOGGED_MESSAGES.has(message)) {
+        return;
+    }
+    LOGGED_MESSAGES.add(message);
+    console.log(message);
+}

package/dist/esm/util/object-utils.d.ts

@@ -11,6 +11,7 @@ export declare function isBuffer(obj: unknown): obj is {
 };
 export declare function isFunction(obj: unknown): obj is Function;
 export declare function isObject(obj: unknown): obj is Record<string, unknown>;
+export declare function isArrayBufferOrView(obj: unknown): obj is ArrayBuffer | ArrayBufferView;
 export declare function getLast<T>(arr: ArrayLike<T>): T | undefined;
 export declare function freeze<T>(obj: T): Readonly<T>;
 export declare function asArray<T>(arg: T | T[]): T[];

package/dist/esm/util/object-utils.js

@@ -40,6 +40,9 @@ export function isFunction(obj) {
 export function isObject(obj) {
     return typeof obj === 'object' && obj !== null;
 }
+export function isArrayBufferOrView(obj) {
+    return obj instanceof ArrayBuffer || ArrayBuffer.isView(obj);
+}
 export function getLast(arr) {
     return arr[arr.length - 1];
 }

package/dist/esm/util/type-utils.d.ts

@@ -1,6 +1,4 @@
-import { AliasedRawBuilder, RawBuilder } from '../raw-builder/raw-builder.js';
-import { AliasedQueryBuilder, SelectQueryBuilder } from '../query-builder/select-query-builder.js';
-import { ExpressionBuilder } from '../query-builder/expression-builder.js';
+import { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
 import { InsertResult } from '../query-builder/insert-result.js';
 import { DeleteResult } from '../query-builder/delete-result.js';
 import { UpdateResult } from '../query-builder/update-result.js';
@@ -99,21 +97,11 @@ export declare type AnyAliasedColumnWithTable<DB, TB extends keyof DB> = {
  */
 export declare type ArrayItemType<T> = T extends ReadonlyArray<infer I> ? I : never;
 export declare type AnySelectQueryBuilder = SelectQueryBuilder<any, any, any>;
-export declare type AnyAliasedQueryBuilder = AliasedQueryBuilder<any, any, any, any>;
-export declare type AnyRawBuilder = RawBuilder<any>;
-export declare type AnyAliasedRawBuilder = AliasedRawBuilder<any, any>;
-export declare type SelectQueryBuilderFactory<DB, TB extends keyof DB> = (qb: ExpressionBuilder<DB, TB>) => AnySelectQueryBuilder;
-export declare type AliasedQueryBuilderFactory<DB, TB extends keyof DB> = (qb: ExpressionBuilder<DB, TB>) => AnyAliasedQueryBuilder;
-export declare type RawBuilderFactory<DB, TB extends keyof DB, O = any> = (qb: ExpressionBuilder<DB, TB>) => RawBuilder<O>;
-export declare type AliasedRawBuilderFactory<DB, TB extends keyof DB> = (qb: ExpressionBuilder<DB, TB>) => AnyAliasedRawBuilder;
 export declare type SingleResultType<O> = O extends InsertResult ? O : O extends DeleteResult ? O : O extends UpdateResult ? O : O | undefined;
 export declare type UnknownRow = Record<string, unknown>;
 export declare type Nullable<T> = {
     [P in keyof T]: T[P] | null;
 };
-export declare type NullableValues<T> = {
-    [P in keyof T]: Nullable<T[P]>;
-};
 /**
  * Takes all properties from T1 and merges all properties from T2
  * that don't exist in T1 as optional properties.
@@ -135,3 +123,5 @@ export declare type NullableValues<T> = {
  * // { name: string, age: number, species?: 'cat' | 'dog' }
  */
 export declare type MergePartial<T1, T2> = T1 & Partial<Omit<T2, keyof T1>>;
+export declare type IsNever<T> = [T] extends [never] ? true : false;
+export declare type Equals<T, U> = (<G>() => G extends T ? 1 : 2) extends <G>() => G extends U ? 1 : 2 ? true : false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kysely",
-  "version": "0.21.6",
+  "version": "0.23.0",
   "description": "Type safe SQL query builder",
   "repository": {
     "type": "git",
@@ -41,6 +41,9 @@
   },
   "author": "Sami Koskimäki <sami@jakso.me>",
   "license": "MIT",
+  "contributors": [
+    "Igal Klebanov <igalklebanov@gmail.com>"
+  ],
   "devDependencies": {
     "@types/better-sqlite3": "^7.5.0",
     "@types/chai": "^4.3.1",

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

@@ -1,18 +0,0 @@
-import { OperationNode } from './operation-node.js';
-import { ReferenceExpressionNode, ValueExpressionNode } from './operation-node-utils.js';
-import { OperatorNode } from './operator-node.js';
-import { RawNode } from './raw-node.js';
-export declare type FilterOperatorNode = OperatorNode | RawNode;
-export interface FilterNode extends OperationNode {
-    readonly kind: 'FilterNode';
-    readonly left?: ReferenceExpressionNode;
-    readonly op: OperatorNode | RawNode;
-    readonly right: ValueExpressionNode;
-}
-/**
- * @internal
- */
-export declare const FilterNode: Readonly<{
-    is(node: OperationNode): node is FilterNode;
-    create(left: ReferenceExpressionNode | undefined, op: OperatorNode | RawNode, right: ValueExpressionNode): FilterNode;
-}>;

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

@@ -1,17 +0,0 @@
-import { AliasNode } from './alias-node.js';
-import { AndNode } from './and-node.js';
-import { ColumnNode } from './column-node.js';
-import { FilterNode } from './filter-node.js';
-import { OrNode } from './or-node.js';
-import { ParensNode } from './parens-node.js';
-import { PrimitiveValueListNode } from './primitive-value-list-node.js';
-import { RawNode } from './raw-node.js';
-import { ReferenceNode } from './reference-node.js';
-import { SelectQueryNode } from './select-query-node.js';
-import { TableNode } from './table-node.js';
-import { ValueListNode } from './value-list-node.js';
-import { ValueNode } from './value-node.js';
-export declare type ReferenceExpressionNode = ColumnNode | ReferenceNode | SelectQueryNode | RawNode;
-export declare type ValueExpressionNode = ValueNode | ValueListNode | PrimitiveValueListNode | ReferenceExpressionNode;
-export declare type TableExpressionNode = TableNode | AliasNode;
-export declare type FilterExpressionNode = FilterNode | AndNode | OrNode | ParensNode | RawNode;

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

@@ -1,16 +0,0 @@
-import { OperationNode } from './operation-node.js';
-import { RawNode } from './raw-node.js';
-import { SelectQueryNode } from './select-query-node.js';
-export declare type UnionExpressionNode = SelectQueryNode | RawNode;
-export interface UnionNode extends OperationNode {
-    readonly kind: 'UnionNode';
-    readonly union: UnionExpressionNode;
-    readonly all: boolean;
-}
-/**
- * @internal
- */
-export declare const UnionNode: Readonly<{
-    is(node: OperationNode): node is UnionNode;
-    create(union: UnionExpressionNode, all: boolean): UnionNode;
-}>;

package/dist/cjs/parser/complex-expression-parser.d.ts

@@ -1,10 +0,0 @@
-import { AliasNode } from '../operation-node/alias-node.js';
-import { RawNode } from '../operation-node/raw-node.js';
-import { SelectQueryNode } from '../operation-node/select-query-node.js';
-import { RawBuilder } from '../raw-builder/raw-builder.js';
-import { AliasedQueryBuilderFactory, AliasedRawBuilderFactory, AnyAliasedQueryBuilder, AnyAliasedRawBuilder, AnySelectQueryBuilder, SelectQueryBuilderFactory, RawBuilderFactory } from '../util/type-utils.js';
-export declare type ComplexExpression<DB, TB extends keyof DB, V = any> = AnySelectQueryBuilder | SelectQueryBuilderFactory<DB, TB> | RawBuilder<V> | RawBuilderFactory<DB, TB, V>;
-export declare type AliasedComplexExpression<DB, TB extends keyof DB> = AnyAliasedQueryBuilder | AliasedQueryBuilderFactory<DB, TB> | AnyAliasedRawBuilder | AliasedRawBuilderFactory<DB, TB>;
-export declare function parseComplexExpression(exp: ComplexExpression<any, any>): SelectQueryNode | RawNode;
-export declare function parseAliasedComplexExpression(exp: AliasedComplexExpression<any, any>): AliasNode;
-export declare function isComplexExpression(obj: unknown): obj is ComplexExpression<any, any>;

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

@@ -1,24 +0,0 @@
-import { FilterNode } from '../operation-node/filter-node.js';
-import { AnyRawBuilder } from '../util/type-utils.js';
-import { Operator } from '../operation-node/operator-node.js';
-import { ExtractTypeFromReferenceExpression, ReferenceExpression } from './reference-parser.js';
-import { ValueExpression, ValueExpressionOrList } from './value-parser.js';
-import { FilterExpressionNode } from '../operation-node/operation-node-utils.js';
-import { WhereInterface } from '../query-builder/where-interface.js';
-import { HavingInterface } from '../query-builder/having-interface.js';
-import { ComplexExpression } from './complex-expression-parser.js';
-export declare type FilterValueExpression<DB, TB extends keyof DB, RE> = ValueExpression<DB, TB, ExtractTypeFromReferenceExpression<DB, TB, RE>>;
-export declare type FilterValueExpressionOrList<DB, TB extends keyof DB, RE> = ValueExpressionOrList<DB, TB, ExtractTypeFromReferenceExpression<DB, TB, RE>>;
-export declare type ExistsExpression<DB, TB extends keyof DB> = ComplexExpression<DB, TB, any>;
-export declare type WhereGrouper<DB, TB extends keyof DB> = (qb: WhereInterface<DB, TB>) => WhereInterface<DB, TB>;
-export declare type HavingGrouper<DB, TB extends keyof DB> = (qb: HavingInterface<DB, TB>) => HavingInterface<DB, TB>;
-export declare type FilterOperator = Operator | AnyRawBuilder;
-declare type FilterType = 'where' | 'having' | 'on';
-export declare function parseWhereFilter(args: any[]): FilterExpressionNode;
-export declare function parseHavingFilter(args: any[]): FilterExpressionNode;
-export declare function parseOnFilter(args: any[]): FilterExpressionNode;
-export declare function parseReferenceFilter(lhs: ReferenceExpression<any, any>, op: FilterOperator, rhs: ReferenceExpression<any, any>): FilterNode;
-export declare function parseExistFilter(arg: ExistsExpression<any, any>): FilterNode;
-export declare function parseNotExistFilter(arg: ExistsExpression<any, any>): FilterNode;
-export declare function parseFilter(type: FilterType, args: any[]): FilterExpressionNode;
-export {};

package/dist/cjs/parser/filter-parser.js

@@ -1,109 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseFilter = exports.parseNotExistFilter = exports.parseExistFilter = exports.parseReferenceFilter = exports.parseOnFilter = exports.parseHavingFilter = exports.parseWhereFilter = void 0;
-const filter_node_js_1 = require("../operation-node/filter-node.js");
-const object_utils_js_1 = require("../util/object-utils.js");
-const operation_node_source_js_1 = require("../operation-node/operation-node-source.js");
-const raw_node_js_1 = require("../operation-node/raw-node.js");
-const operator_node_js_1 = require("../operation-node/operator-node.js");
-const parens_node_js_1 = require("../operation-node/parens-node.js");
-const reference_parser_js_1 = require("./reference-parser.js");
-const value_parser_js_1 = require("./value-parser.js");
-const value_node_js_1 = require("../operation-node/value-node.js");
-const parse_utils_js_1 = require("./parse-utils.js");
-function parseWhereFilter(args) {
-    return parseFilter('where', args);
-}
-exports.parseWhereFilter = parseWhereFilter;
-function parseHavingFilter(args) {
-    return parseFilter('having', args);
-}
-exports.parseHavingFilter = parseHavingFilter;
-function parseOnFilter(args) {
-    return parseFilter('on', args);
-}
-exports.parseOnFilter = parseOnFilter;
-function parseReferenceFilter(lhs, op, rhs) {
-    return filter_node_js_1.FilterNode.create((0, reference_parser_js_1.parseReferenceExpression)(lhs), parseFilterOperator(op), (0, reference_parser_js_1.parseReferenceExpression)(rhs));
-}
-exports.parseReferenceFilter = parseReferenceFilter;
-function parseExistFilter(arg) {
-    return parseExistExpression('exists', arg);
-}
-exports.parseExistFilter = parseExistFilter;
-function parseNotExistFilter(arg) {
-    return parseExistExpression('not exists', arg);
-}
-exports.parseNotExistFilter = parseNotExistFilter;
-function parseFilter(type, args) {
-    if (args.length === 3) {
-        return parseThreeArgFilter(args[0], args[1], args[2]);
-    }
-    else if (args.length === 1) {
-        return parseOneArgFilter(type, args[0]);
-    }
-    throw createFilterError(type, args);
-}
-exports.parseFilter = parseFilter;
-function parseThreeArgFilter(left, op, right) {
-    if ((op === 'is' || op === 'is not') && ((0, object_utils_js_1.isNull)(right) || (0, object_utils_js_1.isBoolean)(right))) {
-        return parseIsFilter(left, op, right);
-    }
-    return filter_node_js_1.FilterNode.create((0, reference_parser_js_1.parseReferenceExpression)(left), parseFilterOperator(op), (0, value_parser_js_1.parseValueExpressionOrList)(right));
-}
-function parseIsFilter(left, op, right) {
-    return filter_node_js_1.FilterNode.create((0, reference_parser_js_1.parseReferenceExpression)(left), parseFilterOperator(op), value_node_js_1.ValueNode.createImmediate(right));
-}
-function parseFilterOperator(op) {
-    if ((0, object_utils_js_1.isString)(op) && operator_node_js_1.OPERATORS.includes(op)) {
-        return operator_node_js_1.OperatorNode.create(op);
-    }
-    else if ((0, operation_node_source_js_1.isOperationNodeSource)(op)) {
-        return op.toOperationNode();
-    }
-    throw new Error(`invalid comparison operator ${JSON.stringify(op)} passed to a filter method`);
-}
-function parseExistExpression(type, arg) {
-    return filter_node_js_1.FilterNode.create(undefined, operator_node_js_1.OperatorNode.create(type), (0, value_parser_js_1.parseValueExpressionOrList)(arg));
-}
-function parseOneArgFilter(type, arg) {
-    if ((0, object_utils_js_1.isFunction)(arg)) {
-        return GROUP_PARSERS[type](arg);
-    }
-    else if ((0, operation_node_source_js_1.isOperationNodeSource)(arg)) {
-        const node = arg.toOperationNode();
-        if (raw_node_js_1.RawNode.is(node)) {
-            return node;
-        }
-    }
-    throw createFilterError(type, arg);
-}
-function createFilterError(type, args) {
-    return new Error(`invalid arguments passed to a '${type}' method: ${JSON.stringify(args)}`);
-}
-const GROUP_PARSERS = (0, object_utils_js_1.freeze)({
-    where(callback) {
-        const query = callback((0, parse_utils_js_1.createSelectQueryBuilder)());
-        const queryNode = query.toOperationNode();
-        if (!queryNode.where) {
-            throw new Error('no `where` methods called insided a group callback');
-        }
-        return parens_node_js_1.ParensNode.create(queryNode.where.where);
-    },
-    having(callback) {
-        const query = callback((0, parse_utils_js_1.createSelectQueryBuilder)());
-        const queryNode = query.toOperationNode();
-        if (!queryNode.having) {
-            throw new Error('no `having` methods called insided a group callback');
-        }
-        return parens_node_js_1.ParensNode.create(queryNode.having.having);
-    },
-    on(callback) {
-        const joinBuilder = callback((0, parse_utils_js_1.createJoinBuilder)('InnerJoin', 'table'));
-        const joinNode = joinBuilder.toOperationNode();
-        if (!joinNode.on) {
-            throw new Error('no `on` methods called insided a group callback');
-        }
-        return parens_node_js_1.ParensNode.create(joinNode.on.on);
-    },
-});

package/dist/cjs/parser/union-parser.d.ts

@@ -1,5 +0,0 @@
-import { UnionNode } from '../operation-node/union-node.js';
-import { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
-import { RawBuilder } from '../raw-builder/raw-builder.js';
-export declare type UnionExpression<DB, O> = SelectQueryBuilder<DB, any, O> | RawBuilder<O>;
-export declare function parseUnion(union: UnionExpression<any, any>, all: boolean): UnionNode;

package/dist/cjs/parser/union-parser.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseUnion = void 0;
-const union_node_js_1 = require("../operation-node/union-node.js");
-function parseUnion(union, all) {
-    return union_node_js_1.UnionNode.create(union.toOperationNode(), all);
-}
-exports.parseUnion = parseUnion;

package/dist/cjs/query-builder/function-builder.d.ts

@@ -1,133 +0,0 @@
-import { StringReference, ExtractTypeFromReferenceExpression } from '../parser/reference-parser.js';
-import { RawBuilder } from '../raw-builder/raw-builder.js';
-/**
- * Helpers for type safe SQL function calls.
- *
- * You can always use the {@link sql} tag to call functions and build arbitrary
- * expressions. This module simply has shortcuts for most common function calls.
- *
- * ### Examples
- *
- * ```ts
- * const { count } = db.fn
- *
- * await db.selectFrom('person')
- *   .innerJoin('pet', 'pet.owner_id', 'person.id')
- *   .select([
- *     'person.id',
- *     count('pet.id').as('pet_count')
- *   ])
- *   .groupBy('person.id')
- *   .having(count('pet.id'), '>', 10)
- *   .execute()
- * ```
- *
- * The generated SQL (PostgreSQL):
- *
- * ```sql
- * select "person"."id", count("pet"."id") as "pet_count"
- * from "person"
- * inner join "pet" on "pet"."owner_id" = "person"."id"
- * group by "person"."id"
- * having count("pet"."id") > $1
- * ```
- */
-export declare class FunctionBuilder<DB, TB extends keyof DB> {
-    #private;
-    constructor();
-    /**
-     * Calls the `max` function for the column given as the argument.
-     *
-     * ### Examples
-     *
-     * ```ts
-     * const { max } = db.fn
-     *
-     * db.selectFrom('toy')
-     *   .select(max('price').as('max_price'))
-     *   .execute()
-     * ```
-     */
-    max<C extends StringReference<DB, TB>>(column: C): RawBuilder<ExtractTypeFromReferenceExpression<DB, TB, C>>;
-    /**
-     * Calls the `min` function for the column given as the argument.
-     *
-     * ### Examples
-     *
-     * ```ts
-     * const { min } = db.fn
-     *
-     * db.selectFrom('toy')
-     *   .select(min('price').as('min_price'))
-     *   .execute()
-     * ```
-     *
-     */
-    min<C extends StringReference<DB, TB>>(column: C): RawBuilder<ExtractTypeFromReferenceExpression<DB, TB, C>>;
-    /**
-     * Calls the `avg` function for the column given as the argument.
-     *
-     * If this is used in a `select` statement the type of the selected expression
-     * will be `number | string` by default. This is because Kysely can't know the
-     * type the db driver outputs. Sometimes the output can be larger than the
-     * largest javascript number and a string is returned instead. Most drivers
-     * allow you to configure the output type of large numbers and Kysely can't
-     * know if you've done so.
-     *
-     * You can specify the output type of the expression by providing
-     * the type as the first type argument:
-     *
-     * ```ts
-     * const { avg } = db.fn
-     *
-     * db.selectFrom('toy')
-     *   .select(avg<number>('price').as('avg_price'))
-     *   .execute()
-     * ```
-     */
-    avg<O extends number | string, C extends StringReference<DB, TB> = StringReference<DB, TB>>(column: C): RawBuilder<O>;
-    /**
-     * Calls the `sum` function for the column given as the argument.
-     *
-     * If this is used in a `select` statement the type of the selected expression
-     * will be `number | string | bigint` by default. This is because Kysely can't
-     * know the type the db driver outputs. Sometimes the output can be larger than
-     * the largest javascript number and a string is returned instead. Most drivers
-     * allow you to configure the output type of large numbers and Kysely can't
-     * know if you've done so.
-     *
-     * You can specify the output type of the expression by providing
-     * the type as the first type argument:
-     *
-     * ```ts
-     * const { sum } = db.fn
-     *
-     * db.selectFrom('toy')
-     *   .select(sum<number>('price').as('total_price'))
-     *   .execute()
-     * ```
-     */
-    sum<O extends number | string | bigint, C extends StringReference<DB, TB> = StringReference<DB, TB>>(column: C): RawBuilder<O>;
-    /**
-     * Calls the `count` function for the column given as the argument.
-     *
-     * If this is used in a `select` statement the type of the selected expression
-     * will be `number | string |bigint` by default. This is because Kysely can't
-     * know the type the db driver outputs. Sometimes the output can be larger than
-     * the largest javascript number and a string is returned instead. Most drivers
-     * allow you to configure the output type of large numbers and Kysely can't
-     * know if you've done so.
-     *
-     * You can specify the output type of the expression by providing
-     * the type as the first type argument:
-     *
-     * ```ts
-     * const { count } = db.fn
-     *
-     * db.selectFrom('toy')
-     *   .select(count<number>('id').as('num_toys'))
-     *   .execute()
-     * ```
-     */
-    count<O extends number | string | bigint, C extends StringReference<DB, TB> = StringReference<DB, TB>>(column: C): RawBuilder<O>;
-}