sveltekit-python-vercel 1.0.2 → 1.0.3

package/esm/src/vite/mod.js

@@ -0,0 +1,116 @@
+import { $ as run$, cd as cd$, which, path, chalk, } from "zx";
+const get_pyServerEndpointAsString = (app_url, serve = false) => `
+    const handle = (method) => (async ({ request, fetch, url }) => {
+        const headers = new Headers()
+        headers.append('content-type', request.headers.get('content-type'));
+        headers.append('accept', request.headers.get('accept'));
+
+        let fullURL;
+
+        if (${serve}) {
+          fullURL = new URL(url.pathname, new URL('${app_url}')) + url.search;
+        } else {
+          fullURL = new URL('/api' + url.pathname, url.origin) + url.search;
+        }
+
+        console.log(\`PY: Reached python endpoint of \${method} \${fullURL}\`)
+        let requestBody = await request.clone().text();
+        console.log(\`PY: Body: \${requestBody}\`);
+
+        if (method === 'GET') {
+          requestBody = null;
+        }
+
+        return fetch(fullURL, { headers, method, body: requestBody, signal: request.signal, duplex: 'half' });
+    });
+    
+    export const GET = handle('GET');
+    export const POST = handle('POST');
+    export const PATCH = handle('PATCH');
+    export const PUT = handle('PUT');
+    export const DELETE = handle('DELETE');
+`;
+export async function sveltekit_python_vercel(opts = {}) {
+    const child_processes = [];
+    async function kill_all_process() {
+        for (const ps of child_processes) {
+            await ps.kill();
+            await ps.exitCode;
+        }
+    }
+    let sveltekit_url;
+    const plugin_python_serve = {
+        name: "vite-plugin-sveltekit-python-serve",
+        apply: "serve",
+        async closeBundle() {
+            await kill_all_process();
+        },
+        async configureServer({ config }) {
+            const packagelocation = path.join(config.root, "node_modules", "sveltekit-python-vercel", "esm/src/vite");
+            // copy asll +server.py files to package directory
+            run$.verbose = false;
+            run$.env.PYTHONDONTWRITEBYTECODE = "1";
+            cd$(packagelocation);
+            const python_path = opts.python_path ?? (await which("python3"));
+            const host = opts.host ?? "0.0.0.0";
+            const port = opts.port ?? 8000;
+            const local_process = run$ `${python_path} -m sveltekit_python_vercel.serve --host ${host} --port ${port} --root ${config.root}`;
+            child_processes.push(local_process);
+            sveltekit_url ??= new URL(`http://${host}:${port}`);
+            cd$(config.root);
+            // local_process.quiet();  // let it be loud for now
+            local_process.nothrow();
+            local_process.stderr.on("data", (s) => {
+                console.log(s.toString().trimEnd()); //Logs stderr always and all of stdout if 'log': True
+            });
+            local_process.stderr.on("error", (s) => {
+                console.error(chalk.red("Error: Python Serve Failed"));
+                console.error(s.toString().trimEnd());
+            });
+            local_process.stdout.on("error", (s) => {
+                console.error(chalk.red("Error: Python Serve Failed"));
+                console.error(s.toString().trimEnd());
+            });
+        },
+    };
+    const plugin_python_build = {
+        name: "vite-plugin-sveltekit_python-build",
+        apply: "build",
+        async configResolved(config) {
+            console.log("PY: ROOT PATH: " + config.root);
+        },
+    };
+    const plugin_py_server_endpoint_serve = {
+        name: "vite-plugin-sveltekit_python-server-endpoint",
+        apply: "serve",
+        transform(src, id) {
+            // console.log("Transform function called for", id); // Add this line
+            if (/\.py$/.test(id)) {
+                if (sveltekit_url === undefined)
+                    throw new Error(`${plugin_python_serve.name} failed to produce a sveltekit_url`);
+                return {
+                    code: get_pyServerEndpointAsString(sveltekit_url, true),
+                    map: null, // provide source map if available
+                };
+            }
+        },
+    };
+    const plugin_py_server_endpoint_build = {
+        name: "vite-plugin-sveltekit_python-server-endpoint",
+        apply: "build",
+        transform(src, id) {
+            if (/\.py$/.test(id)) {
+                return {
+                    code: get_pyServerEndpointAsString(new URL("http://localhost"), false),
+                    map: null,
+                };
+            }
+        },
+    };
+    return [
+        plugin_python_serve,
+        plugin_python_build,
+        plugin_py_server_endpoint_serve,
+        plugin_py_server_endpoint_build,
+    ];
+}

package/esm/src/vite/sveltekit_python_vercel/bin.mjs

@@ -0,0 +1,6 @@
+#!/usr/bin/env zx --install
+
+import {$} from "zx";
+
+const python_path = await $`which python3`;
+await $`${python_path} ./node_modules/sveltekit-python-vercel/esm/src/vite/sveltekit_python_vercel/build.py --root . --packagedir ./node_modules/sveltekit-python-vercel/esm/src/vite/sveltekit_python_vercel`;

package/esm/src/vite/sveltekit_python_vercel/build.py

@@ -0,0 +1,120 @@
+import argparse
+import glob
+import json
+import shutil
+import subprocess
+import sys
+from pathlib import Path, PurePosixPath
+
+parser = argparse.ArgumentParser(description="Run SvelteKit Python Deployment")
+parser.add_argument("--root", default=".", help="Root directory of the SvelteKit project")
+parser.add_argument("--packagedir", default=None, help="Directory of the sveltekit-python-vercel package")
+args = parser.parse_args()
+
+root_dir = Path(args.root).absolute()
+
+func_dir = root_dir / ".vercel" / "output" / "functions" / "api" / "index.func"
+func_dir.mkdir(parents=True, exist_ok=True)
+
+if args.packagedir:
+    shutil.copy(Path(args.packagedir).absolute() / "deploy.py", func_dir / "index.py")
+
+# find all +server.py routes and copy them into the .func directory
+manifest = []
+
+for module_path in glob.glob(str(root_dir / "src/routes/**/+server.py"), recursive=True):
+    rel = Path(module_path).absolute().relative_to(root_dir / "src/routes")
+
+    # replace square brackets with curly brackets
+    rel = Path(str(rel).replace("[", "{").replace("]", "}"))
+
+    # remove any SvteleKit groups from the URL
+    parts = [
+        p for p in PurePosixPath(rel).parts
+        if not (p.startswith("(") and p.endswith(")"))
+    ]
+    rel = Path(*parts)
+
+    target_dir = func_dir / rel.parent
+    target_dir.mkdir(parents=True, exist_ok=True)
+
+    shutil.copy(module_path, target_dir / rel.name)
+
+    if not (target_dir / "__init__.py").exists():
+        (target_dir / "__init__.py").touch()
+
+    # build the API route
+    parent = PurePosixPath(rel).parent
+    if str(parent) == ".":
+        api_route = "/api"
+    else:
+        api_route = "/api/" + str(parent)
+
+    manifest.append({"file": str(PurePosixPath(rel)), "route": api_route})
+    print(f"PYTHON ENDPOINT: {module_path} → {api_route}")
+
+(func_dir / "_manifest.json").write_text(json.dumps(manifest, indent=2))
+
+# bundle the dependency file here
+dep_files = ["requirements.txt", "pyproject.toml", "uv.lock", "Pipfile", "Pipfile.lock"]
+found_dep = False
+for dep_file in dep_files:
+    src = root_dir / dep_file
+    if src.exists():
+        shutil.copy(src, func_dir / dep_file)
+        print(f"PYTHON ENDPOINT: Bundled {dep_file}")
+        found_dep = True
+
+if not found_dep:
+    (func_dir / "requirements.txt").write_text("fastapi\nuvicorn\n")
+    print("PYTHON ENDPOINT: No dependency file found, created minimal requirements.txt")
+
+# pre-install Python packages into _deps/ so they are available in the lambda env
+dep_dir = func_dir / "_deps"
+dep_dir.mkdir(exist_ok=True)
+pip_cmd = [sys.executable, "-m", "pip", "install", "--target", str(dep_dir), "--quiet"]
+if (func_dir / "requirements.txt").exists():
+    pip_cmd += ["-r", str(func_dir / "requirements.txt")]
+    subprocess.run(pip_cmd, check=True)
+    print("PYTHON ENDPOINT: Installed deps from requirements.txt")
+elif (func_dir / "pyproject.toml").exists():
+    # extract dependencies from pyproject.toml
+    try:
+        import tomllib
+    except ImportError:
+        import tomli as tomllib  # type: ignore
+    with open(func_dir / "pyproject.toml", "rb") as _f:
+        _pyproject = tomllib.load(_f)
+    _deps_list = _pyproject.get("project", {}).get("dependencies", [])
+    if _deps_list:
+        subprocess.run(pip_cmd + _deps_list, check=True)
+        print(f"PYTHON ENDPOINT: Installed {len(_deps_list)} deps from pyproject.toml")
+
+# python3.12 is the AWS Lambda runtime string
+vc_config = {"runtime": "python3.12", "handler": "index.handler"}
+(func_dir / ".vc-config.json").write_text(json.dumps(vc_config, indent=2))
+print("PYTHON ENDPOINT: Created .vc-config.json")
+
+# patch the SvelteKit config.json that the endpoints are rerouted to python
+config_path = root_dir / ".vercel" / "output" / "config.json"
+if config_path.exists():
+    config = json.loads(config_path.read_text())
+    routes = config.get("routes", [])
+
+    python_route = {"src": "^/api(/.*)?$", "dest": "api/index"}
+
+    # routes /api/* to python before SvelteKit catches it
+    fs_idx = next(
+        (i for i, r in enumerate(routes) if r.get("handle") == "filesystem"),
+        0,
+    )
+    routes.insert(fs_idx, python_route)
+    config["routes"] = routes
+
+    config_path.write_text(json.dumps(config, indent=2))
+    print("PYTHON ENDPOINT: Patched .vercel/output/config.json")
+else:
+    print(
+        "WARNING: .vercel/output/config.json not found. "
+        "Make sure to run `vite build` before this script."
+    )

package/esm/src/vite/sveltekit_python_vercel/deploy.py

@@ -0,0 +1,141 @@
+import asyncio
+import base64
+import importlib.util
+import json
+import sys
+from pathlib import Path
+from urllib.parse import urlsplit
+
+_base = Path(__file__).parent
+_deps = _base / "_deps"
+if _deps.exists() and str(_deps) not in sys.path:
+    sys.path.insert(0, str(_deps))
+if str(_base) not in sys.path:
+    sys.path.insert(0, str(_base))
+
+from fastapi import FastAPI, Request
+from fastapi.responses import JSONResponse
+
+app = FastAPI()
+
+
+def _load_module(file_path: Path):
+    spec = importlib.util.spec_from_file_location("_route_module", file_path)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+_manifest_path = _base / "_manifest.json"
+if _manifest_path.exists():
+    for _entry in json.loads(_manifest_path.read_text()):
+        _mod = _load_module(_base / _entry["file"])
+        _route = _entry["route"]
+
+        for _method in ["GET", "POST", "PATCH", "PUT", "DELETE"]:
+            _has_upper = hasattr(_mod, _method)
+            _has_lower = hasattr(_mod, _method.lower())
+
+            if _has_upper and _has_lower:
+                raise Exception(
+                    f"Duplicate method {_method} and {_method.lower()} in {_route}"
+                )
+            elif _has_upper:
+                app.add_api_route(_route, getattr(_mod, _method), methods=[_method])
+                print(f"PYTHON ENDPOINT: Registered {_method} {_route}")
+            elif _has_lower:
+                app.add_api_route(_route, getattr(_mod, _method.lower()), methods=[_method])
+                print(f"PYTHON ENDPOINT: Registered {_method} {_route}")
+
+
+@app.exception_handler(Exception)
+async def _exception_handler(request: Request, exc: Exception):
+    return JSONResponse(status_code=500, content={"error": str(exc)})
+
+
+async def _dispatch(scope: dict, body: bytes) -> tuple[int, dict, bytes]:
+    """Run FastAPI for one HTTP request and collect the response."""
+    queue: asyncio.Queue = asyncio.Queue()
+    queue.put_nowait({"type": "http.request", "body": body, "more_body": False})
+
+    status = 500
+    resp_headers: dict = {}
+    resp_body = b""
+
+    async def receive():
+        return await queue.get()
+
+    async def send(message):
+        nonlocal status, resp_body
+        if message["type"] == "http.response.start":
+            status = message["status"]
+            for k, v in message.get("headers", []):
+                if isinstance(k, bytes):
+                    k = k.decode()
+                if isinstance(v, bytes):
+                    v = v.decode()
+                k = k.lower()
+                if k in resp_headers:
+                    existing = resp_headers[k]
+                    resp_headers[k] = (existing if isinstance(existing, list) else [existing]) + [v]
+                else:
+                    resp_headers[k] = v
+        elif message["type"] == "http.response.body":
+            resp_body += message.get("body", b"")
+
+    await app(scope, receive, send)
+    return status, resp_headers, resp_body
+
+
+def handler(event, context):
+    payload = json.loads(event.get("body") or "{}")
+
+    # parse the path and query string
+    parsed = urlsplit(payload.get("path", "/"))
+    path = parsed.path or "/"
+    query = (parsed.query or "").encode()
+
+    # Build ASGI-style header list
+    raw_headers: dict = payload.get("headers") or {}
+    headers_list = []
+    host = payload.get("host", "localhost")
+    scheme = "https"
+    for k, v in raw_headers.items():
+        k_lower = k.lower()
+        if k_lower == "host":
+            host = v
+        if k_lower == "x-forwarded-proto":
+            scheme = v
+        headers_list.append((k_lower.encode(), str(v).encode()))
+
+    scope = {
+        "type": "http",
+        "http_version": "1.1",
+        "method": payload.get("method", "GET").upper(),
+        "path": path,
+        "raw_path": path.encode(),
+        "query_string": query,
+        "root_path": "",
+        "headers": headers_list,
+        "server": (host, 443 if scheme == "https" else 80),
+        "client": (raw_headers.get("x-real-ip", "127.0.0.1"), 0),
+        "scheme": scheme,
+    }
+
+    body = payload.get("body") or b""
+    if payload.get("encoding") == "base64":
+        body = base64.b64decode(body)
+    elif isinstance(body, str):
+        body = body.encode()
+
+    status, resp_headers, resp_body = asyncio.run(_dispatch(scope, body))
+
+    result: dict = {"statusCode": status, "headers": resp_headers}
+    if resp_body:
+        try:
+            result["body"] = resp_body.decode("utf-8")
+        except UnicodeDecodeError:
+            result["body"] = base64.b64encode(resp_body).decode()
+            result["encoding"] = "base64"
+
+    return result

package/esm/src/vite/sveltekit_python_vercel/serve.py

@@ -0,0 +1,82 @@
+import argparse
+import glob
+import importlib
+import importlib.util
+import shutil
+from pathlib import Path, PurePosixPath
+
+import uvicorn
+from fastapi import FastAPI
+
+parser = argparse.ArgumentParser(description="Run Sveltekit Python Server")
+parser.add_argument("--host", default="0.0.0.0", help="Server hostname")
+parser.add_argument("--port", type=int, default=8000, help="Server port")
+parser.add_argument("--root", default=".", help="Directory where the API is located")
+args = parser.parse_args()
+
+app = FastAPI()
+
+root_dir = Path(args.root).absolute()
+
+api_dir = Path("./sveltekit_python_vercel").absolute()
+
+route_dir = root_dir.joinpath("src/routes")
+
+watch_modules = []  # list of modules to watch for changes
+
+for module_path in glob.glob(
+    route_dir.joinpath("**/+server.py").as_posix(), recursive=True
+):
+    abs_module_path = Path(module_path).absolute()
+
+    watch_modules.append(abs_module_path.parent.as_posix())
+
+    api_route = api_dir.joinpath(abs_module_path.relative_to(root_dir / "src/routes"))
+
+    if not api_route.parent.exists():
+        api_route.parent.mkdir(parents=True)
+
+    # copy module path to api_route
+    shutil.copy(module_path, api_route.parent)
+
+    module_name = api_route.stem
+
+    spec = importlib.util.spec_from_file_location(module_name, api_route)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+
+    # Get the relative path of the module from the API directory
+    rel_path = api_route.relative_to(api_dir)
+
+    # Convert the relative path to a string and remove the file extension
+    api_path = f"/{rel_path.parent}"
+
+    # Replace square brackets with curly brackets
+    api_path = api_path.replace("[", "{").replace("]", "}")
+    
+    # remove any groups from the URL
+    api_path = str(PurePosixPath(*[part for part in PurePosixPath(api_path).parts if not part.startswith("(") and not part.endswith(")")]))
+
+    # Add endpoints
+    for method in ["GET", "POST", "PATCH", "PUT", "DELETE"]:
+        # Check for duplicate methods
+        if hasattr(mod, method) and hasattr(mod, method.lower()):
+            raise Exception(
+                f"Duplicate method {method} and {method.lower()} in {api_route}"
+            )
+        elif hasattr(mod, method):
+            app.add_api_route(api_path, getattr(mod, method), methods=[method])
+        elif hasattr(mod, method.lower()):
+            app.add_api_route(api_path, getattr(mod, method.lower()), methods=[method])
+
+
+if __name__ == "__main__":
+    uvicorn.run(
+        "sveltekit_python_vercel.serve:app",
+        host=args.host,
+        port=args.port,
+        log_level="info",
+        reload=True,
+        reload_includes=[*set(watch_modules)],
+        reload_excludes=[api_dir.as_posix()],
+    )

package/package.json

@@ -2,7 +2,7 @@
   "module": "./esm/mod.js",
   "types": "./types/mod.d.ts",
   "name": "sveltekit-python-vercel",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "Write Sveltekit server endpoints in Python and seamlessly deploy to Vercel",
   "repository": {
     "type": "git",

package/types/src/vite/mod.d.ts

@@ -0,0 +1,8 @@
+import { type Plugin } from "vite";
+export interface SveltekitPythonOptions {
+    python_path?: string;
+    log?: boolean;
+    host?: string;
+    port?: number;
+}
+export declare function sveltekit_python_vercel(opts?: SveltekitPythonOptions): Promise<Plugin[]>;