kysely 0.21.6 → 0.23.0

package/dist/cjs/query-builder/function-builder.js

@@ -1,160 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FunctionBuilder = void 0;
-const raw_node_js_1 = require("../operation-node/raw-node.js");
-const reference_parser_js_1 = require("../parser/reference-parser.js");
-const raw_builder_js_1 = require("../raw-builder/raw-builder.js");
-const query_id_js_1 = require("../util/query-id.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
- * ```
- */
-class FunctionBuilder {
-    constructor() {
-        this.min = this.min.bind(this);
-        this.max = this.max.bind(this);
-        this.avg = this.avg.bind(this);
-        this.sum = this.sum.bind(this);
-        this.count = this.count.bind(this);
-    }
-    /**
-     * 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(column) {
-        return this.#oneArgFunction('max', column);
-    }
-    /**
-     * 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(column) {
-        return this.#oneArgFunction('min', column);
-    }
-    /**
-     * 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(column) {
-        return this.#oneArgFunction('avg', column);
-    }
-    /**
-     * 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(column) {
-        return this.#oneArgFunction('sum', column);
-    }
-    /**
-     * 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(column) {
-        return this.#oneArgFunction('count', column);
-    }
-    #oneArgFunction(fn, column) {
-        return new raw_builder_js_1.RawBuilder({
-            queryId: (0, query_id_js_1.createQueryId)(),
-            rawNode: raw_node_js_1.RawNode.create([`${fn}(`, ')'], [(0, reference_parser_js_1.parseStringReference)(column)]),
-        });
-    }
-}
-exports.FunctionBuilder = FunctionBuilder;

package/dist/esm/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/esm/operation-node/filter-node.js

@@ -1,18 +0,0 @@
-/// <reference types="./filter-node.d.ts" />
-import { freeze } from '../util/object-utils.js';
-/**
- * @internal
- */
-export const FilterNode = freeze({
-    is(node) {
-        return node.kind === 'FilterNode';
-    },
-    create(left, op, right) {
-        return freeze({
-            kind: 'FilterNode',
-            left,
-            op,
-            right,
-        });
-    },
-});

package/dist/esm/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/esm/operation-node/operation-node-utils.js

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

package/dist/esm/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/esm/operation-node/union-node.js

@@ -1,17 +0,0 @@
-/// <reference types="./union-node.d.ts" />
-import { freeze } from '../util/object-utils.js';
-/**
- * @internal
- */
-export const UnionNode = freeze({
-    is(node) {
-        return node.kind === 'UnionNode';
-    },
-    create(union, all) {
-        return freeze({
-            kind: 'UnionNode',
-            union,
-            all,
-        });
-    },
-});

package/dist/esm/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/esm/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/esm/parser/filter-parser.js

@@ -1,100 +0,0 @@
-/// <reference types="./filter-parser.d.ts" />
-import { FilterNode } from '../operation-node/filter-node.js';
-import { freeze, isBoolean, isFunction, isNull, isString, } from '../util/object-utils.js';
-import { isOperationNodeSource } from '../operation-node/operation-node-source.js';
-import { RawNode } from '../operation-node/raw-node.js';
-import { OperatorNode, OPERATORS, } from '../operation-node/operator-node.js';
-import { ParensNode } from '../operation-node/parens-node.js';
-import { parseReferenceExpression, } from './reference-parser.js';
-import { parseValueExpressionOrList, } from './value-parser.js';
-import { ValueNode } from '../operation-node/value-node.js';
-import { createJoinBuilder, createSelectQueryBuilder } from './parse-utils.js';
-export function parseWhereFilter(args) {
-    return parseFilter('where', args);
-}
-export function parseHavingFilter(args) {
-    return parseFilter('having', args);
-}
-export function parseOnFilter(args) {
-    return parseFilter('on', args);
-}
-export function parseReferenceFilter(lhs, op, rhs) {
-    return FilterNode.create(parseReferenceExpression(lhs), parseFilterOperator(op), parseReferenceExpression(rhs));
-}
-export function parseExistFilter(arg) {
-    return parseExistExpression('exists', arg);
-}
-export function parseNotExistFilter(arg) {
-    return parseExistExpression('not exists', arg);
-}
-export 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);
-}
-function parseThreeArgFilter(left, op, right) {
-    if ((op === 'is' || op === 'is not') && (isNull(right) || isBoolean(right))) {
-        return parseIsFilter(left, op, right);
-    }
-    return FilterNode.create(parseReferenceExpression(left), parseFilterOperator(op), parseValueExpressionOrList(right));
-}
-function parseIsFilter(left, op, right) {
-    return FilterNode.create(parseReferenceExpression(left), parseFilterOperator(op), ValueNode.createImmediate(right));
-}
-function parseFilterOperator(op) {
-    if (isString(op) && OPERATORS.includes(op)) {
-        return OperatorNode.create(op);
-    }
-    else if (isOperationNodeSource(op)) {
-        return op.toOperationNode();
-    }
-    throw new Error(`invalid comparison operator ${JSON.stringify(op)} passed to a filter method`);
-}
-function parseExistExpression(type, arg) {
-    return FilterNode.create(undefined, OperatorNode.create(type), parseValueExpressionOrList(arg));
-}
-function parseOneArgFilter(type, arg) {
-    if (isFunction(arg)) {
-        return GROUP_PARSERS[type](arg);
-    }
-    else if (isOperationNodeSource(arg)) {
-        const node = arg.toOperationNode();
-        if (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 = freeze({
-    where(callback) {
-        const query = callback(createSelectQueryBuilder());
-        const queryNode = query.toOperationNode();
-        if (!queryNode.where) {
-            throw new Error('no `where` methods called insided a group callback');
-        }
-        return ParensNode.create(queryNode.where.where);
-    },
-    having(callback) {
-        const query = callback(createSelectQueryBuilder());
-        const queryNode = query.toOperationNode();
-        if (!queryNode.having) {
-            throw new Error('no `having` methods called insided a group callback');
-        }
-        return ParensNode.create(queryNode.having.having);
-    },
-    on(callback) {
-        const joinBuilder = callback(createJoinBuilder('InnerJoin', 'table'));
-        const joinNode = joinBuilder.toOperationNode();
-        if (!joinNode.on) {
-            throw new Error('no `on` methods called insided a group callback');
-        }
-        return ParensNode.create(joinNode.on.on);
-    },
-});

package/dist/esm/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/esm/parser/union-parser.js

@@ -1,5 +0,0 @@
-/// <reference types="./union-parser.d.ts" />
-import { UnionNode } from '../operation-node/union-node.js';
-export function parseUnion(union, all) {
-    return UnionNode.create(union.toOperationNode(), all);
-}

package/dist/esm/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>;
-}