kysely 0.23.4 → 0.23.5

package/dist/esm/dialect/postgres/postgres-introspector.js

@@ -32,6 +32,7 @@ export class PostgresIntrospector {
             'a.attnotnull as not_null',
             'a.atthasdef as has_default',
             'c.relname as table',
+            'c.relkind as table_type',
             'ns.nspname as schema',
             'typ.typname as type',
             'dtns.nspname as type_schema',
@@ -47,7 +48,7 @@ export class PostgresIntrospector {
                 .as('auto_incrementing'),
         ])
             // r == normal table
-            .where('c.relkind', '=', 'r')
+            .where('c.relkind', 'in', ['r', 'v'])
             .where('ns.nspname', '!~', '^pg_')
             .where('ns.nspname', '!=', 'information_schema')
             // No system columns
@@ -76,6 +77,7 @@ export class PostgresIntrospector {
             if (!table) {
                 table = freeze({
                     name: it.table,
+                    isView: it.table_type === 'v',
                     schema: it.schema,
                     columns: [],
                 });

package/dist/esm/dialect/sqlite/sqlite-introspector.d.ts

@@ -8,7 +8,7 @@ export declare class SqliteIntrospector implements DatabaseIntrospector {
      */
     getSchemas(): Promise<SchemaMetadata[]>;
     /**
-     * Get table metadata.
+     * Get tables and views metadata.
      */
     getTables(options?: DatabaseMetadataOptions): Promise<TableMetadata[]>;
     /**

package/dist/esm/dialect/sqlite/sqlite-introspector.js

@@ -13,7 +13,7 @@ export class SqliteIntrospector {
     async getTables(options = { withInternalKyselyTables: false }) {
         let query = this.#db
             .selectFrom('sqlite_schema')
-            .where('type', '=', 'table')
+            .where('type', 'in', ['table', 'view'])
             .where('name', 'not like', 'sqlite_%')
             .select('name')
             .orderBy('name')
@@ -34,14 +34,14 @@ export class SqliteIntrospector {
     async #getTableMetadata(table) {
         const db = this.#db;
         // Get the SQL that was used to create the table.
-        const createSql = await db
+        const tableDefinition = await db
             .selectFrom('sqlite_master')
             .where('name', '=', table)
-            .select('sql')
+            .select(['sql', 'type'])
             .$castTo()
-            .execute();
+            .executeTakeFirstOrThrow();
         // Try to find the name of the column that has `autoincrement` 🤦
-        const autoIncrementCol = createSql[0]?.sql
+        const autoIncrementCol = tableDefinition.sql
             ?.split(/[\(\),]/)
             ?.find((it) => it.toLowerCase().includes('autoincrement'))
             ?.trimStart()
@@ -54,6 +54,7 @@ export class SqliteIntrospector {
             .execute();
         return {
             name: table,
+            isView: tableDefinition.type === 'view',
             columns: columns.map((col) => ({
                 name: col.name,
                 dataType: col.type,

package/dist/esm/operation-node/aggregate-function-node.d.ts

@@ -1,12 +1,13 @@
 import { OperationNode } from './operation-node.js';
 import { OverNode } from './over-node.js';
+import { SelectAllNode } from './select-all-node.js';
 import { SimpleReferenceExpressionNode } from './simple-reference-expression-node.js';
 import { WhereNode } from './where-node.js';
 declare type AggregateFunction = 'avg' | 'count' | 'max' | 'min' | 'sum';
 export interface AggregateFunctionNode extends OperationNode {
     readonly kind: 'AggregateFunctionNode';
     readonly func: AggregateFunction;
-    readonly column: SimpleReferenceExpressionNode;
+    readonly aggregated: SimpleReferenceExpressionNode | SelectAllNode;
     readonly distinct?: boolean;
     readonly filter?: WhereNode;
     readonly over?: OverNode;
@@ -16,7 +17,7 @@ export interface AggregateFunctionNode extends OperationNode {
  */
 export declare const AggregateFunctionNode: Readonly<{
     is(node: OperationNode): node is AggregateFunctionNode;
-    create(aggregateFunction: AggregateFunction, column: SimpleReferenceExpressionNode): AggregateFunctionNode;
+    create(aggregateFunction: AggregateFunction, aggregated: SimpleReferenceExpressionNode | SelectAllNode): AggregateFunctionNode;
     cloneWithDistinct(aggregateFunctionNode: AggregateFunctionNode): AggregateFunctionNode;
     cloneWithFilter(aggregateFunctionNode: AggregateFunctionNode, filter: OperationNode): AggregateFunctionNode;
     cloneWithOrFilter(aggregateFunctionNode: AggregateFunctionNode, filter: OperationNode): AggregateFunctionNode;

package/dist/esm/operation-node/aggregate-function-node.js

@@ -8,11 +8,11 @@ export const AggregateFunctionNode = freeze({
     is(node) {
         return node.kind === 'AggregateFunctionNode';
     },
-    create(aggregateFunction, column) {
+    create(aggregateFunction, aggregated) {
         return freeze({
             kind: 'AggregateFunctionNode',
             func: aggregateFunction,
-            column,
+            aggregated,
         });
     },
     cloneWithDistinct(aggregateFunctionNode) {

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

@@ -26,7 +26,7 @@ export interface DeleteQueryNode extends OperationNode {
  */
 export declare const DeleteQueryNode: Readonly<{
     is(node: OperationNode): node is DeleteQueryNode;
-    create(fromItem: OperationNode, withNode?: WithNode): DeleteQueryNode;
+    create(fromItems: OperationNode[], withNode?: WithNode): DeleteQueryNode;
     cloneWithOrderByItem(deleteNode: DeleteQueryNode, item: OrderByItemNode): DeleteQueryNode;
     cloneWithLimit(deleteNode: DeleteQueryNode, limit: LimitNode): DeleteQueryNode;
     cloneWithExplain(deleteNode: DeleteQueryNode, explain: ExplainNode): DeleteQueryNode;

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

@@ -10,10 +10,10 @@ export const DeleteQueryNode = freeze({
     is(node) {
         return node.kind === 'DeleteQueryNode';
     },
-    create(fromItem, withNode) {
+    create(fromItems, withNode) {
         return freeze({
             kind: 'DeleteQueryNode',
-            from: FromNode.create([fromItem]),
+            from: FromNode.create(fromItems),
             ...(withNode && { with: withNode }),
         });
     },

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

@@ -649,7 +649,7 @@ export class OperationNodeTransformer {
     transformAggregateFunction(node) {
         return requireAllProps({
             kind: 'AggregateFunctionNode',
-            column: this.transformNode(node.column),
+            aggregated: this.transformNode(node.aggregated),
             distinct: node.distinct,
             filter: this.transformNode(node.filter),
             func: node.func,
@@ -693,7 +693,7 @@ export class OperationNodeTransformer {
     transformUsing(node) {
         return requireAllProps({
             kind: 'UsingNode',
-            tables: node.tables,
+            tables: this.transformNodeList(node.tables),
         });
     }
     transformDataType(node) {

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

@@ -1,5 +1,5 @@
 /// <reference types="./expression-parser.d.ts" />
-import { isExpression, } from '../expression/expression.js';
+import { isAliasedExpression, isExpression, } from '../expression/expression.js';
 import { isOperationNodeSource } from '../operation-node/operation-node-source.js';
 import { isFunction } from '../util/object-utils.js';
 import { createExpressionBuilder } from './parse-utils.js';
@@ -22,5 +22,5 @@ export function parseAliasedExpression(exp) {
     throw new Error(`invalid aliased expression: ${JSON.stringify(exp)}`);
 }
 export function isExpressionOrFactory(obj) {
-    return isExpression(obj) || isFunction(obj);
+    return isExpression(obj) || isAliasedExpression(obj) || isFunction(obj);
 }

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

@@ -6,6 +6,7 @@ import { AliasedExpression } from '../expression/expression.js';
 export declare type TableExpression<DB, TB extends keyof DB> = TableReference<DB> | AliasedExpressionOrFactory<DB, TB>;
 export declare type TableExpressionOrList<DB, TB extends keyof DB> = TableExpression<DB, TB> | ReadonlyArray<TableExpression<DB, TB>>;
 export declare type TableReference<DB> = AnyAliasedTable<DB> | AnyTable<DB> | AliasedExpression<any, any>;
+export declare type TableReferenceOrList<DB> = TableReference<DB> | ReadonlyArray<TableReference<DB>>;
 export declare type From<DB, TE> = {
     [C in keyof DB | ExtractAliasFromTableExpression<DB, TE>]: C extends ExtractAliasFromTableExpression<DB, TE> ? ExtractRowTypeFromTableExpression<DB, TE, C> : C extends keyof DB ? DB[C] : never;
 };

package/dist/esm/plugin/camel-case/camel-case-plugin.d.ts

@@ -26,6 +26,12 @@ export interface CamelCasePluginOptions {
      * Defaults to false.
      */
     underscoreBetweenUppercaseLetters?: boolean;
+    /**
+     * If true, nested object's keys will not be converted to camel case.
+     *
+     * Defaults to false.
+     */
+    maintainNestedObjectKeys?: boolean;
 }
 /**
  * A plugin that converts snake_case identifiers in the database into
@@ -93,6 +99,7 @@ export interface CamelCasePluginOptions {
  */
 export declare class CamelCasePlugin implements KyselyPlugin {
     #private;
+    readonly opt: CamelCasePluginOptions;
     constructor(opt?: CamelCasePluginOptions);
     /**
      * This is called for each query before it is executed. You can modify the query by

package/dist/esm/plugin/camel-case/camel-case-plugin.js

@@ -67,10 +67,12 @@ import { createCamelCaseMapper, createSnakeCaseMapper, } from './camel-case.js';
  * ```
  */
 export class CamelCasePlugin {
+    opt;
     #camelCase;
     #snakeCase;
     #snakeCaseTransformer;
     constructor(opt = {}) {
+        this.opt = opt;
         this.#camelCase = createCamelCaseMapper(opt);
         this.#snakeCase = createSnakeCaseMapper(opt);
         this.#snakeCaseTransformer = new SnakeCaseTransformer(this.snakeCase.bind(this));
@@ -91,9 +93,9 @@ export class CamelCasePlugin {
         return Object.keys(row).reduce((obj, key) => {
             let value = row[key];
             if (Array.isArray(value)) {
-                value = value.map((it) => (canMap(it) ? this.mapRow(it) : it));
+                value = value.map((it) => (canMap(it, this.opt) ? this.mapRow(it) : it));
             }
-            else if (canMap(value)) {
+            else if (canMap(value, this.opt)) {
                 value = this.mapRow(value);
             }
             obj[this.camelCase(key)] = value;
@@ -107,6 +109,10 @@ export class CamelCasePlugin {
         return this.#camelCase(str);
     }
 }
-function canMap(obj) {
-    return (isObject(obj) && !isDate(obj) && !isBuffer(obj) && !isArrayBufferOrView(obj));
+function canMap(obj, opt) {
+    return (isObject(obj) &&
+        !isDate(obj) &&
+        !isBuffer(obj) &&
+        !isArrayBufferOrView(obj) &&
+        !opt?.maintainNestedObjectKeys);
 }

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

@@ -5,7 +5,7 @@ import { From, FromTables, TableExpression } from '../parser/table-parser.js';
 import { SelectExpression } from '../parser/select-parser.js';
 import { ReturningRow } from '../parser/returning-parser.js';
 import { ReferenceExpression } from '../parser/reference-parser.js';
-import { MergePartial, Nullable, SingleResultType } from '../util/type-utils.js';
+import { MergePartial, Nullable, SimplifyResult, SimplifySingleResult } from '../util/type-utils.js';
 import { Compilable } from '../util/compilable.js';
 import { QueryExecutor } from '../query-executor/query-executor.js';
 import { QueryId } from '../util/query-id.js';
@@ -878,18 +878,18 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      */
     withPlugin(plugin: KyselyPlugin): DeleteQueryBuilder<DB, TB, O>;
     toOperationNode(): DeleteQueryNode;
-    compile(): CompiledQuery<O>;
+    compile(): CompiledQuery<SimplifyResult<O>>;
     /**
      * Executes the query and returns an array of rows.
      *
      * Also see the {@link executeTakeFirst} and {@link executeTakeFirstOrThrow} methods.
      */
-    execute(): Promise<O[]>;
+    execute(): Promise<SimplifyResult<O>[]>;
     /**
      * Executes the query and returns the first result or undefined if
      * the query returned no result.
      */
-    executeTakeFirst(): Promise<SingleResultType<O>>;
+    executeTakeFirst(): Promise<SimplifySingleResult<O>>;
     /**
      * Executes the query and returns the first result or throws if
      * the query returned no result.
@@ -898,7 +898,7 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * provide a custom error class as the only argument to throw a different
      * error.
      */
-    executeTakeFirstOrThrow(errorConstructor?: NoResultErrorConstructor): Promise<O>;
+    executeTakeFirstOrThrow(errorConstructor?: NoResultErrorConstructor): Promise<SimplifyResult<O>>;
     /**
      * Executes query with `explain` statement before `delete` keyword.
      *

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

@@ -352,7 +352,7 @@ export class DeleteQueryBuilder {
         return [
             new DeleteResult(
             // TODO: remove numUpdatedOrDeletedRows.
-            (result.numAffectedRows ?? result.numUpdatedOrDeletedRows)),
+            result.numAffectedRows ?? result.numUpdatedOrDeletedRows ?? 0n),
         ];
     }
     /**