kysely 0.9.4 → 0.9.8

package/dist/esm/dialect/postgres/postgres-query-compiler.js

@@ -1,4 +1,4 @@
 import { DefaultQueryCompiler } from '../../query-compiler/default-query-compiler.js';
-// The default query compiler is for postgres dialect.
+// The default query compiler is for PostgreSQL.
 export class PostgresQueryCompiler extends DefaultQueryCompiler {
 }

package/dist/esm/driver/runtime-driver.js

@@ -75,16 +75,30 @@ class RuntimeConnection {
         try {
             return await this.#connection.executeQuery(compiledQuery);
         }
+        catch (error) {
+            this.#logError(error);
+            throw error;
+        }
         finally {
-            this.#log.query((log) => {
-                log(compiledQuery.sql);
-                log(`duration: ${this.#calculateDurationMillis(startTime)}ms`);
-            });
+            this.#logQuery(compiledQuery, startTime);
         }
     }
+    #logError(error) {
+        this.#log.error(() => ({
+            level: 'error',
+            error,
+        }));
+    }
+    #logQuery(compiledQuery, startTime) {
+        this.#log.query(() => ({
+            level: 'query',
+            sql: compiledQuery.sql,
+            queryDurationMillis: this.#calculateDurationMillis(startTime),
+        }));
+    }
     #calculateDurationMillis(startTime) {
         const endTime = process.hrtime.bigint();
-        const durationTensMillis = Number((endTime - startTime) / 100000n);
-        return durationTensMillis / 10;
+        const durationNanos = Number(endTime - startTime);
+        return durationNanos / 1_000_000;
     }
 }

package/dist/esm/index.d.ts

@@ -120,3 +120,4 @@ export { JoinReferenceExpression, JoinCallbackExpression, } from './parser/join-
 export { InsertObject } from './parser/insert-values-parser.js';
 export { MutationObject } from './parser/update-set-parser.js';
 export { OrderByExpression, OrderByDirectionExpression, } from './parser/order-by-parser.js';
+export { UnionExpression } from './parser/union-parser.js';

package/dist/esm/kysely.d.ts

@@ -194,6 +194,10 @@ export declare class Kysely<DB> extends QueryCreator<DB> {
      * ```
      */
     connection(): ConnectionBuilder<DB>;
+    /**
+     * Returns a copy of this Kysely instance with the given plugin installed.
+     */
+    withPlugin(plugin: KyselyPlugin): Kysely<DB>;
     /**
      * Returns a copy of this Kysely instance without any plugins.
      */
@@ -231,12 +235,13 @@ export interface KyselyConfig {
     /**
      * A list of log levels to log.
      *
-     * Currently there's only one level: `query` and it's logged using
-     * `console.log`. This will be expanded based on user request later.
+     * Currently there's only two levels: `query` and `error`.
+     * This will be expanded based on user feedback later.
      *
      * Log levels:
      *
-     *  - query: Log each query's SQL and duration.
+     *  - query: Log each query's SQL and duration using console.log
+     *  - error: Log all query errors using console.error
      */
     readonly log?: ReadonlyArray<LogLevel>;
 }

package/dist/esm/kysely.js

@@ -235,6 +235,15 @@ export class Kysely extends QueryCreator {
     connection() {
         return new ConnectionBuilder({ ...this.#props });
     }
+    /**
+     * Returns a copy of this Kysely instance with the given plugin installed.
+     */
+    withPlugin(plugin) {
+        return new Kysely({
+            ...this.#props,
+            executor: this.#props.executor.withPlugin(plugin),
+        });
+    }
     /**
      * Returns a copy of this Kysely instance without any plugins.
      */

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

@@ -1,6 +1,6 @@
 import { ArrayItemType } from '../util/type-utils.js';
 import { OperationNode } from './operation-node.js';
-export declare const OPERATORS: readonly ["=", "==", "!=", "<>", ">", ">=", "<", "<=", "in", "not in", "is", "is not", "like", "not like", "ilike", "not ilike", "@>", "<@", "?", "?", "?&", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "exists", "not exists"];
+export declare const OPERATORS: readonly ["=", "==", "!=", "<>", ">", ">=", "<", "<=", "in", "not in", "is", "is not", "like", "not like", "ilike", "not ilike", "@>", "<@", "?", "?", "?&", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "exists", "not exists", "&&", "||", "@@", "@@@", "!!", "<->"];
 export declare type Operator = ArrayItemType<typeof OPERATORS>;
 export interface OperatorNode extends OperationNode {
     readonly kind: 'OperatorNode';

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

@@ -30,6 +30,12 @@ export const OPERATORS = [
     '!~*',
     'exists',
     'not exists',
+    '&&',
+    '||',
+    '@@',
+    '@@@',
+    '!!',
+    '<->',
 ];
 /**
  * @internal

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/query-builder.d.ts

@@ -1583,7 +1583,7 @@ export declare class QueryBuilder<DB, TB extends keyof DB, O = {}> implements Op
      */
     unionAll(expression: UnionExpression<DB, O>): QueryBuilder<DB, TB, O>;
     /**
-     * Simply calls the given method passing `this` as the only argument.
+     * Simply calls the given function passing `this` as the only argument.
      *
      * This method can be useful when adding optional method calls:
      *

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

@@ -816,7 +816,7 @@ export class QueryBuilder {
         });
     }
     /**
-     * Simply calls the given method passing `this` as the only argument.
+     * Simply calls the given function passing `this` as the only argument.
      *
      * This method can be useful when adding optional method calls:
      *

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

@@ -1,8 +1,19 @@
 import { ArrayItemType } from './type-utils.js';
-export declare const LOG_LEVELS: readonly ["query"];
+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(callback: (log: (message: string) => void) => void): void;
+    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

@@ -1,17 +1,33 @@
-export const LOG_LEVELS = ['query'];
+import { freeze } from './object-utils.js';
+export const LOG_LEVELS = ['query', 'error'];
 export class Log {
     #levels;
     constructor(levels) {
-        this.#levels = {
+        this.#levels = freeze({
             query: levels.includes('query'),
-        };
+            error: levels.includes('error'),
+        });
     }
-    query(callback) {
+    query(getEvent) {
         if (this.#levels.query) {
-            callback(this.#query);
+            this.#defaultQuery(getEvent());
         }
     }
-    #query(message) {
-        console.log(`kysely:query: ${message}`);
+    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/package.json

@@ -1,11 +1,14 @@
 {
   "name": "kysely",
-  "version": "0.9.4",
+  "version": "0.9.8",
   "description": "Type safe SQL query builder",
   "repository": {
     "type": "git",
     "url": "git://github.com/koskimas/kysely.git"
   },
+  "engines": {
+    "node": ">=16.0.0"
+  },
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
   "exports": {