kysely 0.22.0 → 0.23.1

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,10 +1,7 @@
-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';
-import { AggregateFunctionBuilder, AliasedAggregateFunctionBuilder } from '../query-builder/aggregate-function-builder.js';
 /**
  * Given an object type, extracts the union of all value types.
  */
@@ -100,24 +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 AnyAliasedAggregateFunctionBuilder = AliasedAggregateFunctionBuilder<any, any, 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 AggregateFunctionBuilderFactory<DB, TB extends keyof DB, O = unknown> = (qb: ExpressionBuilder<DB, TB>) => AggregateFunctionBuilder<DB, TB, O>;
-export declare type AliasedAggregateFunctionBuilderFactory<DB, TB extends keyof DB> = (qb: ExpressionBuilder<DB, TB>) => AnyAliasedAggregateFunctionBuilder;
 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.
@@ -139,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.22.0",
+  "version": "0.23.1",
   "description": "Type safe SQL query builder",
   "repository": {
     "type": "git",

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/filter-node.js

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

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

@@ -1,18 +0,0 @@
-import { AggregateFunctionNode } from './aggregate-function-node.js';
-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 | AggregateFunctionNode;
-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/parser/complex-expression-parser.d.ts

@@ -1,12 +0,0 @@
-import { AggregateFunctionNode } from '../operation-node/aggregate-function-node.js';
-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 { AggregateFunctionBuilder } from '../query-builder/aggregate-function-builder.js';
-import { RawBuilder } from '../raw-builder/raw-builder.js';
-import { AliasedQueryBuilderFactory, AliasedRawBuilderFactory, AnyAliasedQueryBuilder, AnyAliasedRawBuilder, AnySelectQueryBuilder, SelectQueryBuilderFactory, RawBuilderFactory, AggregateFunctionBuilderFactory, AliasedAggregateFunctionBuilderFactory, AnyAliasedAggregateFunctionBuilder } 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> | AggregateFunctionBuilder<DB, TB, V> | AggregateFunctionBuilderFactory<DB, TB, V>;
-export declare type AliasedComplexExpression<DB, TB extends keyof DB> = AnyAliasedQueryBuilder | AliasedQueryBuilderFactory<DB, TB> | AnyAliasedRawBuilder | AliasedRawBuilderFactory<DB, TB> | AnyAliasedAggregateFunctionBuilder | AliasedAggregateFunctionBuilderFactory<DB, TB>;
-export declare function parseComplexExpression(exp: ComplexExpression<any, any>): SelectQueryNode | RawNode | AggregateFunctionNode;
-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/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,18 +0,0 @@
-import { AggregateFunctionNode } from './aggregate-function-node.js';
-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 | AggregateFunctionNode;
-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/parser/complex-expression-parser.d.ts

@@ -1,12 +0,0 @@
-import { AggregateFunctionNode } from '../operation-node/aggregate-function-node.js';
-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 { AggregateFunctionBuilder } from '../query-builder/aggregate-function-builder.js';
-import { RawBuilder } from '../raw-builder/raw-builder.js';
-import { AliasedQueryBuilderFactory, AliasedRawBuilderFactory, AnyAliasedQueryBuilder, AnyAliasedRawBuilder, AnySelectQueryBuilder, SelectQueryBuilderFactory, RawBuilderFactory, AggregateFunctionBuilderFactory, AliasedAggregateFunctionBuilderFactory, AnyAliasedAggregateFunctionBuilder } 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> | AggregateFunctionBuilder<DB, TB, V> | AggregateFunctionBuilderFactory<DB, TB, V>;
-export declare type AliasedComplexExpression<DB, TB extends keyof DB> = AnyAliasedQueryBuilder | AliasedQueryBuilderFactory<DB, TB> | AnyAliasedRawBuilder | AliasedRawBuilderFactory<DB, TB> | AnyAliasedAggregateFunctionBuilder | AliasedAggregateFunctionBuilderFactory<DB, TB>;
-export declare function parseComplexExpression(exp: ComplexExpression<any, any>): SelectQueryNode | RawNode | AggregateFunctionNode;
-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);
-    },
-});