@primate/go 0.1.5 → 0.2.0

package/lib/private/Default.d.ts

@@ -0,0 +1,7 @@
+import Runtime from "#Runtime";
+import type BuildApp from "@primate/core/BuildApp";
+import type NextBuild from "@primate/core/NextBuild";
+export default class Default extends Runtime {
+    build(app: BuildApp, next: NextBuild): import("@rcompat/type/MaybePromise").default<BuildApp>;
+}
+//# sourceMappingURL=Default.d.ts.map

package/lib/private/Default.js

@@ -0,0 +1,115 @@
+import Runtime from "#Runtime";
+import AppError from "@primate/core/AppError";
+import log from "@primate/core/log";
+import wrap from "@primate/core/route/wrap";
+import assert from "@rcompat/assert";
+import user from "@rcompat/env/user";
+import runtime from "@rcompat/runtime";
+import execute from "@rcompat/stdio/execute";
+import which from "@rcompat/stdio/which";
+const command = await which("go");
+const env = {
+    GOARCH: "wasm",
+    GOCACHE: (await execute(`${command} env GOCACHE`, {})).replaceAll("\n", ""),
+    GOOS: "js",
+    HOME: user.HOME,
+};
+const run = (wasm, go) => `${command} build -o ${wasm.name} ${go.name}`;
+const js_wrapper = (path) => `
+import env from "@primate/go/env";
+import toRequest from "@primate/go/to-request";
+import to_response from "@primate/go/to-response";
+import session from "#session";
+import route from "primate/route";
+
+globalThis.PRMT_SESSION = {
+  get exists() {
+    return session.exists;
+  },
+  get id() {
+    return session.id;
+  },
+  get data() {
+    return JSON.stringify(session.try());
+  },
+  create(data) {
+    session.create(JSON.parse(data));
+  },
+  get() {
+    return JSON.stringify(session.get());
+  },
+  try() {
+    return JSON.stringify(session.try());
+  },
+  set(data) {
+    session.set(JSON.parse(data));
+  },
+  destroy() {
+    session.destroy();
+  },
+};
+
+${runtime === "bun"
+    ? `import route_path from "${path}" with { type: "file" };
+const go_route = await Bun.file(route_path).arrayBuffer();`
+    :
+        `import FileRef from "primate/runtime/FileRef";
+
+const buffer = await FileRef.arrayBuffer(import.meta.url+"/../${path}");
+const go_route = new Uint8Array(buffer);`}
+
+env();
+
+// Run Go once to register routes and get available verbs
+const go = new globalThis.Go();
+const result = await WebAssembly.instantiate(go_route, go.importObject);
+go.run(result.instance);
+
+const verbs = globalThis.__primate_verbs || [];
+
+for (const verb of verbs) {
+  route[verb.toLowerCase()](async request => {
+    const requested = await toRequest(request);
+    const freshGo = new globalThis.Go();
+    return WebAssembly.instantiate(go_route, {...freshGo.importObject}).then(freshResult => {
+      freshGo.run(freshResult.instance);
+      return to_response(globalThis.__primate_handle(verb, requested));
+    });
+  });
+}
+`;
+const go_wrapper = (code) => {
+    if (!code.includes("github.com/primate-run/go/route")) {
+        console.warn("Go file does not import \"github.com/primate-run/go/route\" - skipping route registration");
+        return code;
+    }
+    return `${code}
+
+func main() {
+    route.Commit()
+    select{}
+}`;
+};
+export default class Default extends Runtime {
+    build(app, next) {
+        app.bind(this.fileExtension, async (route, { build, context }) => {
+            assert(context === "routes", "go: only route files are supported");
+            const code = await route.text();
+            // wrap user code with main function if they imported our route package
+            await route.write(go_wrapper(code));
+            const wasm = route.bare(".wasm");
+            const js_code = wrap(js_wrapper(wasm.name), route, build);
+            await route.append(".js").write(js_code);
+            try {
+                log.info("compiling {0} to WebAssembly", route);
+                // compile .go to .wasm using user's go.mod from project root
+                await execute(run(wasm, route), { cwd: `${route.directory}`, env });
+            }
+            catch (error) {
+                throw new AppError("Error in module {0}\n{1}", route, error);
+            }
+        });
+        return next(app);
+    }
+}
+//# sourceMappingURL=Default.js.map

package/lib/private/Runtime.d.ts

@@ -0,0 +1,6 @@
+import Module from "@primate/core/backend/Module";
+export default class Runtime extends Module {
+    name: string;
+    defaultExtension: string;
+}
+//# sourceMappingURL=Runtime.d.ts.map

package/lib/private/Runtime.js

@@ -0,0 +1,6 @@
+import Module from "@primate/core/backend/Module";
+export default class Runtime extends Module {
+    name = "go";
+    defaultExtension = ".go";
+}
+//# sourceMappingURL=Runtime.js.map

package/lib/private/to-request.d.ts

@@ -0,0 +1,45 @@
+import type RequestFacade from "@primate/core/request/RequestFacade";
+export default function toRequest(request: RequestFacade): Promise<{
+    body: {
+        fieldsSync: () => string;
+        filesSync: () => {
+            bytes: Uint8Array;
+            field: string;
+            name: string;
+            size: number;
+            type: string;
+        }[];
+        type: "fields";
+    } | {
+        textSync: () => string;
+        type: "text";
+        jsonSync?: undefined;
+        binarySync?: undefined;
+        binaryTypeSync?: undefined;
+    } | {
+        jsonSync: () => string;
+        type: "json";
+        textSync?: undefined;
+        binarySync?: undefined;
+        binaryTypeSync?: undefined;
+    } | {
+        binarySync: () => Uint8Array<ArrayBuffer>;
+        binaryTypeSync: () => string;
+        type: "binary";
+        textSync?: undefined;
+        jsonSync?: undefined;
+    } | {
+        type: "none";
+        textSync?: undefined;
+        jsonSync?: undefined;
+        binarySync?: undefined;
+        binaryTypeSync?: undefined;
+    };
+    cookies: string;
+    headers: string;
+    path: string;
+    query: string;
+    searchParams: string;
+    url: URL;
+}>;
+//# sourceMappingURL=to-request.d.ts.map

package/lib/private/to-request.js

@@ -0,0 +1,76 @@
+async function bridgeFields(body) {
+    const fields = body.fields();
+    const meta = Object.create(null);
+    const files = [];
+    const pending = [];
+    for (const [k, v] of Object.entries(fields)) {
+        if (typeof v === "string") {
+            meta[k] = v;
+            continue;
+        }
+        // v is File
+        const name = v.name;
+        const type = v.type;
+        const size = v.size;
+        meta[k] = { name, size, type };
+        // Precompute bytes so Go can call a SYNC getter
+        pending.push(v.arrayBuffer().then(buffer => {
+            files.push({
+                bytes: new Uint8Array(buffer),
+                field: k,
+                name,
+                size,
+                type,
+            });
+        }));
+    }
+    await Promise.all(pending);
+    const jsonStr = JSON.stringify(meta);
+    return {
+        fieldsSync: () => jsonStr,
+        filesSync: () => files,
+        type: "fields",
+    };
+}
+async function bridgeBody(body) {
+    const type = body.type;
+    switch (type) {
+        case "text": {
+            const s = body.text();
+            return { textSync: () => s, type };
+        }
+        case "json": {
+            const val = body.json();
+            const jsonStr = JSON.stringify(val);
+            return { jsonSync: () => jsonStr, type };
+        }
+        case "fields": {
+            return await bridgeFields(body);
+        }
+        case "binary": {
+            const blob = body.binary();
+            const buf = new Uint8Array(await blob.arrayBuffer());
+            const mime = blob.type || "application/octet-stream";
+            return {
+                binarySync: () => buf,
+                binaryTypeSync: () => mime,
+                type,
+            };
+        }
+        default:
+            return { type: "none" };
+    }
+}
+export default async function toRequest(request) {
+    const body = await bridgeBody(request.body);
+    return {
+        body,
+        cookies: JSON.stringify(request.cookies.toJSON()),
+        headers: JSON.stringify(request.headers.toJSON()),
+        path: JSON.stringify(request.path.toJSON()),
+        query: JSON.stringify(request.query.toJSON()),
+        searchParams: JSON.stringify(request.url.searchParams),
+        url: request.url,
+    };
+}
+//# sourceMappingURL=to-request.js.map

package/lib/private/to-response.d.ts

@@ -0,0 +1,9 @@
+import type ResponseLike from "@primate/core/response/ResponseLike";
+import type Dict from "@rcompat/type/Dict";
+type Handler = "error" | "redirect" | "view";
+type ResponseType = (() => {
+    handler: Handler;
+} & Dict) | string;
+declare const _default: (response: ResponseType) => ResponseLike;
+export default _default;
+//# sourceMappingURL=to-response.d.ts.map

package/lib/private/to-response.js

@@ -0,0 +1,24 @@
+import error from "@primate/core/response/error";
+import redirect from "@primate/core/response/redirect";
+import view from "@primate/core/response/view";
+const parse = (input) => input === null ? undefined : JSON.parse(input);
+const handle_handler = (handler, response) => {
+    if (handler === "view") {
+        const { component, options, props } = response;
+        return view(component, parse(props), parse(options));
+    }
+    if (handler === "redirect") {
+        const { location, status } = response;
+        return redirect(location, status === null ? undefined : status);
+    }
+    const { options } = response;
+    return error(parse(options));
+};
+export default (response) => {
+    if (typeof response === "function") {
+        const { handler, ...args } = response();
+        return handle_handler(handler, args);
+    }
+    return JSON.parse(response);
+};
+//# sourceMappingURL=to-response.js.map

package/lib/private/vendored/wasm_exec.d.ts

@@ -0,0 +1,3 @@
+declare function _default(): void;
+export default _default;
+//# sourceMappingURL=wasm_exec.d.ts.map