zitejs 0.10.0-start.3 → 0.10.0-start.4

package/dist/esm/start/describe.d.ts

@@ -3,6 +3,7 @@ import type { WorkflowConfig } from "./workflow.js";
 export type Access = {
     kind: "signedIn" | "anyone" | "webhook" | "none";
     roles: string[];
+    paused?: true;
 };
 export type DescribedFunction = {
     id: string;

package/dist/esm/start/describe.js

@@ -16,7 +16,8 @@ const accessOf = (chain, problems) => {
     if (base.length > 1)
         problems.push(`access-conflict: ${base.join(" + ")}`);
     const kind = base.includes("webhook") ? "webhook" : base.includes("signedIn") ? "signedIn" : "anyone";
-    return { kind, roles };
+    const paused = kinds.some((k) => k.kind === "webhook" && k.paused === true);
+    return paused ? { kind, roles, paused } : { kind, roles };
 };
 const jsonSchemaOf = (validator) => {
     if (validator && typeof validator === "object" && "_zod" in validator) {

package/dist/esm/start/index.d.ts

@@ -39,7 +39,10 @@ export declare const isSignInRequired: (error: unknown) => boolean;
 export declare function loginHref(redirectTo?: string): string;
 /** What a zitejs middleware means, for describe. Keyed by identity, so composing or re-exporting keeps it. */
 export type ZiteMiddlewareKind = {
-    kind: "signedIn" | "anyone" | "webhook" | "factory";
+    kind: "signedIn" | "anyone" | "factory";
+} | {
+    kind: "webhook";
+    paused?: true;
 } | {
     kind: "role";
     role: string;
@@ -54,8 +57,14 @@ export declare const signedIn: import("@tanstack/react-start").RequestMiddleware
 export declare const anyone: import("@tanstack/react-start").RequestMiddlewareAfterServer<{}, undefined, {
     user: User | null;
 }>;
-/** Webhooks delivered by the platform, which already checked the URL token. */
-export declare const webhook: import("@tanstack/react-start").RequestMiddlewareAfterServer<{}, undefined, undefined>;
+/**
+ * Webhooks delivered by the platform, which already checked the URL token.
+ * `webhook.paused` keeps the URL but runs nothing: the platform answers the
+ * provider 200 and drops the delivery until it's switched back.
+ */
+export declare const webhook: import("@tanstack/react-start").RequestMiddlewareAfterServer<{}, undefined, undefined> & {
+    paused: import("@tanstack/react-start").RequestMiddlewareAfterServer<{}, undefined, undefined>;
+};
 /** Signed-in users with this role. */
 export declare const role: (name: string) => import("@tanstack/react-start").RequestMiddlewareAfterServer<{}, readonly [import("@tanstack/react-start").RequestMiddlewareAfterServer<{}, undefined, {
     user: User;

package/dist/esm/start/index.js

@@ -120,12 +120,17 @@ export const anyone = tag(createMiddleware().server(({ next, serverFnMeta }) =>
     const { user } = host();
     return runInScope({ kind: "anyone", user }, () => next({ context: { user } }));
 })), { kind: "anyone" });
-/** Webhooks delivered by the platform, which already checked the URL token. */
-export const webhook = tag(createMiddleware().server(({ next }) => {
+const webhookMiddleware = (paused) => tag(createMiddleware().server(({ next }) => {
     if (host().invoke?.kind !== "webhook")
         return new Response("Not found", { status: 404 });
     return runInScope({ kind: "webhook", user: null }, () => next());
-}), { kind: "webhook" });
+}), paused ? { kind: "webhook", paused: true } : { kind: "webhook" });
+/**
+ * Webhooks delivered by the platform, which already checked the URL token.
+ * `webhook.paused` keeps the URL but runs nothing: the platform answers the
+ * provider 200 and drops the delivery until it's switched back.
+ */
+export const webhook = Object.assign(webhookMiddleware(false), { paused: webhookMiddleware(true) });
 /** Signed-in users with this role. */
 export const role = (name) => tag(createMiddleware()
     .middleware([signedIn])

package/dist/esm/start/server.js

@@ -150,7 +150,12 @@ export function createZiteFetch(options) {
             const { platform } = host;
             if (!host.runs.length || !platform)
                 return;
-            const flushed = platform.runs({ runs: host.runs }).catch((error) => {
+            const batch = { runs: host.runs };
+            // On the request's session when it has one: one call, not another binding round trip.
+            const flushed = (async () => {
+                const session = host.session ? await host.session : undefined;
+                await (session?.runs ? session.runs(batch) : platform.runs(batch));
+            })().catch((error) => {
                 console.error("[zite] couldn't record runs", error);
             });
             ctx?.waitUntil(flushed);

package/dist/esm/start/types.d.ts

@@ -42,6 +42,10 @@ export type PlatformCallResult = {
 };
 export type PlatformSession = {
     call(call: PlatformCallInput): Promise<PlatformCallResult>;
+    /** As `PlatformBinding.runs`, on a session the request already holds. Hosts before 0.10.0-start.4 lack it. */
+    runs?(batch: {
+        runs: RunRecord[];
+    }): Promise<void>;
 };
 /** What the host hands each request: its platform, already scoped to the app, build, request and user. */
 export type PlatformBinding = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zitejs",
-  "version": "0.10.0-start.3",
+  "version": "0.10.0-start.4",
   "description": "The Zite framework — build apps on Zite Database",
   "type": "module",
   "sideEffects": false,