kysely 0.9.1 → 0.9.5

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

@@ -1,5 +1,6 @@
-import { OperationNodeTransformer } from '../../operation-node/operation-node-transformer.js';
 import { isObject } from '../../util/object-utils.js';
+import { SnakeCaseTransformer } from './camel-case-transformer.js';
+import { createCamelCaseMapper, createSnakeCaseMapper, } from './camel-case.js';
 /**
  * A plugin that converts snake_case identifiers in the database into
  * camelCase in the javascript side.
@@ -69,8 +70,8 @@ export class CamelCasePlugin {
     #snakeCase;
     #snakeCaseTransformer;
     constructor(opt = {}) {
-        this.#camelCase = createCamelCase(opt);
-        this.#snakeCase = createSnakeCase(opt);
+        this.#camelCase = createCamelCaseMapper(opt);
+        this.#snakeCase = createSnakeCaseMapper(opt);
         this.#snakeCaseTransformer = new SnakeCaseTransformer(this.snakeCase.bind(this));
     }
     transformQuery(args) {
@@ -105,118 +106,6 @@ export class CamelCasePlugin {
         return this.#camelCase(str);
     }
 }
-class SnakeCaseTransformer extends OperationNodeTransformer {
-    #snakeCase;
-    constructor(snakeCase) {
-        super();
-        this.#snakeCase = snakeCase;
-    }
-    transformIdentifier(node) {
-        node = super.transformIdentifier(node);
-        return {
-            ...node,
-            identifier: this.#snakeCase(node.identifier),
-        };
-    }
-}
 function canMap(obj) {
     return isObject(obj) && !(obj instanceof Date) && !Buffer.isBuffer(obj);
 }
-function createSnakeCase({ 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;
-        }
-    });
-}
-function createCamelCase({ 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/camel-case/camel-case-transformer.d.ts

@@ -0,0 +1,8 @@
+import { IdentifierNode } from '../../operation-node/identifier-node.js';
+import { OperationNodeTransformer } from '../../operation-node/operation-node-transformer.js';
+import { StringMapper } from './camel-case.js';
+export declare class SnakeCaseTransformer extends OperationNodeTransformer {
+    #private;
+    constructor(snakeCase: StringMapper);
+    protected transformIdentifier(node: IdentifierNode): IdentifierNode;
+}

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

@@ -0,0 +1,15 @@
+import { OperationNodeTransformer } from '../../operation-node/operation-node-transformer.js';
+export class SnakeCaseTransformer extends OperationNodeTransformer {
+    #snakeCase;
+    constructor(snakeCase) {
+        super();
+        this.#snakeCase = snakeCase;
+    }
+    transformIdentifier(node) {
+        node = super.transformIdentifier(node);
+        return {
+            ...node,
+            identifier: this.#snakeCase(node.identifier),
+        };
+    }
+}

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

@@ -0,0 +1,15 @@
+export declare type StringMapper = (str: string) => string;
+/**
+ * Creates a function that transforms camel case strings to snake case.
+ */
+export declare function createSnakeCaseMapper({ upperCase, underscoreBeforeDigits, underscoreBetweenUppercaseLetters, }?: {
+    upperCase?: boolean | undefined;
+    underscoreBeforeDigits?: boolean | undefined;
+    underscoreBetweenUppercaseLetters?: boolean | undefined;
+}): StringMapper;
+/**
+ * Creates a function that transforms snake case strings to camel case.
+ */
+export declare function createCamelCaseMapper({ upperCase, }?: {
+    upperCase?: boolean | undefined;
+}): StringMapper;

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/join-builder.js

@@ -10,13 +10,13 @@ export class JoinBuilder {
     on(...args) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, 'And', parseOnFilter(this.#props.parseContext, args)),
+            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, parseOnFilter(this.#props.parseContext, args)),
         });
     }
     orOn(...args) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, 'Or', parseOnFilter(this.#props.parseContext, args)),
+            joinNode: JoinNode.cloneWithOrOn(this.#props.joinNode, parseOnFilter(this.#props.parseContext, args)),
         });
     }
     /**
@@ -28,7 +28,7 @@ export class JoinBuilder {
     onRef(lhs, op, rhs) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, 'And', parseReferenceFilter(this.#props.parseContext, lhs, op, rhs)),
+            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, parseReferenceFilter(this.#props.parseContext, lhs, op, rhs)),
         });
     }
     /**
@@ -40,7 +40,7 @@ export class JoinBuilder {
     orOnRef(lhs, op, rhs) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, 'Or', parseReferenceFilter(this.#props.parseContext, lhs, op, rhs)),
+            joinNode: JoinNode.cloneWithOrOn(this.#props.joinNode, parseReferenceFilter(this.#props.parseContext, lhs, op, rhs)),
         });
     }
     /**
@@ -52,7 +52,7 @@ export class JoinBuilder {
     onExists(arg) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, 'And', parseExistFilter(this.#props.parseContext, arg)),
+            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, parseExistFilter(this.#props.parseContext, arg)),
         });
     }
     /**
@@ -64,7 +64,7 @@ export class JoinBuilder {
     onNotExists(arg) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, 'And', parseNotExistFilter(this.#props.parseContext, arg)),
+            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, parseNotExistFilter(this.#props.parseContext, arg)),
         });
     }
     /**
@@ -76,7 +76,7 @@ export class JoinBuilder {
     orOnExists(arg) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, 'Or', parseExistFilter(this.#props.parseContext, arg)),
+            joinNode: JoinNode.cloneWithOrOn(this.#props.joinNode, parseExistFilter(this.#props.parseContext, arg)),
         });
     }
     /**
@@ -88,7 +88,7 @@ export class JoinBuilder {
     orOnNotExists(arg) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, 'Or', parseNotExistFilter(this.#props.parseContext, arg)),
+            joinNode: JoinNode.cloneWithOrOn(this.#props.joinNode, parseNotExistFilter(this.#props.parseContext, arg)),
         });
     }
     toOperationNode() {

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.
      *