@burojs/hasura 0.4.0 → 0.5.0

package/dist/index.d.cts

@@ -28,22 +28,16 @@ interface HasuraDataProviderConfig {
    * with a newly obtained token, while false preserves the original 401
    * response.
    *
-   * ⚠️ KNOWN GAP, stated here because this is where a consumer reads: HTTP 401
-   * is NOT how the Hasura deployment this provider was distilled from rejects
-   * a credential. The one capture in this repository of a real rejection
-   * (`packages/mock-kit/fixtures/hasura/error-unauthorized.json`, taken from
-   * the live backend with a deliberately malformed bearer token) came back
-   * **HTTP 200** with an `invalid-jwt` errors envelope. Replayed through this
-   * provider it surfaces as `{ kind: 'protocol', code: 'graphql-error' }` and
-   * `recoverAuth` is never consulted — no refresh, no retry, and app logic
-   * keyed on `kind: 'auth'` never fires either. Pinned by
-   * `tests/fixture-fidelity.test.ts`'s `error-unauthorized` case.
-   *
-   * So this callback fires only for a deployment that really answers 401 (a
-   * proxy or gateway in front of Hasura, typically). Keying recovery on the
-   * error envelope instead is a product decision, deliberately not taken here;
-   * the existing 401 tests use a FABRICATED 401 and must not be read as proof
-   * that recovery works against Hasura itself.
+   * HTTP 401 is what a proxy or gateway in front of Hasura answers. Hasura
+   * itself rejects a credential with **HTTP 200** and an `invalid-jwt` errors
+   * envelope (`packages/mock-kit/fixtures/hasura/error-unauthorized.json`,
+   * captured from a live backend). This provider reports that envelope as
+   * `{ kind: 'auth', code: 'invalid-jwt' }`. When the app has an
+   * `authProvider`, the runtime hands it that error; if the provider chooses
+   * to refresh, a read is replayed once, and a mutation once when it is
+   * replay-safe. `recoverAuth` is
+   * not consulted for the envelope, so one rejection is never refreshed twice.
+   * Pinned by `tests/fixture-fidelity.test.ts`'s `error-unauthorized` case.
    */
   recoverAuth?: () => Promise<boolean>;
   /** Map our resource name → table + field selection. */
@@ -397,6 +391,31 @@ declare function flattenJsonbSpill(item: unknown, spill: JsonbSpillConfig): unkn
  * stable symbol.
  */
 declare const NOT_AUTHENTICATED_CODE = "not-authenticated";
+/**
+ * The envelope codes with which Hasura reports a failure of work it ran OUTSIDE its own
+ * transaction — an Action's webhook or a remote schema — on a custom mutation. Such a side effect
+ * may have happened before the failure, so a custom mutation answered with one of them is
+ * `sent` (spec 4.7, P4-20). A table mutation keeps `protocol/graphql-error` for them: Hasura
+ * rolled its transaction back.
+ *
+ * Spellings confirmed against the Hasura GraphQL Engine v2 source, `instance ToJSON Code` in
+ * `server/lib/hasura-base/src/Hasura/Base/Error.hs` (hasura/graphql-engine@0a1dd53b):
+ * `Unexpected -> "unexpected"`, `RemoteSchemaError -> "remote-schema-error"`,
+ * `ParseFailed -> "parse-failed"`. Action failures are raised in
+ * `server/src-lib/Hasura/GraphQL/Execute/Action.hs`: an HTTP exception calling the webhook, a
+ * webhook 5xx, an unparsable webhook answer and a failed request or response transform are all
+ * `throw500…`, i.e. `unexpected`; a webhook that answered 2xx (its side effect done) with JSON
+ * that does not decode fails in `decodeValue` (`Action.hs:793`), which raises `ParseFailed`
+ * through `liftIResult` (`Error.hs:424`), i.e. `parse-failed`. Hasura has no
+ * `action-webhook-error` or `http-exception` code; a webhook's own 4xx answer carries the code
+ * the webhook chose (`ActionWebhookCode`), or `unexpected` when it chose none, and only that
+ * last case is caught here — a webhook-chosen code is the handler's own definite answer.
+ *
+ * Hasura gives no marker telling an Action-backed or remote-schema mutation apart from any
+ * other registered `operations` document, so every custom mutation is treated this way
+ * (fail-safe: a wrongly `sent` answer costs a "may have been applied" screen, never a duplicate).
+ */
+declare const HASURA_EXTERNAL_FAILURE_CODES: ReadonlySet<string>;
 /**
  * Refusal code for "this mapping declares a `localeField` but the descriptor
  * carries no locale". Exported so an application can match a symbol rather
@@ -752,5 +771,5 @@ declare function hasuraWsUrl(endpoint: string): string;
  */
 declare function createHasuraLiveProvider(config: HasuraLiveProviderConfig): DataLiveProvider;
 //#endregion
-export { type CursorOrderingColumn, DEFAULT_HASURA_ENDPOINT, type DataBodyConfig, FILTER_OPERATOR_UNSUPPORTED_CODE, HASURA_CURSOR_CODES, type HasuraCustomOperation, type HasuraDataProviderConfig, type HasuraLiveProviderConfig, type HasuraOperationRegistry, type JsonbSpillConfig, LOCALE_REQUIRED_CODE, NOT_AUTHENTICATED_CODE, type ResourceMapping, aggregateRoot, assertCursorLimit, assertCursorOrderable, byPkRoot, coerceInt64Filter, createHasuraDataProvider, createHasuraLiveProvider, decodeCursor, effectiveCursorOrdering, encodeCursor, filtersToWhere, flattenJsonbSpill, hasuraWsUrl, keysetWhere, localeWhere, mergeWhere, orderingSignature, partitionDataBody, partitionJsonbSpill, scopeToWhere };
+export { type CursorOrderingColumn, DEFAULT_HASURA_ENDPOINT, type DataBodyConfig, FILTER_OPERATOR_UNSUPPORTED_CODE, HASURA_CURSOR_CODES, HASURA_EXTERNAL_FAILURE_CODES, type HasuraCustomOperation, type HasuraDataProviderConfig, type HasuraLiveProviderConfig, type HasuraOperationRegistry, type JsonbSpillConfig, LOCALE_REQUIRED_CODE, NOT_AUTHENTICATED_CODE, type ResourceMapping, aggregateRoot, assertCursorLimit, assertCursorOrderable, byPkRoot, coerceInt64Filter, createHasuraDataProvider, createHasuraLiveProvider, decodeCursor, effectiveCursorOrdering, encodeCursor, filtersToWhere, flattenJsonbSpill, hasuraWsUrl, keysetWhere, localeWhere, mergeWhere, orderingSignature, partitionDataBody, partitionJsonbSpill, scopeToWhere };
 //# sourceMappingURL=index.d.cts.map

package/dist/index.d.ts

@@ -28,22 +28,16 @@ interface HasuraDataProviderConfig {
    * with a newly obtained token, while false preserves the original 401
    * response.
    *
-   * ⚠️ KNOWN GAP, stated here because this is where a consumer reads: HTTP 401
-   * is NOT how the Hasura deployment this provider was distilled from rejects
-   * a credential. The one capture in this repository of a real rejection
-   * (`packages/mock-kit/fixtures/hasura/error-unauthorized.json`, taken from
-   * the live backend with a deliberately malformed bearer token) came back
-   * **HTTP 200** with an `invalid-jwt` errors envelope. Replayed through this
-   * provider it surfaces as `{ kind: 'protocol', code: 'graphql-error' }` and
-   * `recoverAuth` is never consulted — no refresh, no retry, and app logic
-   * keyed on `kind: 'auth'` never fires either. Pinned by
-   * `tests/fixture-fidelity.test.ts`'s `error-unauthorized` case.
-   *
-   * So this callback fires only for a deployment that really answers 401 (a
-   * proxy or gateway in front of Hasura, typically). Keying recovery on the
-   * error envelope instead is a product decision, deliberately not taken here;
-   * the existing 401 tests use a FABRICATED 401 and must not be read as proof
-   * that recovery works against Hasura itself.
+   * HTTP 401 is what a proxy or gateway in front of Hasura answers. Hasura
+   * itself rejects a credential with **HTTP 200** and an `invalid-jwt` errors
+   * envelope (`packages/mock-kit/fixtures/hasura/error-unauthorized.json`,
+   * captured from a live backend). This provider reports that envelope as
+   * `{ kind: 'auth', code: 'invalid-jwt' }`. When the app has an
+   * `authProvider`, the runtime hands it that error; if the provider chooses
+   * to refresh, a read is replayed once, and a mutation once when it is
+   * replay-safe. `recoverAuth` is
+   * not consulted for the envelope, so one rejection is never refreshed twice.
+   * Pinned by `tests/fixture-fidelity.test.ts`'s `error-unauthorized` case.
    */
   recoverAuth?: () => Promise<boolean>;
   /** Map our resource name → table + field selection. */
@@ -397,6 +391,31 @@ declare function flattenJsonbSpill(item: unknown, spill: JsonbSpillConfig): unkn
  * stable symbol.
  */
 declare const NOT_AUTHENTICATED_CODE = "not-authenticated";
+/**
+ * The envelope codes with which Hasura reports a failure of work it ran OUTSIDE its own
+ * transaction — an Action's webhook or a remote schema — on a custom mutation. Such a side effect
+ * may have happened before the failure, so a custom mutation answered with one of them is
+ * `sent` (spec 4.7, P4-20). A table mutation keeps `protocol/graphql-error` for them: Hasura
+ * rolled its transaction back.
+ *
+ * Spellings confirmed against the Hasura GraphQL Engine v2 source, `instance ToJSON Code` in
+ * `server/lib/hasura-base/src/Hasura/Base/Error.hs` (hasura/graphql-engine@0a1dd53b):
+ * `Unexpected -> "unexpected"`, `RemoteSchemaError -> "remote-schema-error"`,
+ * `ParseFailed -> "parse-failed"`. Action failures are raised in
+ * `server/src-lib/Hasura/GraphQL/Execute/Action.hs`: an HTTP exception calling the webhook, a
+ * webhook 5xx, an unparsable webhook answer and a failed request or response transform are all
+ * `throw500…`, i.e. `unexpected`; a webhook that answered 2xx (its side effect done) with JSON
+ * that does not decode fails in `decodeValue` (`Action.hs:793`), which raises `ParseFailed`
+ * through `liftIResult` (`Error.hs:424`), i.e. `parse-failed`. Hasura has no
+ * `action-webhook-error` or `http-exception` code; a webhook's own 4xx answer carries the code
+ * the webhook chose (`ActionWebhookCode`), or `unexpected` when it chose none, and only that
+ * last case is caught here — a webhook-chosen code is the handler's own definite answer.
+ *
+ * Hasura gives no marker telling an Action-backed or remote-schema mutation apart from any
+ * other registered `operations` document, so every custom mutation is treated this way
+ * (fail-safe: a wrongly `sent` answer costs a "may have been applied" screen, never a duplicate).
+ */
+declare const HASURA_EXTERNAL_FAILURE_CODES: ReadonlySet<string>;
 /**
  * Refusal code for "this mapping declares a `localeField` but the descriptor
  * carries no locale". Exported so an application can match a symbol rather
@@ -752,5 +771,5 @@ declare function hasuraWsUrl(endpoint: string): string;
  */
 declare function createHasuraLiveProvider(config: HasuraLiveProviderConfig): DataLiveProvider;
 //#endregion
-export { type CursorOrderingColumn, DEFAULT_HASURA_ENDPOINT, type DataBodyConfig, FILTER_OPERATOR_UNSUPPORTED_CODE, HASURA_CURSOR_CODES, type HasuraCustomOperation, type HasuraDataProviderConfig, type HasuraLiveProviderConfig, type HasuraOperationRegistry, type JsonbSpillConfig, LOCALE_REQUIRED_CODE, NOT_AUTHENTICATED_CODE, type ResourceMapping, aggregateRoot, assertCursorLimit, assertCursorOrderable, byPkRoot, coerceInt64Filter, createHasuraDataProvider, createHasuraLiveProvider, decodeCursor, effectiveCursorOrdering, encodeCursor, filtersToWhere, flattenJsonbSpill, hasuraWsUrl, keysetWhere, localeWhere, mergeWhere, orderingSignature, partitionDataBody, partitionJsonbSpill, scopeToWhere };
+export { type CursorOrderingColumn, DEFAULT_HASURA_ENDPOINT, type DataBodyConfig, FILTER_OPERATOR_UNSUPPORTED_CODE, HASURA_CURSOR_CODES, HASURA_EXTERNAL_FAILURE_CODES, type HasuraCustomOperation, type HasuraDataProviderConfig, type HasuraLiveProviderConfig, type HasuraOperationRegistry, type JsonbSpillConfig, LOCALE_REQUIRED_CODE, NOT_AUTHENTICATED_CODE, type ResourceMapping, aggregateRoot, assertCursorLimit, assertCursorOrderable, byPkRoot, coerceInt64Filter, createHasuraDataProvider, createHasuraLiveProvider, decodeCursor, effectiveCursorOrdering, encodeCursor, filtersToWhere, flattenJsonbSpill, hasuraWsUrl, keysetWhere, localeWhere, mergeWhere, orderingSignature, partitionDataBody, partitionJsonbSpill, scopeToWhere };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -342,6 +342,63 @@ function flattenJsonbSpill(item, spill) {
 	return out;
 }
 const NOT_AUTHENTICATED_CODE = "not-authenticated";
+const FORBIDDEN_CODES = new Set(["access-denied", "permission-error"]);
+const HASURA_EXTERNAL_FAILURE_CODES = new Set([
+	"unexpected",
+	"remote-schema-error",
+	"parse-failed"
+]);
+const MUTATION_REFUSAL_CODES = new Map([["constraint-violation", "conflict"], ["validation-failed", "validation"]]);
+function graphqlError(errors, operation, external) {
+	const message = errors.map((e) => e.message).join("; ");
+	const codes = errors.flatMap((e) => typeof e.extensions?.code === "string" ? [e.extensions.code] : []);
+	if (codes.includes("invalid-jwt")) return {
+		kind: "auth",
+		code: "invalid-jwt",
+		message,
+		details: errors
+	};
+	const outside = operation === "mutation" && external ? codes.find((code) => HASURA_EXTERNAL_FAILURE_CODES.has(code) || MUTATION_REFUSAL_CODES.has(code) || FORBIDDEN_CODES.has(code)) : void 0;
+	if (outside !== void 0) return {
+		kind: "sent",
+		code: outside,
+		message,
+		retryable: false,
+		details: errors
+	};
+	const forbidden = codes.find((code) => FORBIDDEN_CODES.has(code));
+	if (forbidden !== void 0) return {
+		kind: "forbidden",
+		code: forbidden,
+		message,
+		details: errors
+	};
+	if (operation === "mutation") for (const code of codes) {
+		const kind = MUTATION_REFUSAL_CODES.get(code);
+		if (kind !== void 0) return {
+			kind,
+			code,
+			message,
+			details: errors
+		};
+	}
+	return {
+		kind: "protocol",
+		code: "graphql-error",
+		message,
+		details: errors
+	};
+}
+function answerLost(code, message, status, cause) {
+	return {
+		kind: "sent",
+		code,
+		message,
+		status,
+		retryable: false,
+		...cause === void 0 ? {} : { cause }
+	};
+}
 const LOCALE_REQUIRED_CODE = "locale-required";
 function localeWhere(m, locale) {
 	if (m.localeField === void 0) return void 0;
@@ -498,8 +555,12 @@ function createHasuraDataProvider(config) {
 	const operations = snapshotOperationRegistry(config.operations);
 	const hasCustomQueries = hasRegisteredOperationKind(operations, "query");
 	const hasCustomMutations = hasRegisteredOperationKind(operations, "mutation");
-	async function gql(query, variables, role, signal) {
+	async function gql(query, variables, role, signal, operation, external = false) {
 		try {
+			const requestBody = JSON.stringify({
+				query,
+				variables
+			});
 			const request = async (token) => {
 				const headers = {
 					"Content-Type": "application/json",
@@ -507,15 +568,24 @@ function createHasuraDataProvider(config) {
 				};
 				const effectiveRole = role === void 0 ? defaultRole : normalizeRole(role);
 				if (effectiveRole !== null) headers["X-Hasura-Role"] = effectiveRole;
-				return (config.fetchImpl ?? fetch)(endpoint, {
-					method: "POST",
-					headers,
-					body: JSON.stringify({
-						query,
-						variables
-					}),
-					signal
-				});
+				const fetchImpl = config.fetchImpl ?? fetch;
+				try {
+					return await fetchImpl(endpoint, {
+						method: "POST",
+						headers,
+						body: requestBody,
+						signal
+					});
+				} catch (cause) {
+					if (operation === "mutation" && !signal.aborted) throw {
+						kind: "sent",
+						code: "hasura-request-sent",
+						message: "Hasura did not answer a mutation; it may have been applied.",
+						retryable: false,
+						cause
+					};
+					throw cause;
+				}
 			};
 			let token = await config.getToken();
 			if (!token) throw {
@@ -533,24 +603,32 @@ function createHasuraDataProvider(config) {
 				};
 				res = await request(token);
 			}
-			if (!res.ok) throw {
-				kind: "transport",
-				code: "graphql-http-error",
-				message: `GraphQL HTTP ${res.status}`,
-				status: res.status
-			};
-			const body = await res.json();
-			if (body.errors?.length) throw {
-				kind: "protocol",
-				code: "graphql-error",
-				message: body.errors.map((e) => e.message).join("; "),
-				details: body.errors
-			};
-			if (body.data === void 0) throw {
-				kind: "protocol",
-				code: "empty-graphql-response",
-				message: "Empty GraphQL response."
-			};
+			if (!res.ok) {
+				if (operation === "mutation" && res.status >= 500) throw answerLost("hasura-answer-lost", `GraphQL HTTP ${res.status} after a mutation was sent; it may have been applied.`, res.status);
+				throw {
+					kind: "transport",
+					code: "graphql-http-error",
+					message: `GraphQL HTTP ${res.status}`,
+					status: res.status
+				};
+			}
+			let body;
+			try {
+				body = await res.json();
+				if (body === null || typeof body !== "object") throw new TypeError("The GraphQL answer is not an object.");
+			} catch (cause) {
+				if (operation === "mutation" && !signal.aborted) throw answerLost("hasura-answer-unreadable", "Hasura answered a mutation with a body that could not be read; it may have been applied.", res.status, cause);
+				throw cause;
+			}
+			if (body.errors?.length) throw graphqlError(body.errors, operation, external);
+			if (body.data === void 0) {
+				if (operation === "mutation") throw answerLost("hasura-answer-unreadable", "Hasura answered a mutation without data or errors; it may have been applied.", res.status);
+				throw {
+					kind: "protocol",
+					code: "empty-graphql-response",
+					message: "Empty GraphQL response."
+				};
+			}
 			return body.data;
 		} catch (error) {
 			throw hasuraError(error, signal, "Hasura request failed.");
@@ -576,8 +654,8 @@ function createHasuraDataProvider(config) {
 	}
 	async function executeCustomOperation(resource, operationName, input, kind, signal) {
 		const operation = registeredOperation(resource, operationName, kind);
-		const result = await gql(operation.document, operation.variables(input), operation.role ?? config.resources[resource]?.role, signal);
-		return operation.mapResult?.(result) ?? result;
+		const result = await gql(operation.document, operation.variables(input), operation.role ?? config.resources[resource]?.role, signal, kind, kind === "mutation");
+		return operation.mapResult === void 0 ? result : operation.mapResult(result);
 	}
 	function composeListWhere(m, descriptor, context) {
 		const userWhere = filtersToWhere(coerceInt64Filter(descriptor.filter, m.int64Fields));
@@ -596,7 +674,7 @@ function createHasuraDataProvider(config) {
     }`;
 		const aggVars = {};
 		if (where) aggVars.where = where;
-		return (await gql(metaQuery, where ? aggVars : void 0, m.role, signal)).meta.aggregate.count;
+		return (await gql(metaQuery, where ? aggVars : void 0, m.role, signal, "query")).meta.aggregate.count;
 	}
 	async function upsertDataBody(db, parentId, body, role, signal) {
 		await gql(`mutation UpsertDataBody($object: ${db.table}_insert_input!) {
@@ -607,11 +685,11 @@ function createHasuraDataProvider(config) {
     }`, { object: {
 			[db.fk]: parentId,
 			[db.column]: body
-		} }, role, signal);
+		} }, role, signal, "mutation");
 	}
 	function mutationRecord(m, idField, item, resource, expectedId) {
 		if (item === null || typeof item !== "object" || Array.isArray(item)) throw {
-			kind: "protocol",
+			kind: "not-found",
 			code: "record-not-found",
 			message: `Not found: ${resource}`
 		};
@@ -642,11 +720,11 @@ function createHasuraDataProvider(config) {
 			const where = mergeWhere({ [pkField]: { _eq: id } }, m.fixedFilter);
 			return (await gql(`query One_${m.table}($where: ${m.table}_bool_exp) {
         items: ${m.table}(where: $where, limit: 1) { ${fields} }
-      }`, { where }, m.role, signal)).items?.[0] ?? null;
+      }`, { where }, m.role, signal, "query")).items?.[0] ?? null;
 		}
 		return (await gql(`query One_${m.table}($id: ${pkType}!) {
       item: ${root}(${pkField}: $id) { ${fields} }
-    }`, { id }, m.role, signal)).item;
+    }`, { id }, m.role, signal, "query")).item;
 	}
 	async function listByCursor(m, descriptor, pagination, context) {
 		if (pagination.before !== void 0) throw {
@@ -669,7 +747,7 @@ function createHasuraDataProvider(config) {
       }`;
 		const itemsVars = { limit: pagination.limit + 1 };
 		if (where) itemsVars.where = where;
-		const fetched = (await gql(itemsQuery, itemsVars, m.role, context.signal)).items ?? [];
+		const fetched = (await gql(itemsQuery, itemsVars, m.role, context.signal, "query")).items ?? [];
 		const hasNextPage = fetched.length > pagination.limit;
 		const rows = hasNextPage ? fetched.slice(0, pagination.limit) : fetched;
 		let total;
@@ -714,7 +792,7 @@ function createHasuraDataProvider(config) {
 					offset
 				};
 				if (where) itemsVars.where = where;
-				const itemsData = await gql(itemsQuery, itemsVars, m.role, context.signal);
+				const itemsData = await gql(itemsQuery, itemsVars, m.role, context.signal, "query");
 				let total;
 				const listAggRoot = aggregateRoot(m);
 				if (!m.noAggregate && listAggRoot) try {
@@ -743,7 +821,7 @@ function createHasuraDataProvider(config) {
 				const fields = m.selectFields.join(" ");
 				const data = await gql(`query Many_${m.table}($where: ${m.table}_bool_exp) {
         items: ${m.table}(where: $where) { ${fields} }
-      }`, { where }, m.role, context.signal);
+      }`, { where }, m.role, context.signal, "query");
 				const spill = m.jsonbSpill;
 				return { data: spill ? data.items.map((item) => flattenJsonbSpill(item, spill)) : data.items };
 			},
@@ -760,12 +838,12 @@ function createHasuraDataProvider(config) {
 					const where = mergeWhere(mergeWhere({ [pkField]: { _eq: descriptor.id } }, m.fixedFilter), localeSlice);
 					item = (await gql(`query One_${m.table}($where: ${m.table}_bool_exp) {
           items: ${m.table}(where: $where, limit: 1) { ${fields} }
-        }`, { where }, m.role, context.signal)).items?.[0] ?? null;
+        }`, { where }, m.role, context.signal, "query")).items?.[0] ?? null;
 				} else item = (await gql(`query One_${m.table}($id: ${pkType}!) {
           item: ${root}(${pkField}: $id) { ${fields} }
-        }`, { id: descriptor.id }, m.role, context.signal)).item;
+        }`, { id: descriptor.id }, m.role, context.signal, "query")).item;
 				if (item == null) throw {
-					kind: "protocol",
+					kind: "not-found",
 					code: "record-not-found",
 					message: `Not found: ${descriptor.resource}/${descriptor.id}`
 				};
@@ -801,7 +879,7 @@ function createHasuraDataProvider(config) {
 				const object = m.jsonbSpill ? partitionJsonbSpill(mainInput, m.jsonbSpill, m.selectFields) : mainInput;
 				const data = await gql(`mutation Create_${m.table}($object: ${m.table}_insert_input!) {
         item: insert_${m.table}_one(object: $object) { ${fields} }
-      }`, { object }, m.role, context.signal);
+      }`, { object }, m.role, context.signal, "mutation");
 				const result = mutationRecord(m, descriptor.idField, data.item, descriptor.resource);
 				if (m.dataBody && dataBody) await upsertDataBody(m.dataBody, result.id, dataBody, m.role, context.signal);
 				return result;
@@ -830,7 +908,7 @@ function createHasuraDataProvider(config) {
         }`, {
 						where,
 						set
-					}, m.role, context.signal);
+					}, m.role, context.signal, "mutation");
 					if (ifUpdatedAt != null && ((data.result.affected_rows ?? 0) === 0 || (data.result.returning?.length ?? 0) === 0)) throw {
 						kind: "conflict",
 						code: "stale-record",
@@ -844,7 +922,7 @@ function createHasuraDataProvider(config) {
         }`, {
 						id: descriptor.id,
 						set
-					}, m.role, context.signal)).item;
+					}, m.role, context.signal, "mutation")).item;
 				}
 				const result = mutationRecord(m, descriptor.idField, item, descriptor.resource, descriptor.id);
 				if (m.dataBody && dataBody) await upsertDataBody(m.dataBody, result.id, dataBody, m.role, context.signal);
@@ -859,12 +937,12 @@ function createHasuraDataProvider(config) {
 					const where = mergeWhere({ [pkField]: { _eq: descriptor.id } }, m.fixedFilter);
 					item = (await gql(`mutation Delete_${m.table}($where: ${m.table}_bool_exp!) {
           result: delete_${m.table}(where: $where) { affected_rows returning { ${fields} } }
-        }`, { where }, m.role, context.signal)).result.returning?.[0] ?? null;
+        }`, { where }, m.role, context.signal, "mutation")).result.returning?.[0] ?? null;
 				} else {
 					const pkType = m.pkType ?? "bigint";
 					item = (await gql(`mutation Delete_${m.table}($id: ${pkType}!) {
           item: delete_${m.table}_by_pk(${pkField}: $id) { ${fields} }
-        }`, { id: descriptor.id }, m.role, context.signal)).item;
+        }`, { id: descriptor.id }, m.role, context.signal, "mutation")).item;
 				}
 				mutationRecord(m, descriptor.idField, item, descriptor.resource, descriptor.id);
 				return {
@@ -885,6 +963,6 @@ function createHasuraDataProvider(config) {
 	});
 }
 //#endregion
-export { DEFAULT_HASURA_ENDPOINT, FILTER_OPERATOR_UNSUPPORTED_CODE, HASURA_CURSOR_CODES, LOCALE_REQUIRED_CODE, NOT_AUTHENTICATED_CODE, aggregateRoot, assertCursorLimit, assertCursorOrderable, byPkRoot, coerceInt64Filter, createHasuraDataProvider, createHasuraLiveProvider, decodeCursor, effectiveCursorOrdering, encodeCursor, filtersToWhere, flattenJsonbSpill, hasuraWsUrl, keysetWhere, localeWhere, mergeWhere, orderingSignature, partitionDataBody, partitionJsonbSpill, scopeToWhere };
+export { DEFAULT_HASURA_ENDPOINT, FILTER_OPERATOR_UNSUPPORTED_CODE, HASURA_CURSOR_CODES, HASURA_EXTERNAL_FAILURE_CODES, LOCALE_REQUIRED_CODE, NOT_AUTHENTICATED_CODE, aggregateRoot, assertCursorLimit, assertCursorOrderable, byPkRoot, coerceInt64Filter, createHasuraDataProvider, createHasuraLiveProvider, decodeCursor, effectiveCursorOrdering, encodeCursor, filtersToWhere, flattenJsonbSpill, hasuraWsUrl, keysetWhere, localeWhere, mergeWhere, orderingSignature, partitionDataBody, partitionJsonbSpill, scopeToWhere };
 
 //# sourceMappingURL=index.js.map