@primate/go 0.6.0 → 0.8.0

package/lib/private/default.js

@@ -1,6 +1,5 @@
 import E from "#errors";
 import module from "#module";
-import log from "@primate/core/log";
 import server from "@primate/core/server";
 import assert from "@rcompat/assert";
 import env from "@rcompat/env";
@@ -15,10 +14,12 @@ const ENV = {
 };
 const REPO = "github.com/primate-run/go";
 const [MAJOR, MINOR] = server.TAG.split(".").map(Number);
-const run = (wasm, go) => `${COMMAND} build -o ${wasm.name} ${go.name}`;
-function postlude(code, route_id) {
+function run(wasm, go) {
+    return `${COMMAND} build -o ${wasm.name} ${go.name}`;
+}
+function postlude(app, code, route_id) {
     if (!code.includes(`${REPO}/route`)) {
-        log.warn("Go file does not import {0} - skipping route registration", REPO);
+        app.log.warn `Go file does not import ${REPO}, skipping route registration`;
         return code;
     }
     return `${code}
@@ -27,9 +28,9 @@ func main() {
     select{}
 }`;
 }
-async function check_version() {
+async function check_version(app) {
     try {
-        const version = (await io.run(`go list -m -f '{{.Version}}' ${REPO}`)).trim();
+        const version = (await io.run(`go list -m -f '{{.Version}}' ${REPO}`, { cwd: app.root.path })).trim();
         const version_match = version.match(/^v?(\d+)\.(\d+)\.(\d+)/);
         if (version_match == null)
             throw E.invalid_version_format(version);
@@ -37,7 +38,7 @@ async function check_version() {
         if (major !== MAJOR || minor !== MINOR) {
             throw E.version_not_in_range(version, server.TAG);
         }
-        log.info("using {0} package v{1}.{2}.x", REPO, major, minor);
+        app.log.info `using ${REPO} package v${major}.${minor}.x`;
     }
     catch (error) {
         if (CodeError.is(error))
@@ -48,12 +49,16 @@ async function check_version() {
 }
 function wrap(route_id) {
     return `
-  import wrapper from "@primate/go/wrapper";
-  import bytes from "app:wasm/${route_id}.wasm" with { type: "bytes" };
-  import i18n from "app:config:i18n";
-  import session from "app:config:session";
-  await wrapper(bytes, ${JSON.stringify(route_id)}, { i18n, session });
-`;
+    import route from "primate/route";
+    import wrapper from "@primate/go/wrapper";
+    import bytes from "app:wasm/${route_id}.wasm" with { type: "bytes" };
+    import app from "$:app";
+    import session from "app:config:session";
+    const handlers = await wrapper(bytes, ${JSON.stringify(route_id)}, {
+      i18n: app.i18n, session,
+    });
+    export default route(handlers);
+  `;
 }
 export default function default_module(input = {}) {
     const { extension = module.extension } = module.schema.parse(input);
@@ -61,26 +66,26 @@ export default function default_module(input = {}) {
         name: module.name,
         setup({ onBuild }) {
             onBuild(async (app) => {
-                await check_version();
+                await check_version(app);
                 app.bind(extension, async (route, { context }) => {
                     assert.true(context === "routes", E.only_route_files());
                     const relative = route.debase(app.path.routes);
                     const route_id = relative.path.slice(1, -relative.extension.length);
-                    const build_go_file = app.runpath("wasm", `${route_id}.go`);
-                    await build_go_file.directory.create();
-                    await build_go_file.write(postlude(await route.text(), route_id));
+                    const build_file = app.runpath("wasm", `${route_id}.go`);
+                    await build_file.directory.create();
+                    await build_file.write(postlude(app, await route.text(), route_id));
                     const wasm = app.runpath("wasm", `${route_id}.wasm`);
                     try {
-                        log.info("compiling {0} to WebAssembly", route);
-                        await io.run(run(wasm, build_go_file), {
-                            cwd: build_go_file.directory.path,
+                        app.log.info `compiling ${(route.debase(app.root))} to WebAssembly`;
+                        await io.run(run(wasm, build_file), {
+                            cwd: build_file.directory.path,
                             env: ENV,
                         });
                     }
                     catch (error) {
                         throw E.backend_error(route, error);
                     }
-                    await build_go_file.remove();
+                    await build_file.remove();
                     return wrap(route_id);
                 });
             });

package/lib/private/errors.d.ts

@@ -11,7 +11,13 @@ declare const errors: {
     version_not_in_range: typeof version_not_in_range;
     dependency_not_found: typeof dependency_not_found;
 };
+export declare const Code: {
+    backend_error: "backend_error";
+    only_route_files: "only_route_files";
+    invalid_version_format: "invalid_version_format";
+    version_not_in_range: "version_not_in_range";
+    dependency_not_found: "dependency_not_found";
+};
 export type Code = keyof typeof errors;
-export declare const Code: { [K in Code]: K; };
 export default errors;
 //# sourceMappingURL=errors.d.ts.map

package/lib/private/errors.js

@@ -22,6 +22,6 @@ const errors = error.coded({
     version_not_in_range,
     dependency_not_found,
 });
-export const Code = Object.fromEntries(Object.keys(errors).map(k => [k, k]));
+export const Code = error.names(errors);
 export default errors;
 //# sourceMappingURL=errors.js.map

package/lib/private/module.d.ts

@@ -1,7 +1,7 @@
 declare const module: {
     schema: import("pema").ObjectType<import("pema").NormalizeSchemaObject<{
         readonly extension: import("pema").OptionalType<import("pema").StringType>;
-    }>, {
+    }>, undefined, {
         extension: string | undefined;
     }>;
     name: string;

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

@@ -1,45 +1,38 @@
-import type { RequestFacade } from "@primate/core";
-export default function toRequest(request: RequestFacade): Promise<{
-    body: {
-        formSync: () => string;
-        filesSync: () => {
-            bytes: Uint8Array;
-            field: string;
-            name: string;
-            size: number;
-            type: string;
-        }[];
-        type: "form";
-    } | {
-        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;
-    };
+import type { RequestContentType, RequestFacade } from "@primate/core";
+type FileEntry = {
+    bytes: Uint8Array;
+    field: string;
+    name: string;
+    size: number;
+    type: string;
+};
+type BridgedBody = {
+    type: "json";
+    jsonSync: () => string;
+} | {
+    type: "text";
+    textSync: () => string;
+} | {
+    type: "form";
+    formSync: () => string;
+} | {
+    type: "multipart";
+    formSync: () => string;
+    filesSync: () => FileEntry[];
+} | {
+    type: "blob";
+    blobSync: () => Uint8Array;
+    blobTypeSync: () => string;
+} | {
+    type: "none";
+};
+export default function toRequest(request: RequestFacade, contentType: RequestContentType | ""): Promise<{
+    body: BridgedBody;
     cookies: string;
     headers: string;
     path: string;
     query: string;
-    searchParams: string;
     url: URL;
 }>;
+export {};
 //# sourceMappingURL=to-request.d.ts.map

package/lib/private/to-request.js

@@ -1,72 +1,57 @@
-async function bridge_form(body) {
-    const meta = Object.create(null);
-    const files = [];
-    const pending = [];
-    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
-        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 {
-        formSync: () => jsonStr,
-        filesSync: () => files,
-        type: "form",
-    };
-}
-async function bridgeBody(body) {
-    const type = body.type;
-    switch (type) {
-        case "text": {
-            const s = body.text();
-            return { textSync: () => s, type };
+import is from "@rcompat/is";
+async function bridgeBody(body, contentType) {
+    switch (contentType) {
+        case "text/plain": {
+            const s = await body.text();
+            return { type: "text", textSync: () => s };
+        }
+        case "application/json": {
+            const val = await body.json();
+            return { type: "json", jsonSync: () => JSON.stringify(val) };
         }
-        case "json": {
-            const val = body.json();
-            const jsonStr = JSON.stringify(val);
-            return { jsonSync: () => jsonStr, type };
+        case "application/x-www-form-urlencoded": {
+            const form = await body.form();
+            return { type: "form", formSync: () => JSON.stringify(form) };
         }
-        case "form": {
-            return await bridge_form(body);
+        case "multipart/form-data": {
+            const result = await body.multipart();
+            const pending = [];
+            const bridgedFiles = [];
+            for (const [field, file] of Object.entries(result.files)) {
+                const name = file.name;
+                const type = file.type;
+                const size = file.size;
+                pending.push(file.arrayBuffer().then(buffer => {
+                    bridgedFiles.push({
+                        bytes: new Uint8Array(buffer),
+                        field,
+                        name,
+                        size,
+                        type,
+                    });
+                }));
+            }
+            await Promise.all(pending);
+            return { type: "multipart", formSync: () => JSON.stringify(result.form), filesSync: () => bridgedFiles };
         }
-        case "binary": {
-            const blob = body.binary();
+        case "application/octet-stream": {
+            const blob = await body.blob();
             const buf = new Uint8Array(await blob.arrayBuffer());
-            const mime = blob.type || "application/octet-stream";
-            return {
-                binarySync: () => buf,
-                binaryTypeSync: () => mime,
-                type,
-            };
+            const mime = is.text(blob.type) ? blob.type : "application/octet-stream";
+            return { type: "blob", blobSync: () => buf, blobTypeSync: () => mime };
         }
         default:
             return { type: "none" };
     }
 }
-export default async function toRequest(request) {
-    const body = await bridgeBody(request.body);
+export default async function toRequest(request, contentType) {
+    const body = await bridgeBody(request.body, contentType);
     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,
     };
 }

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

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

package/lib/private/to-response.js

@@ -1,31 +1,34 @@
 import response from "@primate/core/response";
+import is from "@rcompat/is";
 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) => {
-    if (typeof response === "string") {
+function to_response(args) {
+    if (is.string(args)) {
         try {
-            response = JSON.parse(response);
+            args = JSON.parse(args);
         }
         catch {
-            return response;
+            return args;
         }
     }
-    if (response && typeof response === "object") {
-        const handler = response.handler;
+    if (is.dict(args)) {
+        const handler = args.handler;
         if (is_handler(handler)) {
             if (handler === "view") {
-                const { component, props, options } = response;
+                const { component, props, options } = args;
                 return view(component, props ? JSON.parse(props) : {}, options ? JSON.parse(options) : {});
             }
             if (handler === "redirect") {
-                const { location, status } = response;
+                const { location, status } = args;
                 return redirect(location, status);
             }
-            const { options } = response;
+            const { options } = args;
             return error(options ? JSON.parse(options) : {});
         }
     }
-    return response;
-};
+    return args;
+}
+;
+export default to_response;
 //# sourceMappingURL=to-response.js.map

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

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

package/lib/private/wrapper.d.ts

@@ -12,5 +12,5 @@ declare global {
 export default function wrapper(bytes: Uint8Array, route_id: string, context: {
     i18n?: any;
     session?: any;
-}): Promise<void>;
+}): Promise<Record<string, (request: any) => Promise<any>>>;
 //# sourceMappingURL=wrapper.d.ts.map

package/lib/private/wrapper.js

@@ -1,7 +1,6 @@
 import env from "@primate/go/env";
-import toRequest from "@primate/go/to-request";
+import to_request from "@primate/go/to-request";
 import to_response from "@primate/go/to-response";
-import route from "primate/route";
 export default async function wrapper(bytes, route_id, context) {
     if (!globalThis.__primate_go_initialized) {
         globalThis.__primate_go_initialized = new Set();
@@ -50,17 +49,18 @@ export default async function wrapper(bytes, route_id, context) {
     });
     const registry_fn = globalThis[registry_name];
     const registry = registry_fn();
-    const verbs = registry?.length
-        ? Array.from({ length: registry.length }, (_, i) => registry[i])
+    const routes = registry?.length
+        ? Array.from({ length: registry.length }, (_, i) => ({
+            verb: registry[i].verb,
+            contentType: registry[i].contentType,
+        }))
         : [];
-    for (const verb of verbs) {
-        route[verb.toLowerCase()](async (request) => {
-            const requested = await toRequest(request);
+    globalThis.__primate_go_initialized.add(route_id);
+    return Object.fromEntries(routes.map(({ verb, contentType }) => [verb.toLowerCase(), async (request) => {
+            const requested = await to_request(request, contentType);
             const callFn = globalThis[call_go];
             const response = callFn(verb, requested);
             return to_response(response);
-        });
-    }
-    globalThis.__primate_go_initialized.add(route_id);
+        }]));
 }
 //# sourceMappingURL=wrapper.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@primate/go",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "description": "Go backend for Primate",
   "homepage": "https://primate.run/docs/backend/go",
   "bugs": "https://github.com/primate-run/primate/issues",
@@ -17,21 +17,23 @@
     "!/**/*.spec.*"
   ],
   "dependencies": {
-    "@rcompat/assert": "^0.8.1",
-    "@rcompat/env": "^0.17.2",
-    "@rcompat/error": "^0.3.1",
-    "@rcompat/fs": "^0.28.1",
-    "@rcompat/io": "^0.5.1",
-    "@primate/core": "^0.6.0",
-    "pema": "^0.6.0"
+    "@rcompat/assert": "^0.13.0",
+    "@rcompat/env": "^0.22.2",
+    "@rcompat/error": "^0.8.0",
+    "@rcompat/fs": "^0.33.2",
+    "@rcompat/io": "^0.10.0",
+    "@rcompat/is": "^0.11.0",
+    "@primate/core": "^0.8.0",
+    "pema": "^0.8.0"
   },
   "devDependencies": {
-    "@rcompat/type": "^0.11.1"
+    "@rcompat/type": "^0.17.0"
   },
   "peerDependencies": {
-    "primate": "^0.37.0"
+    "primate": "^0.39.0"
   },
   "imports": {
+    "#vendored/wasm_exec": "./src/private/vendored/wasm_exec.js",
     "#*": {
       "@primate/source": "./src/private/*.ts",
       "default": "./lib/private/*.js"
@@ -49,9 +51,8 @@
     }
   },
   "scripts": {
-    "build": "npm run clean && tsc",
+    "build": "npm run clean && tsgo",
     "clean": "rm -rf ./lib",
-    "lint": "eslint .",
-    "test": "npx proby"
+    "lint": "eslint ."
   }
 }