kysely 0.7.1 → 0.7.5

package/dist/esm/parser/select-parser.js

@@ -18,13 +18,13 @@ function parseSelectExpression(ctx, selection) {
         return SelectionNode.create(selection.toOperationNode());
     }
     else if (isFunction(selection)) {
-        return SelectionNode.create(selection(ctx.createSubQueryBuilder()).toOperationNode());
+        return SelectionNode.create(selection(ctx.createExpressionBuilder()).toOperationNode());
     }
     else {
         throw new Error(`invalid value passed to select method: ${JSON.stringify(selection)}`);
     }
 }
-export function parseSelectAllArgs(table) {
+export function parseSelectAll(table) {
     if (!table) {
         return [SelectionNode.createSelectAll()];
     }
@@ -35,7 +35,7 @@ export function parseSelectAllArgs(table) {
         return [parseSelectAllArg(table)];
     }
 }
-export function parseSelectAllArg(table) {
+function parseSelectAllArg(table) {
     if (isString(table)) {
         return SelectionNode.createSelectAllFromTable(table);
     }

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

@@ -18,27 +18,32 @@ export function parseTableExpression(ctx, table) {
         return table.toOperationNode();
     }
     else if (isFunction(table)) {
-        return table(ctx.createSubQueryBuilder()).toOperationNode();
+        return table(ctx.createExpressionBuilder()).toOperationNode();
     }
     else {
         throw new Error(`invalid table expression ${JSON.stringify(table)}`);
     }
 }
 export function parseAliasedTable(from) {
-    const [table, alias] = from.split(' as ').map((it) => it.trim());
-    if (alias) {
+    const ALIAS_SEPARATOR = ' as ';
+    if (from.includes(ALIAS_SEPARATOR)) {
+        const [table, alias] = from.split(ALIAS_SEPARATOR).map(trim);
         return AliasNode.create(parseTable(table), alias);
     }
     else {
-        return parseTable(table);
+        return parseTable(from);
     }
 }
 export function parseTable(from) {
-    if (from.includes('.')) {
-        const [schema, table] = from.split('.').map((it) => it.trim());
+    const SCHEMA_SEPARATOR = '.';
+    if (from.includes(SCHEMA_SEPARATOR)) {
+        const [schema, table] = from.split(SCHEMA_SEPARATOR).map(trim);
         return TableNode.createWithSchema(schema, table);
     }
     else {
         return TableNode.create(from);
     }
 }
+function trim(str) {
+    return str.trim();
+}

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

@@ -20,7 +20,7 @@ export function parseMutationValueExpression(ctx, value) {
         }
     }
     else if (isFunction(value)) {
-        const node = value(ctx.createSubQueryBuilder()).toOperationNode();
+        const node = value(ctx.createExpressionBuilder()).toOperationNode();
         if (!QueryNode.isMutating(node)) {
             return node;
         }

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

@@ -24,7 +24,7 @@ export function parseValueExpression(ctx, arg) {
         }
     }
     else if (isFunction(arg)) {
-        const node = arg(ctx.createSubQueryBuilder()).toOperationNode();
+        const node = arg(ctx.createExpressionBuilder()).toOperationNode();
         if (!QueryNode.isMutating(node)) {
             return node;
         }

package/dist/esm/query-builder/{sub-query-builder.d.ts → expression-builder.d.ts}

@@ -1,9 +1,9 @@
 import { TableExpression, QueryBuilderWithTable } from '../parser/table-parser.js';
 import { NoopQueryExecutor } from '../query-executor/noop-query-executor.js';
-import { DialectAdapter } from '../index.js';
-export declare class SubQueryBuilder<DB, TB extends keyof DB> {
+import { ParseContext } from '../parser/parse-context.js';
+export declare class ExpressionBuilder<DB, TB extends keyof DB> {
     #private;
-    constructor(props: SubQueryBuilderProps);
+    constructor(props: ExpressionBuilderProps);
     /**
      * Creates a subquery.
      *
@@ -50,9 +50,9 @@ export declare class SubQueryBuilder<DB, TB extends keyof DB> {
     /**
      * See {@link QueryCreator.withSchema}
      */
-    withSchema(schema: string): SubQueryBuilder<DB, TB>;
+    withSchema(schema: string): ExpressionBuilder<DB, TB>;
 }
-export interface SubQueryBuilderProps {
-    executor: NoopQueryExecutor;
-    adapter: DialectAdapter;
+export interface ExpressionBuilderProps {
+    readonly executor: NoopQueryExecutor;
+    readonly parseContext: ParseContext;
 }

package/dist/esm/query-builder/{sub-query-builder.js → expression-builder.js}

@@ -4,8 +4,7 @@ import { parseTableExpressionOrList, } from '../parser/table-parser.js';
 import { WithSchemaPlugin } from '../plugin/with-schema/with-schema-plugin.js';
 import { createQueryId } from '../util/query-id.js';
 import { freeze } from '../util/object-utils.js';
-import { createParseContext } from '../parser/parse-context.js';
-export class SubQueryBuilder {
+export class ExpressionBuilder {
     #props;
     constructor(props) {
         this.#props = freeze(props);
@@ -14,20 +13,17 @@ export class SubQueryBuilder {
         return new QueryBuilder({
             queryId: createQueryId(),
             executor: this.#props.executor,
-            adapter: this.#props.adapter,
-            queryNode: SelectQueryNode.create(parseTableExpressionOrList(this.#parseContext, table)),
+            parseContext: this.#props.parseContext,
+            queryNode: SelectQueryNode.create(parseTableExpressionOrList(this.#props.parseContext, table)),
         });
     }
     /**
      * See {@link QueryCreator.withSchema}
      */
     withSchema(schema) {
-        return new SubQueryBuilder({
+        return new ExpressionBuilder({
             ...this.#props,
             executor: this.#props.executor.withPluginAtFront(new WithSchemaPlugin(schema)),
         });
     }
-    get #parseContext() {
-        return createParseContext(this.#props.adapter);
-    }
 }

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

@@ -1,7 +1,7 @@
-import { DialectAdapter } from '../dialect/dialect-adapter.js';
 import { JoinNode } from '../operation-node/join-node.js';
 import { OperationNodeSource } from '../operation-node/operation-node-source.js';
 import { ExistsExpression, FilterOperator } from '../parser/filter-parser.js';
+import { ParseContext } from '../parser/parse-context.js';
 import { ReferenceExpression } from '../parser/reference-parser.js';
 import { ValueExpressionOrList } from '../parser/value-parser.js';
 export declare class JoinBuilder<DB, TB extends keyof DB> implements OperationNodeSource {
@@ -69,5 +69,5 @@ export declare class JoinBuilder<DB, TB extends keyof DB> implements OperationNo
 }
 export interface JoinBuilderProps {
     readonly joinNode: JoinNode;
-    readonly adapter: DialectAdapter;
+    readonly parseContext: ParseContext;
 }

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

@@ -1,6 +1,5 @@
 import { JoinNode } from '../operation-node/join-node.js';
-import { parseExistExpression, parseNotExistExpression, parseOnFilter, parseReferenceFilter, } from '../parser/filter-parser.js';
-import { createParseContext } from '../parser/parse-context.js';
+import { parseExistFilter, parseNotExistFilter, parseOnFilter, parseReferenceFilter, } from '../parser/filter-parser.js';
 import { freeze } from '../util/object-utils.js';
 import { preventAwait } from '../util/prevent-await.js';
 export class JoinBuilder {
@@ -11,13 +10,13 @@ export class JoinBuilder {
     on(...args) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, 'And', parseOnFilter(this.#parseContext, args)),
+            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, 'And', parseOnFilter(this.#props.parseContext, args)),
         });
     }
     orOn(...args) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, 'Or', parseOnFilter(this.#parseContext, args)),
+            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, 'Or', parseOnFilter(this.#props.parseContext, args)),
         });
     }
     /**
@@ -29,7 +28,7 @@ export class JoinBuilder {
     onRef(lhs, op, rhs) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, 'And', parseReferenceFilter(this.#parseContext, lhs, op, rhs)),
+            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, 'And', parseReferenceFilter(this.#props.parseContext, lhs, op, rhs)),
         });
     }
     /**
@@ -41,7 +40,7 @@ export class JoinBuilder {
     orOnRef(lhs, op, rhs) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, 'Or', parseReferenceFilter(this.#parseContext, lhs, op, rhs)),
+            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, 'Or', parseReferenceFilter(this.#props.parseContext, lhs, op, rhs)),
         });
     }
     /**
@@ -53,7 +52,7 @@ export class JoinBuilder {
     onExists(arg) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, 'And', parseExistExpression(this.#parseContext, arg)),
+            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, 'And', parseExistFilter(this.#props.parseContext, arg)),
         });
     }
     /**
@@ -65,7 +64,7 @@ export class JoinBuilder {
     onNotExists(arg) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, 'And', parseNotExistExpression(this.#parseContext, arg)),
+            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, 'And', parseNotExistFilter(this.#props.parseContext, arg)),
         });
     }
     /**
@@ -77,7 +76,7 @@ export class JoinBuilder {
     orOnExists(arg) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, 'Or', parseExistExpression(this.#parseContext, arg)),
+            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, 'Or', parseExistFilter(this.#props.parseContext, arg)),
         });
     }
     /**
@@ -89,14 +88,11 @@ export class JoinBuilder {
     orOnNotExists(arg) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, 'Or', parseNotExistExpression(this.#parseContext, arg)),
+            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, 'Or', parseNotExistFilter(this.#props.parseContext, arg)),
         });
     }
     toOperationNode() {
         return this.#props.joinNode;
     }
-    get #parseContext() {
-        return createParseContext(this.#props.adapter);
-    }
 }
 preventAwait(JoinBuilder, "don't await JoinBuilder instances. They are never executed directly and are always just a part of a query.");

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

@@ -18,7 +18,7 @@ import { Compilable } from '../util/compilable.js';
 import { QueryExecutor } from '../query-executor/query-executor.js';
 import { QueryId } from '../util/query-id.js';
 import { OnConflictConstraintTarget } from '../parser/on-conflict-parser.js';
-import { DialectAdapter } from '../index.js';
+import { ParseContext } from '../parser/parse-context.js';
 /**
  * The main query builder class.
  *
@@ -1010,9 +1010,9 @@ export declare class QueryBuilder<DB, TB extends keyof DB, O = {}> implements Op
      * database, calling `onConflictDoNothing('name')` will ignore the conflict
      * and do nothing. By default the query would throw.
      *
-     * This method generates different SQL on different dialects. For example
-     * `insert ignore` is used on mysql and `on conflict (columns) do nothing`
-     * on postgres and sqlite.
+     * Only some dialects like postgres and sqlite implement the `on conflict`
+     * statement. On MySQL you should use the {@link ignore} method to achieve
+     * similar results.
      *
      * Also see the {@link QueryBuilder.onConflictUpdate | onConflictUpdate}
      * method if you want to perform an update in case of a conflict (upsert).
@@ -1067,6 +1067,27 @@ export declare class QueryBuilder<DB, TB extends keyof DB, O = {}> implements Op
     onConflictDoNothing(column: AnyColumn<DB, TB>): QueryBuilder<DB, TB, O>;
     onConflictDoNothing(columns: ReadonlyArray<AnyColumn<DB, TB>>): QueryBuilder<DB, TB, O>;
     onConflictDoNothing(constraint: OnConflictConstraintTarget): QueryBuilder<DB, TB, O>;
+    /**
+     * Changes an `insert into` query to an `insert ignore into` query.
+     *
+     * If you use the ignore modifier, ignorable errors that occur while executing the
+     * insert statement are ignored. For example, without ignore, a row that duplicates
+     * an existing unique index or primary key value in the table causes a duplicate-key
+     * error and the statement is aborted. With ignore, the row is discarded and no error
+     * occurs.
+     *
+     * This is only supported on some dialects like MySQL. On most dialects you should
+     * use the {@link onConflictDoNothing} method.
+     *
+     * @example
+     * ```ts
+     * await db.insertInto('person')
+     *   .ignore()
+     *   .values(values)
+     *   .execute()
+     * ```
+     */
+    ignore(): QueryBuilder<DB, TB, O>;
     /**
      * Ignores an insert if the column or constraint given as the first
      * argument conflicts with the current rows in the database and
@@ -1082,9 +1103,9 @@ export declare class QueryBuilder<DB, TB extends keyof DB, O = {}> implements Op
      * The second argument (updates) can be anything the {@link QueryBuilder.set | set}
      * method accepts.
      *
-     * This method generates different SQL on different dialects. For example
-     * `on duplicate key update` is used on mysql and `on conflict (columns) do update`
-     * on postgres and sqlite.
+     * The `on conflict do update` statement is only implemented by some dialects
+     * like postgres and sqlite. On MySQL you should use the {@link onDuplicateKeyUpdate}
+     * method instead.
      *
      * Also see the {@link QueryBuilder.onConflictDoNothing | onConflictDoNothing}
      * method.
@@ -1140,6 +1161,24 @@ export declare class QueryBuilder<DB, TB extends keyof DB, O = {}> implements Op
     onConflictUpdate(column: AnyColumn<DB, TB>, updates: MutationObject<DB, TB>): QueryBuilder<DB, TB, O>;
     onConflictUpdate(columns: ReadonlyArray<AnyColumn<DB, TB>>, updates: MutationObject<DB, TB>): QueryBuilder<DB, TB, O>;
     onConflictUpdate(constraint: OnConflictConstraintTarget, updates: MutationObject<DB, TB>): QueryBuilder<DB, TB, O>;
+    /**
+     * Adds `on duplicate key update` to an insert query.
+     *
+     * If you specify `on duplicate key update`, and a row is inserted that would cause
+     * a duplicate value in a unique index or primary key, an update of the old row occurs.
+     *
+     * This is only implemented by some dialects like MySQL. On most dialects you should
+     * use {@link onConflictUpdate} instead.
+     *
+     * @example
+     * ```ts
+     * await db
+     *   .insertInto('person')
+     *   .values(values)
+     *   .onDuplicateKeyUpdate({ species: 'hamster' })
+     * ```
+     */
+    onDuplicateKeyUpdate(updates: MutationObject<DB, TB>): QueryBuilder<DB, TB, O>;
     /**
      * Sets the values to update for an {@link Kysely.updateTable | update} query.
      *
@@ -1566,7 +1605,7 @@ export interface QueryBuilderProps {
     readonly queryId: QueryId;
     readonly queryNode: QueryNode;
     readonly executor: QueryExecutor;
-    readonly adapter: DialectAdapter;
+    readonly parseContext: ParseContext;
 }
 /**
  * {@link QueryBuilder} with an alias. The result of calling {@link QueryBuilder.as}.