ziex 0.1.0-dev.864 → 0.1.0-dev.865

package/aws-lambda/index.d.ts

@@ -1,96 +0,0 @@
-/**
- * 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

@@ -1,126 +0,0 @@
-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/build.zig

@@ -1,5 +0,0 @@
-const std = @import("std");
-
-pub fn build(b: *std.Build) void {
-    _ = b; // stub
-}

package/build.zig.zon

@@ -1,7 +0,0 @@
-.{
-    .name = .ziex_js,
-    .fingerprint = 0x3428b4e119b455bf,
-    .version = "0.1.0-dev.804",
-    .minimum_zig_version = "0.15.2",
-    .paths = .{""},
-}

package/cloudflare/app.d.ts

@@ -1,2 +0,0 @@
-export { Ziex, resolveModule } from "../app";
-export type { WasmInput } from "../app";

package/cloudflare/do.d.ts

@@ -1,48 +0,0 @@
-import type { WsState } from "../runtime";
-import type { KVNamespace } from "../kv";
-type ConnState = WsState & {
-    topics: Set<string>;
-};
-/**
- * Create a Durable Object class that handles WebSocket connections for a ZX app.
- *
- * Each DO instance corresponds to one "room" (keyed by pathname). All clients
- * connecting to the same route share a DO instance, enabling pub/sub via
- * `ctx.socket.subscribe()` / `ctx.socket.publish()`.
- *
- * @example
- * ```ts
- * // worker.ts
- * import { Ziex } from "ziex";
- * import { createWebSocketDO } from "ziex/cloudflare";
- * import module from "./app.wasm";
- *
- * export const ZxWS = createWebSocketDO(module);
- *
- * export default new Ziex({
- *   module,
- *   websocket: (env) => env.ZxWS,
- * });
- * ```
- */
-export declare function createWebSocketDO(module: WebAssembly.Module, options?: {
-    /**
-     * KV namespace bindings for the DO. Pass a factory that receives the DO's
-     * `env` so bindings are resolved at runtime:
-     *
-     * ```ts
-     * createWebSocketDO(module, { kv: (env) => ({ default: env.KV }) })
-     * ```
-     */
-    kv?: (env: any) => Record<string, KVNamespace>;
-    imports?: (mem: () => WebAssembly.Memory) => Record<string, Record<string, unknown>>;
-}): {
-    new (state: any, env: any): {
-        readonly doState: any;
-        readonly env: any;
-        /** All active connections in this room, keyed by their server-side WebSocket. */
-        readonly connections: Map<WebSocket, ConnState>;
-        fetch(request: Request): Promise<Response>;
-    };
-};
-export {};

package/cloudflare/index.d.ts

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