kysely 0.9.8 → 0.11.0

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

@@ -2,10 +2,10 @@ import { InsertQueryNode } from './insert-query-node.js';
 import { SelectQueryNode } from './select-query-node.js';
 import { UpdateQueryNode } from './update-query-node.js';
 import { DeleteQueryNode } from './delete-query-node.js';
-import { WhereChildNode } from './where-node.js';
 import { JoinNode } from './join-node.js';
 import { SelectionNode } from './selection-node.js';
 import { OperationNode } from './operation-node.js';
+import { FilterExpressionNode } from './operation-node-utils.js';
 export declare type QueryNode = SelectQueryNode | DeleteQueryNode | InsertQueryNode | UpdateQueryNode;
 export declare type MutatingQueryNode = DeleteQueryNode | InsertQueryNode | UpdateQueryNode;
 export declare type FilterableQueryNode = SelectQueryNode | DeleteQueryNode | UpdateQueryNode;
@@ -16,8 +16,8 @@ export declare const QueryNode: Readonly<{
     is(node: OperationNode): node is QueryNode;
     isMutating(node: OperationNode): node is MutatingQueryNode;
     isFilterable(node: OperationNode): node is FilterableQueryNode;
-    cloneWithWhere<T extends FilterableQueryNode>(node: T, filter: WhereChildNode): T;
-    cloneWithOrWhere<T_1 extends FilterableQueryNode>(node: T_1, filter: WhereChildNode): T_1;
+    cloneWithWhere<T extends FilterableQueryNode>(node: T, filter: FilterExpressionNode): T;
+    cloneWithOrWhere<T_1 extends FilterableQueryNode>(node: T_1, filter: FilterExpressionNode): T_1;
     cloneWithJoin<T_2 extends FilterableQueryNode>(node: T_2, join: JoinNode): T_2;
     cloneWithReturning<T_3 extends MutatingQueryNode>(node: T_3, selections: ReadonlyArray<SelectionNode>): T_3;
 }>;

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

@@ -9,6 +9,6 @@ export interface RawNode extends OperationNode {
  */
 export declare const RawNode: Readonly<{
     is(node: OperationNode): node is RawNode;
-    create(sqlFragments: string[], params: ReadonlyArray<OperationNode>): RawNode;
+    create(sqlFragments: ReadonlyArray<string>, params: ReadonlyArray<OperationNode>): RawNode;
     createWithSql(sql: string): RawNode;
 }>;

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

@@ -1,12 +1,12 @@
 import { FromNode } from './from-node.js';
 import { GroupByItemNode } from './group-by-item-node.js';
 import { GroupByNode } from './group-by-node.js';
-import { HavingNode, HavingNodeChild } from './having-node.js';
+import { HavingNode } from './having-node.js';
 import { JoinNode } from './join-node.js';
 import { LimitNode } from './limit-node.js';
 import { OffsetNode } from './offset-node.js';
 import { OperationNode } from './operation-node.js';
-import { TableExpressionNode } from './operation-node-utils.js';
+import { FilterExpressionNode, TableExpressionNode } from './operation-node-utils.js';
 import { OrderByItemNode } from './order-by-item-node.js';
 import { OrderByNode } from './order-by-node.js';
 import { SelectionNode } from './selection-node.js';
@@ -19,7 +19,7 @@ export interface SelectQueryNode extends OperationNode {
     readonly from: FromNode;
     readonly selections?: ReadonlyArray<SelectionNode>;
     readonly distinctOnSelections?: ReadonlyArray<SelectionNode>;
-    readonly isDistinct?: boolean;
+    readonly distinct?: boolean;
     readonly joins?: ReadonlyArray<JoinNode>;
     readonly groupBy?: GroupByNode;
     readonly orderBy?: OrderByNode;
@@ -44,8 +44,8 @@ export declare const SelectQueryNode: Readonly<{
     cloneWithGroupByItems(selectNode: SelectQueryNode, items: ReadonlyArray<GroupByItemNode>): SelectQueryNode;
     cloneWithLimit(selectNode: SelectQueryNode, limit: LimitNode): SelectQueryNode;
     cloneWithOffset(selectNode: SelectQueryNode, offset: OffsetNode): SelectQueryNode;
-    cloneWithHaving(selectNode: SelectQueryNode, filter: HavingNodeChild): SelectQueryNode;
-    cloneWithOrHaving(selectNode: SelectQueryNode, filter: HavingNodeChild): SelectQueryNode;
+    cloneWithHaving(selectNode: SelectQueryNode, filter: FilterExpressionNode): SelectQueryNode;
+    cloneWithOrHaving(selectNode: SelectQueryNode, filter: FilterExpressionNode): SelectQueryNode;
     cloneWithDistinct(selectNode: SelectQueryNode): SelectQueryNode;
     cloneWithUnion(selectNode: SelectQueryNode, union: UnionNode): SelectQueryNode;
 }>;

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

@@ -88,7 +88,7 @@ export const SelectQueryNode = freeze({
     cloneWithDistinct(selectNode) {
         return freeze({
             ...selectNode,
-            isDistinct: true,
+            distinct: true,
         });
     },
     cloneWithUnion(selectNode, union) {

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

@@ -1,18 +1,14 @@
-import { AndNode } from './and-node.js';
-import { FilterNode } from './filter-node.js';
+import { FilterExpressionNode } from './operation-node-utils.js';
 import { OperationNode } from './operation-node.js';
-import { OrNode } from './or-node.js';
-import { ParensNode } from './parens-node.js';
-export declare type WhereChildNode = FilterNode | AndNode | OrNode | ParensNode;
 export interface WhereNode extends OperationNode {
     readonly kind: 'WhereNode';
-    readonly where: WhereChildNode;
+    readonly where: FilterExpressionNode;
 }
 /**
  * @internal
  */
 export declare const WhereNode: Readonly<{
     is(node: OperationNode): node is WhereNode;
-    create(filter: WhereChildNode): WhereNode;
-    cloneWithFilter(whereNode: WhereNode, op: 'And' | 'Or', where: WhereChildNode): WhereNode;
+    create(filter: FilterExpressionNode): WhereNode;
+    cloneWithFilter(whereNode: WhereNode, op: 'And' | 'Or', filter: FilterExpressionNode): WhereNode;
 }>;

package/dist/esm/operation-node/where-node.js

@@ -14,12 +14,12 @@ export const WhereNode = freeze({
             where: filter,
         });
     },
-    cloneWithFilter(whereNode, op, where) {
+    cloneWithFilter(whereNode, op, filter) {
         return freeze({
             ...whereNode,
             where: op === 'And'
-                ? AndNode.create(whereNode.where, where)
-                : OrNode.create(whereNode.where, where),
+                ? AndNode.create(whereNode.where, filter)
+                : OrNode.create(whereNode.where, filter),
         });
     },
 });

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

@@ -92,7 +92,7 @@ function parseOnGroup(ctx, callback) {
     if (!joinNode.on) {
         throw new Error('no `on*` methods called insided a group callback');
     }
-    return ParensNode.create(joinNode.on);
+    return ParensNode.create(joinNode.on.on);
 }
 function parseExistExpression(ctx, type, arg) {
     const node = isFunction(arg)

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

@@ -1,7 +1,9 @@
+import { DeleteResult } from '../query-builder/delete-result.js';
+import { InsertResult } from '../query-builder/insert-result.js';
 import { QueryBuilder } from '../query-builder/query-builder.js';
-import { DeleteResultTypeTag, InsertResultTypeTag, UpdateResultTypeTag } from '../util/type-utils.js';
+import { UpdateResult } from '../query-builder/update-result.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 ? Selection<DB, TB, S> : O extends DeleteResultTypeTag ? Selection<DB, TB, S> : O extends UpdateResultTypeTag ? Selection<DB, TB, S> : O & Selection<DB, TB, S>>;
+export declare type QueryBuilderWithReturning<DB, TB extends keyof DB, O, S> = QueryBuilder<DB, TB, O extends InsertResult ? Selection<DB, TB, S> : O extends DeleteResult ? Selection<DB, TB, S> : O extends UpdateResult ? Selection<DB, TB, S> : O & Selection<DB, TB, S>>;

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

@@ -1,7 +1,7 @@
 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, AnyAliasedRawBuilder, AnyColumn, AnyColumnWithTable, InsertResultTypeTag, RowType, ValueType } from '../util/type-utils.js';
+import { AliasedQueryBuilderFactory, AliasedRawBuilderFactory, AnyAliasedColumn, AnyAliasedColumnWithTable, AnyAliasedQueryBuilder, AnyAliasedRawBuilder, AnyColumn, AnyColumnWithTable, RowType, ValueType } from '../util/type-utils.js';
 import { DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
 import { ParseContext } from './parse-context.js';
 /**
@@ -13,7 +13,7 @@ export declare type SelectExpressionOrList<DB, TB extends keyof DB> = SelectExpr
  * 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 & Selection<DB, TB, S>>;
+export declare type QueryBuilderWithSelection<DB, TB extends keyof DB, O, S> = QueryBuilder<DB, TB, O & Selection<DB, TB, S>>;
 /**
  * `selectAll` output query builder type.
  */

package/dist/esm/plugin/immediate-value.ts/immediate-value-plugin.d.ts

@@ -0,0 +1,17 @@
+import { QueryResult } from '../../driver/database-connection.js';
+import { RootOperationNode } from '../../query-compiler/query-compiler.js';
+import { UnknownRow } from '../../util/type-utils.js';
+import { KyselyPlugin, PluginTransformQueryArgs, PluginTransformResultArgs } from '../kysely-plugin.js';
+/**
+ * Transforms all ValueNodes to immediate.
+ *
+ * WARNING! This should never be part of the public API. Users should never use this.
+ * This is an internal helper.
+ *
+ * @internal
+ */
+export declare class ImmediateValuePlugin implements KyselyPlugin {
+    #private;
+    transformQuery(args: PluginTransformQueryArgs): RootOperationNode;
+    transformResult(args: PluginTransformResultArgs): Promise<QueryResult<UnknownRow>>;
+}

package/dist/esm/plugin/immediate-value.ts/immediate-value-plugin.js

@@ -0,0 +1,18 @@
+import { ImmediateValueTransformer } from './immediate-value-transformer.js';
+/**
+ * Transforms all ValueNodes to immediate.
+ *
+ * WARNING! This should never be part of the public API. Users should never use this.
+ * This is an internal helper.
+ *
+ * @internal
+ */
+export class ImmediateValuePlugin {
+    #transformer = new ImmediateValueTransformer();
+    transformQuery(args) {
+        return this.#transformer.transformNode(args.node);
+    }
+    async transformResult(args) {
+        return args.result;
+    }
+}

package/dist/esm/plugin/immediate-value.ts/immediate-value-transformer.d.ts

@@ -0,0 +1,13 @@
+import { OperationNodeTransformer } from '../../operation-node/operation-node-transformer.js';
+import { ValueNode } from '../../operation-node/value-node.js';
+/**
+ * Transforms all ValueNodes to immediate.
+ *
+ * WARNING! This should never be part of the public API. Users should never use this.
+ * This is an internal helper.
+ *
+ * @internal
+ */
+export declare class ImmediateValueTransformer extends OperationNodeTransformer {
+    transformValue(node: ValueNode): ValueNode;
+}

package/dist/esm/plugin/immediate-value.ts/immediate-value-transformer.js

@@ -0,0 +1,17 @@
+import { OperationNodeTransformer } from '../../operation-node/operation-node-transformer.js';
+/**
+ * Transforms all ValueNodes to immediate.
+ *
+ * WARNING! This should never be part of the public API. Users should never use this.
+ * This is an internal helper.
+ *
+ * @internal
+ */
+export class ImmediateValueTransformer extends OperationNodeTransformer {
+    transformValue(node) {
+        return {
+            ...super.transformValue(node),
+            immediate: true,
+        };
+    }
+}

package/dist/esm/plugin/with-schema/with-schema-transformer.d.ts

@@ -1,9 +1,11 @@
 import { AlterTableNode } from '../../operation-node/alter-table-node.js';
 import { CreateIndexNode } from '../../operation-node/create-index-node.js';
 import { CreateTableNode } from '../../operation-node/create-table-node.js';
+import { CreateViewNode } from '../../operation-node/create-view-node.js';
 import { DeleteQueryNode } from '../../operation-node/delete-query-node.js';
 import { DropIndexNode } from '../../operation-node/drop-index-node.js';
 import { DropTableNode } from '../../operation-node/drop-table-node.js';
+import { DropViewNode } from '../../operation-node/drop-view-node.js';
 import { InsertQueryNode } from '../../operation-node/insert-query-node.js';
 import { OperationNodeTransformer } from '../../operation-node/operation-node-transformer.js';
 import { SelectQueryNode } from '../../operation-node/select-query-node.js';
@@ -20,6 +22,8 @@ export declare class WithSchemaTransformer extends OperationNodeTransformer {
     protected transformDropTable(node: DropTableNode): DropTableNode;
     protected transformCreateIndex(node: CreateIndexNode): CreateIndexNode;
     protected transformDropIndex(node: DropIndexNode): DropIndexNode;
+    protected transformCreateView(node: CreateViewNode): CreateViewNode;
+    protected transformDropView(node: DropViewNode): DropViewNode;
     protected transformAlterTable(node: AlterTableNode): AlterTableNode;
     protected transformTable(node: TableNode): TableNode;
 }

package/dist/esm/plugin/with-schema/with-schema-transformer.js

@@ -32,6 +32,12 @@ export class WithSchemaTransformer extends OperationNodeTransformer {
     transformDropIndex(node) {
         return this.#transformRoot(node, (node) => super.transformDropIndex(node));
     }
+    transformCreateView(node) {
+        return this.#transformRoot(node, (node) => super.transformCreateView(node));
+    }
+    transformDropView(node) {
+        return this.#transformRoot(node, (node) => super.transformDropView(node));
+    }
     transformAlterTable(node) {
         return this.#transformRoot(node, (node) => super.transformAlterTable(node));
     }

package/dist/esm/query-builder/delete-result.d.ts

@@ -0,0 +1,5 @@
+export declare class DeleteResult {
+    #private;
+    constructor(numDeletedRows: bigint);
+    get numDeletedRows(): bigint;
+}

package/dist/esm/query-builder/delete-result.js

@@ -0,0 +1,9 @@
+export class DeleteResult {
+    #numDeletedRows;
+    constructor(numDeletedRows) {
+        this.#numDeletedRows = numDeletedRows;
+    }
+    get numDeletedRows() {
+        return this.#numDeletedRows;
+    }
+}

package/dist/esm/query-builder/expression-builder.d.ts

@@ -26,7 +26,7 @@ export declare class ExpressionBuilder<DB, TB extends keyof DB> {
      *   .execute()
      * ```
      *
-     * The generated SQL (postgresql):
+     * The generated SQL (PostgreSQL):
      *
      * ```sql
      * select "person"."id", count("pet"."id") as "pet_count"
@@ -62,7 +62,7 @@ export declare class ExpressionBuilder<DB, TB extends keyof DB> {
      * console.log(result[0].owner_name)
      * ```
      *
-     * The generated SQL (postgresql):
+     * The generated SQL (PostgreSQL):
      *
      * ```sql
      * select

package/dist/esm/query-builder/expression-builder.js

@@ -31,7 +31,7 @@ export class ExpressionBuilder {
      *   .execute()
      * ```
      *
-     * The generated SQL (postgresql):
+     * The generated SQL (PostgreSQL):
      *
      * ```sql
      * select "person"."id", count("pet"."id") as "pet_count"

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

@@ -19,7 +19,7 @@ import { RawBuilder } from '../raw-builder/raw-builder.js';
  *   .execute()
  * ```
  *
- * The generated SQL (postgresql):
+ * The generated SQL (PostgreSQL):
  *
  * ```sql
  * select "person"."id", count("pet"."id") as "pet_count"
@@ -66,7 +66,7 @@ export declare class FunctionBuilder<DB, TB extends keyof DB> {
      * Calls the `sum` function for the column given as the argument.
      *
      * If this is used in a `select` statement the type of the selected expression
-     * will be `number | string | BigInt` by default. This is because Kysely can't
+     * will be `number | string | bigint` by default. This is because Kysely can't
      * know the type the db driver outputs. Sometimes the output can be larger than
      * the largest javascript number and a string is returned instead. Most drivers
      * allow you to configure the output type of large numbers and Kysely can't
@@ -83,12 +83,12 @@ export declare class FunctionBuilder<DB, TB extends keyof DB> {
      *   .execute()
      * ```
      */
-    sum<O extends number | string | BigInt, C extends StringReference<DB, TB> = any>(column: C): RawBuilder<O>;
+    sum<O extends number | string | bigint, C extends StringReference<DB, TB> = any>(column: C): RawBuilder<O>;
     /**
      * Calls the `count` function for the column given as the argument.
      *
      * If this is used in a `select` statement the type of the selected expression
-     * will be `number | string | BigInt` by default. This is because Kysely can't
+     * will be `number | string |bigint` by default. This is because Kysely can't
      * know the type the db driver outputs. Sometimes the output can be larger than
      * the largest javascript number and a string is returned instead. Most drivers
      * allow you to configure the output type of large numbers and Kysely can't
@@ -105,7 +105,7 @@ export declare class FunctionBuilder<DB, TB extends keyof DB> {
      *   .execute()
      * ```
      */
-    count<O extends number | string | BigInt, C extends StringReference<DB, TB> = any>(column: C): RawBuilder<O>;
+    count<O extends number | string | bigint, C extends StringReference<DB, TB> = any>(column: C): RawBuilder<O>;
 }
 export interface FunctionBuilderProps {
     readonly executor: QueryExecutor;

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

@@ -19,7 +19,7 @@ import { createQueryId } from '../util/query-id.js';
  *   .execute()
  * ```
  *
- * The generated SQL (postgresql):
+ * The generated SQL (PostgreSQL):
  *
  * ```sql
  * select "person"."id", count("pet"."id") as "pet_count"
@@ -79,7 +79,7 @@ export class FunctionBuilder {
      * Calls the `sum` function for the column given as the argument.
      *
      * If this is used in a `select` statement the type of the selected expression
-     * will be `number | string | BigInt` by default. This is because Kysely can't
+     * will be `number | string | bigint` by default. This is because Kysely can't
      * know the type the db driver outputs. Sometimes the output can be larger than
      * the largest javascript number and a string is returned instead. Most drivers
      * allow you to configure the output type of large numbers and Kysely can't
@@ -103,7 +103,7 @@ export class FunctionBuilder {
      * Calls the `count` function for the column given as the argument.
      *
      * If this is used in a `select` statement the type of the selected expression
-     * will be `number | string | BigInt` by default. This is because Kysely can't
+     * will be `number | string |bigint` by default. This is because Kysely can't
      * know the type the db driver outputs. Sometimes the output can be larger than
      * the largest javascript number and a string is returned instead. Most drivers
      * allow you to configure the output type of large numbers and Kysely can't

package/dist/esm/query-builder/insert-result.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The result of an insert query.
+ *
+ * If the table has an auto incrementing primary key {@link insertId} will hold
+ * the generated id on dialects that support it. For example PostgreSQL doesn't
+ * return the id by default and {@link insertId} is undefined. On PostgreSQL you
+ * need to use {@link QueryBuilder.returning} or {@link QueryBuilder.returningAll}
+ * to get out the inserted id.
+ *
+ * @example
+ * ```ts
+ * const result = await db
+ *   .insertInto('person')
+ *   .values(person)
+ *   .executeTakeFirst()
+ *
+ * console.log(result.insertId)
+ * ```
+ */
+export declare class InsertResult {
+    #private;
+    constructor(insertId: bigint | undefined);
+    /**
+     * The auto incrementing primary key
+     */
+    get insertId(): bigint | undefined;
+}

package/dist/esm/query-builder/insert-result.js

@@ -0,0 +1,31 @@
+/**
+ * The result of an insert query.
+ *
+ * If the table has an auto incrementing primary key {@link insertId} will hold
+ * the generated id on dialects that support it. For example PostgreSQL doesn't
+ * return the id by default and {@link insertId} is undefined. On PostgreSQL you
+ * need to use {@link QueryBuilder.returning} or {@link QueryBuilder.returningAll}
+ * to get out the inserted id.
+ *
+ * @example
+ * ```ts
+ * const result = await db
+ *   .insertInto('person')
+ *   .values(person)
+ *   .executeTakeFirst()
+ *
+ * console.log(result.insertId)
+ * ```
+ */
+export class InsertResult {
+    #insertId;
+    constructor(insertId) {
+        this.#insertId = insertId;
+    }
+    /**
+     * The auto incrementing primary key
+     */
+    get insertId() {
+        return this.#insertId;
+    }
+}