@vantreeseba/drizzle-graphql 13.1.0 → 13.1.1

package/dist/index.d.cts

@@ -337,6 +337,13 @@ type DrizzleFieldExtension = {
    * Absent everywhere else, so a wrapper can gate purging without parsing arguments.
    */
   hardDelete?: boolean;
+  /**
+   * `true` on the count mutations (`update<Table>Count` / `delete<Table>Count`,
+   * `features.countMutations`): the field writes like its plural `update` / `delete` sibling
+   * — same `operation`, same rows — but resolves to how many rows it wrote (`Int!`) rather
+   * than to the rows. Absent everywhere else.
+   */
+  count?: boolean;
   /** For `kind: 'relation'` and `operation: 'relationAggregate'`: the relation's name. */
   relation?: string;
   /** For `kind: 'relation'` and `operation: 'relationAggregate'`: the table it hangs off. */
@@ -822,7 +829,8 @@ type WriteHookPayload = {
    *
    * Each row holds the columns the client's selection asked for (plus any key a relation or
    * nested write needed), **and** every column the hook names in `columns`. A column the
-   * client did not select and the hook did not name is absent.
+   * client did not select and the hook did not name is absent. The count mutations select
+   * nothing, so there a row holds the named columns, or the primary key when none are named.
    */
   rows: any[];
   context: any;
@@ -1499,6 +1507,17 @@ type SchemaFeatures = {
    * for nothing. Each mutation is generated only when its plural counterpart is
    * (`features.update` / `features.delete`), and honours `features.requireWhere`.
    *
+   * Apart from the answer, they obey every rule the plural write does: the table's `scope`
+   * is ANDed into the `where`; on a `softDelete` table the delete marks rows instead of
+   * removing them (taking `hard` where the plural delete does) and neither mutation reaches
+   * an already-marked row; `contextValues` columns are never reassigned by the update; and
+   * `onWrite` hooks run `before` and `after`, in a transaction, with the plural payload
+   * (`single: false`). An `after` hook needs rows, so on a table with one the write adds a
+   * `RETURNING` of the hook's `columns` — or of the primary key if it names none (every column
+   * on a table without one) — and the count is the number of rows returned. On MySQL, which has
+   * no `RETURNING`, the hook gets `rows: []` as on every MySQL mutation. Their
+   * `extensions.drizzle` carries the plural write's `operation` plus `count: true`.
+   *
    * Off unless asked for, so an existing schema does not grow new mutations on upgrade.
    *
    * @default false

package/dist/index.d.ts

@@ -337,6 +337,13 @@ type DrizzleFieldExtension = {
    * Absent everywhere else, so a wrapper can gate purging without parsing arguments.
    */
   hardDelete?: boolean;
+  /**
+   * `true` on the count mutations (`update<Table>Count` / `delete<Table>Count`,
+   * `features.countMutations`): the field writes like its plural `update` / `delete` sibling
+   * — same `operation`, same rows — but resolves to how many rows it wrote (`Int!`) rather
+   * than to the rows. Absent everywhere else.
+   */
+  count?: boolean;
   /** For `kind: 'relation'` and `operation: 'relationAggregate'`: the relation's name. */
   relation?: string;
   /** For `kind: 'relation'` and `operation: 'relationAggregate'`: the table it hangs off. */
@@ -822,7 +829,8 @@ type WriteHookPayload = {
    *
    * Each row holds the columns the client's selection asked for (plus any key a relation or
    * nested write needed), **and** every column the hook names in `columns`. A column the
-   * client did not select and the hook did not name is absent.
+   * client did not select and the hook did not name is absent. The count mutations select
+   * nothing, so there a row holds the named columns, or the primary key when none are named.
    */
   rows: any[];
   context: any;
@@ -1499,6 +1507,17 @@ type SchemaFeatures = {
    * for nothing. Each mutation is generated only when its plural counterpart is
    * (`features.update` / `features.delete`), and honours `features.requireWhere`.
    *
+   * Apart from the answer, they obey every rule the plural write does: the table's `scope`
+   * is ANDed into the `where`; on a `softDelete` table the delete marks rows instead of
+   * removing them (taking `hard` where the plural delete does) and neither mutation reaches
+   * an already-marked row; `contextValues` columns are never reassigned by the update; and
+   * `onWrite` hooks run `before` and `after`, in a transaction, with the plural payload
+   * (`single: false`). An `after` hook needs rows, so on a table with one the write adds a
+   * `RETURNING` of the hook's `columns` — or of the primary key if it names none (every column
+   * on a table without one) — and the count is the number of rows returned. On MySQL, which has
+   * no `RETURNING`, the hook gets `rows: []` as on every MySQL mutation. Their
+   * `extensions.drizzle` carries the plural write's `operation` plus `count: true`.
+   *
    * Off unless asked for, so an existing schema does not grow new mutations on upgrade.
    *
    * @default false

package/dist/index.js

@@ -3724,6 +3724,145 @@ const runMutation = async (db, context, info, txCtx, body, forceTx) => {
 	return runOnSharedTx(state, body);
 };
 //#endregion
+//#region src/util/builders/common/write-hooks.ts
+/**
+* Normalizes the two registration shapes: a bare function is the `after` hook — the position
+* that has rows, and the one the common audit/outbox case wants — while `{ before, after }`
+* names them explicitly.
+*/
+const normalizeWriteHooks = (hooks, tableColumns, where) => {
+	if (!hooks) return;
+	if (typeof hooks === "function") return { after: hooks };
+	const resolved = {
+		before: hooks.before,
+		after: hooks.after
+	};
+	if (hooks.columns !== void 0) resolved.columns = resolveHookColumns(hooks.columns, !!hooks.after, tableColumns, where);
+	return resolved.before || resolved.after ? resolved : void 0;
+};
+/**
+* Resolves a hook's `columns` against the table it runs on. `where` names the registration
+* (`config.onWrite.posts`) and, for a top-level one, the table, so the error says which.
+*/
+const resolveHookColumns = (spec, hasAfter, tableColumns, where) => {
+	if (!hasAfter) throw new Error(`Drizzle-GraphQL Error: ${where}.columns only applies to an 'after' hook, and none is registered.`);
+	if (spec === "all") return { ...tableColumns };
+	if (!Array.isArray(spec)) throw new Error(`Drizzle-GraphQL Error: ${where}.columns must be an array of column names or 'all'.`);
+	const resolved = {};
+	for (const name of spec) {
+		const column = typeof name === "string" && Object.keys(tableColumns).includes(name) ? tableColumns[name] : void 0;
+		if (!column) throw new Error(`Drizzle-GraphQL Error: ${where}.columns names '${String(name)}', which is not a column of that table.`);
+		resolved[name] = column;
+	}
+	return resolved;
+};
+/**
+* Adds a hook's `columns` to a RETURNING column map, and reports which keys it added — the
+* ones the client never asked for, which have to come back off before the rows are mapped.
+* Returns the map untouched, and no keys, when the hook named none or the selection already
+* covers them.
+*/
+const withHookColumns = (hooks, columns) => {
+	const hookColumns = hooks?.columns;
+	if (!hookColumns) return {
+		returning: columns,
+		added: void 0
+	};
+	const selected = new Set(Object.keys(columns));
+	const added = Object.keys(hookColumns).filter((key) => !selected.has(key));
+	if (!added.length) return {
+		returning: columns,
+		added: void 0
+	};
+	const returning = { ...columns };
+	for (const key of added) returning[key] = hookColumns[key];
+	return {
+		returning,
+		added
+	};
+};
+/**
+* The rows with the hook-only keys taken off, as fresh objects: the hook was handed the
+* originals and may still hold them, so they are not mutated under it.
+*/
+const omitHookColumns = (rows, added) => {
+	if (!added) return rows;
+	return rows.map((row) => {
+		const copy = { ...row };
+		for (const key of added) delete copy[key];
+		return copy;
+	});
+};
+/**
+* Invokes one position of a field's hooks. Returns `undefined` rather than a resolved promise
+* when nothing is registered, so the awaiting call site costs nothing on an unhooked build.
+*/
+const runWriteHook = (hooks, position, payload) => {
+	const hook = position === "before" ? hooks?.before : hooks?.after;
+	if (!hook) return;
+	return Promise.resolve(hook({
+		...payload,
+		position,
+		rows: payload.rows ?? []
+	}));
+};
+//#endregion
+//#region src/util/builders/common/write-scaffold.ts
+/**
+* Wraps one mutation body in the scaffolding above and returns the field it becomes.
+*
+* A field carrying a hook is forced into a transaction even when it would have run straight
+* on `db`: a hook exists to write atomically with the mutation, and one that ran outside the
+* transaction could not roll anything back.
+*/
+const writeResolver = ({ db, tableName, operation, single, fieldName, args: queryArgs, txCtx, policies, run }) => {
+	const hooks = policies?.onWrite?.(tableName, operation);
+	const errorCtx = {
+		table: tableName,
+		operation,
+		field: fieldName
+	};
+	return {
+		name: fieldName,
+		resolver: async (_source, args, context, info) => {
+			try {
+				return await runMutation(db, context, info, txCtx, (executor) => {
+					const payload = {
+						table: tableName,
+						operation,
+						single,
+						args,
+						context,
+						info,
+						tx: executor
+					};
+					let added;
+					return run({
+						executor,
+						args,
+						context,
+						info,
+						before: () => runWriteHook(hooks, "before", payload),
+						after: (rows) => runWriteHook(hooks, "after", {
+							...payload,
+							rows: rows ?? []
+						}),
+						returning: (columns) => {
+							const withHook = withHookColumns(hooks, columns);
+							added = withHook.added;
+							return withHook.returning;
+						},
+						output: (rows) => omitHookColumns(rows, added)
+					});
+				}, !!hooks);
+			} catch (e) {
+				throw withErrorContext(toGraphQLError(e), errorCtx);
+			}
+		},
+		args: queryArgs
+	};
+};
+//#endregion
 //#region src/util/builders/common/mutation-helpers.ts
 /**
 * The `hard` argument on the delete mutations of a soft-deleting table that opted into
@@ -3867,54 +4006,79 @@ const assertSingleMatch = async (executor, table, filters) => {
 * The plural `update` and `delete` always `RETURNING *`, which is the wrong shape for
 * "archive everything older than a year": the caller pays to ship rows it does not want, and
 * on a large match that cost is the whole mutation. These return `Int!` instead — how many
-* rows the write touched, as the driver reported it, with no RETURNING clause at all.
+* rows the write touched.
 *
-* Dialect-independent: drizzle's update/delete builders take the same calls everywhere, and
-* the drivers' disagreement about how to spell the row count is handled by
-* {@link rowsAffected}.
-*/
-const generateWriteCount = ({ db, tableName, table, kind, setArgs, filterArgs, fieldName, requireWhere, filterCtx, txCtx, nested }) => {
+* Leaving the payload off changes nothing else: the write obeys every rule of the plural
+* mutation it mirrors, through the same {@link writeResolver} scaffolding.
+*
+* - `scope` (and the soft-delete marker) is ANDed into the `where`, so only rows the plural
+*   write could reach are counted and written.
+* - On a soft-deleting table the delete is the marking `UPDATE`, not a `DELETE`, and rows that
+*   are already marked are not matched; the update skips marked rows too. `hard: true` exists
+*   exactly where the plural delete takes it.
+* - Context-derived columns are stripped from the update's `set`, as the plural update does.
+* - `onWrite` hooks run `before` and `after`, inside a transaction. The `after` hook is handed
+*   rows, so a table with one pays for a `RETURNING` — of the columns the hook names in
+*   `columns`, or of the primary key when it names none (the whole row on a table without a
+*   key) — and the count is the number of rows returned. Every other write, and every write on
+*   MySQL (no `RETURNING`; its hooks see `rows: []` as on every MySQL mutation), skips the
+*   `RETURNING` and reads the count off the driver's result via {@link rowsAffected}.
+*/
+const generateWriteCount = ({ db, tableName, table, kind, setArgs, filterArgs, fieldName, requireWhere, filterCtx, txCtx, nested, policies, pkNames = [], returnsRows }) => {
+	const softDelete = kind === "delete" ? policies?.softDelete?.(tableName) : void 0;
+	const canHardDelete = softDelete?.hardDelete === true;
 	const queryArgs = {
 		...setArgs ? { set: { type: new GraphQLNonNull(setArgs) } } : {},
-		where: { type: requireWhere ? new GraphQLNonNull(filterArgs) : filterArgs }
+		where: { type: requireWhere ? new GraphQLNonNull(filterArgs) : filterArgs },
+		...canHardDelete ? { hard: hardDeleteArg } : {}
 	};
-	const errorCtx = {
-		table: tableName,
+	const readsRows = returnsRows && !!policies?.onWrite?.(tableName, kind)?.after;
+	const allColumns = getColumns(table);
+	const keyColumns = pkNames.length ? Object.fromEntries(pkNames.map((name) => [name, allColumns[name]])) : allColumns;
+	return writeResolver({
+		db,
+		tableName,
 		operation: kind,
-		field: fieldName
-	};
-	return {
-		name: fieldName,
-		resolver: async (_source, args, context, info) => {
-			try {
-				return await runMutation(db, context, info, txCtx, async (executor) => {
-					const { where, set } = args;
-					const filters = scopedWhere({
-						scope: void 0,
-						tableName,
-						table,
-						where,
-						relationCtx: relationFilterCtx(filterCtx, tableName),
-						required: requireWhere
-					});
-					let query;
-					if (kind === "delete") query = executor.delete(table);
-					else {
-						const entry = nested?.enabled(tableName) ? nested.split(tableName, set) : void 0;
-						if (entry && nested.hasOps(entry.ops)) throw drizzleError("This mutation does not support nested writes — use the one that returns the rows instead.", { code: "DRIZZLE_NESTED_WRITES_UNSUPPORTED" });
-						const values = remapUpdateInput(entry ? entry.columns : set, table, tableName);
-						if (!Object.keys(values).length) throw drizzleError("Unable to update with no values specified!", { code: "DRIZZLE_NO_VALUES" });
-						query = executor.update(table).set(values);
-					}
-					if (filters) query = query.where(filters);
-					return rowsAffected(await query);
-				});
-			} catch (e) {
-				throw withErrorContext(toGraphQLError(e), errorCtx);
+		single: false,
+		fieldName,
+		txCtx,
+		policies,
+		args: queryArgs,
+		run: async ({ executor, args, context, before, after, returning }) => {
+			const { where, set } = args;
+			const hard = canHardDelete && args.hard === true;
+			const scope = policies?.scope?.(context);
+			await before();
+			let query;
+			if (kind === "delete") query = softDelete && !hard ? executor.update(table).set({ [softDelete.columnName]: softDelete.writeDeleted() }) : executor.delete(table);
+			else {
+				const entry = nested?.enabled(tableName) ? nested.split(tableName, set) : void 0;
+				if (entry && nested.hasOps(entry.ops)) throw drizzleError("This mutation does not support nested writes — use the one that returns the rows instead.", { code: "DRIZZLE_NESTED_WRITES_UNSUPPORTED" });
+				const values = stripContextValues(remapUpdateInput(entry ? entry.columns : set, table, tableName), policies?.contextValues?.(tableName));
+				if (!Object.keys(values).length) throw drizzleError("Unable to update with no values specified!", { code: "DRIZZLE_NO_VALUES" });
+				query = executor.update(table).set(values);
 			}
-		},
-		args: queryArgs
-	};
+			const filters = scopedWhere({
+				scope,
+				tableName,
+				table,
+				where,
+				relationCtx: relationFilterCtx(filterCtx, tableName),
+				required: requireWhere,
+				deleted: hard ? "INCLUDE" : void 0
+			});
+			if (filters) query = query.where(filters);
+			if (!readsRows) {
+				const result = await query;
+				await after();
+				return rowsAffected(result);
+			}
+			const named = returning({});
+			const rows = await query.returning(Object.keys(named).length ? named : keyColumns);
+			await after(rows);
+			return rows.length;
+		}
+	});
 };
 //#endregion
 //#region src/util/batch-loader/index.ts
@@ -4852,145 +5016,6 @@ const generateTableTypes = (tableName, tables, relationMap, withReturning, relat
 	};
 };
 //#endregion
-//#region src/util/builders/common/write-hooks.ts
-/**
-* Normalizes the two registration shapes: a bare function is the `after` hook — the position
-* that has rows, and the one the common audit/outbox case wants — while `{ before, after }`
-* names them explicitly.
-*/
-const normalizeWriteHooks = (hooks, tableColumns, where) => {
-	if (!hooks) return;
-	if (typeof hooks === "function") return { after: hooks };
-	const resolved = {
-		before: hooks.before,
-		after: hooks.after
-	};
-	if (hooks.columns !== void 0) resolved.columns = resolveHookColumns(hooks.columns, !!hooks.after, tableColumns, where);
-	return resolved.before || resolved.after ? resolved : void 0;
-};
-/**
-* Resolves a hook's `columns` against the table it runs on. `where` names the registration
-* (`config.onWrite.posts`) and, for a top-level one, the table, so the error says which.
-*/
-const resolveHookColumns = (spec, hasAfter, tableColumns, where) => {
-	if (!hasAfter) throw new Error(`Drizzle-GraphQL Error: ${where}.columns only applies to an 'after' hook, and none is registered.`);
-	if (spec === "all") return { ...tableColumns };
-	if (!Array.isArray(spec)) throw new Error(`Drizzle-GraphQL Error: ${where}.columns must be an array of column names or 'all'.`);
-	const resolved = {};
-	for (const name of spec) {
-		const column = typeof name === "string" && Object.keys(tableColumns).includes(name) ? tableColumns[name] : void 0;
-		if (!column) throw new Error(`Drizzle-GraphQL Error: ${where}.columns names '${String(name)}', which is not a column of that table.`);
-		resolved[name] = column;
-	}
-	return resolved;
-};
-/**
-* Adds a hook's `columns` to a RETURNING column map, and reports which keys it added — the
-* ones the client never asked for, which have to come back off before the rows are mapped.
-* Returns the map untouched, and no keys, when the hook named none or the selection already
-* covers them.
-*/
-const withHookColumns = (hooks, columns) => {
-	const hookColumns = hooks?.columns;
-	if (!hookColumns) return {
-		returning: columns,
-		added: void 0
-	};
-	const selected = new Set(Object.keys(columns));
-	const added = Object.keys(hookColumns).filter((key) => !selected.has(key));
-	if (!added.length) return {
-		returning: columns,
-		added: void 0
-	};
-	const returning = { ...columns };
-	for (const key of added) returning[key] = hookColumns[key];
-	return {
-		returning,
-		added
-	};
-};
-/**
-* The rows with the hook-only keys taken off, as fresh objects: the hook was handed the
-* originals and may still hold them, so they are not mutated under it.
-*/
-const omitHookColumns = (rows, added) => {
-	if (!added) return rows;
-	return rows.map((row) => {
-		const copy = { ...row };
-		for (const key of added) delete copy[key];
-		return copy;
-	});
-};
-/**
-* Invokes one position of a field's hooks. Returns `undefined` rather than a resolved promise
-* when nothing is registered, so the awaiting call site costs nothing on an unhooked build.
-*/
-const runWriteHook = (hooks, position, payload) => {
-	const hook = position === "before" ? hooks?.before : hooks?.after;
-	if (!hook) return;
-	return Promise.resolve(hook({
-		...payload,
-		position,
-		rows: payload.rows ?? []
-	}));
-};
-//#endregion
-//#region src/util/builders/common/write-scaffold.ts
-/**
-* Wraps one mutation body in the scaffolding above and returns the field it becomes.
-*
-* A field carrying a hook is forced into a transaction even when it would have run straight
-* on `db`: a hook exists to write atomically with the mutation, and one that ran outside the
-* transaction could not roll anything back.
-*/
-const writeResolver = ({ db, tableName, operation, single, fieldName, args: queryArgs, txCtx, policies, run }) => {
-	const hooks = policies?.onWrite?.(tableName, operation);
-	const errorCtx = {
-		table: tableName,
-		operation,
-		field: fieldName
-	};
-	return {
-		name: fieldName,
-		resolver: async (_source, args, context, info) => {
-			try {
-				return await runMutation(db, context, info, txCtx, (executor) => {
-					const payload = {
-						table: tableName,
-						operation,
-						single,
-						args,
-						context,
-						info,
-						tx: executor
-					};
-					let added;
-					return run({
-						executor,
-						args,
-						context,
-						info,
-						before: () => runWriteHook(hooks, "before", payload),
-						after: (rows) => runWriteHook(hooks, "after", {
-							...payload,
-							rows: rows ?? []
-						}),
-						returning: (columns) => {
-							const withHook = withHookColumns(hooks, columns);
-							added = withHook.added;
-							return withHook.returning;
-						},
-						output: (rows) => omitHookColumns(rows, added)
-					});
-				}, !!hooks);
-			} catch (e) {
-				throw withErrorContext(toGraphQLError(e), errorCtx);
-			}
-		},
-		args: queryArgs
-	};
-};
-//#endregion
 //#region src/util/features.ts
 /**
 * What a table generates when the config says nothing. Everything is on except the opt-in
@@ -6992,7 +7017,9 @@ const generateSchemaData$2 = (db, schema, relations, options) => {
 			fieldName: updateCountFieldName,
 			requireWhere: tableFeatures.requireWhere,
 			filterCtx,
-			txCtx: mutationTxCtx
+			txCtx: mutationTxCtx,
+			policies,
+			returnsRows: false
 		}) : void 0;
 		const deleteCountGenerated = tableFeatures.delete && tableFeatures.countMutations ? generateWriteCount({
 			db,
@@ -7003,7 +7030,9 @@ const generateSchemaData$2 = (db, schema, relations, options) => {
 			fieldName: deleteCountFieldName,
 			requireWhere: tableFeatures.requireWhere,
 			filterCtx,
-			txCtx: mutationTxCtx
+			txCtx: mutationTxCtx,
+			policies,
+			returnsRows: false
 		}) : void 0;
 		const hardDeleteMeta = softDeleteInfo?.hardDelete ? { hardDelete: true } : {};
 		const withMeta = (generated, meta) => ({
@@ -7073,12 +7102,25 @@ const generateSchemaData$2 = (db, schema, relations, options) => {
 				{
 					generated: updateCountGenerated,
 					type: new GraphQLNonNull(GraphQLInt),
+					meta: {
+						operation: "update",
+						single: false,
+						targetArg: "where",
+						count: true
+					},
 					description: "How many rows the update touched. The rows themselves are not read back, which is the point of this mutation."
 				},
 				{
 					generated: deleteCountGenerated,
 					type: new GraphQLNonNull(GraphQLInt),
-					description: "How many rows the delete removed. The rows themselves are not read back, which is the point of this mutation."
+					meta: {
+						operation: "delete",
+						single: false,
+						targetArg: "where",
+						count: true,
+						...hardDeleteMeta
+					},
+					description: "How many rows the delete removed — or, on a soft-deleting table, marked deleted. The rows themselves are not read back, which is the point of this mutation."
 				}
 			],
 			onConflictInput,
@@ -7579,7 +7621,10 @@ const createSchemaDataGenerator = (adapter) => {
 				requireWhere: tableFeatures.requireWhere,
 				filterCtx,
 				txCtx: mutationTxCtx,
-				nested: nestedRuntime
+				nested: nestedRuntime,
+				policies,
+				pkNames: primaryKeyPropNames(schema[tableName]),
+				returnsRows: true
 			}) : void 0;
 			const deleteCountGenerated = tableFeatures.delete && tableFeatures.countMutations ? generateWriteCount({
 				db,
@@ -7590,7 +7635,10 @@ const createSchemaDataGenerator = (adapter) => {
 				fieldName: deleteCountFieldName,
 				requireWhere: tableFeatures.requireWhere,
 				filterCtx,
-				txCtx: mutationTxCtx
+				txCtx: mutationTxCtx,
+				policies,
+				pkNames: primaryKeyPropNames(schema[tableName]),
+				returnsRows: true
 			}) : void 0;
 			const hardDeleteMeta = softDeleteInfo?.hardDelete ? { hardDelete: true } : {};
 			return {
@@ -7700,12 +7748,25 @@ const createSchemaDataGenerator = (adapter) => {
 					{
 						generated: updateCountGenerated,
 						type: new GraphQLNonNull(GraphQLInt),
+						meta: {
+							operation: "update",
+							single: false,
+							targetArg: "where",
+							count: true
+						},
 						description: "How many rows the update touched. The rows themselves are not read back, which is the point of this mutation."
 					},
 					{
 						generated: deleteCountGenerated,
 						type: new GraphQLNonNull(GraphQLInt),
-						description: "How many rows the delete removed. The rows themselves are not read back, which is the point of this mutation."
+						meta: {
+							operation: "delete",
+							single: false,
+							targetArg: "where",
+							count: true,
+							...hardDeleteMeta
+						},
+						description: "How many rows the delete removed — or, on a soft-deleting table, marked deleted. The rows themselves are not read back, which is the point of this mutation."
 					}
 				],
 				onConflictInput,