@primate/go 0.2.0 → 0.3.0

package/lib/private/Default.d.ts

@@ -2,6 +2,6 @@ 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>;
+    build(app: BuildApp, next: NextBuild): Promise<BuildApp>;
 }
 //# sourceMappingURL=Default.d.ts.map

package/lib/private/Default.js

@@ -1,21 +1,26 @@
 import Runtime from "#Runtime";
 import AppError from "@primate/core/AppError";
+import TAG from "@primate/core/backend/TAG";
+import fail from "@primate/core/fail";
+import location from "@primate/core/location";
 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 = {
+const COMMAND = await which("go");
+const ENV = {
     GOARCH: "wasm",
-    GOCACHE: (await execute(`${command} env GOCACHE`, {})).replaceAll("\n", ""),
+    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) => `
+const REPO = "github.com/primate-run/go";
+const [MAJOR, MINOR] = TAG.split(".").map(Number);
+const run = (wasm, go) => `${COMMAND} build -o ${wasm.name} ${go.name}`;
+function wrapper(path) {
+    return `
 import env from "@primate/go/env";
 import toRequest from "@primate/go/to-request";
 import to_response from "@primate/go/to-response";
@@ -50,64 +55,89 @@ globalThis.PRMT_SESSION = {
 };
 
 ${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";
-
+        ? `import route_path from "./${path}" with { type: "file" };
+const binary = 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);`}
+const binary = 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);
+const result = await WebAssembly.instantiate(binary, 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);
+    const _go = new globalThis.Go();
+    return WebAssembly.instantiate(binary, {..._go.importObject}).then(_result => {
+      _go.run(_result.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");
+}
+;
+function postlude(code) {
+    if (!code.includes(`${REPO}/route`)) {
+        log.warn("Go file does not import {0} - skipping route registration", REPO);
         return code;
     }
     return `${code}
-
 func main() {
     route.Commit()
     select{}
 }`;
-};
+}
+;
+async function check_version() {
+    try {
+        const version = await execute(`go list -m -f '{{.Version}}' ${REPO}`);
+        const trimmed = version.trim();
+        const version_match = trimmed.match(/^v?(\d+)\.(\d+)\.(\d+)/);
+        if (!version_match)
+            throw fail("invalid version format: {0}", trimmed);
+        const [, major, minor] = version_match.map(Number);
+        if (major !== MAJOR || minor !== MINOR) {
+            throw fail("installed version {0} not in range {1}", trimmed, TAG);
+        }
+    }
+    catch (error) {
+        if (error instanceof AppError)
+            throw error;
+        console.log(error);
+        throw fail("{0} dependency not found - run 'go get {0}@v{1}.0'", REPO, TAG);
+    }
+}
 export default class Default extends Runtime {
-    build(app, next) {
-        app.bind(this.fileExtension, async (route, { build, context }) => {
+    async build(app, next) {
+        await check_version();
+        app.bind(this.fileExtension, async (route, { 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);
+            const relative = route.debase(app.path.routes);
+            const basename = relative.path.slice(1, -relative.extension.length);
+            const code = postlude(await route.text());
+            const build_go_file = app.runpath(location.routes, `${basename}.go`);
+            await build_go_file.directory.create({ recursive: true });
+            await build_go_file.write(code);
+            const wasm = app.runpath(location.routes, `${basename}.wasm`);
             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 });
+                await execute(run(wasm, build_go_file), {
+                    cwd: build_go_file.directory.path,
+                    env: ENV,
+                });
             }
             catch (error) {
-                throw new AppError("Error in module {0}\n{1}", route, error);
+                throw fail("error in module {0}\n{1}", route, error);
             }
+            await build_go_file.remove();
+            return wrapper(wasm.name);
         });
         return next(app);
     }

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

@@ -1,7 +1,7 @@
 import type RequestFacade from "@primate/core/request/RequestFacade";
 export default function toRequest(request: RequestFacade): Promise<{
     body: {
-        fieldsSync: () => string;
+        formSync: () => string;
         filesSync: () => {
             bytes: Uint8Array;
             field: string;
@@ -9,7 +9,7 @@ export default function toRequest(request: RequestFacade): Promise<{
             size: number;
             type: string;
         }[];
-        type: "fields";
+        type: "form";
     } | {
         textSync: () => string;
         type: "text";

package/lib/private/to-request.js

@@ -1,19 +1,16 @@
-async function bridgeFields(body) {
-    const fields = body.fields();
+async function bridge_form(body) {
     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
+    for (const [k, v] of Object.entries(body.form())) {
+        meta[k] = v;
+    }
+    for (const [k, v] of Object.entries(body.files())) {
         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
+        // precompute bytes so Go can call a SYNC getter
         pending.push(v.arrayBuffer().then(buffer => {
             files.push({
                 bytes: new Uint8Array(buffer),
@@ -27,9 +24,9 @@ async function bridgeFields(body) {
     await Promise.all(pending);
     const jsonStr = JSON.stringify(meta);
     return {
-        fieldsSync: () => jsonStr,
+        formSync: () => jsonStr,
         filesSync: () => files,
-        type: "fields",
+        type: "form",
     };
 }
 async function bridgeBody(body) {
@@ -44,8 +41,8 @@ async function bridgeBody(body) {
             const jsonStr = JSON.stringify(val);
             return { jsonSync: () => jsonStr, type };
         }
-        case "fields": {
-            return await bridgeFields(body);
+        case "form": {
+            return await bridge_form(body);
         }
         case "binary": {
             const blob = body.binary();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@primate/go",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Primate Go backend",
   "homepage": "https://primate.run/docs/backend/go",
   "bugs": "https://github.com/primate-run/primate/issues",
@@ -23,10 +23,10 @@
     "@rcompat/runtime": "^0.6.0",
     "@rcompat/stdio": "^0.12.2",
     "@rcompat/string": "^0.10.0",
-    "@primate/core": "^0.2.0"
+    "@primate/core": "^0.3.0"
   },
   "peerDependencies": {
-    "primate": "^0.33.0"
+    "primate": "^0.34.0"
   },
   "type": "module",
   "imports": {