zitejs 0.10.0-start.2 → 0.10.0-start.3

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

@@ -12,6 +12,7 @@ declare module "@tanstack/start-client-core" {
 }
 declare const STATUS: {
     readonly BAD_REQUEST: 400;
+    readonly INVALID_INPUT: 400;
     readonly UNAUTHORIZED: 401;
     readonly FORBIDDEN: 403;
     readonly NOT_FOUND: 404;
@@ -20,6 +21,8 @@ declare const STATUS: {
     readonly INTERNAL_ERROR: 500;
 };
 export type ZiteErrorCode = keyof typeof STATUS;
+/** @internal The HTTP status each code answers with. */
+export declare const ZITE_ERROR_STATUS: Readonly<Record<ZiteErrorCode, number>>;
 /** Fail with a status: `throw new ZiteError('FORBIDDEN', 'Only the owner can edit this')`. */
 export declare class ZiteError extends Error {
     readonly code: ZiteErrorCode;

package/dist/esm/start/index.js

@@ -7,6 +7,7 @@ export { createZiteRouter } from "./router.js";
 export { createWorkflow } from "./workflow.js";
 const STATUS = {
     BAD_REQUEST: 400,
+    INVALID_INPUT: 400,
     UNAUTHORIZED: 401,
     FORBIDDEN: 403,
     NOT_FOUND: 404,
@@ -14,6 +15,8 @@ const STATUS = {
     RATE_LIMITED: 429,
     INTERNAL_ERROR: 500,
 };
+/** @internal The HTTP status each code answers with. */
+export const ZITE_ERROR_STATUS = STATUS;
 /** Fail with a status: `throw new ZiteError('FORBIDDEN', 'Only the owner can edit this')`. */
 export class ZiteError extends Error {
     code;
@@ -63,6 +66,29 @@ const host = () => {
         throw new ZiteError("UNAUTHORIZED", "Missing platform context");
     return current;
 };
+// TanStack fails a validator with a plain Error whose message is the issues as JSON.
+const validationIssues = (error) => {
+    if (!(error instanceof Error) || error.constructor !== Error)
+        return undefined;
+    try {
+        const issues = JSON.parse(error.message);
+        return Array.isArray(issues) && issues.length > 0 && issues.every((issue) => typeof issue?.message === "string")
+            ? issues
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+};
+const invalidInput = (issues) => {
+    if (getHost()?.mode === "live")
+        return new ZiteError("INVALID_INPUT", "Invalid input");
+    const describe = ({ message, path = [] }) => {
+        const at = path.map((segment) => String(typeof segment === "object" ? segment.key : segment)).join(".");
+        return at ? `${at}: ${message}` : message;
+    };
+    return new ZiteError("INVALID_INPUT", issues.map(describe).join("; "));
+};
 // Server functions report a status through TanStack's error envelope; server
 // routes need a Response. A nested call's failure is the caller's to handle.
 const withStatus = async (isServerFn, fn) => {
@@ -70,7 +96,9 @@ const withStatus = async (isServerFn, fn) => {
     try {
         return await fn();
     }
-    catch (error) {
+    catch (caught) {
+        const issues = validationIssues(caught);
+        const error = issues ? invalidInput(issues) : caught;
         if (!(error instanceof ZiteError))
             throw error;
         if (!isServerFn)
@@ -88,10 +116,10 @@ export const signedIn = tag(createMiddleware().server(({ next, serverFnMeta }) =
     return runInScope({ kind: "signedIn", user }, () => next({ context: { user } }));
 })), { kind: "signedIn" });
 /** Anyone, signed in or not. Handlers get `context.user: User | null`. */
-export const anyone = tag(createMiddleware().server(({ next }) => {
+export const anyone = tag(createMiddleware().server(({ next, serverFnMeta }) => withStatus(!!serverFnMeta, async () => {
     const { user } = host();
     return runInScope({ kind: "anyone", user }, () => next({ context: { user } }));
-}), { kind: "anyone" });
+})), { kind: "anyone" });
 /** Webhooks delivered by the platform, which already checked the URL token. */
 export const webhook = tag(createMiddleware().server(({ next }) => {
     if (host().invoke?.kind !== "webhook")

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

@@ -7,6 +7,6 @@ import { ZiteError } from "./index.js";
  * adapters first, then whatever the app's own `src/start.ts` sets.
  */
 export declare function createZiteStart<const TAdapters extends ReadonlyArray<AnySerializationAdapter> = [], TDefaultSsr extends SSROption = SSROption, const TRequest extends ReadonlyArray<AnyRequestMiddleware> = [], const TFunction extends ReadonlyArray<AnyFunctionMiddleware> = []>(app?: StartInstance<TAdapters, TDefaultSsr, TRequest, TFunction>): StartInstance<readonly [import("@tanstack/react-router").SerializationAdapter<ZiteError, {
-    code: "BAD_REQUEST" | "UNAUTHORIZED" | "FORBIDDEN" | "NOT_FOUND" | "CONFLICT" | "RATE_LIMITED" | "INTERNAL_ERROR";
+    code: "BAD_REQUEST" | "UNAUTHORIZED" | "FORBIDDEN" | "NOT_FOUND" | "CONFLICT" | "RATE_LIMITED" | "INTERNAL_ERROR" | "INVALID_INPUT";
     message: string;
 }, never>, ...TAdapters], TDefaultSsr, readonly [import("@tanstack/react-start").RequestMiddlewareAfterServer<{}, undefined, undefined>, ...TRequest], readonly [import("@tanstack/react-start").FunctionMiddlewareAfterClient<{}, unknown, undefined, undefined, undefined>, import("@tanstack/react-start").FunctionMiddlewareAfterServer<{}, unknown, undefined, undefined, undefined, undefined, undefined>, ...TFunction]>;

package/dist/esm/start/router.js

@@ -30,5 +30,8 @@ export function createZiteRouter(options) {
             context.user = dehydrated.user;
         },
     });
+    const host = currentHost();
+    if (host)
+        host.router = router;
     return router;
 }

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

@@ -1,5 +1,5 @@
-import type { User, ZiteRequestContext } from "./types.js";
-export type AccessKind = "signedIn" | "anyone" | "webhook" | "workflow";
+import type { AccessKind, User, ZiteRequestContext } from "./types.js";
+export type { AccessKind } from "./types.js";
 export type AccessScope = {
     kind: AccessKind;
     user: User | null;

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

@@ -1,44 +1,32 @@
-import { type AccessKind } from "./scope.js";
-import type { RunRecord, ZiteRequestContext } from "./types.js";
+import type { HostProps, PlatformBinding, ZiteRequestContext } from "./types.js";
 export { runWithHost } from "./scope.js";
 export { describeApp } from "./describe.js";
-export type { RunRecord } from "./types.js";
-export type PlatformCallInput = {
-    integrationId: string;
-    className: string;
-    methodName: string;
-    params: unknown;
-    access: AccessKind;
-    userId: string | null;
-    requestId: string;
-};
-/** The `ZITE` service binding the host's Platform entrypoint gives every app script. */
-export type PlatformBinding = {
-    call(call: PlatformCallInput): Promise<unknown>;
-    /** One batch per request, after its response has ended. */
-    runs(batch: {
-        requestId: string;
-        runs: RunRecord[];
-    }): Promise<void>;
-};
+export type { HostProps, PlatformBinding, PlatformCallInput, PlatformCallResult, PlatformSession, RunRecord } from "./types.js";
 /**
- * Routes every zitejs data, integration and email call through `call`, and only
- * inside an access scope. The access kind travels with the call so the platform
- * can record what a page read and, later, narrow anonymous reads.
+ * Routes every zitejs data, integration and email call to this request's
+ * platform, on one session, and only inside an access scope. The access kind
+ * travels with the call so the platform can record what a page read and narrow
+ * anonymous reads.
  */
-export declare function installPlatformTransport(call: (input: PlatformCallInput) => Promise<unknown>): void;
-/** The host's `x-zite-*` headers. Only the host can set them: the front strips them from public traffic. */
-export declare function hostContextFromRequest(request: Request): ZiteRequestContext;
+export declare function installPlatformTransport(): void;
+/** What the host dispatched this request with. Headers are ignored: props are the only thing it alone can set. */
+export declare function hostContextFromProps(request: Request, props: HostProps): ZiteRequestContext;
+/**
+ * A request the host didn't dispatch: `zitejs describe` under `vite preview`,
+ * and tests, which pass their own platform. Deployed builds have no public URL,
+ * so in production every request carries props.
+ */
+export declare function hostContextFromRequest(request: Request, platform?: PlatformBinding): ZiteRequestContext;
 /** Every server function TanStack compiled, written in by `zite()` at build. Empty in dev, where TanStack doesn't call its id hook. */
 export declare const builtFunctionIds: () => string[];
 /** Each server function's `description` option, written in by `zite()` at build. */
 export declare const builtFunctionDescriptions: () => Record<string, string>;
 type Fetch = (request: Request, ...rest: unknown[]) => Promise<Response> | Response;
 /**
- * The fetch handler of a Start app's server entry. Describe calls get the app's
- * description; everything else runs TanStack with the host's identity in
- * server-only storage. Platform calls go to the `ZITE` binding from the Worker's
- * env, or to `platform` when a test or local dev supplies one.
+ * The fetch handler of a Start app's server entry. A request the host
+ * dispatched carries its identity and platform in props; anything else (describe
+ * under `vite preview`, tests) reads `x-zite-*` headers and uses `platform`
+ * if one is given.
  */
 export declare function createZiteFetch(options: {
     handler: {

package/dist/esm/start/server.js

@@ -1,3 +1,4 @@
+import { ZiteError, ZITE_ERROR_STATUS } from "./index.js";
 import { describeApp } from "./describe.js";
 import { preview } from "./runLog.js";
 import { getHost, requireScope, runWithHost } from "./scope.js";
@@ -5,28 +6,47 @@ import { loadWorkflows, loggedInput, runWorkflow } from "./workflowRun.js";
 export { runWithHost } from "./scope.js";
 export { describeApp } from "./describe.js";
 /**
- * Routes every zitejs data, integration and email call through `call`, and only
- * inside an access scope. The access kind travels with the call so the platform
- * can record what a page read and, later, narrow anonymous reads.
+ * Routes every zitejs data, integration and email call to this request's
+ * platform, on one session, and only inside an access scope. The access kind
+ * travels with the call so the platform can record what a page read and narrow
+ * anonymous reads.
  */
-export function installPlatformTransport(call) {
-    const sdkCall = (integrationId, className, methodName, params) => {
+export function installPlatformTransport() {
+    const sdkCall = async (integrationId, className, methodName, params) => {
         const scope = requireScope(`${className}.${methodName}`);
-        return call({
-            integrationId,
-            className,
-            methodName,
-            params,
-            access: scope.kind,
-            userId: scope.user?.id ?? null,
-            requestId: getHost()?.requestId ?? "",
-        });
+        const host = getHost();
+        // Fails closed: no platform means no platform access, never a fallback.
+        if (!host?.platform)
+            throw new Error("The Zite platform binding is missing");
+        host.session ??= Promise.resolve(host.platform.session());
+        const result = await (await host.session).call({ integrationId, className, methodName, params, access: scope.kind });
+        if ("value" in result)
+            return result.value;
+        const { code, message } = result.error;
+        throw new ZiteError(code in ZITE_ERROR_STATUS ? code : "INTERNAL_ERROR", message);
     };
     globalThis.__wrapSdkCall = sdkCall;
 }
 const decodeUser = (value) => JSON.parse(new TextDecoder().decode(Uint8Array.from(atob(value.replace(/-/g, "+").replace(/_/g, "/")), (c) => c.charCodeAt(0))));
-/** The host's `x-zite-*` headers. Only the host can set them: the front strips them from public traffic. */
-export function hostContextFromRequest(request) {
+const INVOKE_KINDS = new Set(["webhook", "describe", "workflow", "warm"]);
+/** What the host dispatched this request with. Headers are ignored: props are the only thing it alone can set. */
+export function hostContextFromProps(request, props) {
+    return {
+        requestId: props.requestId,
+        url: request.url,
+        user: props.user,
+        mode: props.mode,
+        invoke: props.invoke,
+        runs: [],
+        platform: props.platform,
+    };
+}
+/**
+ * A request the host didn't dispatch: `zitejs describe` under `vite preview`,
+ * and tests, which pass their own platform. Deployed builds have no public URL,
+ * so in production every request carries props.
+ */
+export function hostContextFromRequest(request, platform) {
     const { headers } = request;
     const user = headers.get("x-zite-user");
     const [kind, name = ""] = headers.get("x-zite-invoke")?.split(":") ?? [];
@@ -34,8 +54,10 @@ export function hostContextFromRequest(request) {
         requestId: headers.get("x-zite-request-id") ?? crypto.randomUUID(),
         url: request.url,
         user: user ? decodeUser(user) : null,
-        invoke: kind === "webhook" || kind === "describe" || kind === "workflow" ? { kind, name } : null,
+        mode: "live",
+        invoke: INVOKE_KINDS.has(kind) ? { kind: kind, name } : null,
         runs: [],
+        platform,
     };
 }
 /** Every server function TanStack compiled, written in by `zite()` at build. Empty in dev, where TanStack doesn't call its id hook. */
@@ -83,27 +105,35 @@ async function invokeWorkflow(request, host, workflows) {
     });
     return Response.json(result, { status: result.ok ? 200 : 500 });
 }
+const isZiteError = (error) => error instanceof Error && error.name === "ZiteError" && error.code in ZITE_ERROR_STATUS;
+// TanStack renders any loader error as a 500. A page refused with a ZiteError
+// (a missing role, a record that isn't there) answers with that error's status.
+const pageStatus = (host) => {
+    const matches = host.router?.state?.matches;
+    const failed = matches?.find((match) => match.status === "error")?.error;
+    return isZiteError(failed) ? ZITE_ERROR_STATUS[failed.code] : undefined;
+};
 /**
- * The fetch handler of a Start app's server entry. Describe calls get the app's
- * description; everything else runs TanStack with the host's identity in
- * server-only storage. Platform calls go to the `ZITE` binding from the Worker's
- * env, or to `platform` when a test or local dev supplies one.
+ * The fetch handler of a Start app's server entry. A request the host
+ * dispatched carries its identity and platform in props; anything else (describe
+ * under `vite preview`, tests) reads `x-zite-*` headers and uses `platform`
+ * if one is given.
  */
 export function createZiteFetch(options) {
-    let binding = options.platform;
-    // Fails closed: no binding means no platform access, never a fallback.
-    const platform = () => {
-        if (!binding)
-            throw new Error("The Zite platform binding is missing");
-        return binding;
-    };
-    installPlatformTransport((call) => platform().call(call));
+    installPlatformTransport();
     // Loaded on first use, so a page request never pays for importing workflow modules.
     let workflows;
     const loadedWorkflows = () => (workflows ??= loadWorkflows());
     return async (request, ...rest) => {
-        binding ??= rest[0]?.ZITE;
-        if (request.headers.get("x-zite-invoke") === "describe") {
+        const ctx = rest[1];
+        const host = ctx?.props?.platform
+            ? hostContextFromProps(request, ctx.props)
+            : hostContextFromRequest(request, options.platform);
+        // Starting this isolate was the point: the platform warms a build before its
+        // first visitors, and no app code runs.
+        if (host.invoke?.kind === "warm")
+            return new Response(null, { status: 204 });
+        if (host.invoke?.kind === "describe") {
             return Response.json(await describeApp({
                 fnIds: builtFunctionIds(),
                 descriptions: builtFunctionDescriptions(),
@@ -112,15 +142,18 @@ export function createZiteFetch(options) {
                 workflows: await loadedWorkflows(),
             }));
         }
-        const host = hostContextFromRequest(request);
-        const response = await runWithHost(host, async () => host.invoke?.kind === "workflow" ? invokeWorkflow(request, host, await loadedWorkflows()) : options.handler.fetch(request));
+        let response = await runWithHost(host, async () => host.invoke?.kind === "workflow" ? invokeWorkflow(request, host, await loadedWorkflows()) : options.handler.fetch(request));
+        const status = response.status === 500 ? pageStatus(host) : undefined;
+        if (status)
+            response = new Response(response.body, { status, headers: response.headers });
         return onBodyEnd(response, () => {
-            if (!host.runs.length || !binding)
+            const { platform } = host;
+            if (!host.runs.length || !platform)
                 return;
-            const flushed = binding.runs({ requestId: host.requestId, runs: host.runs }).catch((error) => {
+            const flushed = platform.runs({ runs: host.runs }).catch((error) => {
                 console.error("[zite] couldn't record runs", error);
             });
-            rest[1]?.waitUntil(flushed);
+            ctx?.waitUntil(flushed);
         });
     };
 }

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

@@ -18,15 +18,64 @@ export type RunRecord = {
         message: string;
     };
 };
+export type AccessKind = "signedIn" | "anyone" | "webhook" | "workflow";
+/** One data, integration or email call. Who is calling is the platform's to know, never the app's to say. */
+export type PlatformCallInput = {
+    integrationId: string;
+    className: string;
+    methodName: string;
+    params: unknown;
+    /** The access decision the call ran under; the platform may narrow on it but never widens. */
+    access: AccessKind;
+};
+/**
+ * A call's answer. Errors come back as values: Workers RPC keeps a thrown
+ * error's message but drops its code.
+ */
+export type PlatformCallResult = {
+    value: unknown;
+} | {
+    error: {
+        code: string;
+        message: string;
+    };
+};
+export type PlatformSession = {
+    call(call: PlatformCallInput): Promise<PlatformCallResult>;
+};
+/** What the host hands each request: its platform, already scoped to the app, build, request and user. */
+export type PlatformBinding = {
+    /** Every platform call of one request goes through one session. */
+    session(): PlatformSession | Promise<PlatformSession>;
+    /** One batch per request, after its response has ended. */
+    runs(batch: {
+        runs: RunRecord[];
+    }): Promise<void>;
+};
+export type HostMode = "live" | "preview" | "validate";
+export type HostInvoke = {
+    kind: "webhook" | "describe" | "workflow" | "warm";
+    name: string;
+};
+/** The per-request props the host dispatches with. Only the host can set them. */
+export type HostProps = {
+    platform: PlatformBinding;
+    requestId: string;
+    user: User | null;
+    mode: HostMode;
+    invoke: HostInvoke | null;
+};
 /** What the host resolved for this request. Set by the generated server entry, never by the browser. */
 export type ZiteRequestContext = {
     requestId: string;
     url: string;
     user: User | null;
-    invoke: {
-        kind: "webhook" | "describe" | "workflow";
-        name: string;
-    } | null;
+    mode: HostMode;
+    invoke: HostInvoke | null;
     /** Filled by run capture, flushed to the platform once the response ends. */
     runs: RunRecord[];
+    platform?: PlatformBinding;
+    session?: Promise<PlatformSession>;
+    /** This request's router, so a page's status can follow the error it rendered. */
+    router?: unknown;
 };

package/dist/esm/start/vite.js

@@ -66,6 +66,9 @@ export function zite(options = {}) {
                 },
             };
         },
+        // Each new isolate loads the whole server bundle, so its size is cold-start
+        // time; Vite leaves SSR output unminified.
+        configEnvironment: (name, config) => name === "ssr" && options.cloudflare !== false && config.build?.minify === undefined ? { build: { minify: true } } : undefined,
     };
     // Each server function's `description` option, by name, for the editor.
     const descriptions = new Map();

package/package.json

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