@protobase/server 0.51.3 → 0.52.1

package/dist/webhooks/subscriber-view.js

@@ -1,5 +1,6 @@
 import { requestAccess } from "../request-access.js";
 import { EventCodeError } from "../changes/event-code-error.js";
+import { currentRecord } from "../changes/resource-change.js";
 import { checkRecord, evaluateFilter } from "@protobase/schema";
 //#region src/webhooks/subscriber-view.ts
 /**
@@ -40,6 +41,28 @@ const subscriptionEvent = (change, event, { fields, thin = false } = {}) => ({
 		transaction: change.transaction
 	}
 });
+/**
+* A delivery's stored event as a change again, with its records as the model has them now, to shape it anew for the
+* subscription as it is now: an event stored before a field became sensitive holds it. The database role is unknown.
+*/
+const eventChange = (model, event) => {
+	const { data } = event;
+	return {
+		resource: data.resource,
+		key: data.key,
+		operation: data.operation,
+		...data.before && { before: currentRecord(model, data.before) },
+		...data.after && { after: currentRecord(model, data.after) },
+		changed: data.changed,
+		actor: data.actor,
+		source: data.source,
+		databaseRole: null,
+		...data.tenant !== void 0 && { tenant: data.tenant },
+		transaction: data.transaction,
+		sequence: data.sequence,
+		at: event.timestamp
+	};
+};
 const withUnknownFields = (model, record) => {
 	const fields = Object.values(model.fields).filter((field) => field.sensitive || !Object.hasOwn(record, field.name));
 	const unknown = { ...record };
@@ -96,7 +119,9 @@ const subscriberEvents = (deps) => {
 		if (!accesses.has(cacheKey)) accesses.set(cacheKey, requestAccess(deps, entry, session));
 		const readable = async () => {
 			const access = await accesses.get(cacheKey);
-			return await mayRead(access, change.after ?? change.before) ? access : void 0;
+			const record = change.after ?? change.before;
+			if (!record) return access.resolved.operations.read ? access : void 0;
+			return await mayRead(access, record) ? access : void 0;
 		};
 		const access = await readable().catch((error) => {
 			throw new EventCodeError(`The access check of subscription "${subscription.name}" on ${change.resource} ${change.key}`, error);
@@ -109,4 +134,4 @@ const subscriberEvents = (deps) => {
 	};
 };
 //#endregion
-export { subscriberEvents, subscriberSession, subscriptionEvent };
+export { eventChange, subscriberEvents, subscriberSession, subscriptionEvent };

package/dist/webhooks/webhooks.js

@@ -6,11 +6,11 @@ import { coalesce } from "../changes/coalesce.js";
 import { EventCodeError } from "../changes/event-code-error.js";
 import { eventMatcher } from "../changes/match-events.js";
 import { deleteOutbox, readOutbox } from "../changes/outbox.js";
-import { resourceChange } from "../changes/resource-change.js";
+import { currentChange, resourceChange } from "../changes/resource-change.js";
 import { callerRecords } from "../functions/records.js";
 import { writeHistory } from "../history/write-history.js";
 import { maxTries, nextRetryDelay } from "./retry-schedule.js";
-import { subscriberEvents } from "./subscriber-view.js";
+import { eventChange, subscriberEvents } from "./subscriber-view.js";
 import { attemptDelivery } from "./attempt.js";
 import { subscriptionProblems, subscriptionRouter } from "./route-events.js";
 import { tableSubscriptionName } from "./table/options.js";
@@ -51,7 +51,8 @@ const deliveryGroup = ({ subscription, change }) => `${subscription.name}:${chan
 *   only: the others still receive it, and the retry delivers to that subscription alone. Any other error fails the
 *   whole dispatch, which is retried.
 * - `webhooks.deliver`, one try of an unordered delivery; a failure queues the next try on the Standard Webhooks
-*   schedule, or Retry-After, and the last one is kept as failed.
+*   schedule, or Retry-After, and the last one is kept as failed. Each try, and each of the job below, shapes its event
+*   again for the subscription as it is now, and sends nothing when it may no longer read the record.
 * - `webhooks.deliver-ordered`, the ordered deliveries of one dispatch for one subscription and record, retried with
 *   doubling waits up to a day, holding back the record's later deliveries to that subscription meanwhile.
 *
@@ -103,8 +104,25 @@ const createWebhooks = ({ deps, subscriptions, functions, schema, log, table })
 		const found = id === void 0 ? byName.get(name) : await table?.subscriptions.find(db, id);
 		if (!found) throw new FatalJobError(`The subscription "${name}" no longer exists`);
 		if (found.options.enabled === false) throw new FatalJobError(`The subscription "${name}" is disabled`);
+		const problems = id === void 0 ? [] : subscriptionProblems([found], models, []);
+		if (problems.length > 0) throw new FatalJobError(problems.join("; "));
 		return found;
 	};
+	const modelOf = (resource) => {
+		const model = deps.registry.find(resource)?.model;
+		if (!model) throw new FatalJobError(`The resource "${resource}" no longer exists`);
+		return model;
+	};
+	const reshaper = () => {
+		const eventOf = subscriberEvents(deps);
+		return async (subscription, stored) => {
+			const shaped = await eventOf(subscription, eventChange(modelOf(stored.data.resource), stored), stored.type);
+			return shaped && {
+				...shaped,
+				id: stored.id
+			};
+		};
+	};
 	const deliver = defineJob({
 		name: "webhooks.deliver",
 		maxAttempts: 3,
@@ -113,13 +131,16 @@ const createWebhooks = ({ deps, subscriptions, functions, schema, log, table })
 		concurrency: parallelAttempts,
 		run: async (payload, { db, signal }) => {
 			const subscription = await subscriptionOf(payload.subscription, db);
-			const result = await attempt(subscription, payload.event, db, payload.attempt, signal);
-			report(payload.subscription, payload.event, payload.attempt, result);
+			const event = await reshaper()(subscription, payload.event);
+			if (!event) return;
+			const result = await attempt(subscription, event, db, payload.attempt, signal);
+			report(payload.subscription, event, payload.attempt, result);
 			if (result.ok) return;
 			const delay = result.final ? void 0 : nextRetryDelay(payload.attempt, result.retryAfterMs);
 			if (delay === void 0) throw new FatalJobError(result.error);
 			await deliver.enqueue(db, {
 				...payload,
+				event,
 				attempt: payload.attempt + 1,
 				lastError: result.error
 			}, {
@@ -138,7 +159,13 @@ const createWebhooks = ({ deps, subscriptions, functions, schema, log, table })
 		concurrency: parallelAttempts,
 		run: async (payload, { db, signal, job }) => {
 			const subscription = await subscriptionOf(payload.subscription, db);
-			for (const event of payload.events) {
+			const reshape = reshaper();
+			const events = [];
+			for (const stored of payload.events) {
+				const event = await reshape(subscription, stored);
+				if (event) events.push(event);
+			}
+			for (const event of events) {
 				const result = await attempt(subscription, event, db, job.attempt, signal);
 				report(payload.subscription, event, job.attempt, result);
 				if (result.ok) continue;
@@ -147,11 +174,12 @@ const createWebhooks = ({ deps, subscriptions, functions, schema, log, table })
 			}
 		}
 	});
-	const changeDeliveries = async (db) => {
-		const route = subscriptionRouter(await current(db), models);
+	const changeDeliveries = async (db, only) => {
+		const all = await current(db);
+		const route = subscriptionRouter(only === void 0 ? all : all.filter(({ name }) => name === only), models);
 		const eventOf = subscriberEvents(deps);
-		return async (change, only) => {
-			const routes = route(change, matchers.get(change.resource)(change)).filter(({ subscription }) => only === void 0 || subscription.name === only);
+		return async (change) => {
+			const routes = route(change, matchers.get(change.resource)(change));
 			const deliveries = [];
 			const failures = [];
 			const failed = /* @__PURE__ */ new Set();
@@ -195,8 +223,9 @@ const createWebhooks = ({ deps, subscriptions, functions, schema, log, table })
 		name: "webhooks.dispatch-change",
 		maxAttempts: 1,
 		timeout: "5 minutes",
-		run: async ({ change, subscription: only }, { db }) => {
-			const { deliveries, failures } = await (await changeDeliveries(db))(change, only);
+		run: async ({ change: kept, subscription: only }, { db }) => {
+			const change = currentChange(modelOf(kept.resource), kept);
+			const { deliveries, failures } = await (await changeDeliveries(db, only))(change);
 			if (only !== void 0 && failures.length > 0) throw failures[0].error;
 			await db.transaction().execute(async (trx) => {
 				for (const { subscription, event } of deliveries.filter(({ subscription }) => !subscription.options.ordered)) {

package/dist/write-pipeline.js

@@ -1,10 +1,10 @@
 import { HttpProblem, badRequest } from "./problem.js";
 import { tenantScope } from "./tenant.js";
 import { requestAccess, requireOperation, targetFilter, writableFields } from "./request-access.js";
+import { writeTransaction } from "./transactions.js";
 import { actorSettings, wakeDispatch } from "./changes/actor.js";
 import { isDatabaseError } from "./error-handler.js";
 import { attachFiles, scheduleRemovedFiles } from "./files/attach.js";
-import { writeTransaction } from "./transactions.js";
 import { bindingOf, pendingBinding } from "./encryption/binding.js";
 import { deleteRecord, fetchRecord, insertRecord, restoreRecord, updateRecord } from "./records.js";
 import { assertWritten, checkParents, checkPrecondition, decide, denied, firstKeyField, keyOf, missing, notifier, shown } from "./write-shared.js";

package/dist/write-shared.js

@@ -2,9 +2,9 @@ import { maskEncrypted } from "./encryption/mask-stored.js";
 import { forbidden, notFound, preconditionFailed, preconditionRequired } from "./problem.js";
 import { tenantScope } from "./tenant.js";
 import { andFilters, recordDecision } from "./request-access.js";
+import { pickFields } from "./rows.js";
 import { removedFiles } from "./files/attach.js";
 import { ifMatchSatisfied } from "./etag.js";
-import { pickFields } from "./rows.js";
 import { fetchRecord } from "./records.js";
 import { parentGuard } from "./parent-access.js";
 import { presentFiles } from "./files/present.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@protobase/server",
-  "version": "0.51.3",
+  "version": "0.52.1",
   "description": "The Protobase REST API as a Hono app, with Better Auth sign-in.",
   "license": "Apache-2.0",
   "repository": {
@@ -40,9 +40,9 @@
     "@better-auth/passkey": "^1.7.12",
     "@better-auth/sso": "^1.7.12",
     "@modelcontextprotocol/server": "^2.3.1",
-    "@protobase/layout": "0.51.3",
-    "@protobase/query": "0.51.3",
-    "@protobase/schema": "0.51.3",
+    "@protobase/layout": "0.52.1",
+    "@protobase/query": "0.52.1",
+    "@protobase/schema": "0.52.1",
     "@react-email/render": "^2.1.0",
     "@scalar/hono-api-reference": "^0.12.10",
     "@sentry/core": "^11.7.0",