@ricsam/quickjs-fetch 0.0.1 → 0.2.1

package/dist/types/globals/form-data.d.ts

@@ -0,0 +1,37 @@
+import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
+import type { StateMap } from "@ricsam/quickjs-core";
+/**
+ * Internal state for FormData entries
+ * Each entry can have multiple values (same key appended multiple times)
+ */
+export interface FormDataEntry {
+    name: string;
+    value: string | FormDataFileValue;
+}
+export interface FormDataFileValue {
+    data: Uint8Array;
+    filename: string;
+    type: string;
+}
+export interface FormDataState {
+    entries: FormDataEntry[];
+}
+/**
+ * Create the FormData class for QuickJS
+ */
+export declare function createFormDataClass(context: QuickJSContext, stateMap: StateMap): QuickJSHandle;
+/**
+ * Parse multipart/form-data body
+ */
+export declare function parseMultipartFormData(body: Uint8Array, contentType: string): FormDataState;
+/**
+ * Parse URL-encoded form data
+ */
+export declare function parseUrlEncodedFormData(body: Uint8Array): FormDataState;
+/**
+ * Serialize FormData to multipart/form-data format
+ */
+export declare function serializeFormData(state: FormDataState): {
+    body: Uint8Array;
+    contentType: string;
+};

package/dist/types/globals/headers.d.ts

@@ -0,0 +1,36 @@
+import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
+import type { StateMap } from "@ricsam/quickjs-core";
+import type { HeadersState } from "../types.ts";
+/**
+ * Create the Headers class for QuickJS
+ */
+export declare function createHeadersClass(context: QuickJSContext, stateMap: StateMap): QuickJSHandle;
+/**
+ * Create a HeadersState from a native Headers object
+ */
+export declare function createHeadersStateFromNative(headers: Headers): HeadersState;
+/**
+ * Convert HeadersState to native Headers
+ */
+export declare function headersStateToNative(state: HeadersState): Headers;
+/**
+ * Interface for a Headers-like object that can be returned from getters
+ */
+export interface HeadersLike {
+    headers: Map<string, string[]>;
+    append(name: string, value: string): void;
+    delete(name: string): void;
+    get(name: string): string | null;
+    has(name: string): boolean;
+    set(name: string, value: string): void;
+    entries(): Array<[string, string]>;
+    keys(): string[];
+    values(): string[];
+    forEach(callback: (value: string, key: string) => void): void;
+    getSetCookie(): string[];
+}
+/**
+ * Create a Headers-like object from HeadersState that has all the Headers methods
+ * This is used for getters that need to return an object with Headers API
+ */
+export declare function createHeadersLike(state: HeadersState): HeadersLike;

package/dist/types/globals/request.d.ts

@@ -0,0 +1,16 @@
+import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
+import type { StateMap } from "@ricsam/quickjs-core";
+import type { RequestState } from "../types.ts";
+/**
+ * Type for the stream factory function
+ */
+type StreamFactory = (source: UnderlyingSource) => QuickJSHandle;
+/**
+ * Create the Request class for QuickJS
+ */
+export declare function createRequestClass(context: QuickJSContext, stateMap: StateMap, createStream?: StreamFactory): QuickJSHandle;
+/**
+ * Create a RequestState from a native Request object
+ */
+export declare function createRequestStateFromNative(request: Request): Promise<RequestState>;
+export {};

package/dist/types/globals/response.d.ts

@@ -0,0 +1,25 @@
+import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
+import type { StateMap } from "@ricsam/quickjs-core";
+import type { ResponseState } from "../types.ts";
+/**
+ * Type for the stream factory function
+ */
+type StreamFactory = (source: UnderlyingSource) => QuickJSHandle;
+/**
+ * Create the Response class for QuickJS
+ */
+export declare function createResponseClass(context: QuickJSContext, stateMap: StateMap, createStream?: StreamFactory): QuickJSHandle;
+/**
+ * Add static methods to Response class after it's been set on global
+ * This must be called after Response and Headers are available on global
+ */
+export declare function addResponseStaticMethods(context: QuickJSContext): void;
+/**
+ * Convert ResponseState (or unmarshalled Response object) to native Response
+ */
+export declare function responseStateToNative(state: ResponseState | Record<string, unknown>): Response;
+/**
+ * Create a ResponseState from a native Response
+ */
+export declare function createResponseStateFromNative(response: Response): Promise<ResponseState>;
+export {};

package/dist/types/globals/serve.d.ts

@@ -0,0 +1,16 @@
+import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
+import type { StateMap } from "@ricsam/quickjs-core";
+import type { ServeState, WebSocketCommand } from "../types.ts";
+/**
+ * Create the ServerWebSocket class for QuickJS
+ */
+export declare function createServerWebSocketClass(context: QuickJSContext, stateMap: StateMap, onWebSocketCommand: (cmd: WebSocketCommand) => void): QuickJSHandle;
+/**
+ * Create the Server class for QuickJS
+ */
+export declare function createServerClass(context: QuickJSContext, stateMap: StateMap, serveState: ServeState): QuickJSHandle;
+/**
+ * Create the serve function for QuickJS
+ * Uses context.newFunction instead of defineFunction to properly manage handle lifetimes
+ */
+export declare function createServeFunction(context: QuickJSContext, stateMap: StateMap, serveState: ServeState): QuickJSHandle;

package/dist/types/handle.d.ts

@@ -0,0 +1,6 @@
+import type { QuickJSContext } from "quickjs-emscripten";
+import type { StateMap, FetchHandle, ServeState } from "./types.ts";
+/**
+ * Create the FetchHandle implementation
+ */
+export declare function createFetchHandle(context: QuickJSContext, stateMap: StateMap, serveState: ServeState): FetchHandle;

package/dist/types/index.d.ts

@@ -0,0 +1,5 @@
+export { setupFetch } from "./setup.ts";
+export type { SetupFetchOptions, FetchHandle, WebSocketData, UpgradeRequest, WebSocketCommand, WebSocketOutgoingMessage, WebSocketClose, ServeState, ServerWebSocketState, } from "./types.ts";
+export { createHeadersStateFromNative, headersStateToNative, } from "./globals/headers.ts";
+export { responseStateToNative, createResponseStateFromNative, } from "./globals/response.ts";
+export { createRequestStateFromNative } from "./globals/request.ts";

package/dist/types/setup.d.ts

@@ -0,0 +1,48 @@
+import type { QuickJSContext } from "quickjs-emscripten";
+import type { SetupFetchOptions, FetchHandle } from "./types.ts";
+/**
+ * Setup Fetch API in a QuickJS context
+ *
+ * Injects the following globals:
+ * - fetch
+ * - Request
+ * - Response
+ * - Headers
+ * - AbortController
+ * - AbortSignal
+ * - serve
+ * - FormData
+ *
+ * Also sets up Core APIs (Streams, Blob, File) if not already present.
+ *
+ * **Private globals (internal use):**
+ * - `__Server__` - Server class for serve() handler, instantiated via evalCode
+ * - `__ServerWebSocket__` - WebSocket class for connection handling
+ * - `__scheduleTimeout__` - Host function to schedule AbortSignal.timeout()
+ * - `__checkTimeout__` - Host function to check if timeout elapsed
+ *
+ * These private globals follow the `__Name__` convention and are required for
+ * JavaScript code in QuickJS to create class instances via evalCode.
+ * See PATTERNS.md section 5 for details.
+ *
+ * @example
+ * const handle = setupFetch(context, {
+ *   onFetch: async (request) => {
+ *     // Proxy to real fetch
+ *     return fetch(request);
+ *   }
+ * });
+ *
+ * context.evalCode(`
+ *   serve({
+ *     fetch(request, server) {
+ *       return new Response("Hello!");
+ *     }
+ *   });
+ * `);
+ *
+ * const response = await handle.dispatchRequest(
+ *   new Request("http://localhost/")
+ * );
+ */
+export declare function setupFetch(context: QuickJSContext, options?: SetupFetchOptions): FetchHandle;

package/dist/types/types.d.ts

@@ -0,0 +1,175 @@
+import type { QuickJSHandle } from "quickjs-emscripten";
+import type { StateMap, CoreHandle } from "@ricsam/quickjs-core";
+export type { StateMap, CoreHandle };
+/**
+ * Options for setting up Fetch APIs
+ */
+export interface SetupFetchOptions {
+    /**
+     * Handler for outbound fetch() calls from QuickJS
+     * If not provided, fetch() will throw an error
+     */
+    onFetch?: (request: Request) => Promise<Response>;
+    /** Existing state map (creates new one if not provided) */
+    stateMap?: StateMap;
+    /** Existing core handle (sets up core if not provided) */
+    coreHandle?: CoreHandle;
+}
+/**
+ * Data associated with a WebSocket connection
+ */
+export interface WebSocketData {
+    /** User-provided data from server.upgrade() */
+    data: unknown;
+    /** Connection ID assigned by the host */
+    connectionId: string;
+}
+/**
+ * Pending upgrade request info
+ */
+export interface UpgradeRequest {
+    /** Whether an upgrade was requested */
+    requested: true;
+    /** User data passed to server.upgrade() */
+    data: unknown;
+}
+/**
+ * Message to send to a WebSocket
+ */
+export interface WebSocketOutgoingMessage {
+    type: "message";
+    connectionId: string;
+    data: string | ArrayBuffer;
+}
+/**
+ * Close command for a WebSocket
+ */
+export interface WebSocketClose {
+    type: "close";
+    connectionId: string;
+    code?: number;
+    reason?: string;
+}
+export type WebSocketCommand = WebSocketOutgoingMessage | WebSocketClose;
+/**
+ * Internal state for serve() handler
+ */
+export interface ServeState {
+    fetchHandler: QuickJSHandle | null;
+    websocketHandlers: {
+        open?: QuickJSHandle;
+        message?: QuickJSHandle;
+        close?: QuickJSHandle;
+        error?: QuickJSHandle;
+    };
+    pendingUpgrade: UpgradeRequest | null;
+    activeConnections: Map<string, ServerWebSocketState>;
+}
+export interface ServerWebSocketState {
+    data: unknown;
+    readyState: number;
+    connectionId: string;
+    wsHandle: QuickJSHandle | null;
+}
+/**
+ * Handle returned from setupFetch
+ */
+export interface FetchHandle {
+    /** State map containing all internal states */
+    readonly stateMap: StateMap;
+    /**
+     * Dispatch an HTTP request to the serve() handler
+     *
+     * @returns Response from the QuickJS handler
+     * @throws If no serve() handler is registered
+     */
+    dispatchRequest(request: Request): Promise<Response>;
+    /**
+     * Check if the last request resulted in an upgrade request
+     * Must be called immediately after dispatchRequest()
+     */
+    getUpgradeRequest(): UpgradeRequest | null;
+    /**
+     * Dispatch WebSocket open event
+     *
+     * @param connectionId Unique ID for this connection (host-assigned)
+     * @param data The data object from getUpgradeRequest()
+     */
+    dispatchWebSocketOpen(connectionId: string, data?: unknown): void;
+    /**
+     * Dispatch WebSocket message event
+     */
+    dispatchWebSocketMessage(connectionId: string, message: string | ArrayBuffer): void;
+    /**
+     * Dispatch WebSocket close event
+     */
+    dispatchWebSocketClose(connectionId: string, code: number, reason: string): void;
+    /**
+     * Dispatch WebSocket error event
+     */
+    dispatchWebSocketError(connectionId: string, error: Error): void;
+    /**
+     * Register a callback for outgoing WebSocket messages/commands
+     * Called when QuickJS code calls ws.send() or ws.close()
+     */
+    onWebSocketCommand(callback: (command: WebSocketCommand) => void): () => void;
+    /**
+     * Check if a serve() handler is registered
+     */
+    hasServeHandler(): boolean;
+    /**
+     * Dispose all handles and cleanup
+     */
+    dispose(): void;
+}
+export interface HeadersState {
+    headers: Map<string, string[]>;
+}
+export interface RequestState {
+    method: string;
+    url: string;
+    headersState: HeadersState;
+    body: Uint8Array | null;
+    bodyUsed: boolean;
+    cache: string;
+    credentials: string;
+    destination: string;
+    integrity: string;
+    keepalive: boolean;
+    mode: string;
+    redirect: string;
+    referrer: string;
+    referrerPolicy: string;
+    signal: AbortSignalState | null;
+}
+export interface ResponseState {
+    status: number;
+    statusText: string;
+    headersState: HeadersState;
+    body: Uint8Array | null;
+    bodyUsed: boolean;
+    url: string;
+    redirected: boolean;
+    type: string;
+    ok: boolean;
+}
+export interface AbortControllerState {
+    signalState: AbortSignalState;
+}
+export interface AbortSignalState {
+    aborted: boolean;
+    reason: unknown;
+    listeners: Set<() => void>;
+}
+export interface FormDataFileValue {
+    data: Uint8Array;
+    filename: string;
+    type: string;
+}
+export interface FormDataEntry {
+    name: string;
+    value: string | FormDataFileValue;
+}
+export interface FormDataState {
+    entries: FormDataEntry[];
+}

package/package.json

@@ -1,10 +1,55 @@
 {
   "name": "@ricsam/quickjs-fetch",
-  "version": "0.0.1",
-  "description": "OIDC trusted publishing setup package for @ricsam/quickjs-fetch",
+  "version": "0.2.1",
+  "main": "./dist/cjs/index.cjs",
+  "types": "./dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "require": "./dist/cjs/index.cjs",
+      "import": "./dist/mjs/index.mjs"
+    }
+  },
+  "scripts": {
+    "build": "bun build ./src/index.ts --outdir ./dist --target bun",
+    "test": "bun test",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@ricsam/quickjs-core": "^0.2.1",
+    "quickjs-emscripten": "^0.31.0"
+  },
+  "peerDependencies": {
+    "quickjs-emscripten": "^0.31.0"
+  },
+  "author": "Richard Samuelsson",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ricsam/richie-qjs.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ricsam/richie-qjs/issues"
+  },
+  "homepage": "https://github.com/ricsam/richie-qjs#readme",
   "keywords": [
-    "oidc",
-    "trusted-publishing",
-    "setup"
+    "quickjs",
+    "sandbox",
+    "javascript",
+    "runtime",
+    "fetch",
+    "filesystem",
+    "streams",
+    "wasm",
+    "emscripten"
+  ],
+  "description": "Fetch API implementation for QuickJS runtime",
+  "module": "./dist/mjs/index.mjs",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "README.md"
   ]
-}
+}