@primate/python 0.1.0

package/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) Terrablue <terrablue@proton.me> and contributors.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@primate/python",
+  "version": "0.1.0",
+  "description": "Primate Python backend",
+  "homepage": "https://primatejs.com/modules/python",
+  "bugs": "https://github.com/primatejs/primate/issues",
+  "license": "MIT",
+  "files": [
+    "src/**/*.js",
+    "!src/**/*.spec.js"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/primatejs/primate",
+    "directory": "packages/python"
+  },
+  "dependencies": {
+    "@rcompat/fs": "^0.4.0",
+    "@primate/core": "^0.1.0"
+  },
+  "peerDependencies": {
+    "pyodide": "0.26",
+    "primate": "^0.32.0"
+  },
+  "type": "module",
+  "imports": {
+    "#*": {
+      "@primate/lt": "./src/private/*.js",
+      "default": "./src/private/*.js"
+    }
+  },
+  "exports": {
+    ".": {
+      "runtime": "./src/runtime.js",
+      "default": "./src/default.js"
+    },
+    "./*": "./src/*.js"
+  }
+}

package/src/default.js

@@ -0,0 +1,8 @@
+import build from "#build";
+import default_extension from "#extension";
+import pkgname from "#pkgname";
+
+export default ({ extension = default_extension, packages = [] } = {}) => ({
+  name: pkgname,
+  build: build({ extension, packages }),
+});

package/src/private/build.js

@@ -0,0 +1,42 @@
+const routes_re = /def (?<route>get|post|put|delete)/gu;
+const get_routes = code => [...code.matchAll(routes_re)]
+  .map(({ groups: { route } }) => route);
+
+const make_route = route => `async ${route.toLowerCase()}(request) {
+  const ${route}_fn = pyodide.globals.get("${route}");
+  return to_response(await ${route}_fn(to_request(pyodide.toPy, request)));
+}`;
+
+const make_package = pkg => `await pyodide.loadPackage("${pkg}", {
+  messageCallback: _ => _,
+});\n`;
+
+const js_wrapper = async (path, routes, packages) => `
+  import file from "@rcompat/fs/file";
+  import to_request from "@primate/python/to-request";
+  import to_response from "@primate/python/to-response";
+  import wrap from "@primate/python/wrap";
+  import { loadPyodide as load } from "pyodide";
+
+  const pyodide = await load({ indexURL: "./node_modules/pyodide" });
+  const python_route = await file(${JSON.stringify(path)}).text();
+  ${packages.map(make_package)}
+  pyodide.runPython(wrap(python_route));
+  export default {
+  ${routes.map(route => make_route(route)).join(",\n")}
+  };
+`;
+
+export default ({ extension, packages }) => async (app, next) => {
+  app.bind(extension, async (directory, file) => {
+    const path = directory.join(file);
+    const base = path.directory;
+    const js = path.base.concat(".js");
+    const code = await path.text();
+    const routes = get_routes(code);
+    // write .js wrapper
+    await base.join(js).write(await js_wrapper(`${path}`, routes, packages));
+  });
+
+  return next(app);
+};

package/src/private/extension.js

@@ -0,0 +1 @@
+export default ".py";

package/src/private/pkgname.js

@@ -0,0 +1 @@
+export default "@primate/python";

package/src/runtime.js

@@ -0,0 +1,3 @@
+import pkgname from "#pkgname";
+
+export default () => ({ name: pkgname });

package/src/to-request.js

@@ -0,0 +1,78 @@
+import { unwrap, unwrap_async } from "./unwrap.js";
+
+const dispatchers = ["path", "query", "headers", "cookies"];
+
+const wrap_dispatchers = (toPy, request) =>
+  Object.fromEntries(dispatchers.map(dispatcher =>
+    [dispatcher, {
+    ...request[dispatcher],
+    json() {
+      return toPy(request[dispatcher].json());
+    },
+  }]));
+
+const wrap_store = (toPy, store) => {
+  return {
+    ...store,
+    async validate(input) {
+      return toPy(await store.validate(unwrap_async(input)));
+    },
+    async get(value) {
+      return toPy(await store.get(unwrap_async(value)));
+    },
+    async count(criteria) {
+      return store.count(unwrap_async(criteria));
+    },
+    async find(criteria) {
+      return toPy(await store.find(unwrap_async(criteria)));
+    },
+    async exists(criteria) {
+      return store.exists(unwrap_async(criteria));
+    },
+    async insert(document) {
+      return toPy(await store.insert(unwrap_async(document)));
+    },
+    async update(criteria, document) {
+      const ua = unwrap_async;
+      return toPy(await store.update(ua(criteria), ua(document)));
+    },
+    async save(document) {
+      return toPy(await store.save(unwrap_async(document)));
+    },
+    async delete(criteria) {
+      return store.delete(unwrap_async(criteria));
+    },
+    schema: {
+      async create(description) {
+        return store.schema.create(unwrap_async(description));
+      },
+      async delete() {
+        return store.schema.delete();
+      },
+    },
+  };
+};
+
+const is_store = value => value.connection !== undefined;
+const wrap_stores = (toPy, object) => Object.entries(object)
+  .reduce((reduced, [key, value]) => ({
+    ...reduced,
+    [key]: is_store(value) ? wrap_store(toPy, value) : wrap_stores(toPy, value),
+  }), {});
+
+const wrap_session = (toPy, { session }) => ({
+  ...session,
+  create(data) {
+    session.create(unwrap(data));
+  },
+  json() {
+    return toPy(session.json());
+  },
+});
+
+export default (toPy, request) => ({
+  ...request,
+  ...wrap_dispatchers(toPy, request),
+  session: wrap_session(toPy, request),
+  store: wrap_stores(toPy, request.store),
+});

package/src/to-response.js

@@ -0,0 +1,31 @@
+import error from "@primate/core/handler/error";
+import redirect from "@primate/core/handler/redirect";
+import view from "@primate/core/handler/view";
+
+import { unwrap } from "./unwrap.js";
+
+const handlers = {
+  view({ name, props = {}, options = {} }) {
+    return view(name, props, options);
+  },
+  redirect({ location, options }) {
+    return redirect(location, options);
+  },
+  error({ body, options }) {
+    return error(body, options);
+  },
+};
+
+const handle_handler = response => {
+  const { __handler__ : handler, ...args } = response;
+  return handlers[handler]?.(args) ?? error();
+};
+
+const handle_other = response => response;
+
+export default raw_response => {
+  const response = unwrap(raw_response);
+  return response.__handler__ === undefined
+    ? handle_other(response)
+    : handle_handler(response);
+};

package/src/unwrap.js

@@ -0,0 +1,17 @@
+const dict_converter = value => Object.fromEntries(value);
+
+const normalize = response =>
+  response instanceof Map ? Object.fromEntries(response.entries()) : response;
+const qualify = (response, destroy = true) => {
+  if (response?.toJs !== undefined) {
+    const py_proxy = response;
+    const converted = py_proxy.toJs({ dict_converter });
+    destroy && py_proxy.destroy();
+    return converted;
+  }
+  return response;
+};
+
+export const unwrap = response => normalize(qualify(response));
+
+export const unwrap_async = response => normalize(qualify(response, false));

package/src/wrap.js

@@ -0,0 +1,24 @@
+export default code => `
+class Primate():
+    @staticmethod
+    def view(name, props = None, options = None):
+        return {
+            "__handler__": "view",
+            "name": name,
+            "props": props,
+            "options": options,
+        }
+    @staticmethod
+    def redirect(location, options = None):
+        return {
+            "__handler__": "redirect",
+            "location": location,
+            "options": options,
+        }
+    @staticmethod
+    def error(body, options = None):
+        return {
+            "__handler__": "error",
+            "body": body,
+            "options": options,
+        }\n${code}`;