@protobase/server 0.8.2 → 0.9.0

package/dist/webhooks/attempt.js

@@ -0,0 +1,91 @@
+import { invokeFunction } from "../functions/define-function.js";
+import { retryAfterMs } from "./retry-schedule.js";
+import { standardWebhookHeaders } from "./standard-webhooks.js";
+import { subscriberSession } from "./subscriber-view.js";
+//#region src/webhooks/attempt.ts
+/** How long a receiver has to answer. */
+const attemptTimeoutMs = 15e3;
+const excerpt = async (response) => (await response.text()).slice(0, 200);
+const resultOf = async (response) => {
+	if (response.status >= 200 && response.status < 300) return {
+		ok: true,
+		status: response.status
+	};
+	const body = await excerpt(response);
+	const wait = retryAfterMs(response.headers.get("retry-after"));
+	return {
+		ok: false,
+		status: response.status,
+		error: `${response.status}${body ? `: ${body}` : ""}`,
+		...wait !== void 0 && { retryAfterMs: wait },
+		final: response.status === 410
+	};
+};
+const request = async (url, event, options, signal) => {
+	const body = JSON.stringify(options.body ? options.body(event) : event);
+	const signed = await standardWebhookHeaders(event.id, Math.floor(Date.now() / 1e3), body, options.secret);
+	return new Request(url, {
+		method: "POST",
+		headers: {
+			...options.headers,
+			...signed,
+			"content-type": "application/json"
+		},
+		body,
+		redirect: "manual",
+		signal
+	});
+};
+const callFunction = async (name, subscription, event, options, context, signal) => {
+	const fn = context.functions[name];
+	if (!fn) throw new Error(`The app has no function "${name}"`);
+	const session = subscriberSession(subscription) ?? { user: {
+		id: `subscription:${subscription.name}`,
+		roles: []
+	} };
+	const caller = {
+		session,
+		records: context.records(session)
+	};
+	const functionContext = {
+		name,
+		db: context.db,
+		caller: async () => caller
+	};
+	return invokeFunction(name, fn, await request("http://protobase.internal/", event, options, signal), fn.options.public ? functionContext : {
+		...functionContext,
+		...caller
+	});
+};
+const failure = (error) => ({
+	ok: false,
+	error: error instanceof Error ? error.message : String(error),
+	final: false
+});
+/** One try of one event to one subscription's target, within `attemptTimeoutMs`. It never throws. */
+const attemptDelivery = async (subscription, event, context) => {
+	const signal = AbortSignal.any([context.signal, AbortSignal.timeout(attemptTimeoutMs)]);
+	const { options } = subscription;
+	try {
+		if ("run" in options) {
+			await options.run(event, {
+				db: context.db,
+				attempt: context.attempt,
+				signal
+			});
+			return { ok: true };
+		}
+		if ("function" in options) return await resultOf(await callFunction(options.function, subscription, event, options, context, signal));
+		const blocked = await context.checkUrl?.(options.url);
+		if (blocked) return {
+			ok: false,
+			error: blocked,
+			final: true
+		};
+		return await resultOf(await fetch(await request(options.url, event, options, signal)));
+	} catch (error) {
+		return failure(error);
+	}
+};
+//#endregion
+export { attemptDelivery, attemptTimeoutMs };

package/dist/webhooks/retry-schedule.js

@@ -0,0 +1,40 @@
+//#region src/webhooks/retry-schedule.ts
+const second = 1e3;
+const minute = 60 * second;
+const hour = 60 * minute;
+/**
+* The waits before each retry, as Standard Webhooks recommends: 5 s, 5 m, 30 m, 2 h, 5 h, 10 h, 14 h, 20 h and 24 h,
+* about three days in all, so a delivery has 10 tries.
+*/
+const retryDelays = [
+	5 * second,
+	5 * minute,
+	30 * minute,
+	2 * hour,
+	5 * hour,
+	10 * hour,
+	14 * hour,
+	20 * hour,
+	24 * hour
+];
+const maxTries = retryDelays.length + 1;
+/**
+* How long to wait before the try after `tried` failed ones: the schedule with up to 10% jitter, or longer when the
+* receiver asked with Retry-After, up to a day. `undefined` once the tries are used up.
+*/
+const nextRetryDelay = (tried, retryAfterMs, random = Math.random) => {
+	const scheduled = retryDelays[tried - 1];
+	if (scheduled === void 0) return void 0;
+	const jittered = Math.round(scheduled * (1 + (random() * 2 - 1) * .1));
+	return Math.min(Math.max(jittered, retryAfterMs ?? 0), 24 * hour);
+};
+/** A Retry-After header in milliseconds from `now`: seconds, or an HTTP date. */
+const retryAfterMs = (header, now = Date.now()) => {
+	if (header === null) return void 0;
+	const text = header.trim();
+	if (/^\d+$/.test(text)) return Number(text) * second;
+	const at = Date.parse(text);
+	return Number.isNaN(at) ? void 0 : Math.max(0, at - now);
+};
+//#endregion
+export { maxTries, nextRetryDelay, retryAfterMs, retryDelays };

package/dist/webhooks/route-events.js

@@ -0,0 +1,61 @@
+import { eventPatternMatches } from "./subscription.js";
+import { checkEventFilter, evaluateFilter } from "@protobase/schema";
+//#region src/webhooks/route-events.ts
+const declaredEvents = (models) => models.flatMap((model) => (model.events ?? []).map((event) => ({
+	model,
+	name: event.name
+})));
+const coveredModels = (subscription, models) => {
+	const events = declaredEvents(models).filter(({ name }) => subscription.options.events.some((pattern) => eventPatternMatches(pattern, name)));
+	return [...new Set(events.map(({ model }) => model))];
+};
+/**
+* What is wrong with the subscriptions, given the resources and the app's API functions: a pattern that names no
+* declared event, a `when` that does not check against a resource it covers, a missing function or URL, roles left
+* empty. Disabled subscriptions are checked too, except for their URL.
+*/
+const subscriptionProblems = (subscriptions, models, functions) => subscriptions.flatMap((subscription) => {
+	const { name, options } = subscription;
+	const declared = declaredEvents(models).map((event) => event.name);
+	return [
+		...options.events.filter((pattern) => !declared.some((event) => eventPatternMatches(pattern, event))).map((pattern) => `"${pattern}" matches no declared event`),
+		...options.when === void 0 ? [] : coveredModels(subscription, models).flatMap((model) => {
+			const { problem } = checkEventFilter(model, options.when);
+			return problem ? [`when ${problem} on ${model.name}`] : [];
+		}),
+		..."function" in options && !functions.includes(options.function) ? [`calls the function "${options.function}", which the app does not have`] : [],
+		..."url" in options && options.enabled !== false && !options.url ? ["has an empty url; is its environment variable set?"] : [],
+		...options.as && options.as.roles.length === 0 ? ["delivers as no roles"] : []
+	].map((problem) => `Subscription "${name}" ${problem}`);
+});
+/**
+* Which subscriptions take which of a change's events: enabled, naming the event, of the change's tenant when they set
+* one, and passing their `when` on the record after the change (before it, for a delete). Filters are checked once,
+* here; run `subscriptionProblems` first.
+*/
+const subscriptionRouter = (subscriptions, models) => {
+	const filters = /* @__PURE__ */ new Map();
+	for (const subscription of subscriptions) {
+		if (subscription.options.when === void 0) continue;
+		for (const model of coveredModels(subscription, models)) {
+			const { filter } = checkEventFilter(model, subscription.options.when);
+			if (filter) filters.set(`${subscription.name}\0${model.name}`, filter);
+		}
+	}
+	const passes = (subscription, change) => {
+		const { options } = subscription;
+		if (options.enabled === false) return false;
+		if (options.tenant !== void 0 && String(options.tenant) !== String(change.tenant)) return false;
+		const filter = filters.get(`${subscription.name}\0${change.resource}`);
+		return !filter || evaluateFilter(filter, change.after ?? change.before) === true;
+	};
+	return (change, events) => subscriptions.flatMap((subscription) => {
+		if (!passes(subscription, change)) return [];
+		return events.filter((event) => subscription.options.events.some((pattern) => eventPatternMatches(pattern, event))).map((event) => ({
+			subscription,
+			event
+		}));
+	});
+};
+//#endregion
+export { subscriptionProblems, subscriptionRouter };

package/dist/webhooks/standard-webhooks.d.ts

@@ -0,0 +1,4 @@
+//#region src/webhooks/standard-webhooks.d.ts
+/** A new signing secret, `whsec_` and 32 random bytes in base64. */
+export declare const newWebhookSecret: () => string;
+//#endregion

package/dist/webhooks/standard-webhooks.js

@@ -0,0 +1,36 @@
+//#region src/webhooks/standard-webhooks.ts
+const base64 = (bytes) => btoa(String.fromCharCode(...bytes));
+const secretKey = (secret) => {
+	const text = secret.replace(/^whsec_/, "");
+	if (!/^[A-Za-z0-9+/]+={0,2}$/.test(text)) throw new Error("A webhook secret is `whsec_` and base64");
+	return Uint8Array.from(atob(text), (char) => char.charCodeAt(0));
+};
+/** A new signing secret, `whsec_` and 32 random bytes in base64. */
+const newWebhookSecret = () => `whsec_${base64(crypto.getRandomValues(/* @__PURE__ */ new Uint8Array(32)))}`;
+const sign = async (secret, content) => {
+	const key = await crypto.subtle.importKey("raw", secretKey(secret), {
+		name: "HMAC",
+		hash: "SHA-256"
+	}, false, ["sign"]);
+	return `v1,${base64(new Uint8Array(await crypto.subtle.sign("HMAC", key, new TextEncoder().encode(content))))}`;
+};
+/**
+* The Standard Webhooks headers of one request (https://www.standardwebhooks.com): its id, its time in seconds and,
+* with a secret, the HMAC-SHA256 of `id.timestamp.body` as `v1,<base64>`; with several, one signature per secret,
+* separated by spaces, as during a rotation.
+*/
+const standardWebhookHeaders = async (id, timestamp, body, secret) => {
+	const headers = {
+		"webhook-id": id,
+		"webhook-timestamp": String(timestamp)
+	};
+	const secrets = secret === void 0 ? [] : [secret].flat();
+	if (secrets.length === 0) return headers;
+	const signatures = await Promise.all(secrets.map((each) => sign(each, `${id}.${timestamp}.${body}`)));
+	return {
+		...headers,
+		"webhook-signature": signatures.join(" ")
+	};
+};
+//#endregion
+export { newWebhookSecret, standardWebhookHeaders };

package/dist/webhooks/subscriber-view.js

@@ -0,0 +1,76 @@
+import { requestAccess } from "../request-access.js";
+import { checkRecord, evaluateFilter } from "@protobase/schema";
+//#region src/webhooks/subscriber-view.ts
+/**
+* The session a subscription delivers as, or `undefined` for the system: every record, every field but sensitive ones.
+* Its tenant is the change's, typed as the app's, when the subscription has one.
+*/
+const subscriberSession = ({ name, options }, change) => {
+	if (!options.as) return void 0;
+	const tenant = options.tenant === void 0 ? void 0 : change?.tenant ?? options.tenant;
+	return {
+		user: {
+			id: `subscription:${name}`,
+			roles: options.as.roles
+		},
+		...tenant !== void 0 && {
+			tenant,
+			organization: { id: tenant }
+		}
+	};
+};
+const pick = (record, fields) => fields ? Object.fromEntries(Object.entries(record).filter(([name]) => fields.includes(name))) : record;
+/** A change's event as a subscriber sees it: only `fields` of its records (all without), none at all when `thin`. */
+const subscriptionEvent = (change, event, { fields, thin = false } = {}) => ({
+	id: `evt_${change.sequence}_${event.slice(event.indexOf(".") + 1)}`,
+	type: event,
+	timestamp: change.at,
+	data: {
+		resource: change.resource,
+		operation: change.operation,
+		key: change.key,
+		sequence: change.sequence,
+		...!thin && change.after && { after: pick(change.after, fields) },
+		...!thin && change.before && { before: pick(change.before, fields) },
+		changed: fields ? change.changed.filter((name) => fields.includes(name)) : change.changed,
+		...change.tenant !== void 0 && { tenant: change.tenant },
+		actor: change.actor,
+		source: change.source,
+		transaction: change.transaction
+	}
+});
+const mayRead = async (access, record) => {
+	const { resolved, session, entry } = access;
+	if (!resolved.operations.read) return false;
+	if (resolved.rowFilter.read && evaluateFilter(resolved.rowFilter.read, record) !== true) return false;
+	if (!resolved.recordChecks.includes("read")) return true;
+	const context = {
+		user: session.user,
+		...session.organization && { organization: session.organization }
+	};
+	return checkRecord(entry.source, context, "read", record, void 0, access.deps.accessOptions);
+};
+/**
+* Builds each subscriber's event, under the access rules of the session it delivers as, resolved once per subscription
+* and resource: `undefined` when it may not read the record, after the change or before a delete.
+*/
+const subscriberEvents = (deps) => {
+	const accesses = /* @__PURE__ */ new Map();
+	return async (subscription, change, event) => {
+		const thin = subscription.options.payload === "thin";
+		const session = subscriberSession(subscription, change);
+		if (!session) return subscriptionEvent(change, event, { thin });
+		const entry = deps.registry.find(change.resource);
+		if (!entry) throw new Error(`Not implemented: a change of "${change.resource}", which is no resource of the app`);
+		const cacheKey = `${subscription.name}\0${change.resource}`;
+		if (!accesses.has(cacheKey)) accesses.set(cacheKey, requestAccess(deps, entry, session));
+		const access = await accesses.get(cacheKey);
+		if (!await mayRead(access, change.after ?? change.before)) return void 0;
+		return subscriptionEvent(change, event, {
+			fields: Object.keys(access.readable.fields),
+			thin
+		});
+	};
+};
+//#endregion
+export { subscriberEvents, subscriberSession, subscriptionEvent };

package/dist/webhooks/subscription.d.ts

@@ -0,0 +1,92 @@
+import { Row, TenantValue } from "../types.js";
+import { EventActor, EventOperation } from "@protobase/schema";
+import { Db } from "@protobase/query";
+//#region src/webhooks/subscription.d.ts
+/** What happened, as a receiver gets it in the `data` of an event. Records use field names, as the API shows them. */
+export type EventData = {
+  resource: string;
+  operation: EventOperation;
+  /** The record's key as its URL has it. */
+  key: string;
+  /** Grows with every change of a record, so a receiver can drop an event older than one it has. */
+  sequence: string;
+  after?: Row;
+  before?: Row;
+  changed: string[];
+  tenant?: TenantValue;
+  actor: EventActor | null;
+  source: 'api' | 'database';
+  transaction: string;
+};
+/** One event as it is delivered: the body of a URL or function target, and what a `run` handler gets. */
+export type SubscriptionEvent = {
+  /** The same on every retry and resend: the receiver's idempotency key (`webhook-id`). */
+  id: string;
+  type: string;
+  /** When the change's transaction started, ISO 8601. */
+  timestamp: string;
+  data: EventData;
+  /** Sent by Send test event: made up from a current record, not raised by a change. */
+  test?: true;
+};
+/** What a `run` handler gets beside the event. */
+export type RunContext = {
+  db: Db;
+  /** 1 for the first try. */
+  attempt: number;
+  signal: AbortSignal;
+};
+/** What every subscription may set beside its target. */
+export type SubscriptionCommon = {
+  /** Event names, such as `orders.created`, `orders.*` for every event of a resource, or `*` for all of them. */
+  events: string[];
+  /** A filter on the record, after the change or before a delete, in the language of access rules. */
+  when?: string;
+  /**
+   * Who the subscription delivers as: it gets only the records and fields these roles may read. Without it, every record
+   * and every field but the sensitive ones.
+   */
+  as?: {
+    roles: string[];
+  };
+  /** Only events of records of this tenant (organization). */
+  tenant?: TenantValue;
+  /** `thin` leaves the records out: a receiver reads them through the API. Default `full`. */
+  payload?: 'full' | 'thin';
+  /** One delivery at a time per record, in order; a failing one holds back the record's next. Default false. */
+  ordered?: boolean;
+  /** Default true. */
+  enabled?: boolean;
+};
+/** How a URL or function target is called: a POST of the event as JSON, signed with Standard Webhooks headers. */
+export type SentOptions = {
+  /** Signs the requests (`whsec_` and base64, as `verifyStandardWebhook` takes it); unsigned without one. Several sign during a rotation. */
+  secret?: string | string[];
+  headers?: Record<string, string>;
+  /** The body sent instead of the event, such as Slack's `{ text }`. */
+  body?: (event: SubscriptionEvent) => unknown;
+};
+export type UrlTarget = {
+  url: string | undefined;
+} & SentOptions;
+/** An API function of the app, `/api/functions/<name>`, called in this process. */
+export type FunctionTarget = {
+  function: string;
+} & SentOptions;
+/** Code run for each event; it throws to have the event retried. Config only. */
+export type RunTarget = {
+  run: (event: SubscriptionEvent, context: RunContext) => Promise<void> | void;
+};
+export type SubscriptionOptions = SubscriptionCommon & (UrlTarget | FunctionTarget | RunTarget);
+export type SubscriptionDefinition = {
+  readonly kind: 'subscription';
+  readonly name: string;
+  readonly options: SubscriptionOptions;
+};
+/**
+ * Delivers the events it names, as they happen: export it from the config module like a resource. The URL usually
+ * comes from the environment (`url: process.env.SLACK_WEBHOOK`); the server refuses to start while an enabled one is
+ * empty.
+ */
+export declare const subscription: (name: string, options: SubscriptionOptions) => SubscriptionDefinition;
+//#endregion

package/dist/webhooks/subscription.js

@@ -0,0 +1,28 @@
+//#region src/webhooks/subscription.ts
+const namePattern = /^[A-Za-z][A-Za-z0-9_-]*$/;
+const targets = [
+	"url",
+	"function",
+	"run"
+];
+/**
+* Delivers the events it names, as they happen: export it from the config module like a resource. The URL usually
+* comes from the environment (`url: process.env.SLACK_WEBHOOK`); the server refuses to start while an enabled one is
+* empty.
+*/
+const subscription = (name, options) => {
+	if (!namePattern.test(name)) throw new Error(`Subscription name "${name}" must start with a letter and hold only letters, digits, "_" and "-"`);
+	const named = targets.filter((target) => target in options);
+	if (named.length !== 1) throw new Error(`Subscription "${name}" needs one target: url, function or run${named.length > 1 ? `, not ${named.join(" and ")}` : ""}`);
+	if (options.events.length === 0) throw new Error(`Subscription "${name}" names no events`);
+	return {
+		kind: "subscription",
+		name,
+		options
+	};
+};
+const isSubscription = (value) => typeof value === "object" && value !== null && value.kind === "subscription" && typeof value.name === "string";
+/** Whether an event name matches a subscription's pattern: the name, `<resource>.*` or `*`. */
+const eventPatternMatches = (pattern, event) => pattern === "*" || pattern === event || pattern.endsWith(".*") && event.startsWith(pattern.slice(0, -1));
+//#endregion
+export { eventPatternMatches, isSubscription, subscription };

package/dist/webhooks/table/address-check.js

@@ -0,0 +1,28 @@
+import { lookup } from "node:dns/promises";
+import { isIP } from "node:net";
+//#region src/webhooks/table/address-check.ts
+const v4 = (address) => address.split(".").map(Number);
+const privateV4 = (address) => {
+	const [a, b] = v4(address);
+	return a === 0 || a === 10 || a === 127 || a >= 224 || a === 100 && b >= 64 && b < 128 || a === 169 && b === 254 || a === 172 && b >= 16 && b < 32 || a === 192 && b === 168;
+};
+const privateV6 = (address) => {
+	const lower = address.toLowerCase();
+	const mapped = /^::ffff:(\d+\.\d+\.\d+\.\d+)$/.exec(lower);
+	if (mapped) return privateV4(mapped[1]);
+	return lower === "::" || lower === "::1" || /^f[cd]/.test(lower) || /^fe[89ab]/.test(lower) || /^ff/.test(lower);
+};
+/** Whether an IP address is one a webhook must not reach: the server's own host or network. */
+const isPrivateAddress = (address) => isIP(address) === 4 ? privateV4(address) : privateV6(address);
+/**
+* What is wrong with a URL whose host is, or resolves to, a private, loopback or link-local address, so a subscription someone
+* makes in the admin app cannot reach the server's own network. The address is resolved again when the request is
+* sent, so a host that answers differently the second time still gets through: a firewall rule is the stronger guard.
+*/
+const checkWebhookUrl = async (url) => {
+	const host = new URL(url).hostname.replace(/^\[|\]$/g, "");
+	const blocked = (isIP(host) ? [host] : (await lookup(host, { all: true })).map((entry) => entry.address)).find(isPrivateAddress);
+	return blocked ? `${host} is a private address (${blocked}); webhooks reach public addresses only` : void 0;
+};
+//#endregion
+export { checkWebhookUrl, isPrivateAddress };

package/dist/webhooks/table/options.d.ts

@@ -0,0 +1,23 @@
+import { TenantValue } from "../../types.js";
+//#region src/webhooks/table/options.d.ts
+/** Webhook subscriptions made in the admin app (`extends: [webhooks()]`), kept in a table of the app's database. */
+export type WebhooksOptions = {
+  /** The schema of the subscriptions table and the deliveries view; default `webhooks`. */
+  schema?: string;
+  /** Also keep every try, successes too, for 30 days, listed as Webhook delivery log. Default false. */
+  deliveryLog?: boolean;
+  /**
+   * The roles a subscription's owner holds now in its tenant, which it delivers as. Default: read from the project's
+   * Better Auth (`auth`); a project that signs people in otherwise passes its own.
+   */
+  ownerRoles?: (owner: {
+    id: string;
+    tenant?: TenantValue;
+  }) => Promise<string[]>;
+  /**
+   * Lets subscriptions send to private, loopback and link-local addresses, for development and tests. Default false:
+   * a URL whose host resolves to one is refused, so a subscription cannot reach the app's own network.
+   */
+  allowPrivateAddresses?: boolean;
+};
+//#endregion

package/dist/webhooks/table/options.js

@@ -0,0 +1,14 @@
+//#region src/webhooks/table/options.ts
+const schemaPattern = /^[a-z_][a-z0-9_]*$/;
+/** The schema of the options, checked. */
+const webhooksSchema = (options = {}) => {
+	const schema = options.schema ?? "webhooks";
+	if (!schemaPattern.test(schema)) throw new Error(`Invalid webhooks schema "${schema}": use lowercase letters, digits and "_"`);
+	return schema;
+};
+/** A table subscription's name among all subscriptions: config ones cannot start with `ui:`. */
+const tableSubscriptionName = (id) => `ui:${id}`;
+/** The event names and patterns of a subscription row: separated by spaces or commas. */
+const parseEvents = (text) => text.split(/[\s,]+/).filter((part) => part !== "");
+//#endregion
+export { parseEvents, tableSubscriptionName, webhooksSchema };

package/dist/webhooks/table/owner-roles.js

@@ -0,0 +1,23 @@
+import { parseRoles } from "../../better-auth/parse-roles.js";
+import { effectiveRoles, globalRoles } from "../../better-auth/organizations/app-roles.js";
+import { findMember } from "../../better-auth/organizations/store.js";
+//#region src/webhooks/table/owner-roles.ts
+/**
+* The roles someone holds now, as their next token would carry them: their global roles and, with organizations, their
+* app roles as a member of the tenant. None for a user who is banned or gone.
+*/
+const betterAuthOwnerRoles = (auth) => async ({ id, tenant }) => {
+	const { adapter, internalAdapter } = await auth.$context;
+	const user = await internalAdapter.findUserById(id);
+	if (!user || user.banned) return [];
+	if (!auth.organizations) return parseRoles(user.role);
+	const global = globalRoles(user.role);
+	if (tenant === void 0) return global;
+	const member = await findMember(adapter, {
+		organizationId: String(tenant),
+		userId: id
+	});
+	return member ? effectiveRoles(global, member.appRoles) : global;
+};
+//#endregion
+export { betterAuthOwnerRoles };

package/dist/webhooks/table/plugin.d.ts

@@ -0,0 +1,10 @@
+import { WebhooksOptions } from "./options.js";
+import { ProjectConfig } from "../../project-config.js";
+//#region src/webhooks/table/plugin.d.ts
+/**
+ * Webhook subscriptions made in the admin app: `extends: [webhooks()]` in `protobase.config.ts`. It adds the Webhook
+ * subscriptions and Webhook deliveries pages, over a `webhooks` schema that `protobase migration` writes. Who may
+ * create subscriptions is the resources' access (`webhookSubscriptions.create`, ...); each delivers as its owner.
+ */
+export declare const webhooks: (options?: WebhooksOptions) => ProjectConfig;
+//#endregion

package/dist/webhooks/table/plugin.js

@@ -0,0 +1,18 @@
+import { webhooksSchema } from "./options.js";
+import { webhookResources } from "@protobase/schema";
+//#region src/webhooks/table/plugin.ts
+/**
+* Webhook subscriptions made in the admin app: `extends: [webhooks()]` in `protobase.config.ts`. It adds the Webhook
+* subscriptions and Webhook deliveries pages, over a `webhooks` schema that `protobase migration` writes. Who may
+* create subscriptions is the resources' access (`webhookSubscriptions.create`, ...); each delivers as its owner.
+*/
+const webhooks = (options = {}) => {
+	const schema = webhooksSchema(options);
+	return {
+		name: "protobase-webhooks",
+		config: webhookResources(schema, { deliveryLog: Boolean(options.deliveryLog) }),
+		webhooks: options
+	};
+};
+//#endregion
+export { webhooks };