talizen 0.2.10 → 0.2.12

package/README.md

@@ -216,6 +216,10 @@ export function list(input: { offset?: number }, ctx: TalizenFuncContext) {
 
 `ctx.db`, `ctx.cache`, `ctx.auth`, `ctx.request`, and `ctx.cookies` are injected by the Talizen Func runtime. `talizen/func-runtime` is a type-only authoring module; do not import runtime values from it.
 
+`ctx.request` exposes Fetch-style one-shot body readers. Use `await ctx.request.text()` when a webhook signature must be verified against the exact request bytes, `await ctx.request.json()` for parsed JSON, or `await ctx.request.arrayBuffer()` for binary input. Reading the body sets `ctx.request.bodyUsed`; a second read rejects. `ctx.response.status(code)` sets the actual HTTP response status (100-599), including statuses returned when a Func throws after setting the status. The runtime also provides `TextEncoder` and the HMAC SHA-256 subset of `crypto.subtle` (`importKey`, `sign`, and `verify`) for webhook verification.
+
+Func HTTP responses use the HTTP status code rather than a top-level `ok` field. Successful responses contain `{ result: ... }`; failed responses contain `{ error: ... }`. `invoke()` unwraps `result` for callers.
+
 ## Package Layout
 
 - `talizen/core`: shared runtime config, request helpers, and base data types.

package/func-runtime.d.ts

@@ -74,6 +74,13 @@ export interface FuncRequestRuntime {
     path: string;
     headers: FuncReadonlyStringMap;
     cookies: FuncReadonlyStringMap;
+    readonly bodyUsed: boolean;
+    text(): Promise<string>;
+    json<T = unknown>(): Promise<T>;
+    arrayBuffer(): Promise<ArrayBuffer>;
+}
+export interface FuncResponseRuntime {
+    status(code: number): void;
 }
 export interface FuncCookieSetOptions {
     path?: string;
@@ -96,6 +103,7 @@ export interface TalizenFuncContext {
     trace_id: string;
     extra?: Record<string, unknown>;
     request: FuncRequestRuntime;
+    response: FuncResponseRuntime;
     db: FuncDbRuntime;
     auth: FuncAuthRuntime;
     cache: FuncCacheRuntime;

package/func.d.ts

@@ -4,7 +4,6 @@ export interface FuncLogEntry {
     text: string;
 }
 export interface FuncRunResponse<T = unknown> {
-    ok: boolean;
     result?: T;
     logs?: FuncLogEntry[];
     error?: string;
@@ -13,11 +12,14 @@ export declare class TalizenFuncError extends Error {
     readonly key: string;
     readonly method: string;
     readonly logs: FuncLogEntry[];
-    constructor(key: string, method: string, message: string, logs?: FuncLogEntry[]);
+    readonly status: number;
+    constructor(key: string, method: string, message: string, logs?: FuncLogEntry[], status?: number);
 }
-export declare function invoke<T = unknown>(name: string, input?: unknown, options?: TalizenRequestOptions): Promise<T>;
+export declare function invoke<T = unknown>(name: string, input?: unknown, options?: RunFuncOptions): Promise<T>;
 export interface RunFuncOptions extends TalizenRequestOptions {
     method?: string;
+    timeoutMS?: number;
+    timeoutMs?: number;
 }
 export declare function runFunc<T = unknown>(key: string, input?: unknown, options?: RunFuncOptions): Promise<T>;
 export declare function parseInvokeName(name: string): {

package/func.js

@@ -1,14 +1,16 @@
-import { requestJson, } from "./core.js";
+import { requestJson, TalizenHttpError, } from "./core.js";
 export class TalizenFuncError extends Error {
     key;
     method;
     logs;
-    constructor(key, method, message, logs) {
+    status;
+    constructor(key, method, message, logs, status = 200) {
         super(message);
         this.name = "TalizenFuncError";
         this.key = key;
         this.method = method;
         this.logs = logs ?? [];
+        this.status = status;
     }
 }
 export async function invoke(name, input, options) {
@@ -21,15 +23,44 @@ export async function invoke(name, input, options) {
 export async function runFunc(key, input, options) {
     const normalizedKey = normalizeFuncKey(key);
     const method = normalizeFuncMethod(options?.method);
-    const response = await requestJson(`/func/${encodeFuncKey(normalizedKey)}${method === "main" ? "" : `.${encodeURIComponent(method)}`}`, {
-        method: "POST",
-        body: JSON.stringify(input ?? {}),
-    }, options);
-    if (!response.ok) {
+    const timeoutMS = normalizeTimeoutMS(options?.timeoutMS ?? options?.timeoutMs);
+    const path = `/func/${encodeFuncKey(normalizedKey)}${method === "main" ? "" : `.${encodeURIComponent(method)}`}${timeoutMS ? `?timeout_ms=${timeoutMS}` : ""}`;
+    let response;
+    try {
+        response = await requestJson(path, {
+            method: "POST",
+            body: JSON.stringify(input ?? {}),
+        }, options);
+    }
+    catch (error) {
+        if (error instanceof TalizenHttpError) {
+            throw new TalizenFuncError(normalizedKey, method, funcHttpErrorMessage(error), undefined, error.status);
+        }
+        throw error;
+    }
+    if (response.error) {
         throw new TalizenFuncError(normalizedKey, method, response.error || "Talizen func failed.", response.logs);
     }
     return response.result;
 }
+function funcHttpErrorMessage(error) {
+    try {
+        const payload = JSON.parse(error.body);
+        if (typeof payload.error === "string") {
+            return payload.error;
+        }
+        if (payload.error && typeof payload.error === "object") {
+            const message = payload.error.message;
+            if (typeof message === "string") {
+                return message;
+            }
+        }
+    }
+    catch {
+        // Fall through to the HTTP error body.
+    }
+    return error.body || error.message || "Talizen func failed.";
+}
 export function parseInvokeName(name) {
     const normalized = normalizeFuncKey(name);
     const lastSlash = normalized.lastIndexOf("/");
@@ -67,3 +98,12 @@ function normalizeFuncMethod(method) {
 function encodeFuncKey(key) {
     return key.split("/").map(encodeURIComponent).join("/");
 }
+function normalizeTimeoutMS(timeoutMS) {
+    if (timeoutMS == null) {
+        return undefined;
+    }
+    if (!Number.isFinite(timeoutMS) || timeoutMS <= 0) {
+        throw new Error(`Invalid Talizen func timeoutMS: ${timeoutMS}`);
+    }
+    return Math.floor(timeoutMS);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "talizen",
-  "version": "0.2.10",
+  "version": "0.2.12",
   "description": "Talizen frontend SDK types for cms, form and core.",
   "type": "module",
   "license": "MIT",