kysely 0.3.4 → 0.3.9

package/.prettierignore

@@ -0,0 +1 @@
+*.md

package/README.md

@@ -1,3 +1,6 @@
+[![Discord](https://img.shields.io/discord/890118421587578920)](https://discord.gg/C9aJ49mCra)
+[![Tests](https://github.com/koskimas/kysely/actions/workflows/test.yml/badge.svg)](https://github.com/koskimas/kysely)
+
 # [Kysely](https://koskimas.github.io/kysely/index.html)
 
 A type-safe and autocompletion-friendly typescript SQL query builder for node.js. Heavily inspired by
@@ -26,6 +29,12 @@ Kysely is still young and some useful methods and modules are not yet implemente
 Kysely, please open an issue as soon as you can't find something you want to use.
 
 - [API reference](https://koskimas.github.io/kysely/index.html)
+    - [select](https://koskimas.github.io/kysely/classes/QueryBuilder.html#select)
+    - [where](https://koskimas.github.io/kysely/classes/QueryBuilder.html#where)
+    - [join](https://koskimas.github.io/kysely/classes/QueryBuilder.html#innerJoin)
+    - [insert](https://koskimas.github.io/kysely/classes/QueryBuilder.html#values)
+    - [update](https://koskimas.github.io/kysely/classes/QueryBuilder.html#set)
+    - [delete](https://koskimas.github.io/kysely/classes/Kysely.html#deleteFrom)
 - [Migrations](#migrations)
 
 # Installation

package/dist/cjs/dialect/postgres/postgres-driver.js

@@ -26,6 +26,7 @@ class PostgresDriver extends driver_js_1.Driver {
             port: cfg.port,
             user: cfg.user,
             password: cfg.password,
+            ssl: cfg.ssl,
             // Pool options.
             connectionTimeoutMillis: cfg.pool.connectionTimeoutMillis,
             idleTimeoutMillis: cfg.pool.idleTimeoutMillis,
@@ -63,7 +64,7 @@ exports.PostgresDriver = PostgresDriver;
 async function importPgPool() {
     try {
         // For this to work with both esm and cjs modules we need
-        // this hacky craph here.
+        // this hacky crap here.
         const pg = (await Promise.resolve().then(() => require('pg')));
         if (object_utils_js_1.isFunction(pg.Pool)) {
             return pg.Pool;

package/dist/cjs/driver/driver-config.d.ts

@@ -1,3 +1,5 @@
+/// <reference types="node" />
+import { SecureContextOptions } from 'tls';
 import { DatabaseConnection } from './database-connection.js';
 export interface DriverConfig {
     /**
@@ -24,6 +26,10 @@ export interface DriverConfig {
      * Connection pooling config.
      */
     pool?: PoolConfig;
+    /**
+     * Optional SSL configuration.
+     */
+    ssl?: SecureContextOptions;
 }
 export interface PoolConfig {
     /**

package/dist/cjs/index.d.ts

@@ -95,4 +95,15 @@ export * from './operation-node/offset-node.js';
 export * from './operation-node//on-conflict-node.js';
 export * from './operation-node/operation-node.js';
 export * from './operation-node/operation-node-source.js';
+export * from './operation-node/order-by-node.js';
 export * from './util/compilable.js';
+export { AnyColumn } from './query-builder/type-utils.js';
+export { SelectExpression, SelectExpressionOrList, } from './parser/select-parser';
+export { ReferenceExpression, ReferenceExpressionOrList, } from './parser/reference-parser';
+export { ValueExpression, ValueExpressionOrList } from './parser/value-parser';
+export { ExistsExpression, FilterOperator } from './parser/filter-parser';
+export { TableExpression } from './parser/table-parser';
+export { JoinReferenceExpression, JoinCallbackExpression, } from './parser/join-parser';
+export { InsertObject } from './parser/insert-values-parser';
+export { MutationObject } from './parser/mutation-parser';
+export { OrderByExpression } from './parser/order-by-parser';

package/dist/cjs/index.js

@@ -107,4 +107,5 @@ __exportStar(require("./operation-node/offset-node.js"), exports);
 __exportStar(require("./operation-node//on-conflict-node.js"), exports);
 __exportStar(require("./operation-node/operation-node.js"), exports);
 __exportStar(require("./operation-node/operation-node-source.js"), exports);
+__exportStar(require("./operation-node/order-by-node.js"), exports);
 __exportStar(require("./util/compilable.js"), exports);

package/dist/cjs/kysely.d.ts

@@ -8,6 +8,7 @@ import { MigrationModule } from './migration/migration.js';
 import { QueryExecutor } from './query-executor/query-executor.js';
 import { QueryCreator } from './query-creator.js';
 import { KyselyPlugin } from './plugin/plugin.js';
+import { GeneratedPlaceholder } from './query-builder/type-utils.js';
 /**
  * The main Kysely class.
  *
@@ -62,6 +63,30 @@ export declare class Kysely<DB> extends QueryCreator<DB> {
      * passing in dynamic values for the queries.
      */
     get dynamic(): DynamicModule;
+    /**
+     * A value to be used in place of columns that are generated in the database
+     * when inserting rows.
+     *
+     * @example
+     * In this example the `Person` table has non-null properties `id` and `created_at`
+     * which are both automatically genereted by the database. Since their types are
+     * `number` and `string` respectively instead of `number | null` and `string | null`
+     * the `values` method requires you to give a value for them. the `generated`
+     * placeholder can be used in these cases.
+     *
+     * ```ts
+     * await db.insertInto('person')
+     *   .values({
+     *     id: db.generated,
+     *     created_at: db.generated,
+     *     first_name: 'Jennifer',
+     *     last_name: 'Aniston',
+     *     gender: 'female'
+     *   })
+     *   .execute()
+     * ```
+     */
+    get generated(): GeneratedPlaceholder;
     /**
      * Starts a transaction. If the callback throws the transaction is rolled back,
      * otherwise it's committed.

package/dist/cjs/kysely.js

@@ -11,6 +11,7 @@ const driver_internal_js_1 = require("./driver/driver-internal.js");
 const migration_js_1 = require("./migration/migration.js");
 const query_executor_js_1 = require("./query-executor/query-executor.js");
 const query_creator_js_1 = require("./query-creator.js");
+const generated_placeholder_js_1 = require("./util/generated-placeholder.js");
 /**
  * The main Kysely class.
  *
@@ -97,6 +98,32 @@ class Kysely extends query_creator_js_1.QueryCreator {
     get dynamic() {
         return new dynamic_js_1.DynamicModule();
     }
+    /**
+     * A value to be used in place of columns that are generated in the database
+     * when inserting rows.
+     *
+     * @example
+     * In this example the `Person` table has non-null properties `id` and `created_at`
+     * which are both automatically genereted by the database. Since their types are
+     * `number` and `string` respectively instead of `number | null` and `string | null`
+     * the `values` method requires you to give a value for them. the `generated`
+     * placeholder can be used in these cases.
+     *
+     * ```ts
+     * await db.insertInto('person')
+     *   .values({
+     *     id: db.generated,
+     *     created_at: db.generated,
+     *     first_name: 'Jennifer',
+     *     last_name: 'Aniston',
+     *     gender: 'female'
+     *   })
+     *   .execute()
+     * ```
+     */
+    get generated() {
+        return generated_placeholder_js_1.generatedPlaceholder;
+    }
     /**
      * Starts a transaction. If the callback throws the transaction is rolled back,
      * otherwise it's committed.

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

@@ -112,11 +112,12 @@ class OperationNodeTransformer {
             from: this.transformNode(node.from),
             selections: this.transformNodeList(node.selections),
             distinctOnSelections: this.transformNodeList(node.distinctOnSelections),
+            isDistinct: node.isDistinct,
             joins: this.transformNodeList(node.joins),
             groupBy: this.transformNode(node.groupBy),
             orderBy: this.transformNode(node.orderBy),
             where: this.transformNode(node.where),
-            modifier: node.modifier,
+            modifiers: node.modifiers,
             limit: this.transformNode(node.limit),
             offset: this.transformNode(node.offset),
             with: this.transformNode(node.with),

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

@@ -12,17 +12,18 @@ import { OrderByNode } from './order-by-node.js';
 import { SelectionNode } from './selection-node.js';
 import { WhereNode } from './where-node.js';
 import { WithNode } from './with-node.js';
-export declare type SelectModifier = 'Distinct' | 'ForUpdate' | 'ForNoKeyUpdate' | 'ForShare' | 'ForKeyShare' | 'NoWait' | 'SkipLocked';
+export declare type SelectModifier = 'ForUpdate' | 'ForNoKeyUpdate' | 'ForShare' | 'ForKeyShare' | 'NoWait' | 'SkipLocked';
 export interface SelectQueryNode extends OperationNode {
     readonly kind: 'SelectQueryNode';
     readonly from: FromNode;
     readonly selections?: ReadonlyArray<SelectionNode>;
     readonly distinctOnSelections?: ReadonlyArray<SelectionNode>;
+    readonly isDistinct?: boolean;
     readonly joins?: ReadonlyArray<JoinNode>;
     readonly groupBy?: GroupByNode;
     readonly orderBy?: OrderByNode;
     readonly where?: WhereNode;
-    readonly modifier?: SelectModifier;
+    readonly modifiers?: ReadonlyArray<SelectModifier>;
     readonly limit?: LimitNode;
     readonly offset?: OffsetNode;
     readonly with?: WithNode;
@@ -42,4 +43,5 @@ export declare const selectQueryNode: Readonly<{
     cloneWithLimit(selectNode: SelectQueryNode, limit: LimitNode): SelectQueryNode;
     cloneWithOffset(selectNode: SelectQueryNode, offset: OffsetNode): SelectQueryNode;
     cloneWithHaving(selectNode: SelectQueryNode, op: 'and' | 'or', filter: HavingNodeChild): SelectQueryNode;
+    cloneWithDistinct(selectNode: SelectQueryNode): SelectQueryNode;
 }>;

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

@@ -39,7 +39,9 @@ exports.selectQueryNode = object_utils_js_1.freeze({
     cloneWithModifier(select, modifier) {
         return object_utils_js_1.freeze({
             ...select,
-            modifier,
+            modifiers: select.modifiers
+                ? object_utils_js_1.freeze([...select.modifiers, modifier])
+                : object_utils_js_1.freeze([modifier]),
         });
     },
     cloneWithOrderByItem(selectNode, item) {
@@ -78,4 +80,10 @@ exports.selectQueryNode = object_utils_js_1.freeze({
                 : having_node_js_1.havingNode.create(filter),
         });
     },
+    cloneWithDistinct(selectNode) {
+        return object_utils_js_1.freeze({
+            ...selectNode,
+            isDistinct: true,
+        });
+    },
 });

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

@@ -1,14 +1,13 @@
 import { FilterNode } from '../operation-node/filter-node.js';
-import { RawBuilder } from '../raw-builder/raw-builder.js';
-import { AnyQueryBuilder, QueryBuilderFactory, RawBuilderFactory } from '../query-builder/type-utils.js';
+import { AnyQueryBuilder, AnyRawBuilder, QueryBuilderFactory, RawBuilderFactory } from '../query-builder/type-utils.js';
 import { Operator } from '../operation-node/operator-node.js';
 import { ReferenceExpression } from './reference-parser.js';
 import { JoinBuilder } from '../query-builder/join-builder.js';
 import { FilterExpressionNode } from '../operation-node/operation-node-utils.js';
-export declare type ExistsFilterArg<DB, TB extends keyof DB> = AnyQueryBuilder | QueryBuilderFactory<DB, TB> | RawBuilder<any> | RawBuilderFactory<DB, TB>;
-export declare type FilterOperatorArg = Operator | RawBuilder<any>;
+export declare type ExistsExpression<DB, TB extends keyof DB> = AnyQueryBuilder | QueryBuilderFactory<DB, TB> | AnyRawBuilder | RawBuilderFactory<DB, TB>;
+export declare type FilterOperator = Operator | AnyRawBuilder;
 export declare type FilterType = 'Where' | 'On' | 'Having';
-export declare function parseFilterArgs(filterType: FilterType, args: any[]): FilterExpressionNode;
-export declare function parseReferenceFilterArgs(lhs: ReferenceExpression<any, any>, op: FilterOperatorArg, rhs: ReferenceExpression<any, any>): FilterNode;
-export declare function parseExistsFilterArgs(type: 'exists' | 'not exists', arg: ExistsFilterArg<any, any>): FilterNode;
+export declare function parseFilter(filterType: FilterType, args: any[]): FilterExpressionNode;
+export declare function parseReferenceFilter(lhs: ReferenceExpression<any, any>, op: FilterOperator, rhs: ReferenceExpression<any, any>): FilterNode;
+export declare function parseExistExpression(type: 'exists' | 'not exists', arg: ExistsExpression<any, any>): FilterNode;
 export declare function createEmptyJoinBuilder(): JoinBuilder<any, any>;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createEmptyJoinBuilder = exports.parseExistsFilterArgs = exports.parseReferenceFilterArgs = exports.parseFilterArgs = void 0;
+exports.createEmptyJoinBuilder = exports.parseExistExpression = exports.parseReferenceFilter = exports.parseFilter = 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");
@@ -15,12 +15,12 @@ const query_builder_js_1 = require("../query-builder/query-builder.js");
 const join_builder_js_1 = require("../query-builder/join-builder.js");
 const table_parser_js_1 = require("./table-parser.js");
 const join_node_js_1 = require("../operation-node/join-node.js");
-const index_js_1 = require("../index.js");
-function parseFilterArgs(filterType, args) {
+const value_node_js_1 = require("../operation-node/value-node.js");
+function parseFilter(filterType, args) {
     if (args.length === 3) {
         return parseThreeArgFilter(args[0], args[1], args[2]);
     }
-    else if (args.length === 1) {
+    else if (args.length === 1 && object_utils_js_1.isFunction(args[0])) {
         if (filterType === 'Where') {
             return parseWhereGrouper(args[0]);
         }
@@ -35,12 +35,12 @@ function parseFilterArgs(filterType, args) {
         throw new Error(`invalid arguments passed to a filter method ${JSON.stringify(args)}`);
     }
 }
-exports.parseFilterArgs = parseFilterArgs;
-function parseReferenceFilterArgs(lhs, op, rhs) {
+exports.parseFilter = parseFilter;
+function parseReferenceFilter(lhs, op, rhs) {
     return filter_node_js_1.filterNode.create(reference_parser_js_1.parseReferenceExpression(lhs), parseFilterOperator(op), reference_parser_js_1.parseReferenceExpression(rhs));
 }
-exports.parseReferenceFilterArgs = parseReferenceFilterArgs;
-function parseExistsFilterArgs(type, arg) {
+exports.parseReferenceFilter = parseReferenceFilter;
+function parseExistExpression(type, arg) {
     const node = object_utils_js_1.isFunction(arg)
         ? arg(new sub_query_builder_js_1.SubQueryBuilder()).toOperationNode()
         : arg.toOperationNode();
@@ -49,7 +49,7 @@ function parseExistsFilterArgs(type, arg) {
     }
     return filter_node_js_1.filterNode.create(undefined, operator_node_js_1.operatorNode.create(type), node);
 }
-exports.parseExistsFilterArgs = parseExistsFilterArgs;
+exports.parseExistExpression = parseExistExpression;
 function parseThreeArgFilter(left, op, right) {
     if ((op === 'is' || op === 'is not') && (object_utils_js_1.isNull(right) || object_utils_js_1.isBoolean(right))) {
         return parseIsFilter(left, op, right);
@@ -57,7 +57,7 @@ function parseThreeArgFilter(left, op, right) {
     return filter_node_js_1.filterNode.create(reference_parser_js_1.parseReferenceExpression(left), parseFilterOperator(op), value_parser_js_1.parseValueExpressionOrList(right));
 }
 function parseIsFilter(left, op, right) {
-    return filter_node_js_1.filterNode.create(reference_parser_js_1.parseReferenceExpression(left), parseFilterOperator(op), index_js_1.valueNode.createImmediate(right));
+    return filter_node_js_1.filterNode.create(reference_parser_js_1.parseReferenceExpression(left), parseFilterOperator(op), value_node_js_1.valueNode.createImmediate(right));
 }
 function parseFilterOperator(op) {
     if (operation_node_source_js_1.isOperationNodeSource(op)) {
@@ -72,9 +72,6 @@ function parseFilterOperator(op) {
     throw new Error(`invalid comparison operator ${JSON.stringify(op)} passed to a filter method`);
 }
 function parseWhereGrouper(grouper) {
-    if (!object_utils_js_1.isFunction(grouper)) {
-        throw new Error(`invalid call to queryBuilder.where: ${JSON.stringify(grouper)}`);
-    }
     const query = grouper(query_builder_js_1.createEmptySelectQuery());
     const queryNode = query.toOperationNode();
     if (!queryNode.where) {
@@ -83,9 +80,6 @@ function parseWhereGrouper(grouper) {
     return parens_node_js_1.parensNode.create(queryNode.where.where);
 }
 function parseHavingGrouper(grouper) {
-    if (!object_utils_js_1.isFunction(grouper)) {
-        throw new Error(`invalid call to queryBuilder.having: ${JSON.stringify(grouper)}`);
-    }
     const query = grouper(query_builder_js_1.createEmptySelectQuery());
     const queryNode = query.toOperationNode();
     if (!queryNode.having) {
@@ -94,9 +88,6 @@ function parseHavingGrouper(grouper) {
     return parens_node_js_1.parensNode.create(queryNode.having.having);
 }
 function parseOnGrouper(grouper) {
-    if (!object_utils_js_1.isFunction(grouper)) {
-        throw new Error(`invalid call to joinBuilder.on: ${JSON.stringify(grouper)}`);
-    }
     const joinBuilder = grouper(createEmptyJoinBuilder());
     const joinNode = joinBuilder.toOperationNode();
     if (!joinNode.on) {

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

@@ -1,3 +1,11 @@
 import { ColumnNode } from '../operation-node/column-node.js';
 import { InsertValuesNode } from '../operation-node/insert-query-node.js';
-export declare function parseInsertValuesArgs(args: any): [ReadonlyArray<ColumnNode>, ReadonlyArray<InsertValuesNode>];
+import { AnyQueryBuilder, AnyRawBuilder, GeneratedPlaceholder } from '../query-builder/type-utils.js';
+import { PrimitiveValue } from '../util/object-utils.js';
+export declare type InsertObject<DB, TB extends keyof DB> = {
+    [C in keyof DB[TB]]: InsertValueExpression<DB[TB][C]>;
+};
+export declare type InsertObjectOrList<DB, TB extends keyof DB> = InsertObject<DB, TB> | InsertObject<DB, TB>[];
+declare type InsertValueExpression<T extends PrimitiveValue> = T | AnyQueryBuilder | AnyRawBuilder | GeneratedPlaceholder;
+export declare function parseInsertObjectOrList(args: InsertObjectOrList<any, any>): [ReadonlyArray<ColumnNode>, ReadonlyArray<InsertValuesNode>];
+export {};

package/dist/cjs/parser/insert-values-parser.js

@@ -1,21 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseInsertValuesArgs = void 0;
+exports.parseInsertObjectOrList = void 0;
 const column_node_js_1 = require("../operation-node/column-node.js");
 const primitive_value_list_node_js_1 = require("../operation-node/primitive-value-list-node.js");
 const value_list_node_js_1 = require("../operation-node/value-list-node.js");
+const generated_placeholder_js_1 = require("../util/generated-placeholder.js");
 const object_utils_js_1 = require("../util/object-utils.js");
 const mutation_parser_js_1 = require("./mutation-parser.js");
-function parseInsertValuesArgs(args) {
+function parseInsertObjectOrList(args) {
     return parseInsertColumnsAndValues(Array.isArray(args) ? args : [args]);
 }
-exports.parseInsertValuesArgs = parseInsertValuesArgs;
+exports.parseInsertObjectOrList = parseInsertObjectOrList;
 function parseInsertColumnsAndValues(rows) {
     const columns = [];
     const values = [];
     for (const row of rows) {
         for (const column of Object.keys(row)) {
-            if (!columns.includes(column)) {
+            const value = row[column];
+            if (!columns.includes(column) && !generated_placeholder_js_1.isGeneratedPlaceholder(value)) {
                 columns.push(column);
             }
         }
@@ -24,7 +26,9 @@ function parseInsertColumnsAndValues(rows) {
         const rowValues = columns.map(() => null);
         for (const column of Object.keys(row)) {
             const columnIdx = columns.indexOf(column);
-            rowValues[columnIdx] = row[column];
+            if (columnIdx !== -1) {
+                rowValues[columnIdx] = row[column];
+            }
         }
         if (rowValues.every(object_utils_js_1.isPrimitive)) {
             values.push(primitive_value_list_node_js_1.primitiveValueListNode.create(rowValues));

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

@@ -2,6 +2,6 @@ import { JoinNode, JoinType } from '../operation-node/join-node.js';
 import { AnyColumn, AnyColumnWithTable } from '../query-builder/type-utils.js';
 import { ExtractAliasFromTableExpression, TableExpressionDatabaseType } from './table-parser.js';
 import { JoinBuilder } from '../query-builder/join-builder.js';
-export declare type JoinReferenceArg<DB, TB extends keyof DB, F> = AnyColumn<TableExpressionDatabaseType<DB, F>, TB | ExtractAliasFromTableExpression<DB, F>> | AnyColumnWithTable<TableExpressionDatabaseType<DB, F>, TB | ExtractAliasFromTableExpression<DB, F>>;
-export declare type JoinCallbackArg<DB, TB extends keyof DB, F> = (join: JoinBuilder<TableExpressionDatabaseType<DB, F>, TB | ExtractAliasFromTableExpression<DB, F>>) => JoinBuilder<any, any>;
+export declare type JoinReferenceExpression<DB, TB extends keyof DB, F> = AnyColumn<TableExpressionDatabaseType<DB, F>, TB | ExtractAliasFromTableExpression<DB, F>> | AnyColumnWithTable<TableExpressionDatabaseType<DB, F>, TB | ExtractAliasFromTableExpression<DB, F>>;
+export declare type JoinCallbackExpression<DB, TB extends keyof DB, F> = (join: JoinBuilder<TableExpressionDatabaseType<DB, F>, TB | ExtractAliasFromTableExpression<DB, F>>) => JoinBuilder<any, any>;
 export declare function parseJoinArgs(joinType: JoinType, args: any[]): JoinNode;

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

@@ -24,5 +24,5 @@ function parseCallbackJoin(joinType, from, callback) {
 }
 function parseSingleOnJoin(joinType, from, lhsColumn, rhsColumn) {
     const tableNode = table_parser_js_1.parseTableExpression(from);
-    return join_node_js_1.joinNode.cloneWithOn(join_node_js_1.joinNode.create(joinType, tableNode), 'and', filter_parser_js_1.parseReferenceFilterArgs(lhsColumn, '=', rhsColumn));
+    return join_node_js_1.joinNode.cloneWithOn(join_node_js_1.joinNode.create(joinType, tableNode), 'and', filter_parser_js_1.parseReferenceFilter(lhsColumn, '=', rhsColumn));
 }

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

@@ -1,11 +1,10 @@
 import { RawNode } from '../operation-node/raw-node.js';
 import { SelectQueryNode } from '../operation-node/select-query-node.js';
 import { ValueNode } from '../operation-node/value-node.js';
-import { AnyQueryBuilder } from '../query-builder/type-utils.js';
-import { RawBuilder } from '../raw-builder/raw-builder.js';
+import { AnyQueryBuilder, AnyRawBuilder } from '../query-builder/type-utils.js';
 import { PrimitiveValue } from '../util/object-utils.js';
 export declare type MutationObject<DB, TB extends keyof DB> = {
     [C in keyof DB[TB]]?: MutationValueExpression<DB[TB][C]>;
 };
-export declare type MutationValueExpression<T extends PrimitiveValue> = T | AnyQueryBuilder | RawBuilder<any>;
+export declare type MutationValueExpression<T extends PrimitiveValue> = T | AnyQueryBuilder | AnyRawBuilder;
 export declare function parseMutationValueExpression(value: MutationValueExpression<PrimitiveValue>): ValueNode | RawNode | SelectQueryNode;

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

@@ -2,13 +2,18 @@ import { AliasNode } from '../operation-node/alias-node.js';
 import { ColumnNode } from '../operation-node/column-node.js';
 import { ReferenceExpressionNode } from '../operation-node/operation-node-utils.js';
 import { ReferenceNode } from '../operation-node/reference-node.js';
-import { RawBuilder } from '../raw-builder/raw-builder.js';
-import { AnyColumn, AnyColumnWithTable, AnyQueryBuilder, QueryBuilderFactory, RawBuilderFactory } from '../query-builder/type-utils.js';
+import { PrimitiveValue } from '../util/object-utils.js';
+import { AnyColumn, AnyColumnWithTable, AnyQueryBuilder, AnyRawBuilder, QueryBuilderFactory, RawBuilderFactory, RowType, ValueType } from '../query-builder/type-utils.js';
 import { DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
-export declare type ReferenceExpression<DB, TB extends keyof DB> = AnyColumn<DB, TB> | AnyColumnWithTable<DB, TB> | AnyQueryBuilder | QueryBuilderFactory<DB, TB> | RawBuilder<any> | RawBuilderFactory<DB, TB> | DynamicReferenceBuilder<any>;
+import { RawBuilder } from '../raw-builder/raw-builder.js';
+import { QueryBuilder } from '../query-builder/query-builder.js';
+export declare type ReferenceExpression<DB, TB extends keyof DB> = AnyColumn<DB, TB> | AnyColumnWithTable<DB, TB> | AnyQueryBuilder | QueryBuilderFactory<DB, TB> | AnyRawBuilder | RawBuilderFactory<DB, TB> | DynamicReferenceBuilder<any>;
 export declare type ReferenceExpressionOrList<DB, TB extends keyof DB> = ReferenceExpression<DB, TB> | ReferenceExpression<DB, TB>[];
+export declare type ExtractTypeFromReferenceExpression<DB, TB extends keyof DB, RE> = RE extends string ? ExtractTypeFromStringReference<DB, TB, RE> : RE extends RawBuilder<infer O> ? O : RE extends (qb: any) => RawBuilder<infer O> ? O : RE extends QueryBuilder<any, any, infer O> ? ValueType<O> : RE extends (qb: any) => QueryBuilder<any, any, infer O> ? ValueType<O> : PrimitiveValue;
+declare type ExtractTypeFromStringReference<DB, TB extends keyof DB, S extends string, R = RowType<DB, TB>> = S extends `${infer SC}.${infer T}.${infer C}` ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : S extends `${infer T}.${infer C}` ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : S extends keyof R ? R[S] : PrimitiveValue;
 export declare function parseReferenceExpressionOrList(arg: ReferenceExpressionOrList<any, any>): ReferenceExpressionNode[];
 export declare function parseReferenceExpression(arg: ReferenceExpression<any, any>): ReferenceExpressionNode;
 export declare function parseStringReference(str: string): ColumnNode | ReferenceNode;
 export declare function parseAliasedStringReference(str: string): ColumnNode | ReferenceNode | AliasNode;
 export declare function parseColumnName(column: AnyColumn<any, any>): ColumnNode;
+export {};

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

@@ -1,7 +1,7 @@
 import { QueryBuilder } from '../query-builder/query-builder.js';
 import { DeleteResultTypeTag, InsertResultTypeTag, UpdateResultTypeTag } from '../query-builder/type-utils.js';
-import { SelectResultType } from './select-parser.js';
+import { Selection } from './select-parser.js';
 /**
  * `returning` method output query builder type
  */
-export declare type QueryBuilderWithReturning<DB, TB extends keyof DB, O, S> = QueryBuilder<DB, TB, O extends InsertResultTypeTag ? SelectResultType<DB, TB, S> : O extends DeleteResultTypeTag ? SelectResultType<DB, TB, S> : O extends UpdateResultTypeTag ? SelectResultType<DB, TB, S> : O & SelectResultType<DB, TB, S>>;
+export declare type QueryBuilderWithReturning<DB, TB extends keyof DB, O, S> = QueryBuilder<DB, TB, O extends InsertResultTypeTag ? Selection<DB, TB, S> : O extends DeleteResultTypeTag ? Selection<DB, TB, S> : O extends UpdateResultTypeTag ? Selection<DB, TB, S> : O & Selection<DB, TB, S>>;

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

@@ -1,29 +1,30 @@
 import { AliasedRawBuilder } from '../raw-builder/raw-builder.js';
 import { AliasedQueryBuilder, QueryBuilder } from '../query-builder/query-builder.js';
 import { SelectionNode } from '../operation-node/selection-node.js';
-import { AliasedQueryBuilderFactory, AliasedRawBuilderFactory, AnyAliasedColumn, AnyAliasedColumnWithTable, AnyAliasedQueryBuilder, AnyColumn, AnyColumnWithTable, InsertResultTypeTag, RowType, ValueType } from '../query-builder/type-utils.js';
+import { AliasedQueryBuilderFactory, AliasedRawBuilderFactory, AnyAliasedColumn, AnyAliasedColumnWithTable, AnyAliasedQueryBuilder, AnyAliasedRawBuilder, AnyColumn, AnyColumnWithTable, InsertResultTypeTag, RowType, ValueType } from '../query-builder/type-utils.js';
 import { DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
 /**
  * A selection expression.
  */
-export declare type SelectExpression<DB, TB extends keyof DB> = AnyAliasedColumnWithTable<DB, TB> | AnyAliasedColumn<DB, TB> | AnyColumnWithTable<DB, TB> | AnyColumn<DB, TB> | AliasedRawBuilder<any, any> | AliasedRawBuilderFactory<DB, TB> | AnyAliasedQueryBuilder | AliasedQueryBuilderFactory<DB, TB> | DynamicReferenceBuilder<any>;
+export declare type SelectExpression<DB, TB extends keyof DB> = AnyAliasedColumnWithTable<DB, TB> | AnyAliasedColumn<DB, TB> | AnyColumnWithTable<DB, TB> | AnyColumn<DB, TB> | AnyAliasedRawBuilder | AliasedRawBuilderFactory<DB, TB> | AnyAliasedQueryBuilder | AliasedQueryBuilderFactory<DB, TB> | DynamicReferenceBuilder<any>;
+export declare type SelectExpressionOrList<DB, TB extends keyof DB> = SelectExpression<DB, TB> | ReadonlyArray<SelectExpression<DB, TB>>;
 /**
  * Given a selection expression returns a query builder type that
  * has the selection.
  */
-export declare type QueryBuilderWithSelection<DB, TB extends keyof DB, O, S> = QueryBuilder<DB, TB, O extends InsertResultTypeTag ? InsertResultTypeTag : O & SelectResultType<DB, TB, S>>;
+export declare type QueryBuilderWithSelection<DB, TB extends keyof DB, O, S> = QueryBuilder<DB, TB, O extends InsertResultTypeTag ? InsertResultTypeTag : O & Selection<DB, TB, S>>;
 /**
  * `selectAll` output query builder type.
  */
 export declare type SelectAllQueryBuilder<DB, TB extends keyof DB, O, S extends keyof DB> = QueryBuilder<DB, TB, O & RowType<DB, S>>;
-export declare type SelectResultType<DB, TB extends keyof DB, S> = {
+export declare type Selection<DB, TB extends keyof DB, S> = {
     [A in ExtractAliasFromSelectExpression<S>]: ExtractTypeFromSelectExpression<DB, TB, S, A>;
 };
 declare type ExtractAliasFromSelectExpression<S> = S extends string ? ExtractAliasFromStringSelectExpression<S> : S extends AliasedRawBuilder<any, infer RA> ? RA : S extends (qb: any) => AliasedRawBuilder<any, infer RA> ? RA : S extends AliasedQueryBuilder<any, any, any, infer QA> ? QA : S extends (qb: any) => AliasedQueryBuilder<any, any, any, infer QA> ? QA : S extends DynamicReferenceBuilder<infer RA> ? ExtractAliasFromStringSelectExpression<RA> : never;
 declare type ExtractAliasFromStringSelectExpression<S extends string> = S extends `${string}.${string}.${string} as ${infer A}` ? A : S extends `${string}.${string} as ${infer A}` ? A : S extends `${string} as ${infer A}` ? A : S extends `${string}.${string}.${infer C}` ? C : S extends `${string}.${infer C}` ? C : S;
 declare type ExtractTypeFromSelectExpression<DB, TB extends keyof DB, S, A extends keyof any> = S extends string ? ExtractTypeFromStringSelectExpression<DB, TB, S, A> : S extends AliasedRawBuilder<infer O, infer RA> ? RA extends A ? O : never : S extends (qb: any) => AliasedRawBuilder<infer O, infer RA> ? RA extends A ? O : never : S extends AliasedQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? ValueType<O> : never : S extends (qb: any) => AliasedQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? ValueType<O> : never : S extends DynamicReferenceBuilder<infer RA> ? A extends ExtractAliasFromStringSelectExpression<RA> ? ExtractTypeFromStringSelectExpression<DB, TB, RA, A> | undefined : never : never;
 declare type ExtractTypeFromStringSelectExpression<DB, TB extends keyof DB, S extends string, A extends keyof any, R = RowType<DB, TB>> = S extends `${infer SC}.${infer T}.${infer C} as ${infer RA}` ? RA extends A ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : never : S extends `${infer T}.${infer C} as ${infer RA}` ? RA extends A ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : never : S extends `${infer C} as ${infer RA}` ? RA extends A ? C extends keyof R ? R[C] : never : never : S extends `${infer SC}.${infer T}.${infer C}` ? C extends A ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : never : S extends `${infer T}.${infer C}` ? C extends A ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : never : S extends A ? S extends keyof R ? R[S] : never : never;
-export declare function parseSelectExpressionOrList(selection: SelectExpression<any, any> | SelectExpression<any, any>[]): SelectionNode[];
+export declare function parseSelectExpressionOrList(selection: SelectExpressionOrList<any, any>): SelectionNode[];
 export declare function parseSelectAllArgs(table?: string | string[]): SelectionNode[];
 export declare function parseSelectAllArg(table: string): SelectionNode;
 export {};

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

@@ -7,7 +7,7 @@ const selection_node_js_1 = require("../operation-node/selection-node.js");
 const reference_parser_js_1 = require("./reference-parser.js");
 const sub_query_builder_js_1 = require("../query-builder/sub-query-builder.js");
 function parseSelectExpressionOrList(selection) {
-    if (Array.isArray(selection)) {
+    if (object_utils_js_1.isReadonlyArray(selection)) {
         return selection.map((it) => parseSelectExpression(it));
     }
     else {

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

@@ -1,10 +1,10 @@
 import { AliasedQueryBuilder, QueryBuilder } from '../query-builder/query-builder.js';
 import { TableNode } from '../operation-node/table-node.js';
-import { AliasedQueryBuilderFactory, AnyAliasedQueryBuilder } from '../query-builder/type-utils.js';
+import { AliasedQueryBuilderFactory, AnyAliasedQueryBuilder, AnyAliasedRawBuilder } from '../query-builder/type-utils.js';
 import { AliasedRawBuilder } from '../raw-builder/raw-builder.js';
 import { TableExpressionNode } from '../operation-node/operation-node-utils.js';
 export declare type TableExpression<DB, TB extends keyof DB> = TableReference<DB> | AnyAliasedQueryBuilder | AliasedQueryBuilderFactory<DB, TB>;
-export declare type TableReference<DB> = AnyAliasedTable<DB, any, any> | AnyTable<DB> | AliasedRawBuilder<any, any>;
+export declare type TableReference<DB> = AnyAliasedTable<DB, any, any> | AnyTable<DB> | AnyAliasedRawBuilder;
 export declare type QueryBuilderWithTable<DB, TB extends keyof DB, O, TE> = QueryBuilder<TableExpressionDatabaseType<DB, TE>, TB | ExtractAliasFromTableExpression<DB, TE>, O>;
 export declare type TableExpressionDatabaseType<DB, TE> = DB extends ExtractDatabaseTypeFromTableExpression<DB, TE> ? DB : DB & ExtractDatabaseTypeFromTableExpression<DB, TE>;
 export declare type ExtractAliasFromTableExpression<DB, TE> = TE extends `${string} as ${infer TA}` ? TA : TE extends keyof DB ? TE : TE extends AliasedQueryBuilder<any, any, any, infer QA> ? QA : TE extends (qb: any) => AliasedQueryBuilder<any, any, any, infer QA> ? QA : TE extends (qb: any) => AliasedRawBuilder<any, infer RA> ? RA : never;

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

@@ -1,8 +1,7 @@
 import { ValueExpressionNode } from '../operation-node/operation-node-utils.js';
-import { PrimitiveValue } from '../util/object-utils.js';
-import { AnyQueryBuilder, QueryBuilderFactory, RawBuilderFactory } from '../query-builder/type-utils.js';
-import { RawBuilder } from '../raw-builder/raw-builder.js';
-export declare type ValueExpression<DB, TB extends keyof DB> = PrimitiveValue | AnyQueryBuilder | QueryBuilderFactory<DB, TB> | RawBuilder<any> | RawBuilderFactory<DB, TB>;
-export declare type ValueExpressionOrList<DB, TB extends keyof DB> = ValueExpression<DB, TB> | ValueExpression<DB, TB>[];
-export declare function parseValueExpressionOrList(arg: ValueExpressionOrList<any, any>): ValueExpressionNode;
-export declare function parseValueExpression(arg: ValueExpression<any, any>): ValueExpressionNode;
+import { AnyQueryBuilder, AnyRawBuilder, QueryBuilderFactory, RawBuilderFactory } from '../query-builder/type-utils.js';
+import { ExtractTypeFromReferenceExpression } from './reference-parser.js';
+export declare type ValueExpression<DB, TB extends keyof DB, RE> = ExtractTypeFromReferenceExpression<DB, TB, RE> | AnyQueryBuilder | QueryBuilderFactory<DB, TB> | AnyRawBuilder | RawBuilderFactory<DB, TB>;
+export declare type ValueExpressionOrList<DB, TB extends keyof DB, RE> = ValueExpression<DB, TB, RE> | ValueExpression<DB, TB, RE>[];
+export declare function parseValueExpressionOrList(arg: ValueExpressionOrList<any, any, any>): ValueExpressionNode;
+export declare function parseValueExpression(arg: ValueExpression<any, any, any>): ValueExpressionNode;

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

@@ -9,6 +9,8 @@ const value_node_js_1 = require("../operation-node/value-node.js");
 const object_utils_js_1 = require("../util/object-utils.js");
 const query_node_js_1 = require("../operation-node/query-node.js");
 const sub_query_builder_js_1 = require("../query-builder/sub-query-builder.js");
+const raw_node_js_1 = require("../operation-node/raw-node.js");
+const select_query_node_js_1 = require("../operation-node/select-query-node.js");
 function parseValueExpressionOrList(arg) {
     if (Array.isArray(arg)) {
         return parseValueExpressionList(arg);
@@ -24,7 +26,7 @@ function parseValueExpression(arg) {
     }
     else if (operation_node_source_js_1.isOperationNodeSource(arg)) {
         const node = arg.toOperationNode();
-        if (!query_node_js_1.queryNode.isMutating(node)) {
+        if (raw_node_js_1.rawNode.is(node) || select_query_node_js_1.selectQueryNode.is(node)) {
             return node;
         }
     }

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

@@ -2,7 +2,8 @@ import { CommonTableExpressionNode } from '../operation-node/common-table-expres
 import { QueryBuilder } from '../query-builder/query-builder.js';
 import { QueryCreator } from '../query-creator.js';
 import { RawBuilder } from '../raw-builder/raw-builder.js';
-export declare type CommonTableExpression<DB> = (creator: QueryCreator<DB>) => QueryBuilder<DB, any> | RawBuilder<any>;
+import { AnyRawBuilder } from '../query-builder/type-utils.js';
+export declare type CommonTableExpression<DB> = (creator: QueryCreator<DB>) => QueryBuilder<DB, any> | AnyRawBuilder;
 export declare type QueryCreatorWithCommonTableExpression<DB, N extends string, E extends CommonTableExpression<DB>> = QueryCreator<DB & Record<N, ExtractRowTypeFromCommonTableExpression<E>>>;
 declare type ExtractRowTypeFromCommonTableExpression<E> = E extends (creator: QueryCreator<any>) => infer Q ? Q extends QueryBuilder<any, any, infer QO> ? QO : Q extends RawBuilder<infer RO> ? RO : never : never;
 export declare function parseCommonTableExpression(name: string, expression: CommonTableExpression<any>): CommonTableExpressionNode;