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

package/dist/cjs/auth/index.test.js

@@ -187,3 +187,33 @@ function redirectParamOf(href) {
         (0, vitest_1.expect)(params.get('usageToken')).toBeNull();
     });
 });
+// AUTH-03: what the platform's auth routes receive from the client, on the app's own origin.
+(0, vitest_1.describe)("the client's calls", () => {
+    const calls = () => {
+        const sent = [];
+        vitest_1.vi.stubGlobal('fetch', vitest_1.vi.fn(async (input, init) => {
+            const request = new Request(new URL(String(input instanceof Request ? input.url : input), 'https://app.zite.so'), init);
+            sent.push({
+                path: new URL(request.url).pathname,
+                method: request.method,
+                body: request.method === 'POST' ? await request.json().catch(() => null) : null,
+            });
+            return Response.json({});
+        }));
+        return sent;
+    };
+    (0, vitest_1.it)('sign in by link, sign out and edit the profile on /api/auth', async () => {
+        const sent = calls();
+        // The client takes its fetch when the module loads.
+        vitest_1.vi.resetModules();
+        const { signIn, signOut, updateProfile } = await Promise.resolve().then(() => __importStar(require('./index.js')));
+        await signIn.magicLink({ email: 'ada@x.co' });
+        await signOut();
+        await updateProfile({ firstName: 'Ada' });
+        (0, vitest_1.expect)(sent).toEqual([
+            { path: '/api/auth/sign-in/magic-link', method: 'POST', body: vitest_1.expect.objectContaining({ email: 'ada@x.co' }) },
+            { path: '/api/auth/sign-out', method: 'POST', body: vitest_1.expect.anything() },
+            { path: '/api/auth/update-user', method: 'POST', body: { firstName: 'Ada' } },
+        ]);
+    });
+});

package/dist/cjs/start/entries.js

@@ -17,15 +17,17 @@ const renderStartServerEntry = (target = "cloudflare") => target === "cloudflare
 import handler from '@tanstack/react-start/server-entry';
 import { createZiteWorker } from 'zitejs/start/worker';
 import { getRouter } from '../src/router';
+import { startInstance } from './start';
 
-export default createZiteWorker({ handler, getRouter });
+export default createZiteWorker({ handler, getRouter, startInstance });
 `
     : `// Generated by zitejs for TanStack Start apps. The platform owns this file.
 import handler, { createServerEntry } from '@tanstack/react-start/server-entry';
 import { createZiteFetch } from 'zitejs/start/server';
 import { getRouter } from '../src/router';
+import { startInstance } from './start';
 
-export default createServerEntry({ fetch: createZiteFetch({ handler, getRouter }) });
+export default createServerEntry({ fetch: createZiteFetch({ handler, getRouter, startInstance }) });
 `;
 exports.renderStartServerEntry = renderStartServerEntry;
 /** The start instance: the platform's middleware, then the app's own `src/start.ts` when it has one. */

package/dist/esm/auth/index.test.js

@@ -152,3 +152,33 @@ describe('loginWithRedirect', () => {
         expect(params.get('usageToken')).toBeNull();
     });
 });
+// AUTH-03: what the platform's auth routes receive from the client, on the app's own origin.
+describe("the client's calls", () => {
+    const calls = () => {
+        const sent = [];
+        vi.stubGlobal('fetch', vi.fn(async (input, init) => {
+            const request = new Request(new URL(String(input instanceof Request ? input.url : input), 'https://app.zite.so'), init);
+            sent.push({
+                path: new URL(request.url).pathname,
+                method: request.method,
+                body: request.method === 'POST' ? await request.json().catch(() => null) : null,
+            });
+            return Response.json({});
+        }));
+        return sent;
+    };
+    it('sign in by link, sign out and edit the profile on /api/auth', async () => {
+        const sent = calls();
+        // The client takes its fetch when the module loads.
+        vi.resetModules();
+        const { signIn, signOut, updateProfile } = await import('./index.js');
+        await signIn.magicLink({ email: 'ada@x.co' });
+        await signOut();
+        await updateProfile({ firstName: 'Ada' });
+        expect(sent).toEqual([
+            { path: '/api/auth/sign-in/magic-link', method: 'POST', body: expect.objectContaining({ email: 'ada@x.co' }) },
+            { path: '/api/auth/sign-out', method: 'POST', body: expect.anything() },
+            { path: '/api/auth/update-user', method: 'POST', body: { firstName: 'Ada' } },
+        ]);
+    });
+});

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

@@ -0,0 +1,23 @@
+/**
+ * What a call on an org's own AI key used, read from the provider's answer as
+ * classic's runtime reads it. For analytics only: the org pays the provider.
+ * OpenAI and Anthropic; the host meters Zite's own key itself.
+ */
+export type AiProvider = "openai" | "anthropic";
+export type AiUsageRecord = {
+    provider: AiProvider;
+    model?: string;
+    inputTokens?: number;
+    outputTokens?: number;
+    cachedReadInputTokens?: number;
+    cacheCreationInputTokens?: number;
+    isStreaming?: true;
+};
+export declare const AI_USAGE_HOSTS: Record<string, AiProvider>;
+/** As classic: an OpenAI chat stream reports its usage only when asked to. The body to send instead, if any. */
+export declare const withStreamUsage: (url: URL, method: string, body: unknown) => string | undefined;
+/** The response to hand the app, and its usage once read; a stream is split so the app reads one copy as it arrives. */
+export declare const meterAiResponse: (provider: AiProvider, response: Response) => {
+    response: Response;
+    usage: Promise<AiUsageRecord | undefined>;
+};

package/dist/esm/start/aiUsage.js

@@ -0,0 +1,146 @@
+/**
+ * What a call on an org's own AI key used, read from the provider's answer as
+ * classic's runtime reads it. For analytics only: the org pays the provider.
+ * OpenAI and Anthropic; the host meters Zite's own key itself.
+ */
+export const AI_USAGE_HOSTS = {
+    "api.openai.com": "openai",
+    "api.anthropic.com": "anthropic",
+};
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isNumber = (value) => typeof value === "number" && Number.isFinite(value);
+/** As classic: an OpenAI chat stream reports its usage only when asked to. The body to send instead, if any. */
+export const withStreamUsage = (url, method, body) => {
+    if (method !== "POST" || typeof body !== "string" || !url.pathname.endsWith("/chat/completions"))
+        return undefined;
+    try {
+        const json = JSON.parse(body);
+        if (!isRecord(json) || json.stream !== true)
+            return undefined;
+        const options = isRecord(json.stream_options) ? json.stream_options : {};
+        if (options.include_usage === true)
+            return undefined;
+        return JSON.stringify({ ...json, stream_options: { ...options, include_usage: true } });
+    }
+    catch {
+        return undefined;
+    }
+};
+// OpenAI counts cached tokens inside its input; classic takes them apart.
+const tokensFromJson = (provider, body) => {
+    const tokens = {};
+    if (!isRecord(body))
+        return tokens;
+    if (provider === "openai") {
+        const source = isRecord(body.response) ? body.response : body;
+        if (typeof source.model === "string")
+            tokens.model = source.model;
+        const usage = isRecord(source.usage) ? source.usage : undefined;
+        if (!usage)
+            return tokens;
+        const details = (name) => (isRecord(usage[name]) ? usage[name] : {});
+        const cached = details("prompt_tokens_details").cached_tokens ?? details("input_tokens_details").cached_tokens;
+        const input = usage.prompt_tokens ?? usage.input_tokens;
+        const output = usage.completion_tokens ?? usage.output_tokens;
+        if (isNumber(input))
+            tokens.inputTokens = input - (isNumber(cached) ? cached : 0);
+        if (isNumber(output))
+            tokens.outputTokens = output;
+        if (isNumber(cached))
+            tokens.cachedReadInputTokens = cached;
+        return tokens;
+    }
+    // A stream splits these: message_start has the input, message_delta the running output.
+    const message = isRecord(body.message) ? body.message : body;
+    if (typeof message.model === "string")
+        tokens.model = message.model;
+    const usage = isRecord(message.usage) ? message.usage : isRecord(body.usage) ? body.usage : undefined;
+    if (!usage)
+        return tokens;
+    if (isNumber(usage.input_tokens))
+        tokens.inputTokens = usage.input_tokens;
+    if (isNumber(usage.output_tokens))
+        tokens.outputTokens = usage.output_tokens;
+    if (isNumber(usage.cache_read_input_tokens))
+        tokens.cachedReadInputTokens = usage.cache_read_input_tokens;
+    if (isNumber(usage.cache_creation_input_tokens))
+        tokens.cacheCreationInputTokens = usage.cache_creation_input_tokens;
+    return tokens;
+};
+// Later readings win: Anthropic's output is cumulative, OpenAI's usage comes last.
+const merge = (into, next) => ({
+    model: next.model ?? into.model,
+    inputTokens: next.inputTokens ?? into.inputTokens,
+    outputTokens: next.outputTokens ?? into.outputTokens,
+    cachedReadInputTokens: next.cachedReadInputTokens ?? into.cachedReadInputTokens,
+    cacheCreationInputTokens: next.cacheCreationInputTokens ?? into.cacheCreationInputTokens,
+});
+const MAX_PENDING_LINE = 1024 * 1024;
+const tokensFromStream = async (provider, stream) => {
+    const reader = stream.getReader();
+    const decoder = new TextDecoder();
+    let pending = "";
+    let tokens = {};
+    const readLine = (line) => {
+        if (!line.startsWith("data:"))
+            return;
+        const payload = line.slice(5).trim();
+        if (!payload || payload === "[DONE]")
+            return;
+        try {
+            tokens = merge(tokens, tokensFromJson(provider, JSON.parse(payload)));
+        }
+        catch {
+            // Not JSON; nothing to count.
+        }
+    };
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            pending += decoder.decode(value, { stream: true });
+            const lines = pending.split("\n");
+            pending = lines.pop() ?? "";
+            if (pending.length > MAX_PENDING_LINE)
+                pending = "";
+            lines.forEach(readLine);
+        }
+        readLine(pending);
+    }
+    catch {
+        // What was read before the stream broke still counts.
+    }
+    return tokens;
+};
+const counted = (tokens) => tokens.inputTokens !== undefined || tokens.outputTokens !== undefined;
+const usageOf = (provider, tokens, streaming) => counted(tokens)
+    ? {
+        provider,
+        ...Object.fromEntries(Object.entries(tokens).filter(([, value]) => value !== undefined)),
+        ...(streaming && { isStreaming: true }),
+    }
+    : undefined;
+/** The response to hand the app, and its usage once read; a stream is split so the app reads one copy as it arrives. */
+export const meterAiResponse = (provider, response) => {
+    const type = response.headers.get("content-type") ?? "";
+    if (!response.ok || !response.body)
+        return { response, usage: Promise.resolve(undefined) };
+    if (type.includes("text/event-stream")) {
+        const [forApp, forUs] = response.body.tee();
+        return {
+            response: new Response(forApp, response),
+            usage: tokensFromStream(provider, forUs).then((tokens) => usageOf(provider, tokens, true)),
+        };
+    }
+    if (!type.includes("json"))
+        return { response, usage: Promise.resolve(undefined) };
+    return {
+        response,
+        usage: response
+            .clone()
+            .json()
+            .then((json) => usageOf(provider, tokensFromJson(provider, json), false))
+            .catch(() => undefined),
+    };
+};

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

@@ -2,10 +2,7 @@ import { type AirtableSettings } from "./dispatch.js";
 import type { PlatformSession, ZiteRequestContext } from "../types.js";
 /** The build's Airtable integration `integrationId`, or undefined when it isn't one, or the host can't say. */
 export declare const airtableSettingsOf: (session: PlatformSession, integrationId: string) => Promise<AirtableSettings | undefined>;
-/**
- * One generated Airtable table call, run here with the connection's placeholder
- * token; egress swaps the real one in for Airtable alone, and refreshes it.
- */
+/** One generated Airtable table call, run here with the connection's token, which the outbound fetch refreshes on a 401. */
 export declare function runAirtableCall(host: ZiteRequestContext, session: PlatformSession, integrationId: string, settings: AirtableSettings, methodName: string, params: unknown, access: "signedIn" | "anyone" | "webhook" | "workflow"): Promise<unknown>;
 /** For tests: forget what this isolate learned. */
 export declare const resetAirtableSettings: () => void;

package/dist/esm/start/airtable/index.js

@@ -1,8 +1,8 @@
 import { executeAirtableCall } from "./dispatch.js";
+import { INTEGRATIONS_PLATFORM_ID } from "../credentials.js";
 import { ZiteError, isZiteErrorCode } from "../errors.js";
+import { rememberConnection } from "../outbound.js";
 const AIRTABLE_API = "https://api.airtable.com";
-// The platform id `integrations.get` is answered under (`INTEGRATIONS_SDK_INTEGRATION_ID`).
-const CONNECTIONS = "__connections__";
 // A build's integrations don't change, so per isolate: only answers, never a pending call.
 const settingsHeld = new Map();
 let unsupported = false;
@@ -29,21 +29,20 @@ export const airtableSettingsOf = async (session, integrationId) => {
         throw error;
     }
 };
-/**
- * One generated Airtable table call, run here with the connection's placeholder
- * token; egress swaps the real one in for Airtable alone, and refreshes it.
- */
+/** One generated Airtable table call, run here with the connection's token, which the outbound fetch refreshes on a 401. */
 export async function runAirtableCall(host, session, integrationId, settings, methodName, params, access) {
     // As classic: a demo reaches no connected account.
     if (host.mode === "demo")
         throw new ZiteError("FORBIDDEN", "This action is not available in demo mode");
-    const connection = await session.call({
-        integrationId: CONNECTIONS,
-        className: "Connections",
-        methodName: "get",
-        params: { name: integrationId },
-        access,
-    });
+    const connection = host.credentials
+        ? await host.credentials.get(integrationId)
+        : await session.call({
+            integrationId: INTEGRATIONS_PLATFORM_ID,
+            className: "Connections",
+            methodName: "get",
+            params: { name: integrationId },
+            access,
+        });
     if ("error" in connection) {
         const { code, message, userFacingMessage } = connection.error;
         throw new ZiteError({ code: isZiteErrorCode(code) ? code : "INTERNAL_ERROR", message, userFacingMessage });
@@ -52,6 +51,7 @@ export async function runAirtableCall(host, session, integrationId, settings, me
     if (typeof token !== "string") {
         throw new ZiteError("INTERNAL_ERROR", `The ${integrationId} connection has no token`);
     }
+    rememberConnection(host, integrationId, connection.value);
     host.airtableReads ??= new Map();
     return executeAirtableCall({
         settings,

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

@@ -0,0 +1,19 @@
+/**
+ * Where `integrations.get` reads a connection. In Zite's cloud the host
+ * answers it on the request's session; an app run elsewhere names its own
+ * source in its server entry: memory or the environment here, a shared cache
+ * once one exists.
+ */
+import type { PlatformCallInput, PlatformCallResult, PlatformSession } from "./types.js";
+export type CredentialSource = {
+    get(name: string): Promise<PlatformCallResult>;
+    /** After a provider answered 401: the connection refreshed, where the source can. */
+    refresh?(name: string): Promise<PlatformCallResult>;
+};
+export declare const INTEGRATIONS_PLATFORM_ID = "__connections__";
+/** The host's, on the request's session. */
+export declare const sessionCredentials: (session: PlatformSession, access: PlatformCallInput["access"]) => CredentialSource;
+/** Connections held in memory, by name, as `integrations.get` answers them; `refresh` fetches one anew. */
+export declare const memoryCredentials: (connections: Record<string, unknown>, refresh?: (name: string) => Promise<unknown>) => CredentialSource;
+/** Connections from `ZITE_CONNECTIONS`, JSON by name, for an app run outside Zite. */
+export declare const envCredentials: (env?: Record<string, string | undefined>) => CredentialSource;

package/dist/esm/start/credentials.js

@@ -0,0 +1,30 @@
+/**
+ * Where `integrations.get` reads a connection. In Zite's cloud the host
+ * answers it on the request's session; an app run elsewhere names its own
+ * source in its server entry: memory or the environment here, a shared cache
+ * once one exists.
+ */
+export const INTEGRATIONS_PLATFORM_ID = "__connections__";
+/** The host's, on the request's session. */
+export const sessionCredentials = (session, access) => ({
+    get: (name) => session.call({ integrationId: INTEGRATIONS_PLATFORM_ID, className: "Connections", methodName: "get", params: { name }, access }),
+    ...(session.refreshConnection && { refresh: (name) => session.refreshConnection(name) }),
+});
+const notFound = (name) => ({
+    error: { code: "BAD_REQUEST", message: `Integration ${name} not found` },
+});
+/** Connections held in memory, by name, as `integrations.get` answers them; `refresh` fetches one anew. */
+export const memoryCredentials = (connections, refresh) => ({
+    get: async (name) => (Object.hasOwn(connections, name) ? { value: connections[name] } : notFound(name)),
+    ...(refresh && {
+        refresh: async (name) => {
+            const fresh = await refresh(name);
+            if (fresh === undefined)
+                return notFound(name);
+            connections[name] = fresh;
+            return { value: fresh };
+        },
+    }),
+});
+/** Connections from `ZITE_CONNECTIONS`, JSON by name, for an app run outside Zite. */
+export const envCredentials = (env = process.env) => memoryCredentials(JSON.parse(env.ZITE_CONNECTIONS ?? "{}"));

package/dist/esm/start/entries.js

@@ -12,15 +12,17 @@ export const renderStartServerEntry = (target = "cloudflare") => target === "clo
 import handler from '@tanstack/react-start/server-entry';
 import { createZiteWorker } from 'zitejs/start/worker';
 import { getRouter } from '../src/router';
+import { startInstance } from './start';
 
-export default createZiteWorker({ handler, getRouter });
+export default createZiteWorker({ handler, getRouter, startInstance });
 `
     : `// Generated by zitejs for TanStack Start apps. The platform owns this file.
 import handler, { createServerEntry } from '@tanstack/react-start/server-entry';
 import { createZiteFetch } from 'zitejs/start/server';
 import { getRouter } from '../src/router';
+import { startInstance } from './start';
 
-export default createServerEntry({ fetch: createZiteFetch({ handler, getRouter }) });
+export default createServerEntry({ fetch: createZiteFetch({ handler, getRouter, startInstance }) });
 `;
 /** The start instance: the platform's middleware, then the app's own `src/start.ts` when it has one. */
 export const renderStartInstance = (hasAppStart) => hasAppStart

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

@@ -6,6 +6,7 @@ import type { AnyFunctionMiddleware, AnyRequestMiddleware, StartInstance } from
  * 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<Error, {
+    stack?: string | undefined;
     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/instance.js

@@ -5,6 +5,7 @@ import { createSerializationAdapter, redirect } from "@tanstack/react-router";
 import { toClientError, ZiteError } from "./errors.js";
 import { isSignInRequired, loginHref } from "./index.js";
 import { errorOf, preview } from "./runLog.js";
+import { currentHost } from "./host.js";
 import { getHost, inScope } from "./scope.js";
 // TanStack drops its default CSRF check once an app has a start instance.
 const csrf = createCsrfMiddleware({ filter: (ctx) => ctx.handlerType === "serverFn" });
@@ -50,16 +51,24 @@ const runCapture = createMiddleware({ type: "function" }).server(async ({ next,
 });
 /**
  * Every error a server function or a page's loader sends the browser arrives as a ZiteError, with its code and the
- * message classic would show. Anything else on it, a stack or an SDK's request, stays on the server.
+ * message classic would show. Anything else on it, an SDK's request, stays on the server; its stack goes only to the
+ * editor's preview, for "Fix it for me".
  */
 const ziteErrorAdapter = createSerializationAdapter({
     key: "zite-error",
     test: (value) => value instanceof Error,
     toSerializable: (error) => {
         const { code, message } = toClientError(error);
-        return { code, message };
+        // `currentHost`, not `getHost`: this adapter ships to the browser, which mustn't bundle the request scope.
+        const stack = currentHost()?.mode === "preview" ? error.stack : undefined;
+        return { code, message, ...(stack && { stack }) };
+    },
+    fromSerializable: ({ code, message, stack }) => {
+        const error = new ZiteError(code, message);
+        if (stack)
+            error.stack = stack;
+        return error;
     },
-    fromSerializable: ({ code, message }) => new ZiteError(code, message),
 });
 /**
  * The start instance every Start app builds with: the platform's middleware and

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

@@ -0,0 +1,11 @@
+/**
+ * Every fetch an app makes on the server, wrapped as classic's runtime wraps
+ * it: logged, every secret it knows redacted, with the connection whose token
+ * it carries and what an org's own AI key used; a 401 on a connection's token
+ * refreshed and sent once more; and a call on Zite's own AI key sent to the
+ * host over the app's platform binding.
+ */
+import type { ZiteRequestContext } from "./types.js";
+/** An `integrations.get` answer, whose values name the calls that carry them. */
+export declare const rememberConnection: (host: ZiteRequestContext, name: string, connection: unknown) => void;
+export declare const createOutboundFetch: (nativeFetch: typeof fetch) => typeof fetch;