ziex 0.1.0-dev.786 → 0.1.0-dev.787

package/aws-lambda/index.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Ziex adapter for AWS Lambda (API Gateway v1, v2, and ALB).
+ *
+ * Based on Hono's AWS Lambda adapter implementation.
+ *
+ * @example API Gateway v2 (HTTP API)
+ * ```ts
+ * import { Ziex } from "ziex/cloudflare";
+ * import { handle } from "ziex/aws-lambda";
+ * import module from "./app.wasm";
+ *
+ * const app = new Ziex({ module });
+ * export const handler = handle(app);
+ * ```
+ */
+type ApiGwV1Event = {
+    version?: "1.0";
+    httpMethod: string;
+    path: string;
+    headers: Record<string, string> | null;
+    multiValueHeaders: Record<string, string[]> | null;
+    queryStringParameters: Record<string, string> | null;
+    multiValueQueryStringParameters: Record<string, string[]> | null;
+    body: string | null;
+    isBase64Encoded: boolean;
+    requestContext: {
+        elb?: unknown;
+    };
+};
+type ApiGwV2Event = {
+    version: "2.0";
+    requestContext: {
+        http: {
+            method: string;
+        };
+    };
+    rawPath: string;
+    rawQueryString: string;
+    headers: Record<string, string>;
+    body?: string;
+    isBase64Encoded: boolean;
+};
+type AlbEvent = {
+    httpMethod: string;
+    path: string;
+    headers: Record<string, string> | null;
+    multiValueHeaders: Record<string, string[]> | null;
+    queryStringParameters: Record<string, string> | null;
+    multiValueQueryStringParameters: Record<string, string[]> | null;
+    body: string | null;
+    isBase64Encoded: boolean;
+    requestContext: {
+        elb: unknown;
+    };
+};
+export type LambdaEvent = ApiGwV1Event | ApiGwV2Event | AlbEvent;
+export type LambdaContext = {
+    functionName: string;
+    functionVersion: string;
+    invokedFunctionArn: string;
+    memoryLimitInMB: string;
+    awsRequestId: string;
+    logGroupName: string;
+    logStreamName: string;
+    callbackWaitsForEmptyEventLoop: boolean;
+    getRemainingTimeInMillis(): number;
+};
+export type LambdaResult = {
+    statusCode: number;
+    headers: Record<string, string>;
+    multiValueHeaders: Record<string, string[]>;
+    body: string;
+    isBase64Encoded: boolean;
+    cookies?: string[];
+};
+type FetchApp = {
+    fetch(req: Request, env?: unknown, ctx?: unknown): Promise<Response>;
+};
+export type HandleOptions = {
+    /**
+     * Content types to encode as base64 in the Lambda response.
+     * By default, non-text content types are base64 encoded automatically.
+     */
+    binaryMediaTypes?: string[];
+};
+/**
+ * Wrap a Ziex app as an AWS Lambda handler.
+ *
+ * @example
+ * ```ts
+ * import { handle } from "ziex/aws-lambda";
+ * export const handler = handle(app);
+ * ```
+ */
+export declare function handle(app: FetchApp, options?: HandleOptions): (event: LambdaEvent, _context?: LambdaContext) => Promise<LambdaResult>;
+export {};

package/aws-lambda/index.js

@@ -0,0 +1,126 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/aws-lambda/index.ts
+function isV2(event) {
+  return "requestContext" in event && event.requestContext !== null && "http" in event.requestContext;
+}
+function getMethod(event) {
+  if (isV2(event))
+    return event.requestContext.http.method;
+  return event.httpMethod;
+}
+function getPath(event) {
+  if (isV2(event)) {
+    return event.rawPath + (event.rawQueryString ? `?${event.rawQueryString}` : "");
+  }
+  const e = event;
+  const mvqs = e.multiValueQueryStringParameters;
+  const qs = e.queryStringParameters;
+  let queryString = "";
+  if (mvqs) {
+    queryString = Object.entries(mvqs).flatMap(([k, vs]) => (vs ?? []).map((v) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`)).join("&");
+  } else if (qs) {
+    queryString = new URLSearchParams(qs).toString();
+  }
+  return e.path + (queryString ? `?${queryString}` : "");
+}
+function getHeaders(event) {
+  const headers = new Headers;
+  if (event.headers) {
+    for (const [k, v] of Object.entries(event.headers)) {
+      if (v != null)
+        headers.set(k, v);
+    }
+  }
+  if ("multiValueHeaders" in event && event.multiValueHeaders) {
+    for (const [k, vs] of Object.entries(event.multiValueHeaders)) {
+      if (!vs?.length)
+        continue;
+      headers.delete(k);
+      for (const v of vs)
+        headers.append(k, v);
+    }
+  }
+  return headers;
+}
+function getBody(event) {
+  if (!event.body)
+    return null;
+  if (event.isBase64Encoded)
+    return Buffer.from(event.body, "base64");
+  return event.body;
+}
+function toRequest(event, headers) {
+  const method = getMethod(event);
+  const host = headers.get("host") ?? "localhost";
+  const proto = headers.get("x-forwarded-proto") ?? "https";
+  const path = getPath(event);
+  const url = `${proto}://${host}${path}`;
+  const body = ["GET", "HEAD"].includes(method) ? null : getBody(event);
+  return new Request(url, { method, headers, body });
+}
+var TEXT_CONTENT_TYPES = [
+  "text/",
+  "application/json",
+  "application/xml",
+  "application/javascript",
+  "application/xhtml"
+];
+function isBinaryContent(contentType, binaryMediaTypes) {
+  if (binaryMediaTypes.length > 0) {
+    return binaryMediaTypes.some((t) => contentType.includes(t));
+  }
+  return !TEXT_CONTENT_TYPES.some((t) => contentType.startsWith(t));
+}
+async function toLambdaResult(res, binaryMediaTypes) {
+  const responseHeaders = {};
+  const multiValueHeaders = {};
+  res.headers.forEach((value, key) => {
+    if (key in responseHeaders) {
+      multiValueHeaders[key] = [...multiValueHeaders[key] ?? [responseHeaders[key]], value];
+      delete responseHeaders[key];
+    } else if (key in multiValueHeaders) {
+      multiValueHeaders[key].push(value);
+    } else {
+      responseHeaders[key] = value;
+    }
+  });
+  const contentType = res.headers.get("content-type") ?? "";
+  const binary = isBinaryContent(contentType, binaryMediaTypes);
+  let body;
+  let isBase64Encoded = false;
+  if (binary) {
+    body = Buffer.from(await res.arrayBuffer()).toString("base64");
+    isBase64Encoded = true;
+  } else {
+    body = await res.text();
+  }
+  return {
+    statusCode: res.status,
+    headers: responseHeaders,
+    multiValueHeaders,
+    body,
+    isBase64Encoded
+  };
+}
+function handle(app, options = {}) {
+  const binaryMediaTypes = options.binaryMediaTypes ?? [];
+  return async (event, _context) => {
+    const headers = getHeaders(event);
+    const req = toRequest(event, headers);
+    const res = await app.fetch(req);
+    return toLambdaResult(res, binaryMediaTypes);
+  };
+}
+export {
+  handle
+};

package/cloudflare/app.d.ts

@@ -0,0 +1,95 @@
+import type { KVNamespace } from "./kv";
+type DurableObjectNamespace = {
+    idFromName(name: string): unknown;
+    get(id: unknown): {
+        fetch(req: Request): Promise<Response>;
+    };
+};
+type WASI = {
+    wasiImport: Record<string, (...args: any[]) => unknown>;
+    start(instance: {
+        exports: {
+            memory: WebAssembly.Memory;
+            _start: () => unknown;
+        };
+    }): number;
+    initialize?(instance: {
+        exports: {
+            memory: WebAssembly.Memory;
+            _initialize?: () => unknown;
+        };
+    }): void;
+};
+type ZiexOptions<Env> = {
+    /** Compiled WASM module for the Ziex app. */
+    module: WebAssembly.Module;
+    /** Optional pre-configured WASI instance. */
+    wasi?: WASI;
+    /** Extra WASM import namespaces. */
+    imports?: (mem: () => WebAssembly.Memory) => Record<string, Record<string, unknown>>;
+    /**
+     * Factory that maps platform env bindings to Ziex KV namespaces.
+     * Called per-request so bindings are resolved from the live env.
+     *
+     * @example
+     * ```ts
+     * kv: (env) => ({ default: env.MY_KV })
+     * ```
+     */
+    kv?: (env: Env) => Record<string, KVNamespace>;
+    /**
+     * Factory that maps platform env bindings to a Durable Object namespace
+     * for WebSocket pub/sub. Requires `createWebSocketDO` export on the worker.
+     *
+     * @example
+     * ```ts
+     * websocket: (env) => env.ChatRoom
+     * ```
+     */
+    websocket?: (env: Env) => DurableObjectNamespace;
+};
+/**
+ * Main Ziex application class. Mirrors the Hono API style — construct once,
+ * export as default, and the runtime calls `fetch` for you.
+ *
+ * Works on Cloudflare Workers out of the box. For other platforms use the
+ * adapter methods (e.g. `app.vercel()`).
+ *
+ * @example Cloudflare Workers
+ * ```ts
+ * import { Ziex } from "ziex/cloudflare";
+ * import module from "./app.wasm";
+ *
+ * const app = new Ziex<Env>({
+ *   module,
+ *   kv: (env) => ({ default: env.KV }),
+ *   websocket: (env) => env.ChatRoom,
+ * });
+ *
+ * export const ChatRoom = createWebSocketDO(module);
+ * export default app;
+ * ```
+ *
+ * @example Vercel Edge
+ * ```ts
+ * import { Ziex } from "ziex/cloudflare";
+ * import module from "./app.wasm"; // fetch at runtime on Vercel, see vercel adapter
+ *
+ * const app = new Ziex({ module });
+ * export default app.vercel();
+ * ```
+ */
+export declare class Ziex<Env = Record<string, unknown>> {
+    private readonly options;
+    constructor(options: ZiexOptions<Env>);
+    /**
+     * Cloudflare Workers fetch handler.
+     *
+     * `env` and `ctx` are injected by the CF runtime — you never call this
+     * directly. Just `export default app` and Cloudflare handles the rest.
+     */
+    fetch(request: Request, env: Env, ctx?: {
+        waitUntil(p: Promise<unknown>): void;
+    }): Promise<Response>;
+}
+export {};

package/cloudflare/index.d.ts

@@ -1,2 +1,4 @@
 export * as worker from "./worker";
 export * as kv from "./kv";
+export { Ziex } from "./app";
+export { createWebSocketDO } from "./worker";