kysely 0.28.17 → 0.29.0

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

@@ -1,15 +0,0 @@
-import type { OperationNode } from './operation-node.js';
-export interface UsingNode extends OperationNode {
-    readonly kind: 'UsingNode';
-    readonly tables: ReadonlyArray<OperationNode>;
-}
-type UsingNodeFactory = Readonly<{
-    is(node: OperationNode): node is UsingNode;
-    create(tables: ReadonlyArray<OperationNode>): Readonly<UsingNode>;
-    cloneWithTables(using: UsingNode, tables: ReadonlyArray<OperationNode>): Readonly<UsingNode>;
-}>;
-/**
- * @internal
- */
-export declare const UsingNode: UsingNodeFactory;
-export {};

package/dist/esm/operation-node/value-list-node.d.ts

@@ -1,14 +0,0 @@
-import type { OperationNode } from './operation-node.js';
-export interface ValueListNode extends OperationNode {
-    readonly kind: 'ValueListNode';
-    readonly values: ReadonlyArray<OperationNode>;
-}
-type ValueListNodeFactory = Readonly<{
-    is(node: OperationNode): node is ValueListNode;
-    create(values: ReadonlyArray<OperationNode>): Readonly<ValueListNode>;
-}>;
-/**
- * @internal
- */
-export declare const ValueListNode: ValueListNodeFactory;
-export {};

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

@@ -1,16 +0,0 @@
-import type { OperationNode } from './operation-node.js';
-export interface ValueNode extends OperationNode {
-    readonly kind: 'ValueNode';
-    readonly value: unknown;
-    readonly immediate?: boolean;
-}
-type ValueNodeFactory = Readonly<{
-    is(node: OperationNode): node is ValueNode;
-    create(value: unknown): Readonly<ValueNode>;
-    createImmediate(value: unknown): Readonly<ValueNode>;
-}>;
-/**
- * @internal
- */
-export declare const ValueNode: ValueNodeFactory;
-export {};

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

@@ -1,17 +0,0 @@
-import type { OperationNode } from './operation-node.js';
-import type { PrimitiveValueListNode } from './primitive-value-list-node.js';
-import type { ValueListNode } from './value-list-node.js';
-export type ValuesItemNode = ValueListNode | PrimitiveValueListNode;
-export interface ValuesNode extends OperationNode {
-    readonly kind: 'ValuesNode';
-    readonly values: ReadonlyArray<ValuesItemNode>;
-}
-type ValuesNodeFactory = Readonly<{
-    is(node: OperationNode): node is ValuesNode;
-    create(values: ReadonlyArray<ValuesItemNode>): Readonly<ValuesNode>;
-}>;
-/**
- * @internal
- */
-export declare const ValuesNode: ValuesNodeFactory;
-export {};

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

@@ -1,16 +0,0 @@
-import type { OperationNode } from './operation-node.js';
-export interface WhenNode extends OperationNode {
-    readonly kind: 'WhenNode';
-    readonly condition: OperationNode;
-    readonly result?: OperationNode;
-}
-type WhenNodeFactory = Readonly<{
-    is(node: OperationNode): node is WhenNode;
-    create(condition: OperationNode): Readonly<WhenNode>;
-    cloneWithResult(whenNode: WhenNode, result: OperationNode): Readonly<WhenNode>;
-}>;
-/**
- * @internal
- */
-export declare const WhenNode: WhenNodeFactory;
-export {};

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

@@ -1,15 +0,0 @@
-import type { OperationNode } from './operation-node.js';
-export interface WhereNode extends OperationNode {
-    readonly kind: 'WhereNode';
-    readonly where: OperationNode;
-}
-type WhereNodeFactory = Readonly<{
-    is(node: OperationNode): node is WhereNode;
-    create(filter: OperationNode): Readonly<WhereNode>;
-    cloneWithOperation(whereNode: WhereNode, operator: 'And' | 'Or', operation: OperationNode): Readonly<WhereNode>;
-}>;
-/**
- * @internal
- */
-export declare const WhereNode: WhereNodeFactory;
-export {};

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

@@ -1,18 +0,0 @@
-import type { OperationNode } from './operation-node.js';
-import type { CommonTableExpressionNode } from './common-table-expression-node.js';
-export type WithNodeParams = Omit<WithNode, 'kind' | 'expressions'>;
-export interface WithNode extends OperationNode {
-    readonly kind: 'WithNode';
-    readonly expressions: ReadonlyArray<CommonTableExpressionNode>;
-    readonly recursive?: boolean;
-}
-type WithNodeFactory = Readonly<{
-    is(node: OperationNode): node is WithNode;
-    create(expression: CommonTableExpressionNode, params?: WithNodeParams): Readonly<WithNode>;
-    cloneWithExpression(withNode: WithNode, expression: CommonTableExpressionNode): Readonly<WithNode>;
-}>;
-/**
- * @internal
- */
-export declare const WithNode: WithNodeFactory;
-export {};

package/dist/esm/package.json

@@ -1 +0,0 @@
-{"type":"module","sideEffects":false}

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

@@ -1,23 +0,0 @@
-import { BinaryOperationNode } from '../operation-node/binary-operation-node.js';
-import { type OperationNodeSource } from '../operation-node/operation-node-source.js';
-import { type ComparisonOperator, type BinaryOperator, type Operator } from '../operation-node/operator-node.js';
-import { type ExtractTypeFromReferenceExpression, type ExtractTypeFromStringReference, type ReferenceExpression, type StringReference } from './reference-parser.js';
-import { type ValueExpression, type ValueExpressionOrList } from './value-parser.js';
-import type { OperationNode } from '../operation-node/operation-node.js';
-import type { Expression } from '../expression/expression.js';
-import type { SelectType } from '../util/column-type.js';
-import type { IsNever } from '../util/type-utils.js';
-import type { KyselyTypeError } from '../util/type-error.js';
-export type OperandValueExpression<DB, TB extends keyof DB, RE> = ValueExpression<DB, TB, ExtractTypeFromReferenceExpression<DB, TB, RE>>;
-export type OperandValueExpressionOrList<DB, TB extends keyof DB, RE> = ValueExpressionOrList<DB, TB, ExtractTypeFromReferenceExpression<DB, TB, RE> | null>;
-export type OperatorExpression = Operator | Expression<unknown>;
-export type BinaryOperatorExpression = BinaryOperator | Expression<unknown>;
-export type ComparisonOperatorExpression = ComparisonOperator | Expression<unknown>;
-export type FilterObject<DB, TB extends keyof DB> = IsNever<TB> extends true ? KyselyTypeError<'there are no tables in query context, so a filter object cannot be defined. try passing an array instead.'> : {
-    [R in StringReference<DB, TB>]?: ValueExpressionOrList<DB, TB, SelectType<ExtractTypeFromStringReference<DB, TB, R>>>;
-};
-export declare function parseValueBinaryOperationOrExpression(args: any[]): OperationNode;
-export declare function parseValueBinaryOperation(left: ReferenceExpression<any, any>, operator: BinaryOperatorExpression, right: OperandValueExpressionOrList<any, any, any>): BinaryOperationNode;
-export declare function parseReferentialBinaryOperation(left: ReferenceExpression<any, any>, operator: BinaryOperatorExpression, right: OperandValueExpressionOrList<any, any, any>): BinaryOperationNode;
-export declare function parseFilterObject(obj: Readonly<FilterObject<any, any>>, combinator: 'and' | 'or'): OperationNode;
-export declare function parseFilterList(list: ReadonlyArray<OperationNodeSource | OperationNode>, combinator: 'and' | 'or', withParens?: boolean): OperationNode;

package/dist/esm/parser/binary-operation-parser.js

@@ -1,68 +0,0 @@
-/// <reference types="./binary-operation-parser.d.ts" />
-import { BinaryOperationNode } from '../operation-node/binary-operation-node.js';
-import { isBoolean, isNull, isString, isUndefined, } from '../util/object-utils.js';
-import { isOperationNodeSource, } from '../operation-node/operation-node-source.js';
-import { OperatorNode, OPERATORS, } from '../operation-node/operator-node.js';
-import { parseReferenceExpression, } from './reference-parser.js';
-import { parseValueExpression, parseValueExpressionOrList, } from './value-parser.js';
-import { ValueNode } from '../operation-node/value-node.js';
-import { AndNode } from '../operation-node/and-node.js';
-import { ParensNode } from '../operation-node/parens-node.js';
-import { OrNode } from '../operation-node/or-node.js';
-export function parseValueBinaryOperationOrExpression(args) {
-    if (args.length === 3) {
-        return parseValueBinaryOperation(args[0], args[1], args[2]);
-    }
-    else if (args.length === 1) {
-        return parseValueExpression(args[0]);
-    }
-    throw new Error(`invalid arguments: ${JSON.stringify(args)}`);
-}
-export function parseValueBinaryOperation(left, operator, right) {
-    if (isIsOperator(operator) && needsIsOperator(right)) {
-        return BinaryOperationNode.create(parseReferenceExpression(left), parseOperator(operator), ValueNode.createImmediate(right));
-    }
-    return BinaryOperationNode.create(parseReferenceExpression(left), parseOperator(operator), parseValueExpressionOrList(right));
-}
-export function parseReferentialBinaryOperation(left, operator, right) {
-    return BinaryOperationNode.create(parseReferenceExpression(left), parseOperator(operator), parseReferenceExpression(right));
-}
-export function parseFilterObject(obj, combinator) {
-    return parseFilterList(Object.entries(obj)
-        .filter(([, v]) => !isUndefined(v))
-        .map(([k, v]) => parseValueBinaryOperation(k, needsIsOperator(v) ? 'is' : '=', v)), combinator);
-}
-export function parseFilterList(list, combinator, withParens = true) {
-    const combine = combinator === 'and' ? AndNode.create : OrNode.create;
-    if (list.length === 0) {
-        return BinaryOperationNode.create(ValueNode.createImmediate(1), OperatorNode.create('='), ValueNode.createImmediate(combinator === 'and' ? 1 : 0));
-    }
-    let node = toOperationNode(list[0]);
-    for (let i = 1; i < list.length; ++i) {
-        node = combine(node, toOperationNode(list[i]));
-    }
-    if (list.length > 1 && withParens) {
-        return ParensNode.create(node);
-    }
-    return node;
-}
-function isIsOperator(operator) {
-    return operator === 'is' || operator === 'is not';
-}
-function needsIsOperator(value) {
-    return isNull(value) || isBoolean(value);
-}
-function parseOperator(operator) {
-    if (isString(operator) && OPERATORS.includes(operator)) {
-        return OperatorNode.create(operator);
-    }
-    if (isOperationNodeSource(operator)) {
-        return operator.toOperationNode();
-    }
-    throw new Error(`invalid operator ${JSON.stringify(operator)}`);
-}
-function toOperationNode(nodeOrSource) {
-    return isOperationNodeSource(nodeOrSource)
-        ? nodeOrSource.toOperationNode()
-        : nodeOrSource;
-}

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

@@ -1,12 +0,0 @@
-import type { ExtractTypeFromReferenceExpression } from './reference-parser.js';
-export type ExtractTypeFromCoalesce1<DB, TB extends keyof DB, R1> = ExtractTypeFromReferenceExpression<DB, TB, R1>;
-export type ExtractTypeFromCoalesce2<DB, TB extends keyof DB, R1, R2> = ExtractTypeFromCoalesceValues2<ExtractTypeFromReferenceExpression<DB, TB, R1>, ExtractTypeFromReferenceExpression<DB, TB, R2>>;
-type ExtractTypeFromCoalesceValues2<V1, V2> = null extends V1 ? null extends V2 ? V1 | V2 : NotNull<V1 | V2> : NotNull<V1>;
-export type ExtractTypeFromCoalesce3<DB, TB extends keyof DB, R1, R2, R3> = ExtractTypeFromCoalesceValues3<ExtractTypeFromReferenceExpression<DB, TB, R1>, ExtractTypeFromReferenceExpression<DB, TB, R2>, ExtractTypeFromReferenceExpression<DB, TB, R3>>;
-type ExtractTypeFromCoalesceValues3<V1, V2, V3> = null extends V1 ? null extends V2 ? null extends V3 ? V1 | V2 | V3 : NotNull<V1 | V2 | V3> : NotNull<V1 | V2> : NotNull<V1>;
-export type ExtractTypeFromCoalesce4<DB, TB extends keyof DB, R1, R2, R3, R4> = ExtractTypeFromCoalesceValues4<ExtractTypeFromReferenceExpression<DB, TB, R1>, ExtractTypeFromReferenceExpression<DB, TB, R2>, ExtractTypeFromReferenceExpression<DB, TB, R3>, ExtractTypeFromReferenceExpression<DB, TB, R4>>;
-type ExtractTypeFromCoalesceValues4<V1, V2, V3, V4> = null extends V1 ? null extends V2 ? null extends V3 ? null extends V4 ? V1 | V2 | V3 | V4 : NotNull<V1 | V2 | V3 | V4> : NotNull<V1 | V2 | V3> : NotNull<V1 | V2> : NotNull<V1>;
-export type ExtractTypeFromCoalesce5<DB, TB extends keyof DB, R1, R2, R3, R4, R5> = ExtractTypeFromCoalesceValues5<ExtractTypeFromReferenceExpression<DB, TB, R1>, ExtractTypeFromReferenceExpression<DB, TB, R2>, ExtractTypeFromReferenceExpression<DB, TB, R3>, ExtractTypeFromReferenceExpression<DB, TB, R4>, ExtractTypeFromReferenceExpression<DB, TB, R5>>;
-type ExtractTypeFromCoalesceValues5<V1, V2, V3, V4, V5> = null extends V1 ? null extends V2 ? null extends V3 ? null extends V4 ? null extends V5 ? V1 | V2 | V3 | V4 | V5 : NotNull<V1 | V2 | V3 | V4 | V5> : NotNull<V1 | V2 | V3 | V4> : NotNull<V1 | V2 | V3> : NotNull<V1 | V2> : NotNull<V1>;
-type NotNull<T> = Exclude<T, null>;
-export {};

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

@@ -1 +0,0 @@
-export type Collation = 'nocase' | 'binary' | 'rtrim' | (string & {});

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

@@ -1,5 +0,0 @@
-import type { Expression } from '../expression/expression.js';
-import { type ColumnDataType } from '../operation-node/data-type-node.js';
-import type { OperationNode } from '../operation-node/operation-node.js';
-export type DataTypeExpression = ColumnDataType | Expression<any>;
-export declare function parseDataTypeExpression(dataType: DataTypeExpression): OperationNode;

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

@@ -1,4 +0,0 @@
-import type { Expression } from '../expression/expression.js';
-import type { OperationNode } from '../operation-node/operation-node.js';
-export type DefaultValueExpression = unknown | Expression<unknown>;
-export declare function parseDefaultValueExpression(value: DefaultValueExpression): OperationNode;

package/dist/esm/parser/delete-from-parser.d.ts

@@ -1,9 +0,0 @@
-import type { DeleteQueryBuilder } from '../query-builder/delete-query-builder.js';
-import type { DeleteResult } from '../query-builder/delete-result.js';
-import type { ShallowRecord } from '../util/type-utils.js';
-import type { ExtractTableAlias, From, FromTables, TableExpressionOrList } from './table-parser.js';
-export type DeleteFrom<DB, TE extends TableExpressionOrList<DB, never>> = [
-    TE
-] extends [keyof DB] ? DeleteQueryBuilder<DB, ExtractTableAlias<DB, TE>, DeleteResult> : [
-    TE
-] extends [`${infer T} as ${infer A}`] ? T extends keyof DB ? DeleteQueryBuilder<DB & ShallowRecord<A, DB[T]>, A, DeleteResult> : never : TE extends ReadonlyArray<infer T> ? DeleteQueryBuilder<From<DB, T>, FromTables<DB, never, T>, DeleteResult> : DeleteQueryBuilder<From<DB, TE>, FromTables<DB, never, TE>, DeleteResult>;

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

@@ -1,20 +0,0 @@
-import { type AliasedExpression, type Expression } from '../expression/expression.js';
-import type { AliasNode } from '../operation-node/alias-node.js';
-import type { OperationNode } from '../operation-node/operation-node.js';
-import { type ExpressionBuilder } from '../expression/expression-builder.js';
-import type { SelectQueryBuilderExpression } from '../query-builder/select-query-builder-expression.js';
-/**
- * Like `Expression<V>` but also accepts a select query with an output
- * type extending `Record<string, V>`. This type is useful because SQL
- * treats records with a single column as single values.
- */
-export type OperandExpression<V> = Expression<V> | SelectQueryBuilderExpression<Record<string, V>>;
-export type ExpressionOrFactory<DB, TB extends keyof DB, V> = OperandExpression<V> | OperandExpressionFactory<DB, TB, V>;
-export type AliasedExpressionOrFactory<DB, TB extends keyof DB> = AliasedExpression<any, any> | AliasedExpressionFactory<DB, TB>;
-export type ExpressionFactory<DB, TB extends keyof DB, V> = (eb: ExpressionBuilder<DB, TB>) => Expression<V>;
-type OperandExpressionFactory<DB, TB extends keyof DB, V> = (eb: ExpressionBuilder<DB, TB>) => OperandExpression<V>;
-type AliasedExpressionFactory<DB, TB extends keyof DB> = (eb: ExpressionBuilder<DB, TB>) => AliasedExpression<any, any>;
-export declare function parseExpression(exp: ExpressionOrFactory<any, any, any>): OperationNode;
-export declare function parseAliasedExpression(exp: AliasedExpressionOrFactory<any, any>): AliasNode;
-export declare function isExpressionOrFactory(obj: unknown): obj is ExpressionOrFactory<any, any, any>;
-export {};

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

@@ -1,2 +0,0 @@
-import { type FetchModifier, FetchNode } from '../operation-node/fetch-node.js';
-export declare function parseFetch(rowCount: number | bigint, modifier: FetchModifier): FetchNode;

package/dist/esm/parser/group-by-parser.d.ts

@@ -1,6 +0,0 @@
-import { GroupByItemNode } from '../operation-node/group-by-item-node.js';
-import { type ExpressionBuilder } from '../expression/expression-builder.js';
-import { type ReferenceExpression } from './reference-parser.js';
-export type GroupByExpression<DB, TB extends keyof DB, O> = ReferenceExpression<DB, TB> | (keyof O & string);
-export type GroupByArg<DB, TB extends keyof DB, O> = GroupByExpression<DB, TB, O> | ReadonlyArray<GroupByExpression<DB, TB, O>> | ((eb: ExpressionBuilder<DB, TB>) => ReadonlyArray<GroupByExpression<DB, TB, O>>);
-export declare function parseGroupBy(groupBy: GroupByArg<any, any, any>): GroupByItemNode[];

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

@@ -1,2 +0,0 @@
-import { SchemableIdentifierNode } from '../operation-node/schemable-identifier-node.js';
-export declare function parseSchemableIdentifier(id: string): SchemableIdentifierNode;

package/dist/esm/parser/identifier-parser.js

@@ -1,20 +0,0 @@
-/// <reference types="./identifier-parser.d.ts" />
-import { SchemableIdentifierNode } from '../operation-node/schemable-identifier-node.js';
-export function parseSchemableIdentifier(id) {
-    const SCHEMA_SEPARATOR = '.';
-    if (id.includes(SCHEMA_SEPARATOR)) {
-        const parts = id.split(SCHEMA_SEPARATOR).map(trim);
-        if (parts.length === 2) {
-            return SchemableIdentifierNode.createWithSchema(parts[0], parts[1]);
-        }
-        else {
-            throw new Error(`invalid schemable identifier ${id}`);
-        }
-    }
-    else {
-        return SchemableIdentifierNode.create(id);
-    }
-}
-function trim(str) {
-    return str.trim();
-}

package/dist/esm/parser/insert-values-parser.d.ts

@@ -1,14 +0,0 @@
-import { ColumnNode } from '../operation-node/column-node.js';
-import { type ValueExpression } from './value-parser.js';
-import { ValuesNode } from '../operation-node/values-node.js';
-import type { NonNullableInsertKeys, NullableInsertKeys, InsertType } from '../util/column-type.js';
-import { type ExpressionBuilder } from '../expression/expression-builder.js';
-export type InsertObject<DB, TB extends keyof DB> = {
-    [C in NonNullableInsertKeys<DB[TB]>]: ValueExpression<DB, TB, InsertType<DB[TB][C]>>;
-} & {
-    [C in NullableInsertKeys<DB[TB]>]?: ValueExpression<DB, TB, InsertType<DB[TB][C]>> | undefined;
-};
-export type InsertObjectOrList<DB, TB extends keyof DB> = InsertObject<DB, TB> | ReadonlyArray<InsertObject<DB, TB>>;
-export type InsertObjectOrListFactory<DB, TB extends keyof DB, UT extends keyof DB = never> = (eb: ExpressionBuilder<DB, TB | UT>) => InsertObjectOrList<DB, TB>;
-export type InsertExpression<DB, TB extends keyof DB, UT extends keyof DB = never> = InsertObjectOrList<DB, TB> | InsertObjectOrListFactory<DB, TB, UT>;
-export declare function parseInsertExpression(arg: InsertExpression<any, any, any>): [ReadonlyArray<ColumnNode>, ValuesNode];

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

@@ -1,10 +0,0 @@
-import { JoinNode, type JoinType } from '../operation-node/join-node.js';
-import type { JoinBuilder } from '../query-builder/join-builder.js';
-import type { AnyColumn, AnyColumnWithTable, DrainOuterGeneric } from '../util/type-utils.js';
-import { type From, type FromTables } from './table-parser.js';
-export type JoinReferenceExpression<DB, TB extends keyof DB, TE> = DrainOuterGeneric<AnyJoinColumn<DB, TB, TE> | AnyJoinColumnWithTable<DB, TB, TE>>;
-export type JoinCallbackExpression<DB, TB extends keyof DB, TE> = (join: JoinBuilder<From<DB, TE>, FromTables<DB, TB, TE>>) => JoinBuilder<any, any>;
-type AnyJoinColumn<DB, TB extends keyof DB, TE> = AnyColumn<From<DB, TE>, FromTables<DB, TB, TE>>;
-type AnyJoinColumnWithTable<DB, TB extends keyof DB, TE> = AnyColumnWithTable<From<DB, TE>, FromTables<DB, TB, TE>>;
-export declare function parseJoin(joinType: JoinType, args: any[]): JoinNode;
-export {};

package/dist/esm/parser/merge-into-parser.d.ts

@@ -1,7 +0,0 @@
-import type { MergeQueryBuilder } from '../query-builder/merge-query-builder.js';
-import type { MergeResult } from '../query-builder/merge-result.js';
-import type { ShallowRecord } from '../util/type-utils.js';
-import type { ExtractTableAlias, SimpleTableReference } from './table-parser.js';
-export type MergeInto<DB, TE extends SimpleTableReference<DB>> = [TE] extends [
-    keyof DB
-] ? MergeQueryBuilder<DB, ExtractTableAlias<DB, TE>, MergeResult> : [TE] extends [`${infer T} as ${infer A}`] ? T extends keyof DB ? MergeQueryBuilder<DB & ShallowRecord<A, DB[T]>, A, MergeResult> : never : never;

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

@@ -1,9 +0,0 @@
-import type { InsertQueryNode } from '../operation-node/insert-query-node.js';
-import { type OperationNodeSource } from '../operation-node/operation-node-source.js';
-import type { OperationNode } from '../operation-node/operation-node.js';
-import { WhenNode } from '../operation-node/when-node.js';
-export declare function parseMergeWhen(type: {
-    isMatched: boolean;
-    bySource?: boolean;
-}, args?: any[], refRight?: boolean): WhenNode;
-export declare function parseMergeThen(result: 'delete' | 'do nothing' | OperationNodeSource | InsertQueryNode): OperationNode;

package/dist/esm/parser/on-commit-action-parse.d.ts

@@ -1,2 +0,0 @@
-import { type OnCommitAction } from '../operation-node/create-table-node.js';
-export declare function parseOnCommitAction(action: OnCommitAction): OnCommitAction;

package/dist/esm/parser/on-modify-action-parser.d.ts

@@ -1,2 +0,0 @@
-import { type OnModifyForeignAction } from '../operation-node/references-node.js';
-export declare function parseOnModifyForeignAction(action: OnModifyForeignAction): OnModifyForeignAction;

package/dist/esm/parser/on-modify-action-parser.js

@@ -1,8 +0,0 @@
-/// <reference types="./on-modify-action-parser.d.ts" />
-import { ON_MODIFY_FOREIGN_ACTIONS, } from '../operation-node/references-node.js';
-export function parseOnModifyForeignAction(action) {
-    if (ON_MODIFY_FOREIGN_ACTIONS.includes(action)) {
-        return action;
-    }
-    throw new Error(`invalid OnModifyForeignAction ${action}`);
-}

package/dist/esm/parser/order-by-parser.d.ts

@@ -1,25 +0,0 @@
-import { type DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
-import { type Expression } from '../expression/expression.js';
-import { OrderByItemNode } from '../operation-node/order-by-item-node.js';
-import { OrderByItemBuilder } from '../query-builder/order-by-item-builder.js';
-import { type ExpressionOrFactory } from './expression-parser.js';
-import { type ReferenceExpression, type StringReference } from './reference-parser.js';
-export type OrderByExpression<DB, TB extends keyof DB, O> = StringReference<DB, TB> | (keyof O & string) | ExpressionOrFactory<DB, TB, any> | DynamicReferenceBuilder<any>;
-export type OrderByModifiers = OrderByDirection | OrderByModifiersCallbackExpression;
-export type OrderByDirection = 'asc' | 'desc';
-export declare function isOrderByDirection(thing: unknown): thing is OrderByDirection;
-export type OrderByModifiersCallbackExpression = (builder: OrderByItemBuilder) => OrderByItemBuilder;
-/**
- * @deprecated performance reasons, use {@link OrderByExpression} instead.
- */
-export type DirectedOrderByStringReference<DB, TB extends keyof DB, O> = `${StringReference<DB, TB> | (keyof O & string)} ${OrderByDirection}`;
-/**
- * @deprecated replaced with {@link OrderByModifiers}
- */
-export type OrderByDirectionExpression = OrderByDirection | Expression<any>;
-/**
- * @deprecated use {@link OrderByExpression} instead.
- */
-export type UndirectedOrderByExpression<DB, TB extends keyof DB, O> = ReferenceExpression<DB, TB> | (keyof O & string);
-export declare function parseOrderBy(args: any[]): OrderByItemNode[];
-export declare function parseOrderByItem(expr: OrderByExpression<any, any, any>, modifiers?: OrderByModifiers): OrderByItemNode;

package/dist/esm/parser/parse-utils.d.ts

@@ -1,10 +0,0 @@
-import { type JoinType } from '../operation-node/join-node.js';
-import { JoinBuilder } from '../query-builder/join-builder.js';
-import { OverBuilder } from '../query-builder/over-builder.js';
-import { type SelectQueryBuilder } from '../query-builder/select-query-builder.js';
-import { QueryCreator } from '../query-creator.js';
-import { type TableExpression } from './table-parser.js';
-export declare function createSelectQueryBuilder(): SelectQueryBuilder<any, any, any>;
-export declare function createQueryCreator(): QueryCreator<any>;
-export declare function createJoinBuilder(joinType: JoinType, table: TableExpression<any, any>): JoinBuilder<any, any>;
-export declare function createOverBuilder(): OverBuilder<any, any>;

package/dist/esm/parser/partition-by-parser.d.ts

@@ -1,6 +0,0 @@
-import type { DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
-import { PartitionByItemNode } from '../operation-node/partition-by-item-node.js';
-import { type StringReference } from './reference-parser.js';
-export type PartitionByExpression<DB, TB extends keyof DB> = StringReference<DB, TB> | DynamicReferenceBuilder<any>;
-export type PartitionByExpressionOrList<DB, TB extends keyof DB> = ReadonlyArray<PartitionByExpression<DB, TB>> | PartitionByExpression<DB, TB>;
-export declare function parsePartitionBy(partitionBy: PartitionByExpressionOrList<any, any>): PartitionByItemNode[];

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

@@ -1,31 +0,0 @@
-import { AliasNode } from '../operation-node/alias-node.js';
-import { ColumnNode } from '../operation-node/column-node.js';
-import { ReferenceNode } from '../operation-node/reference-node.js';
-import type { AnyColumn, AnyColumnWithTable, ExtractColumnType } from '../util/type-utils.js';
-import type { SelectQueryBuilderExpression } from '../query-builder/select-query-builder-expression.js';
-import { type ExpressionOrFactory } from './expression-parser.js';
-import type { DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
-import type { SelectType } from '../util/column-type.js';
-import type { OperationNode } from '../operation-node/operation-node.js';
-import type { Expression } from '../expression/expression.js';
-import type { SimpleReferenceExpressionNode } from '../operation-node/simple-reference-expression-node.js';
-import { type OrderByDirection } from './order-by-parser.js';
-import { type JSONOperatorWith$ } from '../operation-node/operator-node.js';
-import { JSONReferenceNode } from '../operation-node/json-reference-node.js';
-export type StringReference<DB, TB extends keyof DB> = AnyColumn<DB, TB> | AnyColumnWithTable<DB, TB>;
-export type SimpleReferenceExpression<DB, TB extends keyof DB> = StringReference<DB, TB> | DynamicReferenceBuilder<any>;
-export type ReferenceExpression<DB, TB extends keyof DB> = SimpleReferenceExpression<DB, TB> | ExpressionOrFactory<DB, TB, any>;
-export type ReferenceExpressionOrList<DB, TB extends keyof DB> = ReferenceExpression<DB, TB> | ReadonlyArray<ReferenceExpression<DB, TB>>;
-export type ExtractTypeFromReferenceExpression<DB, TB extends keyof DB, RE, DV = unknown> = SelectType<ExtractRawTypeFromReferenceExpression<DB, TB, RE, DV>>;
-export type ExtractRawTypeFromReferenceExpression<DB, TB extends keyof DB, RE, DV = unknown> = RE extends string ? ExtractTypeFromStringReference<DB, TB, RE> : RE extends SelectQueryBuilderExpression<infer O> ? O[keyof O] | null : RE extends (qb: any) => SelectQueryBuilderExpression<infer O> ? O[keyof O] | null : RE extends Expression<infer O> ? O : RE extends (qb: any) => Expression<infer O> ? O : DV;
-export type ExtractTypeFromStringReference<DB, TB extends keyof DB, RE extends string, DV = unknown> = RE extends `${infer SC}.${infer T}.${infer C}` ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : RE extends `${infer T}.${infer C}` ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : RE extends AnyColumn<DB, TB> ? ExtractColumnType<DB, TB, RE> : DV;
-export type OrderedColumnName<C extends string> = C extends `${string} ${infer O}` ? O extends OrderByDirection ? C : never : C;
-export type ExtractColumnNameFromOrderedColumnName<C extends string> = C extends `${infer CL} ${infer O}` ? O extends OrderByDirection ? CL : never : C;
-export declare function parseSimpleReferenceExpression(exp: SimpleReferenceExpression<any, any>): SimpleReferenceExpressionNode;
-export declare function parseReferenceExpressionOrList(arg: ReferenceExpressionOrList<any, any>): OperationNode[];
-export declare function parseReferenceExpression(exp: ReferenceExpression<any, any>): OperationNode;
-export declare function parseJSONReference(ref: string, op: JSONOperatorWith$): JSONReferenceNode;
-export declare function parseStringReference(ref: string): ReferenceNode;
-export declare function parseAliasedStringReference(ref: string): SimpleReferenceExpressionNode | AliasNode;
-export declare function parseColumnName(column: AnyColumn<any, any>): ColumnNode;
-export declare function parseOrderedColumnName(column: string): OperationNode;

package/dist/esm/parser/reference-parser.js

@@ -1,95 +0,0 @@
-/// <reference types="./reference-parser.d.ts" />
-import { AliasNode } from '../operation-node/alias-node.js';
-import { ColumnNode } from '../operation-node/column-node.js';
-import { ReferenceNode } from '../operation-node/reference-node.js';
-import { TableNode } from '../operation-node/table-node.js';
-import { isReadonlyArray, isString } from '../util/object-utils.js';
-import { parseExpression, isExpressionOrFactory, } from './expression-parser.js';
-import { IdentifierNode } from '../operation-node/identifier-node.js';
-import { isOrderByDirection, parseOrderBy, } from './order-by-parser.js';
-import { OperatorNode, isJSONOperator, } from '../operation-node/operator-node.js';
-import { JSONReferenceNode } from '../operation-node/json-reference-node.js';
-import { JSONOperatorChainNode } from '../operation-node/json-operator-chain-node.js';
-import { JSONPathNode } from '../operation-node/json-path-node.js';
-export function parseSimpleReferenceExpression(exp) {
-    if (isString(exp)) {
-        return parseStringReference(exp);
-    }
-    return exp.toOperationNode();
-}
-export function parseReferenceExpressionOrList(arg) {
-    if (isReadonlyArray(arg)) {
-        return arg.map((it) => parseReferenceExpression(it));
-    }
-    else {
-        return [parseReferenceExpression(arg)];
-    }
-}
-export function parseReferenceExpression(exp) {
-    if (isExpressionOrFactory(exp)) {
-        return parseExpression(exp);
-    }
-    return parseSimpleReferenceExpression(exp);
-}
-export function parseJSONReference(ref, op) {
-    const referenceNode = parseStringReference(ref);
-    if (isJSONOperator(op)) {
-        return JSONReferenceNode.create(referenceNode, JSONOperatorChainNode.create(OperatorNode.create(op)));
-    }
-    const opWithoutLastChar = op.slice(0, -1);
-    if (isJSONOperator(opWithoutLastChar)) {
-        return JSONReferenceNode.create(referenceNode, JSONPathNode.create(OperatorNode.create(opWithoutLastChar)));
-    }
-    throw new Error(`Invalid JSON operator: ${op}`);
-}
-export function parseStringReference(ref) {
-    const COLUMN_SEPARATOR = '.';
-    if (!ref.includes(COLUMN_SEPARATOR)) {
-        return ReferenceNode.create(ColumnNode.create(ref));
-    }
-    const parts = ref.split(COLUMN_SEPARATOR).map(trim);
-    if (parts.length === 3) {
-        return parseStringReferenceWithTableAndSchema(parts);
-    }
-    if (parts.length === 2) {
-        return parseStringReferenceWithTable(parts);
-    }
-    throw new Error(`invalid column reference ${ref}`);
-}
-export function parseAliasedStringReference(ref) {
-    const ALIAS_SEPARATOR = ' as ';
-    if (ref.includes(ALIAS_SEPARATOR)) {
-        const [columnRef, alias] = ref.split(ALIAS_SEPARATOR).map(trim);
-        return AliasNode.create(parseStringReference(columnRef), IdentifierNode.create(alias));
-    }
-    else {
-        return parseStringReference(ref);
-    }
-}
-export function parseColumnName(column) {
-    return ColumnNode.create(column);
-}
-export function parseOrderedColumnName(column) {
-    const ORDER_SEPARATOR = ' ';
-    if (column.includes(ORDER_SEPARATOR)) {
-        const [columnName, order] = column.split(ORDER_SEPARATOR).map(trim);
-        if (!isOrderByDirection(order)) {
-            throw new Error(`invalid order direction "${order}" next to "${columnName}"`);
-        }
-        return parseOrderBy([columnName, order])[0];
-    }
-    else {
-        return parseColumnName(column);
-    }
-}
-function parseStringReferenceWithTableAndSchema(parts) {
-    const [schema, table, column] = parts;
-    return ReferenceNode.create(ColumnNode.create(column), TableNode.createWithSchema(schema, table));
-}
-function parseStringReferenceWithTable(parts) {
-    const [table, column] = parts;
-    return ReferenceNode.create(ColumnNode.create(column), TableNode.create(table));
-}
-function trim(str) {
-    return str.trim();
-}

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

@@ -1,8 +0,0 @@
-import type { DeleteResult } from '../query-builder/delete-result.js';
-import type { InsertResult } from '../query-builder/insert-result.js';
-import type { MergeResult } from '../query-builder/merge-result.js';
-import type { UpdateResult } from '../query-builder/update-result.js';
-import type { Selection, AllSelection, CallbackSelection } from './select-parser.js';
-export type ReturningRow<DB, TB extends keyof DB, O, SE> = O extends InsertResult | DeleteResult | UpdateResult | MergeResult ? Selection<DB, TB, SE> : O & Selection<DB, TB, SE>;
-export type ReturningCallbackRow<DB, TB extends keyof DB, O, CB> = O extends InsertResult | DeleteResult | UpdateResult | MergeResult ? CallbackSelection<DB, TB, CB> : O & CallbackSelection<DB, TB, CB>;
-export type ReturningAllRow<DB, TB extends keyof DB, O> = O extends InsertResult | DeleteResult | UpdateResult | MergeResult ? AllSelection<DB, TB> : O & AllSelection<DB, TB>;

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

@@ -1,4 +0,0 @@
-import { RawNode } from '../operation-node/raw-node.js';
-export type RollbackToSavepoint<S extends string[], SN extends S[number]> = S extends [...infer L, infer R] ? R extends SN ? S : RollbackToSavepoint<L extends string[] ? L : never, SN> : never;
-export type ReleaseSavepoint<S extends string[], SN extends S[number]> = S extends [...infer L, infer R] ? R extends SN ? L : ReleaseSavepoint<L extends string[] ? L : never, SN> : never;
-export declare function parseSavepointCommand(command: string, savepointName: string): RawNode;

package/dist/esm/parser/select-from-parser.d.ts

@@ -1,6 +0,0 @@
-import type { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
-import type { ShallowRecord } from '../util/type-utils.js';
-import type { ExtractTableAlias, From, FromTables, TableExpressionOrList } from './table-parser.js';
-export type SelectFrom<DB, TB extends keyof DB, TE extends TableExpressionOrList<DB, TB>> = [TE] extends [keyof DB] ? SelectQueryBuilder<DB, TB | ExtractTableAlias<DB, TE>, {}> : [
-    TE
-] extends [`${infer T} as ${infer A}`] ? T extends keyof DB ? SelectQueryBuilder<DB & ShallowRecord<A, DB[T]>, TB | A, {}> : never : TE extends ReadonlyArray<infer T> ? SelectQueryBuilder<From<DB, T>, FromTables<DB, TB, T>, {}> : SelectQueryBuilder<From<DB, TE>, FromTables<DB, TB, TE>, {}>;