kysely 0.9.2 → 0.9.6

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

@@ -0,0 +1,104 @@
+/**
+ * Creates a function that transforms camel case strings to snake case.
+ */
+export function createSnakeCaseMapper({ upperCase = false, underscoreBeforeDigits = false, underscoreBetweenUppercaseLetters = false, } = {}) {
+    return memoize((str) => {
+        if (str.length === 0) {
+            return str;
+        }
+        const upper = str.toUpperCase();
+        const lower = str.toLowerCase();
+        let out = lower[0];
+        for (let i = 1, l = str.length; i < l; ++i) {
+            const char = str[i];
+            const prevChar = str[i - 1];
+            const upperChar = upper[i];
+            const prevUpperChar = upper[i - 1];
+            const lowerChar = lower[i];
+            const prevLowerChar = lower[i - 1];
+            // If underScoreBeforeDigits is true then, well, insert an underscore
+            // before digits :). Only the first digit gets an underscore if
+            // there are multiple.
+            if (underscoreBeforeDigits && isDigit(char) && !isDigit(prevChar)) {
+                out += '_' + char;
+                continue;
+            }
+            // Test if `char` is an upper-case character and that the character
+            // actually has different upper and lower case versions.
+            if (char === upperChar && upperChar !== lowerChar) {
+                const prevCharacterIsUppercase = prevChar === prevUpperChar && prevUpperChar !== prevLowerChar;
+                // If underscoreBetweenUppercaseLetters is true, we always place an underscore
+                // before consecutive uppercase letters (e.g. "fooBAR" becomes "foo_b_a_r").
+                // Otherwise, we don't (e.g. "fooBAR" becomes "foo_bar").
+                if (underscoreBetweenUppercaseLetters || !prevCharacterIsUppercase) {
+                    out += '_' + lowerChar;
+                }
+                else {
+                    out += lowerChar;
+                }
+            }
+            else {
+                out += char;
+            }
+        }
+        if (upperCase) {
+            return out.toUpperCase();
+        }
+        else {
+            return out;
+        }
+    });
+}
+/**
+ * Creates a function that transforms snake case strings to camel case.
+ */
+export function createCamelCaseMapper({ upperCase = false, } = {}) {
+    return memoize((str) => {
+        if (str.length === 0) {
+            return str;
+        }
+        if (upperCase && isAllUpperCaseSnakeCase(str)) {
+            // Only convert to lower case if the string is all upper
+            // case snake_case. This allows camelCase strings to go
+            // through without changing.
+            str = str.toLowerCase();
+        }
+        let out = str[0];
+        for (let i = 1, l = str.length; i < l; ++i) {
+            const char = str[i];
+            const prevChar = str[i - 1];
+            if (char !== '_') {
+                if (prevChar === '_') {
+                    out += char.toUpperCase();
+                }
+                else {
+                    out += char;
+                }
+            }
+        }
+        return out;
+    });
+}
+function isAllUpperCaseSnakeCase(str) {
+    for (let i = 1, l = str.length; i < l; ++i) {
+        const char = str[i];
+        if (char !== '_' && char !== char.toUpperCase()) {
+            return false;
+        }
+    }
+    return true;
+}
+function isDigit(char) {
+    return char >= '0' && char <= '9';
+}
+function memoize(func) {
+    const cache = new Map();
+    return (str) => {
+        let mapped = cache.get(str);
+        if (!mapped) {
+            mapped = func(str);
+            cache.set(str, mapped);
+        }
+        return mapped;
+    };
+}

package/dist/esm/plugin/kysely-plugin.d.ts

@@ -21,7 +21,7 @@ export interface KyselyPlugin {
      *     return args.node
      *   },
      *
-     *   transformResult(args: PluginTransformResultArgs): QueryResult<AnyRow> {
+     *   transformResult(args: PluginTransformResultArgs): QueryResult<UnknownRow> {
      *     const data = this.data.get(args.queryId)
      *     return args.result
      *   }

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

@@ -18,6 +18,7 @@ import { QueryExecutor } from '../query-executor/query-executor.js';
 import { QueryId } from '../util/query-id.js';
 import { OnConflictConstraintTarget } from '../parser/on-conflict-parser.js';
 import { ParseContext } from '../parser/parse-context.js';
+import { UnionExpression } from '../parser/union-parser.js';
 /**
  * The main query builder class.
  *
@@ -998,7 +999,7 @@ export declare class QueryBuilder<DB, TB extends keyof DB, O = {}> implements Op
      * ```
      */
     values(row: InsertObject<DB, TB>): QueryBuilder<DB, TB, O>;
-    values(row: InsertObject<DB, TB>[]): QueryBuilder<DB, TB, O>;
+    values(row: ReadonlyArray<InsertObject<DB, TB>>): QueryBuilder<DB, TB, O>;
     /**
      * Ignores the insert if the column or constraint given as the first
      * argument conflicts with the current rows in the database. The
@@ -1553,6 +1554,69 @@ export declare class QueryBuilder<DB, TB extends keyof DB, O = {}> implements Op
      * ```
      */
     offset(offset: number): QueryBuilder<DB, TB, O>;
+    /**
+     * Combines another select query or raw expression to this query using `union`.
+     *
+     * The output row type of the combined query must match `this` query.
+     *
+     * @xample
+     * ```ts
+     * db.selectFrom('person')
+     *   .select(['id', 'first_name as name'])
+     *   .union(db.selectFrom('pet').select(['id', 'name']))
+     *   .orderBy('name')
+     * ```
+     */
+    union(expression: UnionExpression<DB, O>): QueryBuilder<DB, TB, O>;
+    /**
+     * Combines another select query or raw expression to this query using `union all`.
+     *
+     * The output row type of the combined query must match `this` query.
+     *
+     * @xample
+     * ```ts
+     * db.selectFrom('person')
+     *   .select(['id', 'first_name as name'])
+     *   .unionAll(db.selectFrom('pet').select(['id', 'name']))
+     *   .orderBy('name')
+     * ```
+     */
+    unionAll(expression: UnionExpression<DB, O>): QueryBuilder<DB, TB, O>;
+    /**
+     * Simply calls the given function passing `this` as the only argument.
+     *
+     * This method can be useful when adding optional method calls:
+     *
+     * @example
+     * ```ts
+     * db.selectFrom('person')
+     *   .selectAll()
+     *   .call((qb) => {
+     *     if (something) {
+     *       return qb.where('something', '=', something)
+     *     } else {
+     *       return qb.where('somethingElse', '=', somethingElse)
+     *     }
+     *   })
+     *   .execute()
+     * ```
+     *
+     * The next example uses a helper funtion `log` to log a query:
+     *
+     * @example
+     * ```ts
+     * function log<T extends AnyQueryBuilder>(qb: T): T {
+     *   console.log(qb.compile())
+     *   return qb
+     * }
+     *
+     * db.selectFrom('person')
+     *   .selectAll()
+     *   .call(log)
+     *   .execute()
+     * ```
+     */
+    call<T>(func: (qb: this) => T): T;
     /**
      * Gives an alias for the query. This method is only useful for sub queries.
      *

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

@@ -17,6 +17,7 @@ import { freeze } from '../util/object-utils.js';
 import { DeleteQueryNode } from '../operation-node/delete-query-node.js';
 import { OnDuplicateKeyNode } from '../operation-node/on-duplicate-key-node.js';
 import { parseGroupBy } from '../parser/group-by-parser.js';
+import { parseUnion } from '../parser/union-parser.js';
 /**
  * The main query builder class.
  *
@@ -774,6 +775,83 @@ export class QueryBuilder {
             queryNode: SelectQueryNode.cloneWithOffset(this.#props.queryNode, OffsetNode.create(offset)),
         });
     }
+    /**
+     * Combines another select query or raw expression to this query using `union`.
+     *
+     * The output row type of the combined query must match `this` query.
+     *
+     * @xample
+     * ```ts
+     * db.selectFrom('person')
+     *   .select(['id', 'first_name as name'])
+     *   .union(db.selectFrom('pet').select(['id', 'name']))
+     *   .orderBy('name')
+     * ```
+     */
+    union(expression) {
+        assertCanHaveUnion(this.#props.queryNode);
+        return new QueryBuilder({
+            ...this.#props,
+            queryNode: SelectQueryNode.cloneWithUnion(this.#props.queryNode, parseUnion(expression, false)),
+        });
+    }
+    /**
+     * Combines another select query or raw expression to this query using `union all`.
+     *
+     * The output row type of the combined query must match `this` query.
+     *
+     * @xample
+     * ```ts
+     * db.selectFrom('person')
+     *   .select(['id', 'first_name as name'])
+     *   .unionAll(db.selectFrom('pet').select(['id', 'name']))
+     *   .orderBy('name')
+     * ```
+     */
+    unionAll(expression) {
+        assertCanHaveUnion(this.#props.queryNode);
+        return new QueryBuilder({
+            ...this.#props,
+            queryNode: SelectQueryNode.cloneWithUnion(this.#props.queryNode, parseUnion(expression, true)),
+        });
+    }
+    /**
+     * Simply calls the given function passing `this` as the only argument.
+     *
+     * This method can be useful when adding optional method calls:
+     *
+     * @example
+     * ```ts
+     * db.selectFrom('person')
+     *   .selectAll()
+     *   .call((qb) => {
+     *     if (something) {
+     *       return qb.where('something', '=', something)
+     *     } else {
+     *       return qb.where('somethingElse', '=', somethingElse)
+     *     }
+     *   })
+     *   .execute()
+     * ```
+     *
+     * The next example uses a helper funtion `log` to log a query:
+     *
+     * @example
+     * ```ts
+     * function log<T extends AnyQueryBuilder>(qb: T): T {
+     *   console.log(qb.compile())
+     *   return qb
+     * }
+     *
+     * db.selectFrom('person')
+     *   .selectAll()
+     *   .call(log)
+     *   .execute()
+     * ```
+     */
+    call(func) {
+        return func(this);
+    }
     /**
      * Gives an alias for the query. This method is only useful for sub queries.
      *
@@ -979,3 +1057,8 @@ function assertCanHaveOffset(node) {
         throw new Error('only a select query can have an offset');
     }
 }
+function assertCanHaveUnion(node) {
+    if (!SelectQueryNode.is(node)) {
+        throw new Error('only a select query can have an union');
+    }
+}

package/dist/esm/query-compiler/default-query-compiler.d.ts

@@ -60,6 +60,8 @@ import { ForeignKeyConstraintNode } from '../operation-node/foreign-key-constrai
 import { ColumnDefinitionNode } from '../operation-node/column-definition-node.js';
 import { ModifyColumnNode } from '../operation-node/modify-column-node.js';
 import { OnDuplicateKeyNode } from '../operation-node/on-duplicate-key-node.js';
+import { ColumnNode } from '../operation-node/column-node.js';
+import { UnionNode } from '../operation-node/union-node.js';
 export declare class DefaultQueryCompiler extends OperationNodeVisitor implements QueryCompiler {
     #private;
     protected get numParameters(): number;
@@ -67,6 +69,8 @@ export declare class DefaultQueryCompiler extends OperationNodeVisitor implement
     protected getSql(): string;
     protected visitSelectQuery(node: SelectQueryNode): void;
     protected visitFrom(node: FromNode): void;
+    protected visitSelection(node: SelectionNode): void;
+    protected visitColumn(node: ColumnNode): void;
     protected compileDistinctOn(selections: ReadonlyArray<SelectionNode>): void;
     protected compileList(nodes: ReadonlyArray<OperationNode>, separator?: string): void;
     protected visitWhere(node: WhereNode): void;
@@ -125,6 +129,7 @@ export declare class DefaultQueryCompiler extends OperationNodeVisitor implement
     protected visitModifyColumn(node: ModifyColumnNode): void;
     protected visitAddConstraint(node: AddConstraintNode): void;
     protected visitDropConstraint(node: DropConstraintNode): void;
+    protected visitUnion(node: UnionNode): void;
     protected append(str: string): void;
     protected appendValue(parameter: unknown): void;
     protected getLeftIdentifierWrapper(): string;

package/dist/esm/query-compiler/default-query-compiler.js

@@ -14,7 +14,7 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
         this.visitNode(node);
         return freeze({
             sql: this.getSql(),
-            parameters: this.#parameters,
+            parameters: [...this.#parameters],
         });
     }
     getSql() {
@@ -60,6 +60,10 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.append(' ');
             this.visitNode(node.having);
         }
+        if (node.union) {
+            this.append(' ');
+            this.compileList(node.union, ' ');
+        }
         if (node.orderBy) {
             this.append(' ');
             this.visitNode(node.orderBy);
@@ -86,6 +90,12 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
         this.append('from ');
         this.compileList(node.froms);
     }
+    visitSelection(node) {
+        this.visitNode(node.selection);
+    }
+    visitColumn(node) {
+        this.visitNode(node.column);
+    }
     compileDistinctOn(selections) {
         this.append('distinct on (');
         this.compileList(selections);
@@ -627,6 +637,13 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
         this.append('drop constraint ');
         this.visitNode(node.constraintName);
     }
+    visitUnion(node) {
+        this.append('union ');
+        if (node.all) {
+            this.append('all ');
+        }
+        this.visitNode(node.union);
+    }
     append(str) {
         this.#sql += str;
     }

package/dist/esm/query-executor/default-query-executor.d.ts

@@ -9,6 +9,7 @@ export declare class DefaultQueryExecutor extends QueryExecutor {
     constructor(compiler: QueryCompiler, connectionProvider: ConnectionProvider, plugins?: KyselyPlugin[]);
     compileQuery(node: RootOperationNode): CompiledQuery;
     protected executeQueryImpl<R>(compiledQuery: CompiledQuery): Promise<QueryResult<R>>;
+    withPlugin(plugin: KyselyPlugin): DefaultQueryExecutor;
     withPluginAtFront(plugin: KyselyPlugin): DefaultQueryExecutor;
     withConnectionProvider(connectionProvider: ConnectionProvider): QueryExecutor;
     withoutPlugins(): QueryExecutor;

package/dist/esm/query-executor/default-query-executor.js

@@ -15,6 +15,12 @@ export class DefaultQueryExecutor extends QueryExecutor {
             return connection.executeQuery(compiledQuery);
         });
     }
+    withPlugin(plugin) {
+        return new DefaultQueryExecutor(this.#compiler, this.#connectionProvider, [
+            ...this.plugins,
+            plugin,
+        ]);
+    }
     withPluginAtFront(plugin) {
         return new DefaultQueryExecutor(this.#compiler, this.#connectionProvider, [
             plugin,

package/dist/esm/query-executor/noop-query-executor.d.ts

@@ -11,6 +11,7 @@ export declare class NoopQueryExecutor extends QueryExecutor {
     compileQuery(): CompiledQuery;
     protected executeQueryImpl<R>(): Promise<QueryResult<R>>;
     withConnectionProvider(): QueryExecutor;
+    withPlugin(plugin: KyselyPlugin): NoopQueryExecutor;
     withPluginAtFront(plugin: KyselyPlugin): NoopQueryExecutor;
     withoutPlugins(): QueryExecutor;
 }

package/dist/esm/query-executor/noop-query-executor.js

@@ -14,6 +14,9 @@ export class NoopQueryExecutor extends QueryExecutor {
     withConnectionProvider() {
         throw new Error('this query cannot have a connection provider');
     }
+    withPlugin(plugin) {
+        return new NoopQueryExecutor([...this.plugins, plugin]);
+    }
     withPluginAtFront(plugin) {
         return new NoopQueryExecutor([plugin, ...this.plugins]);
     }

package/dist/esm/query-executor/query-executor.d.ts

@@ -35,15 +35,20 @@ export declare abstract class QueryExecutor {
      * Executes a compiled query.
      */
     protected abstract executeQueryImpl<R>(compiledQuery: CompiledQuery, queryId: QueryId): Promise<QueryResult<R>>;
+    /**
+     * Returns a copy of this executor with a new connection provider.
+     */
+    abstract withConnectionProvider(connectionProvider: ConnectionProvider): QueryExecutor;
     /**
      * Returns a copy of this executor with a plugin added as the
-     * first plugin.
+     * last plugin.
      */
-    abstract withPluginAtFront(plugin: KyselyPlugin): QueryExecutor;
+    abstract withPlugin(plugin: KyselyPlugin): QueryExecutor;
     /**
-     * Returns a copy of this executor with a new connection provider.
+     * Returns a copy of this executor with a plugin added as the
+     * first plugin.
      */
-    abstract withConnectionProvider(connectionProvider: ConnectionProvider): QueryExecutor;
+    abstract withPluginAtFront(plugin: KyselyPlugin): QueryExecutor;
     /**
      * Returns a copy of this executor without any plugins.
      */

package/dist/esm/util/log.d.ts

@@ -0,0 +1,19 @@
+import { ArrayItemType } from './type-utils.js';
+export declare const LOG_LEVELS: readonly ["query", "error"];
+export declare type LogLevel = ArrayItemType<typeof LOG_LEVELS>;
+export declare class Log {
+    #private;
+    constructor(levels: ReadonlyArray<LogLevel>);
+    query(getEvent: () => QueryLogEvent): void;
+    error(getEvent: () => ErrorLogEvent): void;
+}
+export declare type LogEvent = QueryLogEvent | ErrorLogEvent;
+export interface QueryLogEvent {
+    readonly level: 'query';
+    readonly sql: string;
+    readonly queryDurationMillis: number;
+}
+export interface ErrorLogEvent {
+    readonly level: 'error';
+    readonly error: unknown;
+}

package/dist/esm/util/log.js

@@ -0,0 +1,33 @@
+import { freeze } from './object-utils.js';
+export const LOG_LEVELS = ['query', 'error'];
+export class Log {
+    #levels;
+    constructor(levels) {
+        this.#levels = freeze({
+            query: levels.includes('query'),
+            error: levels.includes('error'),
+        });
+    }
+    query(getEvent) {
+        if (this.#levels.query) {
+            this.#defaultQuery(getEvent());
+        }
+    }
+    error(getEvent) {
+        if (this.#levels.error) {
+            this.#defaultError(getEvent());
+        }
+    }
+    #defaultQuery(event) {
+        console.log(`kysely:query: ${event.sql}`);
+        console.log(`kysely:query: duration: ${event.queryDurationMillis.toFixed(1)}ms`);
+    }
+    #defaultError(event) {
+        if (event.error instanceof Error) {
+            console.error(`kysely:error: ${event.error.stack ?? event.error.message}`);
+        }
+        else {
+            console.error(`kysely:error: ${event}`);
+        }
+    }
+}

package/dist/esm/util/random-string.js

@@ -1,8 +1,11 @@
 const CHARS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
 export function randomString(length) {
-    let chars = new Array(length);
+    let chars = '';
     for (let i = 0; i < length; ++i) {
-        chars[i] = CHARS[Math.floor(Math.random() * CHARS.length)];
+        chars += randomChar();
     }
-    return chars.join('');
+    return chars;
+}
+function randomChar() {
+    return CHARS[Math.floor(Math.random() * CHARS.length)];
 }

package/dist/esm/util/type-utils.d.ts

@@ -136,19 +136,19 @@ export declare type RawBuilderFactory<DB, TB extends keyof DB> = (qb: Expression
 export declare type AliasedRawBuilderFactory<DB, TB extends keyof DB> = (qb: ExpressionBuilder<DB, TB>) => AnyAliasedRawBuilder;
 export interface InsertResultTypeTag {
     /** @internal */
-    __isInsertResultTypeTag__: true;
+    readonly __isInsertResultTypeTag__: true;
 }
 export interface DeleteResultTypeTag {
     /** @internal */
-    __isDeleteResultTypeTag__: true;
+    readonly __isDeleteResultTypeTag__: true;
 }
 export interface UpdateResultTypeTag {
     /** @internal */
-    __isUpdateResultTypeTag__: true;
+    readonly __isUpdateResultTypeTag__: true;
 }
 export interface GeneratedPlaceholder {
     /** @internal */
-    __isGeneratedPlaceholder__: true;
+    readonly __isGeneratedPlaceholder__: true;
 }
 export declare type ManyResultRowType<O> = O extends InsertResultTypeTag ? number | undefined : O extends DeleteResultTypeTag ? number : O extends UpdateResultTypeTag ? number : O;
 export declare type SingleResultRowType<O> = O extends InsertResultTypeTag ? number | undefined : O extends DeleteResultTypeTag ? number : O extends UpdateResultTypeTag ? number : O | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kysely",
-  "version": "0.9.2",
+  "version": "0.9.6",
   "description": "Type safe SQL query builder",
   "repository": {
     "type": "git",