kysely 0.27.3 → 0.27.5

package/dist/cjs/parser/table-parser.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseTable = exports.parseAliasedTable = exports.parseTableExpression = exports.parseTableExpressionOrList = void 0;
+exports.parseTableExpressionOrList = parseTableExpressionOrList;
+exports.parseTableExpression = parseTableExpression;
+exports.parseAliasedTable = parseAliasedTable;
+exports.parseTable = parseTable;
 const object_utils_js_1 = require("../util/object-utils.js");
 const alias_node_js_1 = require("../operation-node/alias-node.js");
 const table_node_js_1 = require("../operation-node/table-node.js");
@@ -14,7 +17,6 @@ function parseTableExpressionOrList(table) {
         return [parseTableExpression(table)];
     }
 }
-exports.parseTableExpressionOrList = parseTableExpressionOrList;
 function parseTableExpression(table) {
     if ((0, object_utils_js_1.isString)(table)) {
         return parseAliasedTable(table);
@@ -23,7 +25,6 @@ function parseTableExpression(table) {
         return (0, expression_parser_js_1.parseAliasedExpression)(table);
     }
 }
-exports.parseTableExpression = parseTableExpression;
 function parseAliasedTable(from) {
     const ALIAS_SEPARATOR = ' as ';
     if (from.includes(ALIAS_SEPARATOR)) {
@@ -34,7 +35,6 @@ function parseAliasedTable(from) {
         return parseTable(from);
     }
 }
-exports.parseAliasedTable = parseAliasedTable;
 function parseTable(from) {
     const SCHEMA_SEPARATOR = '.';
     if (from.includes(SCHEMA_SEPARATOR)) {
@@ -45,7 +45,6 @@ function parseTable(from) {
         return table_node_js_1.TableNode.create(from);
     }
 }
-exports.parseTable = parseTable;
 function trim(str) {
     return str.trim();
 }

package/dist/cjs/parser/top-parser.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseTop = void 0;
+exports.parseTop = parseTop;
 const top_node_js_1 = require("../operation-node/top-node.js");
 const object_utils_js_1 = require("../util/object-utils.js");
 function parseTop(expression, modifiers) {
@@ -12,7 +12,6 @@ function parseTop(expression, modifiers) {
     }
     return top_node_js_1.TopNode.create(expression, modifiers);
 }
-exports.parseTop = parseTop;
 function isTopModifiers(modifiers) {
     return (modifiers === 'percent' ||
         modifiers === 'with ties' ||

package/dist/cjs/parser/unary-operation-parser.js

@@ -1,18 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseUnaryOperation = exports.parseNotExists = exports.parseExists = void 0;
+exports.parseExists = parseExists;
+exports.parseNotExists = parseNotExists;
+exports.parseUnaryOperation = parseUnaryOperation;
 const operator_node_js_1 = require("../operation-node/operator-node.js");
 const unary_operation_node_js_1 = require("../operation-node/unary-operation-node.js");
 const reference_parser_js_1 = require("./reference-parser.js");
 function parseExists(operand) {
     return parseUnaryOperation('exists', operand);
 }
-exports.parseExists = parseExists;
 function parseNotExists(operand) {
     return parseUnaryOperation('not exists', operand);
 }
-exports.parseNotExists = parseNotExists;
 function parseUnaryOperation(operator, operand) {
     return unary_operation_node_js_1.UnaryOperationNode.create(operator_node_js_1.OperatorNode.create(operator), (0, reference_parser_js_1.parseReferenceExpression)(operand));
 }
-exports.parseUnaryOperation = parseUnaryOperation;

package/dist/cjs/parser/update-set-parser.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseUpdateObjectExpression = exports.parseUpdate = void 0;
+exports.parseUpdate = parseUpdate;
+exports.parseUpdateObjectExpression = parseUpdateObjectExpression;
 const column_node_js_1 = require("../operation-node/column-node.js");
 const column_update_node_js_1 = require("../operation-node/column-update-node.js");
 const expression_builder_js_1 = require("../expression/expression-builder.js");
@@ -15,7 +16,6 @@ function parseUpdate(...args) {
     }
     return parseUpdateObjectExpression(args[0]);
 }
-exports.parseUpdate = parseUpdate;
 function parseUpdateObjectExpression(update) {
     const updateObj = (0, object_utils_js_1.isFunction)(update) ? update((0, expression_builder_js_1.expressionBuilder)()) : update;
     return Object.entries(updateObj)
@@ -24,4 +24,3 @@ function parseUpdateObjectExpression(update) {
         return column_update_node_js_1.ColumnUpdateNode.create(column_node_js_1.ColumnNode.create(key), (0, value_parser_js_1.parseValueExpression)(value));
     });
 }
-exports.parseUpdateObjectExpression = parseUpdateObjectExpression;

package/dist/cjs/parser/value-parser.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseSafeImmediateValue = exports.isSafeImmediateValue = exports.parseValueExpression = exports.parseValueExpressionOrList = void 0;
+exports.parseValueExpressionOrList = parseValueExpressionOrList;
+exports.parseValueExpression = parseValueExpression;
+exports.isSafeImmediateValue = isSafeImmediateValue;
+exports.parseSafeImmediateValue = parseSafeImmediateValue;
 const primitive_value_list_node_js_1 = require("../operation-node/primitive-value-list-node.js");
 const value_list_node_js_1 = require("../operation-node/value-list-node.js");
 const value_node_js_1 = require("../operation-node/value-node.js");
@@ -12,25 +15,21 @@ function parseValueExpressionOrList(arg) {
     }
     return parseValueExpression(arg);
 }
-exports.parseValueExpressionOrList = parseValueExpressionOrList;
 function parseValueExpression(exp) {
     if ((0, expression_parser_js_1.isExpressionOrFactory)(exp)) {
         return (0, expression_parser_js_1.parseExpression)(exp);
     }
     return value_node_js_1.ValueNode.create(exp);
 }
-exports.parseValueExpression = parseValueExpression;
 function isSafeImmediateValue(value) {
     return (0, object_utils_js_1.isNumber)(value) || (0, object_utils_js_1.isBoolean)(value) || (0, object_utils_js_1.isNull)(value);
 }
-exports.isSafeImmediateValue = isSafeImmediateValue;
 function parseSafeImmediateValue(value) {
     if (!isSafeImmediateValue(value)) {
         throw new Error(`unsafe immediate value ${JSON.stringify(value)}`);
     }
     return value_node_js_1.ValueNode.createImmediate(value);
 }
-exports.parseSafeImmediateValue = parseSafeImmediateValue;
 function parseValueExpressionList(arg) {
     if (arg.some(expression_parser_js_1.isExpressionOrFactory)) {
         return value_list_node_js_1.ValueListNode.create(arg.map((it) => parseValueExpression(it)));

package/dist/cjs/parser/with-parser.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseCommonTableExpression = void 0;
+exports.parseCommonTableExpression = parseCommonTableExpression;
 const common_table_expression_name_node_js_1 = require("../operation-node/common-table-expression-name-node.js");
 const parse_utils_js_1 = require("./parse-utils.js");
 const object_utils_js_1 = require("../util/object-utils.js");
@@ -13,7 +13,6 @@ function parseCommonTableExpression(nameOrBuilderCallback, expression) {
     }
     return common_table_expression_node_js_1.CommonTableExpressionNode.create(parseCommonTableExpressionName(nameOrBuilderCallback), expressionNode);
 }
-exports.parseCommonTableExpression = parseCommonTableExpression;
 function cteBuilderFactory(expressionNode) {
     return (name) => {
         return new cte_builder_js_1.CTEBuilder({

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

@@ -35,47 +35,48 @@ export interface CamelCasePluginOptions {
 }
 /**
  * A plugin that converts snake_case identifiers in the database into
- * camelCase in the javascript side.
+ * camelCase in the JavaScript side.
  *
  * For example let's assume we have a table called `person_table`
  * with columns `first_name` and `last_name` in the database. When
  * using `CamelCasePlugin` we would setup Kysely like this:
  *
  * ```ts
- * interface Person {
- *   firstName: string
- *   lastName: string
- * }
+ * import * as Sqlite from 'better-sqlite3'
+ * import { CamelCasePlugin, Kysely, SqliteDialect } from 'kysely'
  *
- * interface Database {
- *   personTable: Person
+ * interface CamelCasedDatabase {
+ *   userMetadata: {
+ *     firstName: string
+ *     lastName: string
+ *   }
  * }
  *
- * const db = new Kysely<Database>({
- *   dialect: new PostgresDialect({
- *     database: 'kysely_test',
- *     host: 'localhost',
+ * const db = new Kysely<CamelCasedDatabase>({
+ *   dialect: new SqliteDialect({
+ *     database: new Sqlite(':memory:'),
  *   }),
- *   plugins: [
- *     new CamelCasePlugin()
- *   ]
+ *   plugins: [new CamelCasePlugin()],
  * })
  *
- * const person = await db.selectFrom('personTable')
+ * const person = await db.selectFrom('userMetadata')
  *   .where('firstName', '=', 'Arnold')
  *   .select(['firstName', 'lastName'])
  *   .executeTakeFirst()
  *
- * // generated sql:
- * // select first_name, last_name from person_table where first_name = $1
- *
  * if (person) {
  *   console.log(person.firstName)
  * }
  * ```
  *
+ * The generated SQL (SQLite):
+ *
+ * ```sql
+ * select "first_name", "last_name" from "user_metadata" where "first_name" = ?
+ * ```
+ *
  * As you can see from the example, __everything__ needs to be defined
- * in camelCase in the typescript code: table names, columns, schemas,
+ * in camelCase in the TypeScript code: table names, columns, schemas,
  * __everything__. When using the `CamelCasePlugin` Kysely works as if
  * the database was defined in camelCase.
  *
@@ -88,11 +89,15 @@ export interface CamelCasePluginOptions {
  * ```ts
  * class MyCamelCasePlugin extends CamelCasePlugin {
  *   protected override snakeCase(str: string): string {
- *     return mySnakeCase(str)
+ *     // ...
+ *
+ *     return str
  *   }
  *
  *   protected override camelCase(str: string): string {
- *     return myCamelCase(str)
+ *     // ...
+ *
+ *     return str
  *   }
  * }
  * ```
@@ -111,19 +116,41 @@ export declare class CamelCasePlugin implements KyselyPlugin {
      * can use a `WeakMap` with {@link PluginTransformQueryArgs.queryId | args.queryId} as the key:
      *
      * ```ts
-     * const plugin = {
-     *   data: new WeakMap<QueryId, SomeData>(),
+     * import type {
+     *   KyselyPlugin,
+     *   QueryResult,
+     *   RootOperationNode,
+     *   UnknownRow
+     * } from 'kysely'
+     *
+     * interface MyData {
+     *   // ...
+     * }
+     * const data = new WeakMap<any, MyData>()
      *
+     * const plugin = {
      *   transformQuery(args: PluginTransformQueryArgs): RootOperationNode {
-     *     this.data.set(args.queryId, something)
+     *     const something: MyData = {}
+     *
+     *     // ...
+     *
+     *     data.set(args.queryId, something)
+     *
+     *     // ...
+     *
      *     return args.node
      *   },
      *
-     *   transformResult(args: PluginTransformResultArgs): QueryResult<UnknownRow> {
-     *     const data = this.data.get(args.queryId)
+     *   async transformResult(args: PluginTransformResultArgs): Promise<QueryResult<UnknownRow>> {
+     *     // ...
+     *
+     *     const something = data.get(args.queryId)
+     *
+     *     // ...
+     *
      *     return args.result
      *   }
-     * }
+     * } satisfies KyselyPlugin
      * ```
      *
      * You should use a `WeakMap` instead of a `Map` or some other strong references because `transformQuery`

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

@@ -6,47 +6,48 @@ const camel_case_transformer_js_1 = require("./camel-case-transformer.js");
 const camel_case_js_1 = require("./camel-case.js");
 /**
  * A plugin that converts snake_case identifiers in the database into
- * camelCase in the javascript side.
+ * camelCase in the JavaScript side.
  *
  * For example let's assume we have a table called `person_table`
  * with columns `first_name` and `last_name` in the database. When
  * using `CamelCasePlugin` we would setup Kysely like this:
  *
  * ```ts
- * interface Person {
- *   firstName: string
- *   lastName: string
- * }
+ * import * as Sqlite from 'better-sqlite3'
+ * import { CamelCasePlugin, Kysely, SqliteDialect } from 'kysely'
  *
- * interface Database {
- *   personTable: Person
+ * interface CamelCasedDatabase {
+ *   userMetadata: {
+ *     firstName: string
+ *     lastName: string
+ *   }
  * }
  *
- * const db = new Kysely<Database>({
- *   dialect: new PostgresDialect({
- *     database: 'kysely_test',
- *     host: 'localhost',
+ * const db = new Kysely<CamelCasedDatabase>({
+ *   dialect: new SqliteDialect({
+ *     database: new Sqlite(':memory:'),
  *   }),
- *   plugins: [
- *     new CamelCasePlugin()
- *   ]
+ *   plugins: [new CamelCasePlugin()],
  * })
  *
- * const person = await db.selectFrom('personTable')
+ * const person = await db.selectFrom('userMetadata')
  *   .where('firstName', '=', 'Arnold')
  *   .select(['firstName', 'lastName'])
  *   .executeTakeFirst()
  *
- * // generated sql:
- * // select first_name, last_name from person_table where first_name = $1
- *
  * if (person) {
  *   console.log(person.firstName)
  * }
  * ```
  *
+ * The generated SQL (SQLite):
+ *
+ * ```sql
+ * select "first_name", "last_name" from "user_metadata" where "first_name" = ?
+ * ```
+ *
  * As you can see from the example, __everything__ needs to be defined
- * in camelCase in the typescript code: table names, columns, schemas,
+ * in camelCase in the TypeScript code: table names, columns, schemas,
  * __everything__. When using the `CamelCasePlugin` Kysely works as if
  * the database was defined in camelCase.
  *
@@ -59,11 +60,15 @@ const camel_case_js_1 = require("./camel-case.js");
  * ```ts
  * class MyCamelCasePlugin extends CamelCasePlugin {
  *   protected override snakeCase(str: string): string {
- *     return mySnakeCase(str)
+ *     // ...
+ *
+ *     return str
  *   }
  *
  *   protected override camelCase(str: string): string {
- *     return myCamelCase(str)
+ *     // ...
+ *
+ *     return str
  *   }
  * }
  * ```

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createCamelCaseMapper = exports.createSnakeCaseMapper = void 0;
+exports.createSnakeCaseMapper = createSnakeCaseMapper;
+exports.createCamelCaseMapper = createCamelCaseMapper;
 /**
  * Creates a function that transforms camel case strings to snake case.
  */
@@ -52,7 +53,6 @@ function createSnakeCaseMapper({ upperCase = false, underscoreBeforeDigits = fal
         }
     });
 }
-exports.createSnakeCaseMapper = createSnakeCaseMapper;
 /**
  * Creates a function that transforms snake case strings to camel case.
  */
@@ -83,7 +83,6 @@ function createCamelCaseMapper({ upperCase = false, } = {}) {
         return out;
     });
 }
-exports.createCamelCaseMapper = createCamelCaseMapper;
 function isAllUpperCaseSnakeCase(str) {
     for (let i = 1, l = str.length; i < l; ++i) {
         const char = str[i];

package/dist/cjs/plugin/deduplicate-joins/deduplicate-joins-plugin.d.ts

@@ -5,7 +5,7 @@ import { KyselyPlugin, PluginTransformQueryArgs, PluginTransformResultArgs } fro
 /**
  * Plugin that removes duplicate joins from queries.
  *
- * See [this recipe](https://github.com/koskimas/kysely/tree/master/site/docs/recipes/deduplicate-joins.md)
+ * See [this recipe](https://github.com/kysely-org/kysely/blob/master/site/docs/recipes/0008-deduplicate-joins.md)
  */
 export declare class DeduplicateJoinsPlugin implements KyselyPlugin {
     #private;
@@ -19,19 +19,41 @@ export declare class DeduplicateJoinsPlugin implements KyselyPlugin {
      * can use a `WeakMap` with {@link PluginTransformQueryArgs.queryId | args.queryId} as the key:
      *
      * ```ts
-     * const plugin = {
-     *   data: new WeakMap<QueryId, SomeData>(),
+     * import type {
+     *   KyselyPlugin,
+     *   QueryResult,
+     *   RootOperationNode,
+     *   UnknownRow
+     * } from 'kysely'
+     *
+     * interface MyData {
+     *   // ...
+     * }
+     * const data = new WeakMap<any, MyData>()
      *
+     * const plugin = {
      *   transformQuery(args: PluginTransformQueryArgs): RootOperationNode {
-     *     this.data.set(args.queryId, something)
+     *     const something: MyData = {}
+     *
+     *     // ...
+     *
+     *     data.set(args.queryId, something)
+     *
+     *     // ...
+     *
      *     return args.node
      *   },
      *
-     *   transformResult(args: PluginTransformResultArgs): QueryResult<UnknownRow> {
-     *     const data = this.data.get(args.queryId)
+     *   async transformResult(args: PluginTransformResultArgs): Promise<QueryResult<UnknownRow>> {
+     *     // ...
+     *
+     *     const something = data.get(args.queryId)
+     *
+     *     // ...
+     *
      *     return args.result
      *   }
-     * }
+     * } satisfies KyselyPlugin
      * ```
      *
      * You should use a `WeakMap` instead of a `Map` or some other strong references because `transformQuery`

package/dist/cjs/plugin/deduplicate-joins/deduplicate-joins-plugin.js

@@ -5,7 +5,7 @@ const deduplicate_joins_transformer_js_1 = require("./deduplicate-joins-transfor
 /**
  * Plugin that removes duplicate joins from queries.
  *
- * See [this recipe](https://github.com/koskimas/kysely/tree/master/site/docs/recipes/deduplicate-joins.md)
+ * See [this recipe](https://github.com/kysely-org/kysely/blob/master/site/docs/recipes/0008-deduplicate-joins.md)
  */
 class DeduplicateJoinsPlugin {
     #transformer = new deduplicate_joins_transformer_js_1.DeduplicateJoinsTransformer();

package/dist/cjs/plugin/deduplicate-joins/deduplicate-joins-transformer.js

@@ -26,8 +26,8 @@ class DeduplicateJoinsTransformer extends operation_node_transformer_js_1.Operat
         const out = [];
         for (let i = 0; i < joins.length; ++i) {
             let foundDuplicate = false;
-            for (let j = i + 1; j < joins.length; ++j) {
-                if ((0, object_utils_js_1.compare)(joins[i], joins[j])) {
+            for (let j = 0; j < out.length; ++j) {
+                if ((0, object_utils_js_1.compare)(joins[i], out[j])) {
                     foundDuplicate = true;
                     break;
                 }

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

@@ -22,19 +22,41 @@ export declare class ImmediateValuePlugin implements KyselyPlugin {
      * can use a `WeakMap` with {@link PluginTransformQueryArgs.queryId | args.queryId} as the key:
      *
      * ```ts
-     * const plugin = {
-     *   data: new WeakMap<QueryId, SomeData>(),
+     * import type {
+     *   KyselyPlugin,
+     *   QueryResult,
+     *   RootOperationNode,
+     *   UnknownRow
+     * } from 'kysely'
+     *
+     * interface MyData {
+     *   // ...
+     * }
+     * const data = new WeakMap<any, MyData>()
      *
+     * const plugin = {
      *   transformQuery(args: PluginTransformQueryArgs): RootOperationNode {
-     *     this.data.set(args.queryId, something)
+     *     const something: MyData = {}
+     *
+     *     // ...
+     *
+     *     data.set(args.queryId, something)
+     *
+     *     // ...
+     *
      *     return args.node
      *   },
      *
-     *   transformResult(args: PluginTransformResultArgs): QueryResult<UnknownRow> {
-     *     const data = this.data.get(args.queryId)
+     *   async transformResult(args: PluginTransformResultArgs): Promise<QueryResult<UnknownRow>> {
+     *     // ...
+     *
+     *     const something = data.get(args.queryId)
+     *
+     *     // ...
+     *
      *     return args.result
      *   }
-     * }
+     * } satisfies KyselyPlugin
      * ```
      *
      * You should use a `WeakMap` instead of a `Map` or some other strong references because `transformQuery`

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

@@ -13,19 +13,41 @@ export interface KyselyPlugin {
      * can use a `WeakMap` with {@link PluginTransformQueryArgs.queryId | args.queryId} as the key:
      *
      * ```ts
-     * const plugin = {
-     *   data: new WeakMap<QueryId, SomeData>(),
+     * import type {
+     *   KyselyPlugin,
+     *   QueryResult,
+     *   RootOperationNode,
+     *   UnknownRow
+     * } from 'kysely'
+     *
+     * interface MyData {
+     *   // ...
+     * }
+     * const data = new WeakMap<any, MyData>()
      *
+     * const plugin = {
      *   transformQuery(args: PluginTransformQueryArgs): RootOperationNode {
-     *     this.data.set(args.queryId, something)
+     *     const something: MyData = {}
+     *
+     *     // ...
+     *
+     *     data.set(args.queryId, something)
+     *
+     *     // ...
+     *
      *     return args.node
      *   },
      *
-     *   transformResult(args: PluginTransformResultArgs): QueryResult<UnknownRow> {
-     *     const data = this.data.get(args.queryId)
+     *   async transformResult(args: PluginTransformResultArgs): Promise<QueryResult<UnknownRow>> {
+     *     // ...
+     *
+     *     const something = data.get(args.queryId)
+     *
+     *     // ...
+     *
      *     return args.result
      *   }
-     * }
+     * } satisfies KyselyPlugin
      * ```
      *
      * You should use a `WeakMap` instead of a `Map` or some other strong references because `transformQuery`

package/dist/cjs/plugin/noop-plugin.d.ts

@@ -13,19 +13,41 @@ export declare class NoopPlugin implements KyselyPlugin {
      * can use a `WeakMap` with {@link PluginTransformQueryArgs.queryId | args.queryId} as the key:
      *
      * ```ts
-     * const plugin = {
-     *   data: new WeakMap<QueryId, SomeData>(),
+     * import type {
+     *   KyselyPlugin,
+     *   QueryResult,
+     *   RootOperationNode,
+     *   UnknownRow
+     * } from 'kysely'
+     *
+     * interface MyData {
+     *   // ...
+     * }
+     * const data = new WeakMap<any, MyData>()
      *
+     * const plugin = {
      *   transformQuery(args: PluginTransformQueryArgs): RootOperationNode {
-     *     this.data.set(args.queryId, something)
+     *     const something: MyData = {}
+     *
+     *     // ...
+     *
+     *     data.set(args.queryId, something)
+     *
+     *     // ...
+     *
      *     return args.node
      *   },
      *
-     *   transformResult(args: PluginTransformResultArgs): QueryResult<UnknownRow> {
-     *     const data = this.data.get(args.queryId)
+     *   async transformResult(args: PluginTransformResultArgs): Promise<QueryResult<UnknownRow>> {
+     *     // ...
+     *
+     *     const something = data.get(args.queryId)
+     *
+     *     // ...
+     *
      *     return args.result
      *   }
-     * }
+     * } satisfies KyselyPlugin
      * ```
      *
      * You should use a `WeakMap` instead of a `Map` or some other strong references because `transformQuery`