kysely 0.29.0-rc.0 → 0.29.0

package/dist/dialect/database-introspector.d.ts

@@ -10,12 +10,6 @@ export interface DatabaseIntrospector {
      * Get tables and views metadata.
      */
     getTables(options?: DatabaseMetadataOptions): Promise<TableMetadata[]>;
-    /**
-     * Get the database metadata such as table and column names.
-     *
-     * @deprecated Use getTables() instead.
-     */
-    getMetadata(options?: DatabaseMetadataOptions): Promise<DatabaseMetadata>;
 }
 export interface DatabaseMetadataOptions {
     /**
@@ -27,13 +21,6 @@ export interface DatabaseMetadataOptions {
 export interface SchemaMetadata {
     readonly name: string;
 }
-export interface DatabaseMetadata {
-    /**
-     * The tables and views found in the database.
-     * The propery isView can be used to tell them apart.
-     */
-    readonly tables: TableMetadata[];
-}
 export interface TableMetadata {
     readonly name: string;
     readonly isView: boolean;

package/dist/dialect/mssql/mssql-dialect-config.d.ts

@@ -1,4 +1,3 @@
-import type { KyselyTypeError } from '../../util/type-error.js';
 export interface MssqlDialectConfig {
     /**
      * When `true`, connections are reset to their initial states when released
@@ -74,10 +73,6 @@ export interface Tedious {
     connectionFactory: () => TediousConnection | Promise<TediousConnection>;
     ISOLATION_LEVEL: TediousIsolationLevel;
     Request: TediousRequestClass;
-    /**
-     * @deprecated use {@link MssqlDialectConfig.resetConnectionsOnRelease} instead.
-     */
-    resetConnectionOnRelease?: KyselyTypeError<'deprecated: use `MssqlDialectConfig.resetConnectionsOnRelease` instead'>;
     TYPES: TediousTypes;
 }
 export interface TediousConnection {
@@ -142,12 +137,7 @@ export interface Tarn {
      * Tarn.js' pool options, excluding `create`, `destroy` and `validate` functions,
      * which must be implemented by this dialect.
      */
-    options: Omit<TarnPoolOptions<any>, 'create' | 'destroy' | 'validate'> & {
-        /**
-         * @deprecated use {@link MssqlDialectConfig.validateConnections} instead.
-         */
-        validateConnections?: KyselyTypeError<'deprecated: use `MssqlDialectConfig.validateConnections` instead'>;
-    };
+    options: Omit<TarnPoolOptions<any>, 'create' | 'destroy' | 'validate'>;
     /**
      * Tarn.js' Pool class.
      */

package/dist/dialect/mssql/mssql-driver.js

@@ -13,9 +13,8 @@ export class MssqlDriver {
     constructor(config) {
         this.#config = freeze({ ...config });
         const { tarn, tedious, validateConnections } = this.#config;
-        const { validateConnections: deprecatedValidateConnections, ...poolOptions } = tarn.options;
         this.#pool = new tarn.Pool({
-            ...poolOptions,
+            ...tarn.options,
             create: async () => {
                 const connection = await tedious.connectionFactory();
                 return await new MssqlConnection(connection, tedious).connect();
@@ -25,8 +24,7 @@ export class MssqlDriver {
             },
             // @ts-ignore `tarn` accepts a function that returns a promise here, but
             // the types are not aligned and it type errors.
-            validate: validateConnections === false ||
-                deprecatedValidateConnections === false
+            validate: validateConnections === false
                 ? undefined
                 : (connection) => connection[PRIVATE_VALIDATE_METHOD](),
         });
@@ -53,8 +51,7 @@ export class MssqlDriver {
         await connection.rollbackTransaction(savepointName);
     }
     async releaseConnection(connection) {
-        if (this.#config.resetConnectionsOnRelease ||
-            this.#config.tedious.resetConnectionOnRelease) {
+        if (this.#config.resetConnectionsOnRelease) {
             await connection[PRIVATE_RESET_METHOD]();
         }
         this.#pool.release(connection);
@@ -68,7 +65,6 @@ class MssqlConnection {
     #hasSocketError;
     #tedious;
     #inflightRequest;
-    #sessionId;
     constructor(connection, tedious) {
         this.#connection = connection;
         this.#hasSocketError = false;

package/dist/dialect/mssql/mssql-introspector.d.ts

@@ -1,5 +1,5 @@
 import type { Kysely } from '../../kysely.js';
-import type { DatabaseIntrospector, DatabaseMetadata, DatabaseMetadataOptions, SchemaMetadata, TableMetadata } from '../database-introspector.js';
+import type { DatabaseIntrospector, DatabaseMetadataOptions, SchemaMetadata, TableMetadata } from '../database-introspector.js';
 export declare class MssqlIntrospector implements DatabaseIntrospector {
     #private;
     constructor(db: Kysely<any>);
@@ -11,10 +11,4 @@ export declare class MssqlIntrospector implements DatabaseIntrospector {
      * Get tables and views metadata.
      */
     getTables(options?: DatabaseMetadataOptions): Promise<TableMetadata[]>;
-    /**
-     * Get the database metadata such as table and column names.
-     *
-     * @deprecated Use getTables() instead.
-     */
-    getMetadata(options?: DatabaseMetadataOptions): Promise<DatabaseMetadata>;
 }

package/dist/dialect/mssql/mssql-introspector.js

@@ -100,9 +100,4 @@ export class MssqlIntrospector {
         }
         return Object.values(tableDictionary);
     }
-    async getMetadata(options) {
-        return {
-            tables: await this.getTables(options),
-        };
-    }
 }

package/dist/dialect/mysql/mysql-introspector.d.ts

@@ -1,4 +1,4 @@
-import type { DatabaseIntrospector, DatabaseMetadata, DatabaseMetadataOptions, SchemaMetadata, TableMetadata } from '../database-introspector.js';
+import type { DatabaseIntrospector, DatabaseMetadataOptions, SchemaMetadata, TableMetadata } from '../database-introspector.js';
 import type { Kysely } from '../../kysely.js';
 export declare class MysqlIntrospector implements DatabaseIntrospector {
     #private;
@@ -11,10 +11,4 @@ export declare class MysqlIntrospector implements DatabaseIntrospector {
      * Get tables and views metadata.
      */
     getTables(options?: DatabaseMetadataOptions): Promise<TableMetadata[]>;
-    /**
-     * Get the database metadata such as table and column names.
-     *
-     * @deprecated Use getTables() instead.
-     */
-    getMetadata(options?: DatabaseMetadataOptions): Promise<DatabaseMetadata>;
 }

package/dist/dialect/mysql/mysql-introspector.js

@@ -46,11 +46,6 @@ export class MysqlIntrospector {
         const rawColumns = await query.execute();
         return this.#parseTableMetadata(rawColumns);
     }
-    async getMetadata(options) {
-        return {
-            tables: await this.getTables(options),
-        };
-    }
     #parseTableMetadata(columns) {
         return columns.reduce((tables, it) => {
             let table = tables.find((tbl) => tbl.name === it.TABLE_NAME);

package/dist/dialect/mysql/mysql-query-compiler.d.ts

@@ -17,5 +17,11 @@ export declare class MysqlQueryCompiler extends DefaultQueryCompiler {
      * @see https://dev.mysql.com/doc/refman/9.6/en/string-literals.html
      */
     protected sanitizeStringLiteral(value: string): string;
+    /**
+     * Member values appear inside `"..."` in the JSON path, which itself sits
+     * inside a SQL string literal. They must therefore be escaped twice — once
+     * for the JSON path grammar, then again for MySQL's string literal parser.
+     */
+    protected sanitizeJSONPathMemberValue(value: string): string;
     protected visitCreateIndex(node: CreateIndexNode): void;
 }

package/dist/dialect/mysql/mysql-query-compiler.js

@@ -1,7 +1,8 @@
 /// <reference types="./mysql-query-compiler.d.ts" />
 import { DefaultQueryCompiler } from '../../query-compiler/default-query-compiler.js';
-const LITERAL_ESCAPE_REGEX = /\\|'/g;
+const LITERAL_ESCAPE_REGEX = /[\\']/g;
 const ID_WRAP_REGEX = /`/g;
+const JSON_PATH_MEMBER_ESCAPE_REGEX = /[\\'"]/g;
 export class MysqlQueryCompiler extends DefaultQueryCompiler {
     getCurrentParameterPlaceholder() {
         return '?';
@@ -37,6 +38,14 @@ export class MysqlQueryCompiler extends DefaultQueryCompiler {
     sanitizeStringLiteral(value) {
         return value.replace(LITERAL_ESCAPE_REGEX, (char) => char === '\\' ? '\\\\' : "''");
     }
+    /**
+     * Member values appear inside `"..."` in the JSON path, which itself sits
+     * inside a SQL string literal. They must therefore be escaped twice — once
+     * for the JSON path grammar, then again for MySQL's string literal parser.
+     */
+    sanitizeJSONPathMemberValue(value) {
+        return value.replace(JSON_PATH_MEMBER_ESCAPE_REGEX, (char) => char === '\\' ? '\\\\\\\\' : char === "'" ? "''" : '\\\\"');
+    }
     visitCreateIndex(node) {
         this.append('create ');
         if (node.unique) {

package/dist/dialect/postgres/postgres-introspector.d.ts

@@ -1,4 +1,4 @@
-import type { DatabaseIntrospector, DatabaseMetadata, DatabaseMetadataOptions, SchemaMetadata, TableMetadata } from '../database-introspector.js';
+import type { DatabaseIntrospector, DatabaseMetadataOptions, SchemaMetadata, TableMetadata } from '../database-introspector.js';
 import type { Kysely } from '../../kysely.js';
 export declare class PostgresIntrospector implements DatabaseIntrospector {
     #private;
@@ -11,10 +11,4 @@ export declare class PostgresIntrospector implements DatabaseIntrospector {
      * Get tables and views metadata.
      */
     getTables(options?: DatabaseMetadataOptions): Promise<TableMetadata[]>;
-    /**
-     * Get the database metadata such as table and column names.
-     *
-     * @deprecated Use getTables() instead.
-     */
-    getMetadata(options?: DatabaseMetadataOptions): Promise<DatabaseMetadata>;
 }

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

@@ -66,27 +66,28 @@ export class PostgresIntrospector {
         const rawColumns = await query.execute();
         return this.#parseTableMetadata(rawColumns);
     }
-    async getMetadata(options) {
-        return {
-            tables: await this.getTables(options),
-        };
-    }
     #parseTableMetadata(columns) {
-        const tableDictionary = new Map();
-        for (let i = 0, len = columns.length; i < len; i++) {
-            const column = columns[i];
-            const { schema, table } = column;
-            const tableKey = `schema:${schema};table:${table}`;
-            if (!tableDictionary.has(tableKey)) {
-                tableDictionary.set(tableKey, freeze({
+        const tables = [];
+        const schemas = new Map();
+        for (const column of columns) {
+            let schema = schemas.get(column.schema);
+            if (!schema) {
+                schema = new Map();
+                schemas.set(column.schema, schema);
+            }
+            let table = schema.get(column.table);
+            if (!table) {
+                table = freeze({
                     columns: [],
                     isForeign: column.table_type === 'f',
                     isView: column.table_type === 'v',
-                    name: table,
-                    schema,
-                }));
+                    name: column.table,
+                    schema: column.schema,
+                });
+                schema.set(column.table, table);
+                tables.push(table);
             }
-            tableDictionary.get(tableKey).columns.push(freeze({
+            table.columns.push(freeze({
                 comment: column.column_description ?? undefined,
                 dataType: column.type,
                 dataTypeSchema: column.type_schema,
@@ -96,6 +97,6 @@ export class PostgresIntrospector {
                 name: column.column,
             }));
         }
-        return Array.from(tableDictionary.values());
+        return tables;
     }
 }

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

@@ -1,4 +1,4 @@
-import type { DatabaseIntrospector, DatabaseMetadata, DatabaseMetadataOptions, SchemaMetadata, TableMetadata } from '../database-introspector.js';
+import type { DatabaseIntrospector, DatabaseMetadataOptions, SchemaMetadata, TableMetadata } from '../database-introspector.js';
 import type { Kysely } from '../../kysely.js';
 export declare class SqliteIntrospector implements DatabaseIntrospector {
     #private;
@@ -11,10 +11,4 @@ export declare class SqliteIntrospector implements DatabaseIntrospector {
      * Get tables and views metadata.
      */
     getTables(options?: DatabaseMetadataOptions): Promise<TableMetadata[]>;
-    /**
-     * Get the database metadata such as table and column names.
-     *
-     * @deprecated Use getTables() instead.
-     */
-    getMetadata(options?: DatabaseMetadataOptions): Promise<DatabaseMetadata>;
 }

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

@@ -13,11 +13,6 @@ export class SqliteIntrospector {
     async getTables(options = { withInternalKyselyTables: false }) {
         return await this.#getTableMetadata(options);
     }
-    async getMetadata(options) {
-        return {
-            tables: await this.getTables(options),
-        };
-    }
     #tablesQuery(qb, options) {
         let tablesQuery = qb
             .selectFrom('sqlite_master')

package/dist/dialect/sqlite/sqlite-query-compiler.d.ts

@@ -10,5 +10,6 @@ export declare class SqliteQueryCompiler extends DefaultQueryCompiler {
     protected getRightIdentifierWrapper(): string;
     protected getAutoIncrement(): string;
     protected sanitizeIdentifier(identifier: string): string;
+    protected sanitizeJSONPathMemberValue(value: string): string;
     protected visitDefaultInsertValue(_: DefaultInsertValueNode): void;
 }

package/dist/dialect/sqlite/sqlite-query-compiler.js

@@ -1,6 +1,7 @@
 /// <reference types="./sqlite-query-compiler.d.ts" />
 import { DefaultQueryCompiler } from '../../query-compiler/default-query-compiler.js';
 const ID_WRAP_REGEX = /"/g;
+const JSON_PATH_MEMBER_ESCAPE_REGEX = /[\\'"]/g;
 export class SqliteQueryCompiler extends DefaultQueryCompiler {
     visitOrAction(node) {
         this.append('or ');
@@ -27,6 +28,9 @@ export class SqliteQueryCompiler extends DefaultQueryCompiler {
     sanitizeIdentifier(identifier) {
         return identifier.replace(ID_WRAP_REGEX, '""');
     }
+    sanitizeJSONPathMemberValue(value) {
+        return value.replace(JSON_PATH_MEMBER_ESCAPE_REGEX, (char) => char === '\\' ? '\\\\' : char === "'" ? "''" : '\\"');
+    }
     visitDefaultInsertValue(_) {
         // sqlite doesn't support the `default` keyword in inserts.
         this.append('null');

package/dist/expression/expression-builder.d.ts

@@ -908,12 +908,6 @@ export interface ExpressionBuilder<DB, TB extends keyof DB> {
      * ```
      */
     cast<T, RE extends ReferenceExpression<DB, TB> = ReferenceExpression<DB, TB>>(expr: RE, dataType: DataTypeExpression): ExpressionWrapper<DB, TB, T>;
-    /**
-     * See {@link QueryCreator.withSchema}
-     *
-     * @deprecated Will be removed in kysely 0.25.0.
-     */
-    withSchema(schema: string): ExpressionBuilder<DB, TB>;
 }
 export declare function createExpressionBuilder<DB, TB extends keyof DB>(executor?: QueryExecutor): ExpressionBuilder<DB, TB>;
 export declare function expressionBuilder<DB, TB extends keyof DB>(_: SelectQueryBuilder<DB, TB, any>): ExpressionBuilder<DB, TB>;

package/dist/expression/expression-builder.js

@@ -2,7 +2,6 @@
 import { createSelectQueryBuilder, } from '../query-builder/select-query-builder.js';
 import { SelectQueryNode } from '../operation-node/select-query-node.js';
 import { parseTableExpressionOrList, parseTable, } from '../parser/table-parser.js';
-import { WithSchemaPlugin } from '../plugin/with-schema/with-schema-plugin.js';
 import { createQueryId } from '../util/query-id.js';
 import { createFunctionModule, } from '../query-builder/function-module.js';
 import { parseJSONReference, parseReferenceExpression, parseStringReference, } from '../parser/reference-parser.js';
@@ -112,9 +111,6 @@ export function createExpressionBuilder(executor = NOOP_QUERY_EXECUTOR) {
         cast(expr, dataType) {
             return new ExpressionWrapper(CastNode.create(parseReferenceExpression(expr), parseDataTypeExpression(dataType)));
         },
-        withSchema(schema) {
-            return createExpressionBuilder(executor.withPluginAtFront(new WithSchemaPlugin(schema)));
-        },
     });
     eb.fn = createFunctionModule();
     eb.eb = eb;

package/dist/operation-node/drop-table-node.d.ts

@@ -1,6 +1,10 @@
 import type { OperationNode } from './operation-node.js';
 import type { TableNode } from './table-node.js';
-export type DropTablexNodeParams = Omit<Partial<DropTableNode>, 'kind' | 'table'>;
+export type DropTableNodeParams = Omit<Partial<DropTableNode>, 'kind' | 'table'>;
+/**
+ * @deprecated use {@link DropTableNodeParams} instead.
+ */
+export type DropTablexNodeParams = DropTableNodeParams;
 export interface DropTableNode extends OperationNode {
     readonly kind: 'DropTableNode';
     readonly table: TableNode;
@@ -10,8 +14,8 @@ export interface DropTableNode extends OperationNode {
 }
 type DropTableNodeFactory = Readonly<{
     is(node: OperationNode): node is DropTableNode;
-    create(table: TableNode, params?: DropTablexNodeParams): Readonly<DropTableNode>;
-    cloneWith(dropIndex: DropTableNode, params: DropTablexNodeParams): Readonly<DropTableNode>;
+    create(table: TableNode, params?: DropTableNodeParams): Readonly<DropTableNode>;
+    cloneWith(dropIndex: DropTableNode, params: DropTableNodeParams): Readonly<DropTableNode>;
 }>;
 /**
  * @internal

package/dist/operation-node/insert-query-node.d.ts

@@ -19,8 +19,6 @@ export interface InsertQueryNode extends OperationNode {
     readonly onConflict?: OnConflictNode;
     readonly onDuplicateKey?: OnDuplicateKeyNode;
     readonly with?: WithNode;
-    /** @deprecated use {@link orAction} instead. */
-    readonly ignore?: boolean;
     readonly orAction?: OrActionNode;
     readonly replace?: boolean;
     readonly explain?: ExplainNode;

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

@@ -275,7 +275,6 @@ export class OperationNodeTransformer {
             onDuplicateKey: this.transformNode(node.onDuplicateKey, queryId),
             endModifiers: this.transformNodeList(node.endModifiers, queryId),
             with: this.transformNode(node.with, queryId),
-            ignore: node.ignore,
             orAction: this.transformNode(node.orAction, queryId),
             replace: node.replace,
             explain: this.transformNode(node.explain, queryId),

package/dist/operation-node/primary-key-constraint-node.d.ts

@@ -18,14 +18,4 @@ type PrimaryKeyConstraintNodeFactory = Readonly<{
  * @internal
  */
 export declare const PrimaryKeyConstraintNode: PrimaryKeyConstraintNodeFactory;
-/**
- * Backwards compatibility for a typo in the codebase.
- *
- * @deprecated Use {@link PrimaryKeyConstraintNode} instead.
- */
-export declare const PrimaryConstraintNode: Readonly<{
-    is(node: OperationNode): node is PrimaryKeyConstraintNode;
-    create(columns: string[], constraintName?: string): Readonly<PrimaryKeyConstraintNode>;
-    cloneWith(node: PrimaryKeyConstraintNode, props: PrimaryKeyConstraintNodeProps): Readonly<PrimaryKeyConstraintNode>;
-}>;
 export {};

package/dist/operation-node/primary-key-constraint-node.js

@@ -22,9 +22,3 @@ export const PrimaryKeyConstraintNode = freeze({
         return freeze({ ...node, ...props });
     },
 });
-/**
- * Backwards compatibility for a typo in the codebase.
- *
- * @deprecated Use {@link PrimaryKeyConstraintNode} instead.
- */
-export const PrimaryConstraintNode = PrimaryKeyConstraintNode;

package/dist/plugin/parse-json-results/parse-json-results-plugin.d.ts

@@ -9,10 +9,10 @@ export interface ParseJSONResultsPluginOptions {
      * Defaults to a function that checks if the string starts and ends with `{}` or `[]` - meaning anything that might be a JSON string, is attempted to be parsed - and if fails, proceeds.
      *
      * @param value - The string value to check.
-     * @param path - The JSON path leading to this value. e.g. `$[0].users[0].profile`
+     * @param jsonPath - The JSON path leading to this value. e.g. `$[0]."users"[0]."profile"`
      * @return `true` if the string should be JSON parsed.
      */
-    shouldParse?: (value: string, path: string) => boolean;
+    shouldParse?: (value: string, jsonPath: string) => boolean;
     /**
      * When `'in-place'`, arrays' and objects' values are parsed in-place. This is
      * the most time and space efficient option.

package/dist/plugin/parse-json-results/parse-json-results-plugin.js

@@ -54,7 +54,7 @@ export class ParseJSONResultsPlugin {
             objectStrategy: options.objectStrategy || 'in-place',
             reviver: options.reviver || ((_, value) => value),
             shouldParse: shouldParse
-                ? (value, path) => maybeJson(value) && shouldParse(value, path)
+                ? (value, jsonPath) => maybeJson(value) && shouldParse(value, jsonPath)
                 : maybeJson,
         });
     }
@@ -69,28 +69,28 @@ export class ParseJSONResultsPlugin {
         };
     }
 }
-function parseArray(arr, path, options) {
+function parseArray(arr, jsonPath, options) {
     const target = options.objectStrategy === 'create' ? new Array(arr.length) : arr;
     for (let i = 0; i < arr.length; ++i) {
-        target[i] = parse(arr[i], `${path}[${i}]`, options);
+        target[i] = parse(arr[i], `${jsonPath}[${i}]`, options);
     }
     return target;
 }
-function parse(value, path, options) {
+function parse(value, jsonPath, options) {
     if (isString(value)) {
-        return parseString(value, path, options);
+        return parseString(value, jsonPath, options);
     }
     if (Array.isArray(value)) {
-        return parseArray(value, path, options);
+        return parseArray(value, jsonPath, options);
     }
     if (isPlainObject(value)) {
-        return parseObject(value, path, options);
+        return parseObject(value, jsonPath, options);
     }
     return value;
 }
-function parseString(str, path, options) {
+function parseString(str, jsonPath, options) {
     const { shouldParse } = options;
-    if (!shouldParse(str, path)) {
+    if (!shouldParse(str, jsonPath)) {
         return str;
     }
     try {
@@ -106,7 +106,7 @@ function parseString(str, path, options) {
                 delete value.prototype;
             }
             return options.reviver(key, value, ...otherArgs);
-        }), path, { ...options, objectStrategy: 'in-place' });
+        }), jsonPath, { ...options, objectStrategy: 'in-place' });
     }
     catch (error) {
         // custom JSON detection should expose parsing errors.
@@ -122,7 +122,7 @@ function maybeJson(value) {
     return ((value.startsWith('{') && value.endsWith('}')) ||
         (value.startsWith('[') && value.endsWith(']')));
 }
-function parseObject(obj, path, options) {
+function parseObject(obj, jsonPath, options) {
     const { objectStrategy } = options;
     const target = objectStrategy === 'create' ? {} : obj;
     for (const key of Object.keys(obj)) {
@@ -130,7 +130,7 @@ function parseObject(obj, path, options) {
         if (key === '__proto__') {
             continue;
         }
-        const parsed = parse(obj[key], `${path}.${key}`, options);
+        const parsed = parse(obj[key], `${jsonPath}."${key}"`, options);
         // prevent prototype pollution
         if (key === 'constructor' &&
             isPlainObject(parsed) &&

package/dist/query-builder/json-path-builder.js

@@ -7,6 +7,7 @@ import { JSONPathNode } from '../operation-node/json-path-node.js';
 import { JSONReferenceNode } from '../operation-node/json-reference-node.js';
 import { isOperationNodeSource } from '../operation-node/operation-node-source.js';
 import { ValueNode } from '../operation-node/value-node.js';
+const HASH_NEGATIVE_INDEX_REGEX = /^#-\d+$/;
 export class JSONPathBuilder {
     #node;
     constructor(node) {
@@ -80,6 +81,13 @@ export class JSONPathBuilder {
      * ```
      */
     at(index) {
+        if ((typeof index !== 'number' && typeof index !== 'string') ||
+            (typeof index === 'number' && !Number.isInteger(index)) ||
+            (typeof index === 'string' &&
+                index !== 'last' &&
+                !HASH_NEGATIVE_INDEX_REGEX.test(index))) {
+            throw new Error(`Unexpected index value in .at(...): ${index}`);
+        }
         return this.#createBuilderWithPathLeg('ArrayLocation', index);
     }
     /**

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

@@ -8,7 +8,7 @@ import { UpdateQueryNode } from '../operation-node/update-query-node.js';
 import { parseUpdate, } from '../parser/update-set-parser.js';
 import { freeze } from '../util/object-utils.js';
 import { UpdateResult } from './update-result.js';
-import { isNoResultErrorConstructor, NoResultError, } from './no-result-error.js';
+import { isNoResultErrorConstructor, NoResultError } from './no-result-error.js';
 import { parseReferentialBinaryOperation, parseValueBinaryOperationOrExpression, } from '../parser/binary-operation-parser.js';
 import { parseValueExpression, } from '../parser/value-parser.js';
 import { LimitNode } from '../operation-node/limit-node.js';

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

@@ -229,6 +229,7 @@ export declare class DefaultQueryCompiler extends OperationNodeVisitor implement
     protected getRightExplainOptionsWrapper(): string;
     protected sanitizeIdentifier(identifier: string): string;
     protected sanitizeStringLiteral(value: string): string;
+    protected sanitizeJSONPathMemberValue(value: string): string;
     protected addParameter(parameter: unknown): void;
     protected appendImmediateValue(value: unknown): void;
     protected appendStringLiteral(value: string): void;

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

@@ -9,8 +9,8 @@ import { freeze, isString, isNumber, isBoolean, isNull, isDate, isBigInt, } from
 import { CreateViewNode } from '../operation-node/create-view-node.js';
 import { SetOperationNode } from '../operation-node/set-operation-node.js';
 import { WhenNode } from '../operation-node/when-node.js';
-import { logOnce } from '../util/log-once.js';
 const LIT_WRAP_REGEX = /'/g;
+const JSON_PATH_MEMBER_WRAP_REGEX = /['"]/g;
 export class DefaultQueryCompiler extends OperationNodeVisitor {
     #sql = '';
     #parameters = [];
@@ -164,11 +164,6 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.append(' ');
         }
         this.append(node.replace ? 'replace' : 'insert');
-        // TODO: remove in 0.29.
-        if (node.ignore) {
-            logOnce('`InsertQueryNode.ignore` is deprecated. Use `InsertQueryNode.orAction` instead.');
-            this.append(' ignore');
-        }
         if (node.orAction) {
             this.append(' ');
             this.visitNode(node.orAction);
@@ -1220,13 +1215,17 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
     }
     visitJSONPathLeg(node) {
         const isArrayLocation = node.type === 'ArrayLocation';
-        this.append(isArrayLocation ? '[' : '.');
-        this.append(typeof node.value === 'string'
-            ? this.sanitizeStringLiteral(node.value)
-            : String(node.value));
+        const value = String(node.value);
         if (isArrayLocation) {
+            this.append('[');
+            this.append(this.sanitizeStringLiteral(value));
             this.append(']');
         }
+        else {
+            this.append('."');
+            this.append(this.sanitizeJSONPathMemberValue(value));
+            this.append('"');
+        }
     }
     visitJSONOperatorChain(node) {
         for (let i = 0, len = node.values.length; i < len; i++) {
@@ -1375,6 +1374,9 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
     sanitizeStringLiteral(value) {
         return value.replace(LIT_WRAP_REGEX, "''");
     }
+    sanitizeJSONPathMemberValue(value) {
+        return value.replace(JSON_PATH_MEMBER_WRAP_REGEX, (char) => char === "'" ? "''" : '\\"');
+    }
     addParameter(parameter) {
         this.#parameters.push(parameter);
     }

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "kysely",
-  "version": "0.29.0-rc.0",
+  "version": "0.29.0",
   "description": "Type safe SQL query builder",
   "repository": {
     "type": "git",
-    "url": "git://github.com/kysely-org/kysely.git"
+    "url": "git+https://github.com/kysely-org/kysely.git"
   },
   "homepage": "https://kysely.dev",
   "keywords": [
@@ -25,7 +25,7 @@
     "plugins"
   ],
   "engines": {
-    "node": ">=20.0.0"
+    "node": ">=22.0.0"
   },
   "type": "module",
   "main": "dist/index.js",
@@ -63,40 +63,39 @@
   "devDependencies": {
     "@arethetypeswrong/cli": "0.18.2",
     "@ark/attest": "0.56.0",
-    "@electric-sql/pglite": "0.4.4",
+    "@electric-sql/pglite": "0.4.5",
     "@types/better-sqlite3": "7.6.13",
     "@types/chai": "5.2.3",
     "@types/chai-as-promised": "8.0.2",
     "@types/mocha": "10.0.10",
-    "@types/node": "25.5.2",
+    "@types/node": "25.6.1",
     "@types/pg": "8.20.0",
     "@types/pg-cursor": "2.7.2",
     "@types/prototype-pollution-vulnerable-lodash.merge-dont-upgrade": "npm:@types/lodash.merge@4.6.1",
     "@types/semver": "7.7.1",
     "@types/sinon": "21.0.1",
-    "better-sqlite3": "12.8.0",
+    "better-sqlite3": "12.9.0",
     "chai": "6.2.2",
     "chai-as-promised": "8.0.2",
     "esbuild": "0.28.0",
     "jsr": "0.14.3",
     "lodash": "4.18.1",
     "mocha": "11.7.5",
-    "mysql2": "3.21.0",
+    "mysql2": "3.22.3",
     "pathe": "2.0.3",
     "pg": "8.20.0",
     "pg-cursor": "2.19.0",
-    "pkg-types": "2.3.0",
     "playwright": "1.59.1",
-    "prettier": "3.8.1",
+    "prettier": "3.8.3",
     "prototype-pollution-vulnerable-lodash.merge-dont-upgrade": "npm:lodash.merge@4.6.1",
     "semver": "7.7.4",
-    "sinon": "21.0.3",
-    "std-env": "4.0.0",
+    "sinon": "22.0.0",
+    "std-env": "4.1.0",
     "tarn": "3.0.2",
     "tedious": "19.2.1",
     "tsd": "0.33.0",
     "tsx": "4.21.0",
-    "typescript": "6.0.2"
+    "typescript": "6.0.3"
   },
   "scripts": {
     "clean": "rm -rf dist & rm -rf test/node/dist & rm -rf test/browser/bundle.js",