@primate/go 0.5.0 → 0.6.0

package/lib/private/default.d.ts

@@ -0,0 +1,4 @@
+import type { Input } from "#module";
+import type { Module } from "@primate/core";
+export default function default_module(input?: Input): Module;
+//# sourceMappingURL=default.d.ts.map

package/lib/private/default.js

@@ -0,0 +1,90 @@
+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";
+import { CodeError } from "@rcompat/error";
+import io from "@rcompat/io";
+const COMMAND = await io.which("go");
+const ENV = {
+    GOARCH: "wasm",
+    GOCACHE: (await io.run(`${COMMAND} env GOCACHE`, {})).replaceAll("\n", ""),
+    GOOS: "js",
+    HOME: env.get("HOME"),
+};
+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) {
+    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("${route_id}")
+    select{}
+}`;
+}
+async function check_version() {
+    try {
+        const version = (await io.run(`go list -m -f '{{.Version}}' ${REPO}`)).trim();
+        const version_match = version.match(/^v?(\d+)\.(\d+)\.(\d+)/);
+        if (version_match == null)
+            throw E.invalid_version_format(version);
+        const [, major, minor] = version_match.map(Number);
+        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);
+    }
+    catch (error) {
+        if (CodeError.is(error))
+            throw error;
+        const command = `go get ${REPO}@v${server.TAG}.0`;
+        throw E.dependency_not_found(REPO, command);
+    }
+}
+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 });
+`;
+}
+export default function default_module(input = {}) {
+    const { extension = module.extension } = module.schema.parse(input);
+    return {
+        name: module.name,
+        setup({ onBuild }) {
+            onBuild(async (app) => {
+                await check_version();
+                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 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,
+                            env: ENV,
+                        });
+                    }
+                    catch (error) {
+                        throw E.backend_error(route, error);
+                    }
+                    await build_go_file.remove();
+                    return wrap(route_id);
+                });
+            });
+        },
+    };
+}
+//# sourceMappingURL=default.js.map

package/lib/private/errors.d.ts

@@ -0,0 +1,17 @@
+import type { FileRef } from "@rcompat/fs";
+declare function backend_error(route: FileRef, cause: Error): import("@rcompat/error").TemplateError;
+declare function only_route_files(): import("@rcompat/error").TemplateError;
+declare function invalid_version_format(format: string): import("@rcompat/error").TemplateError;
+declare function version_not_in_range(version: string, tag: string): import("@rcompat/error").TemplateError;
+declare function dependency_not_found(dependency: string, command: string): import("@rcompat/error").TemplateError;
+declare const errors: {
+    backend_error: typeof backend_error;
+    only_route_files: typeof only_route_files;
+    invalid_version_format: typeof invalid_version_format;
+    version_not_in_range: typeof version_not_in_range;
+    dependency_not_found: typeof 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

@@ -0,0 +1,27 @@
+import error from "@rcompat/error";
+const t = error.template;
+function backend_error(route, cause) {
+    return t `error in module ${route.path}\n${cause}`;
+}
+function only_route_files() {
+    return t `go: only route files are supported`;
+}
+function invalid_version_format(format) {
+    return t `invalid version format: ${format}`;
+}
+function version_not_in_range(version, tag) {
+    return t `installed version ${version} not in range ${tag}`;
+}
+function dependency_not_found(dependency, command) {
+    return t `${dependency} dependency not found - run ${command}`;
+}
+const errors = error.coded({
+    backend_error,
+    only_route_files,
+    invalid_version_format,
+    version_not_in_range,
+    dependency_not_found,
+});
+export const Code = Object.fromEntries(Object.keys(errors).map(k => [k, k]));
+export default errors;
+//# sourceMappingURL=errors.js.map

package/lib/private/module.d.ts

@@ -0,0 +1,13 @@
+declare const module: {
+    schema: import("pema").ObjectType<import("pema").NormalizeSchemaObject<{
+        readonly extension: import("pema").OptionalType<import("pema").StringType>;
+    }>, {
+        extension: string | undefined;
+    }>;
+    name: string;
+    extension: string;
+};
+type Input = typeof module.schema.input;
+export type { Input };
+export default module;
+//# sourceMappingURL=module.d.ts.map

package/lib/private/module.js

@@ -0,0 +1,11 @@
+import p from "pema";
+const schema = p({
+    extension: p.string.optional(),
+});
+const module = {
+    schema,
+    name: "go",
+    extension: ".go",
+};
+export default module;
+//# sourceMappingURL=module.js.map

package/lib/private/runtime.d.ts

@@ -0,0 +1,4 @@
+import type { Input } from "#module";
+import type { Module } from "@primate/core";
+export default function runtime_module(input?: Input): Module;
+//# sourceMappingURL=runtime.d.ts.map

package/lib/private/runtime.js

@@ -0,0 +1,10 @@
+import module from "#module";
+export default function runtime_module(input = {}) {
+    const options = module.schema.parse(input);
+    void options;
+    return {
+        name: module.name,
+        setup() { },
+    };
+}
+//# sourceMappingURL=runtime.js.map

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

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

package/lib/public/default.d.ts

@@ -1,4 +1,2 @@
-import Default from "#Default";
-declare const _default: (options?: typeof Default.input) => Default;
-export default _default;
+export { default } from "#default";
 //# sourceMappingURL=default.d.ts.map

package/lib/public/default.js

@@ -1,3 +1,2 @@
-import Default from "#Default";
-export default (options) => new Default(options);
+export { default } from "#default";
 //# sourceMappingURL=default.js.map

package/lib/public/runtime.d.ts

@@ -1,4 +1,2 @@
-import Runtime from "#Runtime";
-declare const _default: (options?: typeof Runtime.input) => Runtime;
-export default _default;
+export { default } from "#runtime";
 //# sourceMappingURL=runtime.d.ts.map

package/lib/public/runtime.js

@@ -1,3 +1,2 @@
-import Runtime from "#Runtime";
-export default (options) => new Runtime(options);
+export { default } from "#runtime";
 //# sourceMappingURL=runtime.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@primate/go",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Go backend for Primate",
   "homepage": "https://primate.run/docs/backend/go",
   "bugs": "https://github.com/primate-run/primate/issues",
@@ -17,37 +17,41 @@
     "!/**/*.spec.*"
   ],
   "dependencies": {
-    "@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"
+    "@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"
   },
   "devDependencies": {
-    "@rcompat/type": "^0.9.0"
+    "@rcompat/type": "^0.11.1"
   },
   "peerDependencies": {
-    "primate": "^0.36.0"
+    "primate": "^0.37.0"
   },
   "imports": {
     "#*": {
-      "apekit": "./src/private/*.ts",
+      "@primate/source": "./src/private/*.ts",
       "default": "./lib/private/*.js"
     }
   },
   "exports": {
     ".": {
+      "@rcompat/source": "./src/public/default.ts",
       "runtime": "./lib/public/runtime.js",
       "default": "./lib/public/default.js"
     },
     "./*": {
-      "apekit": "./src/public/*.ts",
+      "@primate/source": "./src/public/*.ts",
       "default": "./lib/public/*.js"
     }
   },
   "scripts": {
     "build": "npm run clean && tsc",
     "clean": "rm -rf ./lib",
-    "lint": "eslint ."
+    "lint": "eslint .",
+    "test": "npx proby"
   }
 }

package/lib/private/Default.d.ts

@@ -1,7 +0,0 @@
-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): Promise<BuildApp>;
-}
-//# sourceMappingURL=Default.d.ts.map

package/lib/private/Default.js

@@ -1,84 +0,0 @@
-import Runtime from "#Runtime";
-import AppError from "@primate/core/AppError";
-import TAG from "@primate/core/backend/TAG";
-import fail from "@primate/core/fail";
-import log from "@primate/core/log";
-import assert from "@rcompat/assert";
-import user from "@rcompat/env/user";
-import io from "@rcompat/io";
-const COMMAND = await io.which("go");
-const ENV = {
-    GOARCH: "wasm",
-    GOCACHE: (await io.run(`${COMMAND} env GOCACHE`, {})).replaceAll("\n", ""),
-    GOOS: "js",
-    HOME: user.HOME,
-};
-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 postlude(code, route_id) {
-    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("${route_id}")
-        select{}
-    }`;
-}
-async function check_version() {
-    try {
-        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)
-            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);
-        }
-        log.info("using {0} package v{1}.{2}.x", REPO, major, minor);
-    }
-    catch (error) {
-        if (error instanceof AppError)
-            throw error;
-        throw fail("{0} dependency not found - run 'go get {0}@v{1}.0'", REPO, TAG);
-    }
-}
-export default class Default extends Runtime {
-    async build(app, next) {
-        await check_version();
-        app.bind(this.fileExtension, async (route, { context }) => {
-            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();
-            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 io.run(run(wasm, build_go_file), {
-                    cwd: build_go_file.directory.path,
-                    env: ENV,
-                });
-            }
-            catch (error) {
-                throw fail("error in module {0}\n{1}", route, error);
-            }
-            await build_go_file.remove();
-            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 });
-      `;
-        });
-        return next(app);
-    }
-}
-//# sourceMappingURL=Default.js.map

package/lib/private/Runtime.d.ts

@@ -1,6 +0,0 @@
-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

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