pqb 0.28.0 → 0.29.0

package/dist/index.mjs

@@ -3363,13 +3363,13 @@ const pushInsertSql = (ctx, q, query, quotedAs) => {
   }
   if (query.onConflict) {
     ctx.sql.push("ON CONFLICT");
-    const { expr, type } = query.onConflict;
-    if (expr) {
-      if (typeof expr === "string") {
-        ctx.sql.push(`("${((_b = shape[expr]) == null ? void 0 : _b.data.name) || expr}")`);
-      } else if (Array.isArray(expr)) {
+    const { target } = query.onConflict;
+    if (target) {
+      if (typeof target === "string") {
+        ctx.sql.push(`("${((_b = shape[target]) == null ? void 0 : _b.data.name) || target}")`);
+      } else if (Array.isArray(target)) {
         ctx.sql.push(
-          `(${expr.reduce(
+          `(${target.reduce(
             (sql, item, i) => {
               var _a2;
               return sql + (i ? ", " : "") + `"${((_a2 = shape[item]) == null ? void 0 : _a2.data.name) || item}"`;
@@ -3377,50 +3377,67 @@ const pushInsertSql = (ctx, q, query, quotedAs) => {
             ""
           )})`
         );
-      } else if ("toSQL" in expr) {
-        ctx.sql.push(expr.toSQL(ctx, quotedAs));
+      } else if ("toSQL" in target) {
+        ctx.sql.push(target.toSQL(ctx, quotedAs));
       } else {
-        ctx.sql.push(`ON CONSTRAINT "${expr.constraint}"`);
+        ctx.sql.push(`ON CONSTRAINT "${target.constraint}"`);
       }
     }
-    if (type === "ignore") {
-      ctx.sql.push("DO NOTHING");
-    } else if (type === "merge") {
-      let set;
-      const { update } = query.onConflict;
-      if (update) {
-        if (typeof update === "string") {
-          const name = ((_c = shape[update]) == null ? void 0 : _c.data.name) || update;
-          set = `"${name}" = excluded."${name}"`;
-        } else if (Array.isArray(update)) {
-          set = update.reduce((sql, item, i) => {
+    if ("merge" in query.onConflict) {
+      let sql;
+      const { merge } = query.onConflict;
+      if (merge) {
+        if (typeof merge === "string") {
+          const name = ((_c = shape[merge]) == null ? void 0 : _c.data.name) || merge;
+          sql = `"${name}" = excluded."${name}"`;
+        } else if ("except" in merge) {
+          const notExcluded = [];
+          const except = toArray(merge.except);
+          for (let i = 0; i < columns.length; i++) {
+            if (!except.includes(columns[i])) {
+              notExcluded.push(quotedColumns[i]);
+            }
+          }
+          sql = mergeColumnsSql(notExcluded);
+        } else {
+          sql = merge.reduce((sql2, item, i) => {
             var _a2;
             const name = ((_a2 = shape[item]) == null ? void 0 : _a2.data.name) || item;
-            return sql + (i ? ", " : "") + `"${name}" = excluded."${name}"`;
+            return sql2 + (i ? ", " : "") + `"${name}" = excluded."${name}"`;
           }, "");
-        } else if (isExpression(update)) {
-          set = update.toSQL(ctx, quotedAs);
-        } else {
-          const arr = [];
-          for (const key in update) {
-            arr.push(
-              `"${((_d = shape[key]) == null ? void 0 : _d.data.name) || key}" = ${addValue(
-                ctx.values,
-                update[key]
-              )}`
-            );
-          }
-          set = arr.join(", ");
         }
       } else {
-        set = quotedColumns.map((column) => `${column} = excluded.${column}`).join(", ");
+        sql = mergeColumnsSql(quotedColumns);
+      }
+      ctx.sql.push("DO UPDATE SET", sql);
+    } else if (query.onConflict.set) {
+      let sql;
+      const { set } = query.onConflict;
+      if (isExpression(set)) {
+        sql = set.toSQL(ctx, quotedAs);
+      } else {
+        const arr = [];
+        for (const key in set) {
+          arr.push(
+            `"${((_d = shape[key]) == null ? void 0 : _d.data.name) || key}" = ${addValue(
+              ctx.values,
+              set[key]
+            )}`
+          );
+        }
+        sql = arr.join(", ");
       }
-      ctx.sql.push("DO UPDATE SET", set);
+      ctx.sql.push("DO UPDATE SET", sql);
+    } else {
+      ctx.sql.push("DO NOTHING");
     }
   }
   pushWhereStatementSql(ctx, q, query, quotedAs);
   return pushReturningSql(ctx, q, query, quotedAs, query.afterCreateSelect);
 };
+const mergeColumnsSql = (quotedColumns2) => {
+  return quotedColumns2.map((column) => `${column} = excluded.${column}`).join(", ");
+};
 const encodeRow = (ctx, q, QueryClass, row, runtimeDefaults, quotedAs) => {
   const arr = row.map((value) => {
     if (typeof value === "function") {
@@ -6237,9 +6254,9 @@ class Create {
    *   password: '1234',
    * });
    *
-   * // When using `.onConflictIgnore()`,
+   * // When using `.onConflictDoNothing()`,
    * // the record may be not created and the `createdCount` will be 0.
-   * const createdCount = await db.table.insert(data).onConflictIgnore();
+   * const createdCount = await db.table.insert(data).onConflictDoNothing();
    *
    * await db.table.create({
    *   // raw SQL
@@ -6432,7 +6449,7 @@ class Create {
    *
    * Columns provided in `defaults` are marked as optional in the following `create`.
    *
-   * Default data is the same as in [create](#create) and [createMany](#createMany),
+   * Default data is the same as in {@link create} and {@link createMany},
    * so you can provide a raw SQL, or a query with a query.
    *
    * ```ts
@@ -6460,8 +6477,9 @@ class Create {
    * or a composite primary key unique index on a set of columns,
    * and a row being created has the same value as a row that already exists in the table in this column(s).
    *
-   * Use `onConflictIgnore()` to suppress the error and continue without updating the record,
-   * or `onConflict(['uniqueColumn']).merge()` to update the record with a new data.
+   * Use {@link onConflictDoNothing} to suppress the error and continue without updating the record,
+   * or the `merge` to update the record with new values automatically,
+   * or the `set` to specify own values for the update.
    *
    * `onConflict` only accepts column names that are defined in `primaryKey` or `unique` in the table definition.
    * To specify a constraint, its name also must be explicitly set in `primaryKey` or `unique` in the table code.
@@ -6470,11 +6488,11 @@ class Create {
    * for updating the record.
    *
    * If your table has multiple potential reasons for unique constraint violation, such as username and email columns in a user table,
-   * consider using [upsert](#upsert) instead.
+   * consider using `upsert` instead.
    *
    * ```ts
    * // leave `onConflict` without argument to ignore or merge on any conflict
-   * db.table.create(data).onConflictIgnore();
+   * db.table.create(data).onConflictDoNothing();
    *
    * // single column:
    * db.table.create(data).onConfict('email').merge();
@@ -6507,13 +6525,28 @@ class Create {
    *   .ignore();
    * ```
    *
+   * For `merge` and `set`, you can append `where` to update data only for the matching rows:
+   *
+   * ```ts
+   * const timestamp = Date.now();
+   *
+   * db.table
+   *   .create(data)
+   *   .onConflict('email')
+   *   .set({
+   *     name: 'John Doe',
+   *     updatedAt: timestamp,
+   *   })
+   *   .where({ updatedAt: { lt: timestamp } });
+   * ```
+   *
    * @param arg - optionally provide an array of columns
    */
   onConflict(arg) {
     return new OnConflictQueryBuilder(this, arg);
   }
   /**
-   * Use `onConflictIgnore` to suppress unique constraint violation error when creating a record.
+   * Use `onConflictDoNothing` to suppress unique constraint violation error when creating a record.
    *
    * Adds `ON CONFLICT (columns) DO NOTHING` clause to the insert statement, columns are optional.
    *
@@ -6526,38 +6559,37 @@ class Create {
    *     name: 'John Doe',
    *   })
    *   // on any conflict:
-   *   .onConflictIgnore()
+   *   .onConflictDoNothing()
    *   // or, for a specific column:
-   *   .onConflictIgnore('email')
+   *   .onConflictDoNothing('email')
    *   // or, for a specific constraint:
-   *   .onConflictIgnore({ constraint: 'unique_index_name' });
+   *   .onConflictDoNothing({ constraint: 'unique_index_name' });
    * ```
    *
-   * When there is a conflict, nothing can be returned from the database, so `onConflictIgnore` adds `| undefined` part to the response type.
+   * When there is a conflict, nothing can be returned from the database, so `onConflictDoNothing` adds `| undefined` part to the response type.
    *
    * ```ts
    * const maybeRecord: RecordType | undefined = await db.table
    *   .create(data)
-   *   .onConflictIgnore();
+   *   .onConflictDoNothing();
    *
    * const maybeId: number | undefined = await db.table
    *   .get('id')
    *   .create(data)
-   *   .onConflictIgnore();
+   *   .onConflictDoNothing();
    * ```
    *
    * When creating multiple records, only created records will be returned. If no records were created, array will be empty:
    *
    * ```ts
    * // array can be empty
-   * const arr = await db.table.createMany([data, data, data]).onConflictIgnore();
+   * const arr = await db.table.createMany([data, data, data]).onConflictDoNothing();
    * ```
    */
-  onConflictIgnore(arg) {
+  onConflictDoNothing(arg) {
     const q = this.clone();
     q.q.onConflict = {
-      type: "ignore",
-      expr: arg
+      target: arg
     };
     if (q.q.returnType === "oneOrThrow") {
       q.q.returnType = "one";
@@ -6573,112 +6605,83 @@ class OnConflictQueryBuilder {
     this.onConflict = onConflict;
   }
   /**
-   * Available only after [onConflict](#onconflict).
+   * Available only after `onConflict`.
    *
-   * Adds an `ON CONFLICT (columns) DO UPDATE` clause to the insert statement.
+   * Updates the record with a given data when conflict occurs.
    *
    * ```ts
-   * db.table
-   *   .create({
-   *     email: 'ignore@example.com',
-   *     name: 'John Doe',
-   *   })
-   *   // for a specific column:
-   *   .onConflict('email')
-   *   // or, for a specific constraint:
-   *   .onConflict({ constraint: 'unique_constraint_name' })
-   *   .merge();
+   * db.table.create(data).onConflict('column').set({
+   *   description: 'setting different data on conflict',
+   * });
    * ```
    *
-   * This also works with batch creates:
+   * The `set` can take a raw SQL expression:
    *
    * ```ts
    * db.table
-   *   .createMany([
-   *     { email: 'john@example.com', name: 'John Doe' },
-   *     { email: 'jane@example.com', name: 'Jane Doe' },
-   *     { email: 'alex@example.com', name: 'Alex Doe' },
-   *   ])
-   *   .onConflict('email')
-   *   .merge();
-   * ```
-   *
-   * It is also possible to specify a subset of the columns to merge when a conflict occurs.
-   * For example, you may want to set a `createdAt` column when creating but would prefer not to update it if the row already exists:
-   *
-   * ```ts
-   * const timestamp = Date.now();
+   *   .create(data)
+   *   .onConflict()
+   *   .set(db.table.sql`raw SQL expression`);
    *
+   * // update records only on certain conditions
    * db.table
-   *   .create({
-   *     email: 'ignore@example.com',
-   *     name: 'John Doe',
-   *     createdAt: timestamp,
-   *     updatedAt: timestamp,
-   *   })
+   *   .create(data)
    *   .onConflict('email')
-   *   // update only a single column
-   *   .merge('email')
-   *   // or, update multiple columns
-   *   .merge(['email', 'name', 'updatedAt']);
+   *   .set({ key: 'value' })
+   *   .where({ ...certainConditions });
    * ```
    *
-   * It's possible to specify data to update separately from the data to create.
-   * This is useful if you want to make an update with different data than in creating.
-   * For example, changing a value if the row already exists:
+   * @param set - object containing new column values, or raw SQL
+   */
+  set(set) {
+    this.query.q.onConflict = {
+      target: this.onConflict,
+      set
+    };
+    return this.query;
+  }
+  /**
+   * Available only after `onConflict`.
    *
-   * ```ts
-   * const timestamp = Date.now();
+   * Use this method to merge all the data you have passed into `create` to update the existing record on conflict.
    *
-   * db.table
-   *   .create({
-   *     email: 'ignore@example.com',
-   *     name: 'John Doe',
-   *     createdAt: timestamp,
-   *     updatedAt: timestamp,
-   *   })
-   *   .onConflict('email')
-   *   .merge({
-   *     name: 'John Doe The Second',
-   *   });
-   * ```
+   * If the table has columns with **dynamic** default values, such values will be applied as well.
    *
-   * You can use `where` to update only the matching rows:
+   * You can exclude certain columns from being merged by passing the `exclude` option.
    *
    * ```ts
-   * const timestamp = Date.now();
+   * // merge the full data
+   * db.table.create(data).onConflict('email').merge();
    *
+   * // merge only a single column
+   * db.table.create(data).onConflict('email').merge('name');
+   *
+   * // merge multiple columns
+   * db.table.create(data).onConflict('email').merge(['name', 'quantity']);
+   *
+   * // merge all columns except some
    * db.table
-   *   .create({
-   *     email: 'ignore@example.com',
-   *     name: 'John Doe',
-   *     createdAt: timestamp,
-   *     updatedAt: timestamp,
-   *   })
+   *   .create(data)
    *   .onConflict('email')
-   *   .merge({
-   *     name: 'John Doe',
-   *     updatedAt: timestamp,
-   *   })
-   *   .where({ updatedAt: { lt: timestamp } });
-   * ```
+   *   .merge({ except: ['name', 'quantity'] });
    *
-   * `merge` can take a raw SQL expression:
+   * // merge can be applied also for batch creates
+   * db.table.createMany([data1, data2, data2]).onConflict('email').merge();
    *
-   * ```ts
+   * // update records only on certain conditions
    * db.table
    *   .create(data)
-   *   .onConflict()
-   *   .merge(db.table.sql`raw SQL expression`);
+   *   .onConflict('email')
+   *   .merge()
+   *   .where({ ...certainConditions });
    * ```
    *
-   * @param update - column, or array of columns, or object for new column values, or raw SQL
+   * @param merge - no argument will merge all data, or provide a column(s) to merge, or provide `except` to update all except some.
    */
-  merge(update) {
+  merge(merge) {
     this.query.q.onConflict = {
-      type: "merge",
-      expr: this.onConflict,
-      update
+      target: this.onConflict,
+      merge
     };
     return this.query;
   }