zitejs 0.10.0-start.10 → 0.10.0-start.13

package/dist/esm/start/server.js

@@ -1,3 +1,7 @@
+// For the generated server entry only. Apps never import this.
+import { requestHandler } from "@tanstack/react-start/server";
+import { createSsrRpc } from "@tanstack/react-start/ssr-rpc";
+import { runWithStartContext } from "@tanstack/start-storage-context";
 import { asZiteError, isZiteErrorCode, ZiteError, ZITE_ERROR_STATUS } from "./errors.js";
 import { describeApp } from "./describe.js";
 import { runRegistration } from "./registration.js";
@@ -5,6 +9,9 @@ import { isAuthHookName, loadAuthHooks } from "./authHooks.js";
 import { errorOf, preview } from "./runLog.js";
 import { DATA_INTEGRATION_ID, dataContextOf, runDataCall } from "./data/index.js";
 import { airtableSettingsOf, runAirtableCall } from "./airtable/index.js";
+import { withoutConsole } from "./quiet.js";
+import { createOutboundFetch, rememberConnection } from "./outbound.js";
+import { INTEGRATIONS_PLATFORM_ID } from "./credentials.js";
 import { getHost, requireScope, runInScope, runWithHost } from "./scope.js";
 import { ZITEJS_VERSION } from "./version.js";
 import { loadWorkflows, loggedInput, runWorkflow } from "./workflowRun.js";
@@ -20,6 +27,11 @@ export function installPlatformTransport() {
     const sdkCall = async (integrationId, className, methodName, params) => {
         const scope = requireScope(`${className}.${methodName}`);
         const host = getHost();
+        const getsConnection = integrationId === INTEGRATIONS_PLATFORM_ID && methodName === "get";
+        const name = String(params?.name ?? "");
+        // An app run outside Zite reads its connections from its own source, with no platform at all.
+        if (getsConnection && host?.credentials)
+            return connectionAnswer(host, name, await host.credentials.get(name));
         // Fails closed: no platform means no platform access, never a fallback.
         if (!host?.platform)
             throw new Error("The Zite platform binding is missing");
@@ -38,6 +50,8 @@ export function installPlatformTransport() {
             }
         }
         const result = await session.call({ integrationId, className, methodName, params, access: scope.kind });
+        if (getsConnection)
+            return connectionAnswer(host, name, result);
         if ("value" in result)
             return result.value;
         const { code, message, userFacingMessage } = result.error;
@@ -46,6 +60,15 @@ export function installPlatformTransport() {
     globalThis.__wrapSdkCall = sdkCall;
     watchOutboundFetches();
 }
+/** `integrations.get`'s answer, whose values then name the calls made with them. */
+const connectionAnswer = (host, name, result) => {
+    if ("value" in result) {
+        rememberConnection(host, name, result.value);
+        return result.value;
+    }
+    const { code, message, userFacingMessage } = result.error;
+    throw new ZiteError({ code: isZiteErrorCode(code) ? code : "INTERNAL_ERROR", message, userFacingMessage });
+};
 /** A data call the app made itself, recorded as the host recorded the ones it made. */
 const recordCall = async (host, call, run) => {
     const at = Date.now();
@@ -67,31 +90,18 @@ const recordCall = async (host, call, run) => {
         throw error;
     }
 };
-let fetchesWatched = false;
-const fetchedHost = (input) => {
-    try {
-        return new URL(input instanceof Request ? input.url : input).host;
-    }
-    catch {
-        return "?";
-    }
-};
-// A page that fetched depends on more than the reads the host saw, so the host
-// must hear of it before the fetch goes out. Next patches fetch for the same reason.
+// Keyed on globalThis so two copies of zitejs in one bundle wrap fetch once.
+const WATCHED_KEY = Symbol.for("zitejs:outbound-fetch");
+// Next patches fetch for the same reasons: the page cache must hear of each, and the run log too.
 const watchOutboundFetches = () => {
-    if (fetchesWatched)
+    const marks = globalThis;
+    if (marks[WATCHED_KEY])
         return;
-    fetchesWatched = true;
-    const nativeFetch = globalThis.fetch.bind(globalThis);
-    globalThis.fetch = async (input, init) => {
-        const watch = getHost()?.watch;
-        if (watch)
-            await watch.uncacheable(`fetch ${fetchedHost(input)}`);
-        return nativeFetch(input, init);
-    };
+    marks[WATCHED_KEY] = true;
+    globalThis.fetch = createOutboundFetch(globalThis.fetch.bind(globalThis));
 };
 const decodeUser = (value) => JSON.parse(new TextDecoder().decode(Uint8Array.from(atob(value.replace(/-/g, "+").replace(/_/g, "/")), (c) => c.charCodeAt(0))));
-const INVOKE_KINDS = new Set(["webhook", "describe", "workflow", "register", "warm", "authHook"]);
+const INVOKE_KINDS = new Set(["webhook", "describe", "workflow", "register", "warm", "authHook", "function"]);
 // What a request without props may ask for: neither runs app code on anyone's behalf.
 const UNHOSTED_INVOKE_KINDS = new Set(["warm", "describe"]);
 /** What the host dispatched this request with. Headers are ignored: props are the only thing it alone can set. */
@@ -106,6 +116,7 @@ export function hostContextFromProps(request, props) {
         baseId: props.baseId,
         previewClaim: props.previewClaim,
         env: props.env,
+        envConnections: props.envConnections,
         runRoot: props.runRoot,
         runs: [],
         platform: props.platform,
@@ -206,6 +217,38 @@ async function invokeWorkflow(request, host, workflows) {
     });
     return Response.json(result, { status: result.ok ? 200 : 500 });
 }
+// The host sends `{ input }`, an editor's test run of a server function. It runs
+// as a call from a page would on the server: its own middleware decides access
+// for the user the host dispatched with, validates the input and records the run.
+async function invokeFunction(request, options) {
+    if (request.method !== "POST" || new URL(request.url).pathname !== INVOKE_PATH)
+        return new Response("Not found", { status: 404 });
+    const id = getHost()?.invoke?.name ?? "";
+    if (!builtFunctionIds().includes(id)) {
+        return Response.json({ ok: false, error: { code: "NOT_FOUND", message: `No server function ${id}` } }, { status: 404 });
+    }
+    const input = (await request.json().catch(() => ({})))?.input;
+    const startContext = {
+        request,
+        getRouter: options.getRouter,
+        startOptions: (await options.startInstance?.getOptions()) ?? {},
+        executedRequestMiddlewares: new Set(),
+        contextAfterGlobalMiddlewares: {},
+        handlerType: "serverFn",
+    };
+    // In TanStack's request event too, which the function's own status setting reads.
+    return requestHandler(async () => {
+        try {
+            const answer = (await runWithStartContext(startContext, () => createSsrRpc(id)({ data: input, context: {} })));
+            if (answer.error !== undefined)
+                throw answer.error;
+            return Response.json({ ok: true, output: answer.result ?? null });
+        }
+        catch (error) {
+            return Response.json({ ok: false, error: errorOf(error) }, { status: 500 });
+        }
+    })(request, undefined);
+}
 // The host sends `{ op, input }`: `subscribe` with the platform's notification
 // URL and secret, or `unsubscribe` with what `subscribe` returned.
 async function invokeRegistration(request, host, workflows) {
@@ -263,7 +306,7 @@ export function createZiteHandlers(options) {
     const serve = async (request, ctx, watch) => {
         const host = ctx?.props?.platform
             ? hostContextFromProps(request, ctx.props)
-            : hostContextFromRequest(request, options.platform);
+            : { ...hostContextFromRequest(request, options.platform), credentials: options.credentials };
         if (watch)
             host.watch = watch;
         setRequestEnv(host);
@@ -283,24 +326,33 @@ export function createZiteHandlers(options) {
         }
         let response = await runWithHost(host, async () => host.invoke?.kind === "workflow"
             ? invokeWorkflow(request, host, await loadedWorkflows())
-            : host.invoke?.kind === "register"
-                ? invokeRegistration(request, host, await loadedWorkflows())
-                : host.invoke?.kind === "authHook"
-                    ? invokeAuthHook(request, host)
-                    : options.handler.fetch(request));
+            : host.invoke?.kind === "function"
+                ? invokeFunction(request, options)
+                : host.invoke?.kind === "register"
+                    ? withoutConsole(async () => invokeRegistration(request, host, await loadedWorkflows()))
+                    : host.invoke?.kind === "authHook"
+                        ? invokeAuthHook(request, host)
+                        : 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, () => {
             const { platform } = host;
-            if ((!host.runs.length && !host.calls?.length && !host.pending?.length) || !platform)
+            if ((!host.runs.length && !host.calls?.length && !host.fetches?.length && !host.pending?.length) || !platform)
                 return;
             // On the request's session when it has one: one call, not another binding round trip.
             const flushed = (async () => {
                 await Promise.all(host.pending ?? []);
-                if (!host.runs.length && !host.calls?.length)
+                if (!host.runs.length && !host.calls?.length && !host.fetches?.length)
                     return;
-                const batch = { runs: host.runs, ...(host.calls?.length && { calls: host.calls }) };
+                const batch = {
+                    runs: host.runs,
+                    ...(host.calls?.length && { calls: host.calls }),
+                    ...(host.fetches?.length && { fetches: host.fetches }),
+                };
+                // Only a session takes fetches.
+                if (host.fetches?.length)
+                    host.session ??= Promise.resolve(platform.session());
                 const session = host.session ? await host.session : undefined;
                 await (session?.runs ? session.runs(batch) : platform.runs(batch));
             })().catch((error) => {

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

@@ -1,3 +1,5 @@
+import type { AiUsageRecord } from "./aiUsage.js";
+import type { CredentialSource } from "./credentials.js";
 export type Role = {
     id: string;
     name: string;
@@ -76,13 +78,37 @@ export type CallRecord = {
         message: string;
     };
 };
+/** An outbound fetch, by host and path (never its query), with the connection whose token it carried. */
+export type FetchRecord = {
+    at: number;
+    method: string;
+    /** Whole, with every secret the request knows redacted. */
+    url: string;
+    /** As classic's run log shows it: cut short, secrets redacted. */
+    requestBody?: string;
+    status?: number;
+    durationMs: number;
+    error?: string;
+    connection?: string;
+    /** Sent again with a refreshed token after a 401. */
+    retried?: true;
+    /** On Zite's own AI key, which the host meters itself. */
+    ziteAi?: true;
+    /** What a call on the org's own AI key used, for analytics. */
+    ai?: AiUsageRecord;
+};
 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. */
+    /** As `PlatformBinding.runs`, on a session the request already holds. Hosts before 0.10.0-start.4 lack it; before 0.10.0-start.13, `fetches`. */
     runs?(batch: {
         runs: RunRecord[];
         calls?: CallRecord[];
+        fetches?: FetchRecord[];
     }): Promise<void>;
+    /** After a provider answered 401: the connection refreshed, as `integrations.get` now answers it. Hosts before 0.10.0-start.13 lack it. */
+    refreshConnection?(name: string): Promise<PlatformCallResult>;
+    /** A call on Zite's own AI key, which the host makes with the real key. Hosts before 0.10.0-start.13 lack it. */
+    aiFetch?(request: Request): Promise<Response>;
     /** The build's base and SDK names, which the app's data dispatch translates against. */
     dataContext?(): Promise<{
         baseId: string | null;
@@ -120,7 +146,7 @@ export type PlatformBinding = {
 /** A demo is the published build serving a read-only visitor: as live, but every write is refused. */
 export type HostMode = "live" | "preview" | "demo" | "validate";
 export type HostInvoke = {
-    kind: "webhook" | "describe" | "workflow" | "register" | "warm" | "authHook";
+    kind: "webhook" | "describe" | "workflow" | "register" | "warm" | "authHook" | "function";
     name: string;
 };
 /** The per-request props the host dispatches with. Only the host can set them. */
@@ -136,8 +162,10 @@ export type HostProps = {
     baseId?: string;
     /** An editor preview's access, which zitejs keeps on the app's links and calls. */
     previewClaim?: string;
-    /** `process.env` as classic sets it: connections' vars, secrets as placeholders egress swaps but S3's, then the user's own secrets. */
+    /** `process.env` as classic sets it: connections' vars, then the user's own secrets. */
     env?: Record<string, string>;
+    /** Which connection each token var in `env` holds. Hosts before 0.10.0-start.13 don't send it. */
+    envConnections?: Record<string, string>;
     /** A resumed run's first attempt, whose saved steps it replays. Hosts before 0.10.0-start.10 don't send it. */
     runRoot?: string;
 };
@@ -153,8 +181,25 @@ export type ZiteRequestContext = {
     previewClaim?: string;
     /** Classic's connection env vars the host sent, set into `process.env` for the request. */
     env?: Record<string, string>;
+    envConnections?: Record<string, string>;
     /** A resumed run's first attempt, whose saved steps it replays. */
     runRoot?: string;
+    /** Where `integrations.get` reads, when not the host: an entry run outside Zite's names its own. */
+    credentials?: CredentialSource;
+    /** The connection each token this request was handed belongs to. */
+    connectionTokens?: Map<string, string>;
+    /** `integrations.get`'s answers this request, by name. */
+    connectionAnswers?: Map<string, unknown>;
+    /** One refresh per connection per request, however many calls got a 401. */
+    refreshing?: Map<string, Promise<string | undefined>>;
+    /** The outbound fetches, flushed with its runs. */
+    fetches?: FetchRecord[];
+    /** The secrets its fetch log redacts, longest first; cleared when a connection is learned. */
+    secretValues?: string[];
+    /** The isolate's refresh count `secretValues` was read at. */
+    secretsAt?: number;
+    /** How much of its fetch log is bodies so far. */
+    fetchLogChars?: number;
     /** Filled by run capture, flushed to the platform once the response ends. */
     runs: RunRecord[];
     /** The data calls this request made, flushed with its runs. */

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

@@ -1 +1 @@
-export declare const ZITEJS_VERSION = "0.10.0-start.10";
+export declare const ZITEJS_VERSION = "0.10.0-start.13";

package/dist/esm/start/version.js

@@ -1,2 +1,2 @@
 // Written by scripts/write-version.mjs from package.json.
-export const ZITEJS_VERSION = "0.10.0-start.10";
+export const ZITEJS_VERSION = "0.10.0-start.13";

package/package.json

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