Initial Commit

packages/api-stack/api/wasm-compiler-javy/tests/integration/tiny-plugin.test.ts

@@ -0,0 +1,145 @@
+import { mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import type { WasmSandboxHandle } from "@suaveplan/api-sandbox-wasm";
+import { createSandboxedWasmPluginModule } from "@suaveplan/api-sandbox-wasm-host-bridge";
+import { describe, expect, it } from "@suaveplan/testing/runner";
+import { compilePluginToWasm } from "../../src/index.js";
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const FIXTURE = resolve(HERE, "../fixtures/tiny-plugin/src/index.ts");
+
+const MANIFEST = {
+    name: "tiny-plugin",
+    version: "0.1.0",
+    apiHost: "@suaveplan/api-host@0" as const,
+    isolation: "sandboxed" as const,
+    trustLevel: "first-party" as const,
+    requiredCapabilities: [],
+};
+
+/**
+ * Structural sandbox stub. The wasi-stdio bridge variant only reaches
+ * for `dispose` and `disposed` — `instance.exports` is never touched.
+ */
+function createSandboxStub(): WasmSandboxHandle {
+    let disposed = false;
+    return {
+        pluginName: "tiny-plugin",
+        instance: { exports: {} } as unknown as WebAssembly.Instance,
+        preopens: [],
+        outbound: { allow: () => false } as never,
+        dispose: () => {
+            disposed = true;
+        },
+        get disposed() {
+            return disposed;
+        },
+    } as unknown as WasmSandboxHandle;
+}
+
+describe("tiny-plugin compile + deploy", () => {
+    it("compiles, validates, extracts routes, and deploys via wasi-stdio bridge", {
+        timeout: 120000,
+    }, async () => {
+        const outDir = mkdtempSync(join(tmpdir(), "tiny-compile-"));
+        const result = await compilePluginToWasm({
+            pluginEntry: FIXTURE,
+            outDir,
+            pluginName: "tiny-plugin",
+        });
+        const paths = result.manifest.routes.map((r) => r.path);
+        expect(paths).toContain("/tiny/hello");
+        expect(paths).toContain("/tiny/echo");
+        expect(result.sizeBytes).toBeGreaterThan(1000);
+
+        const wasmBytes = new Uint8Array(readFileSync(result.wasmPath));
+        const wasmModule = await WebAssembly.compile(wasmBytes);
+
+        const sandbox = createSandboxStub();
+
+        const install = createSandboxedWasmPluginModule({
+            abiVariant: "wasi-stdio",
+            sandbox,
+            manifest: MANIFEST,
+            wasmModule,
+        });
+
+        expect(install.routes.length).toBe(2);
+        install.lifecycle.start();
+
+        const helloRoute = install.routes.find((r) => r.path === "/tiny/hello");
+        expect(helloRoute).toBeDefined();
+        const ctx = buildRequestContext(
+            "https://example.com/tiny/hello",
+            "GET"
+        );
+        const resp = await (
+            helloRoute as never as {
+                handler: (c: unknown) => Promise<Response>;
+            }
+        ).handler(ctx);
+        expect(resp.status).toBe(200);
+        const text = await resp.text();
+        expect(text.includes("hello")).toBe(true);
+
+        // Lifecycle dispose roundtrip
+        install.lifecycle.dispose();
+        rmSync(outDir, { recursive: true, force: true });
+    });
+
+    it("exercises the echo POST route", { timeout: 120000 }, async () => {
+        const outDir = mkdtempSync(join(tmpdir(), "tiny-echo-"));
+        const result = await compilePluginToWasm({
+            pluginEntry: FIXTURE,
+            outDir,
+            pluginName: "tiny-plugin",
+        });
+        const wasmBytes = new Uint8Array(readFileSync(result.wasmPath));
+        const wasmModule = await WebAssembly.compile(wasmBytes);
+        const sandbox = createSandboxStub();
+        const install = createSandboxedWasmPluginModule({
+            abiVariant: "wasi-stdio",
+            sandbox,
+            manifest: MANIFEST,
+            wasmModule,
+        });
+        install.lifecycle.start();
+        const echoRoute = install.routes.find((r) => r.path === "/tiny/echo");
+        const ctx = buildRequestContext(
+            "https://example.com/tiny/echo",
+            "POST",
+            "hello-echo-body"
+        );
+        const resp = await (
+            echoRoute as never as {
+                handler: (c: unknown) => Promise<Response>;
+            }
+        ).handler(ctx);
+        expect(resp.status).toBe(200);
+        const body = await resp.text();
+        expect(body).toBe("hello-echo-body");
+        install.lifecycle.dispose();
+        rmSync(outDir, { recursive: true, force: true });
+    });
+});
+
+function buildRequestContext(
+    url: string,
+    method: string,
+    body?: string
+): unknown {
+    const init: RequestInit = { method };
+    if (body !== undefined) init.body = body;
+    return {
+        request: new Request(url, init),
+        params: {},
+        plugin: { name: "tiny-plugin" },
+        principal: null,
+        tenant: null,
+        capabilities: {} as Record<string, true>,
+        requestId: "tiny-req-1",
+        timestamp: Date.now(),
+    };
+}