@primate/python 0.6.0 → 0.8.0

package/lib/private/default.js

@@ -1,36 +1,55 @@
 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 fs from "@rcompat/fs";
 import io from "@rcompat/io";
 const PACKAGE = "primate-run";
 const [MAJOR, MINOR] = server.TAG.split(".").map(Number);
-async function show_package() {
-    const str0 = () => "";
-    let out = await io.run(`pip show ${PACKAGE} 2>/dev/null`).catch(str0);
-    if (out.trim().length > 0)
+async function show_package(app) {
+    function run(command) {
+        return io.run(command, { cwd: app.root.path })
+            .then(out => out.trim())
+            .catch(() => "");
+    }
+    let out = await run(`pip show ${PACKAGE} 2>/dev/null`);
+    if (out.length > 0)
         return out;
-    out = await io.run(`uv pip show ${PACKAGE} 2>/dev/null`).catch(str0);
-    if (out.trim().length > 0)
+    out = await run(`uv pip show ${PACKAGE} 2>/dev/null`);
+    if (out.length > 0)
         return out;
-    out = await io.run(`python -m pip show ${PACKAGE} 2>/dev/null`).catch(str0);
-    if (out.trim().length > 0)
+    out = await run(`python -m pip show ${PACKAGE} 2>/dev/null`);
+    if (out.length > 0)
         return out;
     return null;
 }
-async function check_version() {
-    const output = await show_package();
+async function check_version(app) {
+    const output = await show_package(app);
     if (output === null)
-        throw E.package_not_found();
+        throw E.pkg_not_found();
     const version_match = output.match(/Version:\s*(\d+)\.(\d+)\.(\d+)/);
     if (version_match === null)
-        throw E.package_not_found();
+        throw E.pkg_not_found();
     const [major, minor] = version_match.slice(1).map(Number);
     if (major !== MAJOR || minor !== MINOR)
-        throw E.package_mismatch(major, minor);
-    log.info("using {0} package {1}.{2}.x", PACKAGE, major, minor);
+        throw E.pkg_mismatch(major, minor);
+    app.log.info `using ${PACKAGE} package ${major}.${minor}.x`;
+}
+function wrap(source, id, packages_str, primate_run) {
+    return `
+    import route from "primate/route";
+    import wrapper from "@primate/python/wrapper";
+    import app from "$:app";
+    import session from "app:config:session";
+    const handlers = await wrapper(
+      ${JSON.stringify(source)},
+      ${packages_str},
+      ${JSON.stringify(primate_run)},
+      ${JSON.stringify(id)},
+      { i18n: app.i18n, session }
+    );
+    export default route(handlers);
+  `;
 }
 export default function default_module(input = {}) {
     const { extension = module.extension } = module.schema.parse(input);
@@ -38,7 +57,7 @@ export default function default_module(input = {}) {
         name: module.name,
         setup({ onBuild }) {
             onBuild(async (app) => {
-                await check_version();
+                await check_version(app);
                 const requirements_txt = app.root.join("requirements.txt");
                 let packages = [];
                 if (await requirements_txt.exists()) {
@@ -53,18 +72,7 @@ export default function default_module(input = {}) {
                     assert.true(context === "routes", E.only_route_files());
                     const relative = file.debase(app.path.routes).path.replace(/^\//, "");
                     const source = await file.text();
-                    return `
-        import wrapper from "@primate/python/wrapper";
-        import i18n from "app:config:i18n";
-        import session from "app:config:session";
-        await wrapper(
-          ${JSON.stringify(source)},
-          ${packages_str},
-          "${PACKAGE}~=${server.TAG}.0",
-          "${relative}",
-          { i18n, session }
-        );
-      `;
+                    return wrap(source, relative, packages_str, `${PACKAGE}~=${server.TAG}.0`);
                 });
             });
         },

package/lib/private/errors.d.ts

@@ -1,10 +1,10 @@
 declare function only_route_files(): import("@rcompat/error").TemplateError;
-declare function package_not_found(): import("@rcompat/error").TemplateError;
-declare function package_mismatch(major: number, minor: number): import("@rcompat/error").TemplateError;
+declare function pkg_not_found(): import("@rcompat/error").TemplateError;
+declare function pkg_mismatch(major: number, minor: number): import("@rcompat/error").TemplateError;
 declare const errors: {
     only_route_files: typeof only_route_files;
-    package_not_found: typeof package_not_found;
-    package_mismatch: typeof package_mismatch;
+    pkg_not_found: typeof pkg_not_found;
+    pkg_mismatch: typeof pkg_mismatch;
 };
 export type Code = keyof typeof errors;
 export declare const Code: { [K in Code]: K; };

package/lib/private/errors.js

@@ -5,19 +5,19 @@ const t = error.template;
 function only_route_files() {
     return t `python: only route files are supported`;
 }
-function package_not_found() {
+function pkg_not_found() {
     const command = `pip install ${PACKAGE}~=${server.TAG}.0`;
     return t `package not found, run ${command}`;
 }
-function package_mismatch(major, minor) {
+function pkg_mismatch(major, minor) {
     const range = `~> ${server.TAG}.x`;
     const version = `${major}.${minor}.x`;
     return t `${PACKAGE} package version ${version} not in range ${range}`;
 }
 const errors = error.coded({
     only_route_files,
-    package_not_found,
-    package_mismatch,
+    pkg_not_found,
+    pkg_mismatch,
 });
 export const Code = Object.fromEntries(Object.keys(errors).map(k => [k, k]));
 export default errors;

package/lib/private/handler-property.d.ts

@@ -1,3 +1,3 @@
-declare const _default: "__PRMT__";
+declare const _default = "__PRMT__";
 export default _default;
 //# sourceMappingURL=handler-property.d.ts.map

package/lib/private/helpers.d.ts

@@ -1,5 +1,5 @@
 declare const _default: {
-    type(value: unknown): "string" | "boolean" | "array" | "object" | "integer" | "float" | "nil" | undefined;
+    type(value: unknown): "array" | "boolean" | "float" | "integer" | "nil" | "object" | "string" | undefined;
 };
 export default _default;
 //# sourceMappingURL=helpers.d.ts.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,4 +1,4 @@
-import type { RequestFacade } from "@primate/core";
+import type { RequestContentType, RequestFacade } from "@primate/core";
 import type { Dict } from "@rcompat/type";
 type FileEntry = {
     bytes: Uint8Array;
@@ -7,35 +7,33 @@ type FileEntry = {
     size: number;
     type: string;
 };
-export default function to_request(request: RequestFacade): Promise<{
-    url: {
-        href: string;
-        origin: string;
-        protocol: string;
-        username: string;
-        password: string;
-        host: string;
-        hostname: string;
-        port: string;
-        pathname: string;
-        search: string;
-        hash: string;
-    };
-    body: {
-        text: () => string;
-        json: () => string;
-        form: () => Dict<string>;
-        files: () => FileEntry[];
-        binary: () => {
-            buffer: Uint8Array<ArrayBuffer>;
-            mime: string;
-        };
-        none: () => null;
-    };
-    path: Dict;
-    query: Dict;
-    headers: Dict;
-    cookies: Dict;
+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 to_request(request: RequestFacade, contentType: RequestContentType | ""): Promise<{
+    url: URL;
+    body: BridgedBody;
+    path: Dict<string>;
+    query: Dict<string>;
+    headers: Dict<string>;
+    cookies: Dict<string>;
 }>;
 export {};
 //# sourceMappingURL=to-request.d.ts.map

package/lib/private/to-request.js

@@ -1,25 +1,45 @@
-function plainUrl(u) {
-    return {
-        href: u.href,
-        origin: u.origin,
-        protocol: u.protocol,
-        username: u.username,
-        password: u.password,
-        host: u.host,
-        hostname: u.hostname,
-        port: u.port,
-        pathname: u.pathname,
-        search: u.search,
-        hash: u.hash,
-    };
+async function bridge_body(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 "application/x-www-form-urlencoded": {
+            const form = await body.form();
+            return { type: "form", formSync: () => JSON.stringify(form) };
+        }
+        case "multipart/form-data": {
+            const { form, files } = await body.multipart();
+            const pending = [];
+            const bridgedFiles = [];
+            for (const [field, file] of Object.entries(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(form), filesSync: () => bridgedFiles };
+        }
+        case "application/octet-stream": {
+            const blob = await body.blob();
+            const buf = new Uint8Array(await blob.arrayBuffer());
+            return { type: "blob", blobSync: () => buf, blobTypeSync: () => blob.type || "application/octet-stream" };
+        }
+        default:
+            return { type: "none" };
+    }
 }
-function toDict(obj) {
+function to_dict(obj) {
     const out = Object.create(null);
     if (obj instanceof URLSearchParams) {
-        obj.forEach((v, k) => {
-            if (!(k in out))
-                out[k] = v ?? "";
-        });
+        obj.forEach((v, k) => { out[k] = v; });
     }
     else {
         for (const [k, v] of Object.entries(obj)) {
@@ -28,71 +48,15 @@ function toDict(obj) {
     }
     return out;
 }
-async function bridge_form(body) {
-    const form = Object.create(null);
-    const files = [];
-    const pending = [];
-    for (const [k, v] of Object.entries(body.form())) {
-        form[k] = v;
-    }
-    for (const [k, v] of Object.entries(body.files())) {
-        const name = v.name;
-        const type = v.type;
-        const size = v.size;
-        pending.push(v.arrayBuffer().then(buffer => {
-            files.push({
-                bytes: new Uint8Array(buffer),
-                field: k,
-                name,
-                size,
-                type,
-            });
-        }));
-    }
-    await Promise.all(pending);
-    return {
-        form: () => form,
-        files: () => files,
-    };
-}
-async function bridgeBody(body) {
-    let form, buffer, blob;
-    if (body.type === "form") {
-        form = await bridge_form(body);
-    }
-    if (body.type === "binary") {
-        blob = body.binary();
-        buffer = new Uint8Array(await blob.arrayBuffer());
-    }
-    return {
-        text: () => body.text(),
-        json: () => {
-            return JSON.stringify(body.json());
-        },
-        form: () => form.form(),
-        files: () => form.files(),
-        binary: () => {
-            const mime = blob.type || "application/octet-stream";
-            return {
-                buffer,
-                mime,
-            };
-        },
-        none: () => null,
-    };
-}
-export default async function to_request(request) {
-    const body = await bridgeBody(request.body);
-    const cookies = toDict(request.cookies.toJSON());
-    const headers = toDict(request.headers.toJSON());
-    const path = toDict(request.path.toJSON());
-    const query = toDict(request.query.toJSON());
-    const u = request.url;
-    const url = plainUrl(new URL(String(u)));
+export default async function to_request(request, contentType) {
+    const body = await bridge_body(request.body, contentType);
     return {
-        url,
+        url: request.url,
         body,
-        path, query, headers, cookies,
+        path: request.path.toJSON(),
+        query: request.query.toJSON(),
+        headers: request.headers.toJSON(),
+        cookies: request.cookies.toJSON(),
     };
 }
 //# sourceMappingURL=to-request.js.map

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

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

package/lib/private/to-response.js

@@ -1,26 +1,33 @@
 import HANDLER_PROPERTY from "#handler-property";
 import unwrap from "#unwrap";
 import response from "@primate/core/response";
+import is from "@rcompat/is";
 const { error, redirect, view } = response;
 const handlers = { error, redirect, view };
-const handle_handler = (handler, response) => {
+const handle_handler = (handler, args) => {
     if (handler === "view") {
-        const { name, options, props } = response;
+        const { name, options, props } = args;
         return view(name, props, 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);
 };
-const is_handler = (handler) => typeof handler === "string" && Object.keys(handlers).includes(handler);
-export default (response) => {
-    const unwrapped = unwrap(response);
+function is_handler(x) {
+    return is.string(x) && Object.keys(handlers).includes(x);
+}
+function to_response(args) {
+    if (is.undefined(args))
+        return null;
+    const unwrapped = unwrap(args);
     const handler = unwrapped[HANDLER_PROPERTY];
     return is_handler(handler)
         ? handle_handler(handler, unwrapped)
         : unwrapped;
-};
+}
+;
+export default to_response;
 //# sourceMappingURL=to-response.js.map

package/lib/private/unwrap.d.ts

@@ -1,5 +1,4 @@
+import type { Dict } from "@rcompat/type";
 import type { PyProxy } from "pyodide/ffi";
-export default function unwrap(response: PyProxy): {
-    [k: string]: unknown;
-};
+export default function unwrap(response: PyProxy): Dict;
 //# sourceMappingURL=unwrap.d.ts.map

package/lib/private/wrapper.d.ts

@@ -1,5 +1,5 @@
 export default function wrapper(source: string, packages: string[], primate_run: string, 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

@@ -3,7 +3,6 @@ import helpers from "@primate/python/helpers";
 import pyodide from "@primate/python/pyodide";
 import to_request from "@primate/python/to-request";
 import to_response from "@primate/python/to-response";
-import route from "primate/route";
 const messageCallback = () => { };
 let _micropip = null;
 const installed = new Set();
@@ -48,6 +47,16 @@ function wrap_i18n(i18n) {
         set(locale) { i18n.locale.set(locale); },
     };
 }
+async function get_entries(python, route_id) {
+    const result = python.runPython(`
+    [{"verb": verb, "content_type": entry["content_type"] or ""}
+     for verb, entry in Route.registry(${JSON.stringify(route_id)}).items()]
+  `).toJs({ dict_converter: Object.fromEntries });
+    return result.map((e) => ({
+        verb: String(e.verb),
+        content_type: String(e.content_type),
+    }));
+}
 export default async function wrapper(source, packages, primate_run, id, context = {}) {
     const python = await pyodide();
     const micropip = await load_micropip(python);
@@ -62,24 +71,23 @@ export default async function wrapper(source, packages, primate_run, id, context
     Route.scope(${route_id})
   `);
     await python.runPython(source);
-    const verbs = python.runPython(`
-    from primate import Route
-    list(Route.registry(${route_id}).keys())
-  `).toJs();
+    const entries = await get_entries(python, id);
     const wrapped_session = wrap_session(context.session);
     const wrapped_i18n = wrap_i18n(context.i18n);
-    for (const verb of verbs) {
-        route[verb.toLowerCase()](async (request) => {
-            python.globals.set("js_req", await to_request(request));
+    return Object.fromEntries(entries.map(({ verb, content_type }) => [
+        verb.toLowerCase(),
+        async (request) => {
+            const jsReq = await to_request(request, content_type);
+            python.globals.set("js_req", jsReq);
             python.globals.set("helpers_obj", helpers);
             python.globals.set("session_obj", wrapped_session);
             python.globals.set("i18n_obj", wrapped_i18n);
             const verb_str = JSON.stringify(verb);
             try {
                 const result = await python.runPythonAsync(`
-          from primate import Route
-          await Route.call_js(${route_id}, ${verb_str}, js_req, helpers_obj, session_obj, i18n_obj)
-        `);
+            from primate import Route
+            await Route.call_js(${route_id}, ${verb_str}, js_req, helpers_obj, session_obj, i18n_obj)
+          `);
                 return to_response(result);
             }
             catch (e) {
@@ -92,7 +100,7 @@ export default async function wrapper(source, packages, primate_run, id, context
                 python.globals.delete("session_obj");
                 python.globals.delete("i18n_obj");
             }
-        });
-    }
+        },
+    ]));
 }
 //# sourceMappingURL=wrapper.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@primate/python",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "description": "Python backend for Primate",
   "homepage": "https://primate.run/docs/backend/python",
   "bugs": "https://github.com/primate-run/primate/issues",
@@ -17,19 +17,20 @@
     "!/**/*.spec.*"
   ],
   "dependencies": {
-    "@rcompat/assert": "^0.8.1",
-    "@rcompat/error": "^0.3.1",
-    "@rcompat/fs": "^0.28.1",
-    "@rcompat/io": "^0.5.1",
-    "pyodide": "^0.29.3",
-    "@primate/core": "^0.6.0",
-    "pema": "^0.6.0"
+    "@rcompat/assert": "^0.13.0",
+    "@rcompat/error": "^0.8.0",
+    "@rcompat/fs": "^0.33.2",
+    "@rcompat/io": "^0.10.0",
+    "@rcompat/is": "^0.11.0",
+    "pyodide": "^0.29.4",
+    "pema": "^0.8.0",
+    "@primate/core": "^0.8.0"
   },
   "devDependencies": {
-    "@rcompat/type": "^0.11.1"
+    "@rcompat/type": "^0.17.0"
   },
   "peerDependencies": {
-    "primate": "^0.37.0"
+    "primate": "^0.39.0"
   },
   "imports": {
     "#*": {
@@ -48,9 +49,8 @@
     }
   },
   "scripts": {
-    "build": "npm run clean && tsc",
+    "build": "npm run clean && tsgo",
     "clean": "rm -rf ./lib",
-    "lint": "eslint .",
-    "test": "npx proby"
+    "lint": "eslint ."
   }
 }