@primate/go 0.4.0 → 0.5.0

package/lib/private/Default.js

@@ -5,12 +5,11 @@ import fail from "@primate/core/fail";
 import log from "@primate/core/log";
 import assert from "@rcompat/assert";
 import user from "@rcompat/env/user";
-import execute from "@rcompat/stdio/execute";
-import which from "@rcompat/stdio/which";
-const COMMAND = await which("go");
+import io from "@rcompat/io";
+const COMMAND = await io.which("go");
 const ENV = {
     GOARCH: "wasm",
-    GOCACHE: (await execute(`${COMMAND} env GOCACHE`, {})).replaceAll("\n", ""),
+    GOCACHE: (await io.run(`${COMMAND} env GOCACHE`, {})).replaceAll("\n", ""),
     GOOS: "js",
     HOME: user.HOME,
 };
@@ -30,7 +29,7 @@ function postlude(code, route_id) {
 }
 async function check_version() {
     try {
-        const version = await execute(`go list -m -f '{{.Version}}' ${REPO}`);
+        const version = await io.run(`go list -m -f '{{.Version}}' ${REPO}`);
         const trimmed = version.trim();
         const version_match = trimmed.match(/^v?(\d+)\.(\d+)\.(\d+)/);
         if (!version_match)
@@ -51,18 +50,18 @@ export default class Default extends Runtime {
     async build(app, next) {
         await check_version();
         app.bind(this.fileExtension, async (route, { context }) => {
-            assert(context === "routes", "go: only route files are supported");
+            assert.true(context === "routes", "go: only route files are supported");
             const relative = route.debase(app.path.routes);
             const route_id = relative.path.slice(1, -relative.extension.length);
             // create a temporary .go file in the build directory for compilation
             // this is necessary because `go build` requires an actual file on disk
             const build_go_file = app.runpath("wasm", `${route_id}.go`);
-            await build_go_file.directory.create({ recursive: true });
+            await build_go_file.directory.create();
             await build_go_file.write(postlude(await route.text(), route_id));
             const wasm = app.runpath("wasm", `${route_id}.wasm`);
             try {
                 log.info("compiling {0} to WebAssembly", route);
-                await execute(run(wasm, build_go_file), {
+                await io.run(run(wasm, build_go_file), {
                     cwd: build_go_file.directory.path,
                     env: ENV,
                 });
@@ -74,7 +73,9 @@ export default class Default extends Runtime {
             return `
         import wrapper from "@primate/go/wrapper";
         import bytes from "app:wasm/${route_id}.wasm" with { type: "bytes" };
-        await wrapper(bytes, ${JSON.stringify(route_id)});
+        import i18n from "app:config:i18n";
+        import session from "app:config:session";
+        await wrapper(bytes, ${JSON.stringify(route_id)}, { i18n, session });
       `;
         });
         return next(app);

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

@@ -1,4 +1,4 @@
-import type RequestFacade from "@primate/core/request/RequestFacade";
+import type { RequestFacade } from "@primate/core/request";
 export default function toRequest(request: RequestFacade): Promise<{
     body: {
         formSync: () => string;

package/lib/private/to-request.js

@@ -10,7 +10,7 @@ async function bridge_form(body) {
         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),

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

@@ -1,4 +1,4 @@
-import type ResponseLike from "@primate/core/response/ResponseLike";
+import { type ResponseLike } from "@primate/core/response";
 declare const _default: (response: any) => ResponseLike;
 export default _default;
 //# sourceMappingURL=to-response.d.ts.map

package/lib/private/to-response.js

@@ -1,6 +1,5 @@
-import error from "@primate/core/response/error";
-import redirect from "@primate/core/response/redirect";
-import view from "@primate/core/response/view";
+import response from "@primate/core/response";
+const { error, redirect, view } = response;
 const handlers = { error, redirect, view };
 const is_handler = (handler) => typeof handler === "string" && Object.keys(handlers).includes(handler);
 export default (response) => {

package/lib/private/wrapper.d.ts

@@ -6,7 +6,11 @@ declare global {
         };
     };
     var PRMT_SESSION: any;
+    var PRMT_I18N: any;
     var __primate_go_initialized: Set<string> | undefined;
 }
-export default function wrapper(bytes: Uint8Array, routeId: string): Promise<void>;
+export default function wrapper(bytes: Uint8Array, route_id: string, context: {
+    i18n?: any;
+    session?: any;
+}): Promise<void>;
 //# sourceMappingURL=wrapper.d.ts.map

package/lib/private/wrapper.js

@@ -1,24 +1,38 @@
 import env from "@primate/go/env";
 import toRequest from "@primate/go/to-request";
 import to_response from "@primate/go/to-response";
-import session from "primate/config/session";
 import route from "primate/route";
-export default async function wrapper(bytes, routeId) {
+export default async function wrapper(bytes, route_id, context) {
     if (!globalThis.__primate_go_initialized) {
         globalThis.__primate_go_initialized = new Set();
     }
-    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(); },
-    };
+    if (context.session !== undefined) {
+        const session = context.session;
+        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(); },
+        };
+    }
+    if (context.i18n !== undefined) {
+        const i18n = context.i18n;
+        globalThis.PRMT_I18N = {
+            get locale() { return i18n.locale.get(); },
+            t(key, params) {
+                if (!params)
+                    return i18n(key);
+                return i18n(key, JSON.parse(params));
+            },
+            set(locale) { i18n.locale.set(locale); },
+        };
+    }
     env();
-    const safe_route_id = routeId.replace(/\//g, "_");
+    const safe_route_id = route_id.replace(/\//g, "_");
     const registry_name = `__primate_go_registry_${safe_route_id}`;
     const call_go = `__primate_call_go_${safe_route_id}`;
     delete globalThis[registry_name];
@@ -30,7 +44,7 @@ export default async function wrapper(bytes, routeId) {
         const go = new globalThis.Go();
         WebAssembly.instantiate(bytes, go.importObject).then(result => {
             go.run(result.instance).catch(err => {
-                console.error("Go runtime error:", routeId, err);
+                console.error("Go runtime error:", route_id, err);
             });
         });
     });
@@ -47,6 +61,6 @@ export default async function wrapper(bytes, routeId) {
             return to_response(response);
         });
     }
-    globalThis.__primate_go_initialized.add(routeId);
+    globalThis.__primate_go_initialized.add(route_id);
 }
 //# sourceMappingURL=wrapper.js.map

package/package.json

@@ -1,34 +1,34 @@
 {
   "name": "@primate/go",
-  "version": "0.4.0",
-  "description": "Primate Go backend",
+  "version": "0.5.0",
+  "description": "Go backend for Primate",
   "homepage": "https://primate.run/docs/backend/go",
   "bugs": "https://github.com/primate-run/primate/issues",
+  "type": "module",
   "license": "MIT",
-  "files": [
-    "/lib/**/*.js",
-    "/lib/**/*.d.ts",
-    "!/**/*.spec.*"
-  ],
   "repository": {
     "type": "git",
     "url": "https://github.com/primate-run/primate",
     "directory": "packages/go"
   },
+  "files": [
+    "/lib/**/*.js",
+    "/lib/**/*.d.ts",
+    "!/**/*.spec.*"
+  ],
   "dependencies": {
-    "@rcompat/assert": "^0.3.1",
-    "@rcompat/cli": "^0.11.3",
-    "@rcompat/env": "^0.9.2",
-    "@rcompat/fs": "^0.22.3",
-    "@rcompat/runtime": "^0.6.0",
-    "@rcompat/stdio": "^0.12.2",
-    "@rcompat/string": "^0.10.0",
-    "@primate/core": "^0.4.0"
+    "@rcompat/assert": "^0.6.0",
+    "@rcompat/env": "^0.13.0",
+    "@rcompat/fs": "^0.25.2",
+    "@rcompat/io": "^0.3.0",
+    "@primate/core": "^0.5.0"
+  },
+  "devDependencies": {
+    "@rcompat/type": "^0.9.0"
   },
   "peerDependencies": {
-    "primate": "^0.35.0"
+    "primate": "^0.36.0"
   },
-  "type": "module",
   "imports": {
     "#*": {
       "apekit": "./src/private/*.ts",