coloco 0.1.1__tar.gz

coloco-0.1.1/PKG-INFO

@@ -0,0 +1,58 @@
+Metadata-Version: 2.1
+Name: coloco
+Version: 0.1.1
+Summary: A kit for creating FastAPI + Svelte applications
+Author-Email: Channel Cat <channelcat@gmail.com>
+License: MIT
+Requires-Python: >=3.11
+Requires-Dist: aerich[toml]==0.8.1
+Requires-Dist: fastapi==0.115.0
+Requires-Dist: PyJWT==2.10.1
+Requires-Dist: tortoise-orm[asyncpg]==0.24.0
+Requires-Dist: typer==0.15.2
+Requires-Dist: uvicorn==0.31.0
+Description-Content-Type: text/markdown
+
+# Coloco
+
+A kit for creating FastAPI + Svelte applications focusing on locality of code and decreased boilerplate.  Create simple full-stack apps with built-in codegen.  Deploy with a package that can be hosted with python or a docker container.
+
+File-based routing for your front-end and back-end.  Expose API endpoints with docs via `fastapi`.  Generate a front-end with `svelte`.
+
+Example:
+
+`hello/api.py`
+```python
+from coloco import api
+
+@api
+def test(name: str) -> str:
+    return f"Hello {name}!"
+
+```
+
+`hello/index.svelte`
+```svelte
+<script lang="ts">
+  import { test } from "./api";
+
+  const results = test({ query: { name: "DoItLive" } });
+</script>
+
+{#if $results.loading}
+    Loading...
+{:else}
+    The server says {$results.data}
+{/if}
+```
+
+Serves the page `myapp.com/hello`, which calls `myapp.com/hello/test?name=DoItLive` and prints the message `Hello DoItLive!`
+
+# Opinions
+
+This framework is opinionated and combines the following tools/concepts:
+ * FastAPI
+ * Svelte
+ * openapi-ts (codegen)
+ * file-based routing (using svelte5-router)
+ * tortoise-orm (optional)

coloco-0.1.1/README.md

@@ -0,0 +1,43 @@
+# Coloco
+
+A kit for creating FastAPI + Svelte applications focusing on locality of code and decreased boilerplate.  Create simple full-stack apps with built-in codegen.  Deploy with a package that can be hosted with python or a docker container.
+
+File-based routing for your front-end and back-end.  Expose API endpoints with docs via `fastapi`.  Generate a front-end with `svelte`.
+
+Example:
+
+`hello/api.py`
+```python
+from coloco import api
+
+@api
+def test(name: str) -> str:
+    return f"Hello {name}!"
+
+```
+
+`hello/index.svelte`
+```svelte
+<script lang="ts">
+  import { test } from "./api";
+
+  const results = test({ query: { name: "DoItLive" } });
+</script>
+
+{#if $results.loading}
+    Loading...
+{:else}
+    The server says {$results.data}
+{/if}
+```
+
+Serves the page `myapp.com/hello`, which calls `myapp.com/hello/test?name=DoItLive` and prints the message `Hello DoItLive!`
+
+# Opinions
+
+This framework is opinionated and combines the following tools/concepts:
+ * FastAPI
+ * Svelte
+ * openapi-ts (codegen)
+ * file-based routing (using svelte5-router)
+ * tortoise-orm (optional)

coloco-0.1.1/pyproject.toml

@@ -0,0 +1,32 @@
+[project]
+name = "coloco"
+version = "0.1.1"
+description = "A kit for creating FastAPI + Svelte applications"
+authors = [
+    { name = "Channel Cat", email = "channelcat@gmail.com" },
+]
+dependencies = [
+    "aerich[toml]==0.8.1",
+    "fastapi==0.115.0",
+    "PyJWT==2.10.1",
+    "tortoise-orm[asyncpg]==0.24.0",
+    "typer==0.15.2",
+    "uvicorn==0.31.0",
+]
+requires-python = ">=3.11"
+readme = "README.md"
+
+[project.license]
+text = "MIT"
+
+[project.scripts]
+coloco = "coloco:main"
+
+[build-system]
+requires = [
+    "pdm-backend",
+]
+build-backend = "pdm.backend"
+
+[tool.pdm]
+distribution = true

coloco-0.1.1/src/coloco/__init__.py

@@ -0,0 +1,12 @@
+from .app import create_app
+from .codegen import generate_openapi_schema, generate_openapi_code
+from .exceptions import UserError
+from .api import api
+
+__all__ = [
+    "api",
+    "create_app",
+    "generate_openapi_schema",
+    "generate_openapi_code",
+    "UserError",
+]

coloco-0.1.1/src/coloco/__main__.py

@@ -0,0 +1,15 @@
+import typer
+from .cli.dev import dev
+from .cli.api import app as api_app
+from .cli.node import app as node_app
+from .cli.createapp import createapp
+
+app = typer.Typer()
+
+app.command()(dev)
+app.add_typer(node_app, name="node")
+app.add_typer(api_app, name="api")
+app.command()(createapp)
+
+if __name__ == "__main__":
+    app()

coloco-0.1.1/src/coloco/api.py

@@ -0,0 +1,110 @@
+from contextlib import asynccontextmanager
+from fastapi import APIRouter, FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+import logging
+from os import environ
+from .codegen import (
+    custom_generate_unique_id,
+    generate_openapi_code,
+    generate_openapi_schema,
+)
+from .lifespan import execute_lifespan, register_lifespan
+from .static import bind_static
+from .exceptions import bind_exceptions
+
+
+logging.basicConfig(level=logging.INFO)
+
+
+@asynccontextmanager
+async def generate_openapi(app: FastAPI):
+    logging.info("Generating OpenAPI schema...")
+    generate_openapi_schema(app)
+    generate_openapi_code(host=f"http://localhost:5172", diff_files=True)
+
+    yield
+
+
+def create_api(is_dev: bool = False):
+    if not is_dev:
+        kwargs = {
+            "openapi_url": None,
+            "docs_url": None,
+            "redoc_url": None,
+        }
+    else:
+        kwargs = {
+            "lifespan": execute_lifespan,
+        }
+        register_lifespan(generate_openapi)
+
+    api = FastAPI(
+        generate_unique_id_function=custom_generate_unique_id,
+        **kwargs,
+    )
+    api.service = CORSMiddleware(
+        app=api,
+        allow_origins=[
+            f"http://localhost:5173",
+            "https://mysite.app",
+        ],
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+    # bind_static(api)
+    bind_exceptions(api)
+
+    return api
+
+
+# ========================= Global routing =========================
+
+global_router = APIRouter()
+
+
+def api(func):
+    # Auto-route
+    return _add_global_route([f"/{func.__name__}"], {}, func, "GET")
+
+
+def _add_global_route(args, kwargs, func, method: str):
+    # Prepend module name to path
+    path = args[0] if args else kwargs.get("path", "")
+    path = (
+        # TODO: Make this configurable
+        "/api/"
+        + func.__module__.rsplit(".", 1)[0].replace(".", "/")
+        + ("" if path.startswith("/") else "/")
+        + path
+    )
+    if args:
+        args = (path, *args[1:])
+    else:
+        kwargs["path"] = path
+
+    return global_router.api_route(
+        *args,
+        **{
+            **kwargs,
+            "summary": (kwargs.get("summary", "") + f" ({func.__module__})").strip(),
+            "methods": [method],
+        },
+    )(func)
+
+
+def _make_route_decorator(method: str):
+    def route_wrapper(*args, **kwargs):
+        def handler_wrapper(func):
+            return _add_global_route(args, kwargs, func, method)
+
+        return handler_wrapper
+
+    return route_wrapper
+
+
+api.get = _make_route_decorator("GET")
+api.post = _make_route_decorator("POST")
+api.put = _make_route_decorator("PUT")
+api.delete = _make_route_decorator("DELETE")

coloco-0.1.1/src/coloco/app.py

@@ -0,0 +1,58 @@
+from .api import create_api, global_router
+from dataclasses import dataclass
+from fastapi import FastAPI
+from importlib import import_module
+import os
+from rich import print
+
+
+@dataclass
+class ColocoApp:
+    api: FastAPI
+    name: str
+
+
+import os
+
+
+def find_api_files(directory):
+    api_files = []
+    try:
+        with os.scandir(directory) as entries:
+            for entry in entries:
+                if entry.is_dir():
+                    # Skip directories starting with "+" and "node_modules"
+                    if (
+                        not entry.name.startswith("+")
+                        and not entry.name == "node_modules"
+                        and not entry.name == "coloco"
+                    ):
+                        api_files.extend(find_api_files(entry.path))
+                elif entry.is_file() and entry.name == "api.py":
+                    api_files.append(entry.path)
+    except (PermissionError, FileNotFoundError) as e:
+        print(f"Error accessing {directory}: {e}")
+    return api_files
+
+
+def create_app(name: str):
+    api = create_api(is_dev=True)
+
+    # Discover all api.py files from root, excluding node_modules and +app
+    api_files = find_api_files(".")
+    for api_file in api_files:
+        # convert python file path to module path
+        module_name = api_file.replace("./", "").replace(".py", "").replace("/", ".")
+        try:
+            module = import_module(module_name)
+        except Exception as e:
+            print(f"[red]Error importing '{api_file}': {e}[/red]")
+            continue
+        # if not hasattr(module, "router"):
+        #     print(f"[red]Module '{api_file}' has no router[/red]")
+        #     continue
+        # api.include_router(module.router)
+
+    api.include_router(global_router)
+
+    return ColocoApp(api=api, name=name)

coloco-0.1.1/src/coloco/cli/api.py

@@ -0,0 +1,48 @@
+from importlib import import_module
+import typer
+from rich import print
+import uvicorn
+from ..app import ColocoApp
+
+
+app = typer.Typer()
+
+
+@app.command()
+def serve(
+    app: str,
+    host: str = "127.0.0.1",
+    port: int = 80,
+    log_level: str = "info",
+    reload=False,
+):
+    if not "." in app:
+        print(
+            "[red]App should be the name of a variable in a python file, example: main.py -> api = main.api[/red]"
+        )
+        raise typer.Abort()
+
+    module_name, var_name = app.rsplit(".", 1)
+    try:
+        module = import_module(module_name)
+    except ImportError:
+        print(f"[red]Module or python file {module_name} not found[/red]")
+        raise typer.Abort()
+
+    if not hasattr(module, var_name):
+        print(f"[red]Variable {var_name} not found in module {module_name}[/red]")
+        raise typer.Abort()
+
+    var = getattr(module, var_name)
+
+    if not isinstance(var, ColocoApp):
+        print(f"[red]{var_name} is not a ColocoApp.  Please use create_app[/red]")
+        raise typer.Abort()
+
+    uvicorn.run(
+        f"{module_name}:{var_name}.api.service",
+        host=host,
+        port=port,
+        reload=reload,
+        log_level=log_level,
+    )

coloco-0.1.1/src/coloco/cli/createapp.py

@@ -0,0 +1,36 @@
+import typer
+from rich import print
+import os
+import shutil
+
+
+def createapp(name: str):
+    current_dir = os.path.dirname(os.path.abspath(__file__))
+    template_dir = f"{current_dir}/../templates/standard"
+    install_dir = f"{os.getcwd()}/{name}"
+    print(f"Creating app {name}...")
+    print(f"App created in {install_dir}")
+
+    template_vars = {
+        "project_name": name,
+    }
+
+    # Create directory
+    os.makedirs(install_dir, exist_ok=True)
+
+    # Copy all tpl files in folders and subfolders to install_dir under their relative paths
+    for root, dirs, files in os.walk(template_dir):
+        relative_path = os.path.relpath(root, template_dir)
+        install_subdir = os.path.join(install_dir, relative_path)
+        if not os.path.exists(install_subdir):
+            os.makedirs(install_subdir)
+        for file in files:
+            if file.endswith("-tpl"):
+                with open(os.path.join(root, file), "r") as f:
+                    content = f.read()
+                for key, value in template_vars.items():
+                    content = content.replace(f"{{{{ {key} }}}}", value)
+                with open(
+                    os.path.join(install_dir, relative_path, file[:-4]), "w"
+                ) as f:
+                    f.write(content)

coloco-0.1.1/src/coloco/cli/dev.py

@@ -0,0 +1,16 @@
+from rich import print
+from .api import serve
+from subprocess import Popen
+
+
+def dev(app: str, host: str = "127.0.0.1"):
+    node = Popen([f"npm run dev"], cwd="+node", shell=True)
+    serve(
+        app=app,
+        host=host,
+        port=5172,
+        reload=True,
+        log_level="debug",
+    )
+    node.terminate()
+    node.wait()

coloco-0.1.1/src/coloco/cli/node.py

@@ -0,0 +1,49 @@
+import typer
+import os
+from rich import print
+import shutil
+import subprocess
+
+app = typer.Typer()
+
+
+@app.command()
+def install():
+    """Installs node dependencies for the project"""
+
+    # if not exists +node/package.json, raise error
+    if not os.path.exists("+node/package.json"):
+        print(
+            "[red]Error: +node/package.json not found.  Please ensure you are in a coloco project directory.[/red]"
+        )
+        raise typer.Abort()
+
+    # copy +node/package.json to /package.json
+    shutil.copyfile("+node/package.json", "package.json")
+    if os.path.exists("+node/package-lock.json"):
+        shutil.copyfile("+node/package-lock.json", "package-lock.json")
+
+    try:
+        # run npm install
+        subprocess.run(["npm", "install"], cwd=".")
+
+        # move package.json and package-lock.json back to +node
+        shutil.move("package.json", "+node/package.json")
+        shutil.move("package-lock.json", "+node/package-lock.json")
+    except Exception as e:
+        print(f"[red]Error installing packages: {e}[/red]")
+        try:
+            os.remove("package.json")
+            os.remove("package-lock.json")
+        except Exception:
+            pass
+        raise typer.Abort()
+
+    print("[green]Packages installed successfully.[/green]")
+
+
+@app.command()
+def dev():
+    """Runs the node dev server"""
+    print("[green]Running node dev server...[/green]")
+    subprocess.run(["npm", "run", "dev"], cwd="+node")

coloco-0.1.1/src/coloco/codegen.py

@@ -0,0 +1,61 @@
+from fastapi import FastAPI
+from fastapi.routing import APIRoute
+import json
+from subprocess import run
+
+import os
+import shutil
+import filecmp
+
+
+def compare_and_copy(source_dir, target_dir):
+    """
+    Compares files in two directories and copies files from source to target if they differ, creating target directories if needed.
+
+    Args:
+        source_dir (str): Path to the source directory.
+        target_dir (str): Path to the target directory.
+    """
+    for root, _, files in os.walk(source_dir):
+        rel_path = os.path.relpath(root, source_dir)  # Get relative path from source
+        target_path = os.path.join(target_dir, rel_path)
+        os.makedirs(
+            target_path, exist_ok=True
+        )  # Create target directory if it doesn't exist
+
+        for file in files:
+            source_file = os.path.join(root, file)
+            target_file = os.path.join(target_path, file)
+
+            if not os.path.exists(target_file) or not filecmp.cmp(
+                source_file, target_file
+            ):
+                shutil.copy2(source_file, target_file)
+
+
+def custom_generate_unique_id(route: APIRoute) -> str:
+    return f"{route.name}"
+
+
+def generate_openapi_schema(app: FastAPI, path="/tmp/openapi.json"):
+    with open(path, "w") as f:
+        json.dump(app.openapi(), f)
+
+
+def generate_openapi_code(
+    host,
+    spec_path="/tmp/openapi.json",
+    output_dir="/app/+app/.generated/client",
+    diff_files=False,
+):
+    temp_dir = "/tmp/backend_api"
+
+    run(
+        f"npx openapi-ts "
+        f"--base {host} "
+        f"--input {spec_path} "
+        f"--output {temp_dir if diff_files else output_dir} ".split(),
+        cwd="/app/+node",
+    )
+    if diff_files:
+        compare_and_copy(temp_dir, output_dir)

coloco-0.1.1/src/coloco/exceptions.py

@@ -0,0 +1,32 @@
+from fastapi import FastAPI
+from fastapi.responses import JSONResponse
+from fastapi.requests import Request
+
+
+class UserError(Exception):
+    status_code: int
+    code: str
+
+    def __init__(self, *args: object, status_code=400, code="bad_request") -> None:
+        super().__init__(*args)
+        self.code = code
+
+
+class ServerError(Exception):
+    pass
+
+
+def bind_exceptions(api: FastAPI):
+    @api.exception_handler(UserError)
+    async def user_error_handler(request: Request, exc: UserError):
+        return JSONResponse(
+            status_code=exc.status_code,
+            content={"error": {"code": exc.code, "message": f"{exc}"}},
+        )
+
+    @api.exception_handler(Exception)
+    async def exception_handler(request: Request, exc: Exception):
+        return JSONResponse(
+            status_code=500,
+            content={"error": {"code": "api_error", "message": f"{exc}"}},
+        )

coloco-0.1.1/src/coloco/lifespan.py

@@ -0,0 +1,30 @@
+from contextlib import asynccontextmanager
+from asyncio import iscoroutinefunction
+from fastapi import FastAPI
+
+lifespan_wrappers = []
+
+
+@asynccontextmanager
+async def execute_lifespan(app: FastAPI):
+    contexts = []
+
+    for lifespan_handler in lifespan_wrappers:
+        generator = lifespan_handler(app)
+        contexts.append(generator)
+        if hasattr(generator, "__aenter__"):
+            await generator.__aenter__()
+        else:
+            next(generator)
+
+    yield
+
+    while contexts and (generator := contexts.pop()):
+        if hasattr(generator, "__aexit__"):
+            await generator.__aexit__(None, None, None)
+        else:
+            next(generator)
+
+
+def register_lifespan(handler):
+    lifespan_wrappers.append(handler)

coloco-0.1.1/src/coloco/requirements.txt

@@ -0,0 +1,6 @@
+aerich[toml]==0.8.1
+fastapi==0.115.0
+PyJWT==2.10.1
+tortoise-orm[asyncpg]==0.24.0
+typer==0.15.2
+uvicorn==0.31.0

coloco-0.1.1/src/coloco/static.py

@@ -0,0 +1,12 @@
+from fastapi import FastAPI
+from fastapi.responses import FileResponse
+from fastapi.staticfiles import StaticFiles
+
+
+# Static Files
+def bind_static(api: FastAPI):
+    api.mount("/static", StaticFiles(directory="static"), name="static")
+
+    @api.get("/")
+    def index():
+        return FileResponse("static/index.html")

coloco-0.1.1/src/coloco/templates/docker/.dockerignore-tpl

@@ -0,0 +1,16 @@
+node_modules
+dist
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Env
+.env
+.env.*
+!.env.example
+!.env.test
+
+# Vite
+vite.config.js.timestamp-*
+vite.config.ts.timestamp-*

coloco-0.1.1/src/coloco/templates/docker/Dockerfile-tpl

@@ -0,0 +1,59 @@
+# Dev Container
+
+FROM python:3.12-alpine
+
+RUN apk add --update nodejs npm
+
+# Python Install
+WORKDIR /app
+ADD ./requirements.txt /app/requirements.txt
+RUN python -m pip install -r /app/requirements.txt
+
+# TODO: remove this when coloco is a package
+ADD ./coloco/requirements.txt /app/coloco/requirements.txt
+RUN python -m pip install -r /app/coloco/requirements.txt
+
+# Node Install
+RUN mkdir /.npm && chown -R 1000:1000 "/.npm"
+ADD ./+node/package.json /app/package.json
+ADD ./+node/package-lock.json /app/package-lock.json
+RUN npm install
+
+# Codegen
+# RUN npm install -g @hey-api/client-fetch @hey-api/openapi-ts
+
+ADD . /app
+
+# ADD backend /api
+# RUN python -c "from main import app; from coloco.codegen import generate_openapi_schema; generate_openapi_schema(app.api, '/tmp/openapi.json')"
+
+# # Frontend Build
+
+# FROM node:20-alpine as frontend
+
+# WORKDIR /app
+
+# ADD frontend/package.json /app/package.json
+# ADD frontend/package-lock.json /app/package-lock.json
+
+# RUN npm install
+
+# COPY --from=backend /tmp/openapi.json /tmp/openapi.json
+
+# RUN npx @hey-api/openapi-ts \
+#     --base https://mysite.app \
+#     --input /tmp/openapi.json \
+#     --output /app/src/backend \
+#     --client legacy/fetch
+
+# ADD frontend /app
+# RUN npm run build
+
+# # Combined Image
+
+# FROM backend
+
+# COPY --from=frontend /app/dist /api/static
+# ENV MODE=production
+
+CMD ["python", "-m", "coloco", "start"]

coloco-0.1.1/src/coloco/templates/docker/docker-compose.yml-tpl

@@ -0,0 +1,29 @@
+services:
+  app:
+    build: .
+    volumes:
+      - ./:/app
+      - /app/node_modules
+    user: 1000:1000
+    ports:
+      - 5172:5172
+      - 5173:5173
+    entrypoint: python -m coloco
+    command: dev --host 0.0.0.0 main.app
+    tty: true
+
+  # Helper Scripts
+  install-local-node:
+    profiles: [ script ]
+    build: .
+    user: 1000:1000
+    volumes:
+      - ./:/app
+    command: python -m coloco node install
+
+  shell:
+    profiles: [ script ]
+    build: .
+    volumes:
+      - ./:/app
+    command: sh

coloco-0.1.1/src/coloco/templates/standard/+app/404.svelte-tpl

@@ -0,0 +1 @@
+Not found!

coloco-0.1.1/src/coloco/templates/standard/+app/app.css-tpl

@@ -0,0 +1,79 @@
+:root {
+  font-family: Inter, system-ui, Avenir, Helvetica, Arial, sans-serif;
+  line-height: 1.5;
+  font-weight: 400;
+
+  color-scheme: light dark;
+  color: rgba(255, 255, 255, 0.87);
+  background-color: #242424;
+
+  font-synthesis: none;
+  text-rendering: optimizeLegibility;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+}
+
+a {
+  font-weight: 500;
+  color: #646cff;
+  text-decoration: inherit;
+}
+a:hover {
+  color: #535bf2;
+}
+
+body {
+  margin: 0;
+  display: flex;
+  place-items: center;
+  min-width: 320px;
+  min-height: 100vh;
+}
+
+h1 {
+  font-size: 3.2em;
+  line-height: 1.1;
+}
+
+.card {
+  padding: 2em;
+}
+
+#app {
+  max-width: 1280px;
+  margin: 0 auto;
+  padding: 2rem;
+  text-align: center;
+}
+
+button {
+  border-radius: 8px;
+  border: 1px solid transparent;
+  padding: 0.6em 1.2em;
+  font-size: 1em;
+  font-weight: 500;
+  font-family: inherit;
+  background-color: #1a1a1a;
+  cursor: pointer;
+  transition: border-color 0.25s;
+}
+button:hover {
+  border-color: #646cff;
+}
+button:focus,
+button:focus-visible {
+  outline: 4px auto -webkit-focus-ring-color;
+}
+
+@media (prefers-color-scheme: light) {
+  :root {
+    color: #213547;
+    background-color: #ffffff;
+  }
+  a:hover {
+    color: #747bff;
+  }
+  button {
+    background-color: #f9f9f9;
+  }
+}

coloco-0.1.1/src/coloco/templates/standard/+app/app.svelte-tpl

@@ -0,0 +1,25 @@
+<script lang="ts">
+  import { setupClient } from "@coloco/client";
+  import { route, Router, getRoutes } from "@coloco/router";
+
+  import Index from "./index.svelte";
+  import NotFound from "./404.svelte";
+
+  setupClient({
+    baseUrl: "http://localhost:5172",
+  });
+  const routes = getRoutes({
+    index: Index,
+    notFound: NotFound,
+  });
+</script>
+
+<main>
+  Main Page<br /><br />
+
+  <a use:route href="/">Home</a><br />
+  <a use:route href="/example">Example</a><br />
+  <a use:route href="/missing">Missing</a>
+
+  <Router basePath="/" {routes} />
+</main>

coloco-0.1.1/src/coloco/templates/standard/+app/index.html-tpl

@@ -0,0 +1,15 @@
+<!doctype html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>{{ project_name }}</title>
+</head>
+
+<body>
+    <div id="app"></div>
+    <script type="module" src="/main.ts"></script>
+</body>
+
+</html>

coloco-0.1.1/src/coloco/templates/standard/+app/index.svelte-tpl

@@ -0,0 +1 @@
+I am the home page!

coloco-0.1.1/src/coloco/templates/standard/+app/main.ts

@@ -0,0 +1,9 @@
+import { mount } from 'svelte'
+import './app.css'
+import App from './app.svelte'
+
+const app = mount(App, {
+  target: document.getElementById('app')!,
+})
+
+export default app

coloco-0.1.1/src/coloco/templates/standard/+node/openapi-ts.config.ts-tpl

@@ -0,0 +1,10 @@
+import { defaultPlugins } from '@hey-api/openapi-ts';
+import { defineConfig } from '@coloco/codegen-svelte';
+
+export default {
+  plugins: [
+    ...defaultPlugins,
+    '@hey-api/client-fetch',
+    defineConfig({ name: 'coloco-codegen', outputPath: './api' }),
+  ],
+};

coloco-0.1.1/src/coloco/templates/standard/+node/package.json-tpl

@@ -0,0 +1,24 @@
+{
+  "name": "{{ project_name }}",
+  "private": true,
+  "version": "1.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview",
+    "check": "svelte-check --tsconfig ./tsconfig.app.json && tsc -p tsconfig.node.json"
+  },
+  "devDependencies": {
+    "@hey-api/client-fetch": "^0.8.2",
+    "@hey-api/openapi-ts": "^0.64.7",
+    "@mateothegreat/svelte5-router": "^0.1.38",
+    "@sveltejs/vite-plugin-svelte": "^5.0.3",
+    "@tsconfig/svelte": "^5.0.4",
+    "@types/node": "^22.13.4",
+    "svelte": "^5.19.6",
+    "svelte-check": "^4.1.4",
+    "typescript": "~5.7.2",
+    "vite": "^6.1.0"
+  }
+}

coloco-0.1.1/src/coloco/templates/standard/+node/svelte.config.js-tpl

@@ -0,0 +1,7 @@
+import { vitePreprocess } from '@sveltejs/vite-plugin-svelte'
+
+export default {
+  // Consult https://svelte.dev/docs#compile-time-svelte-preprocess
+  // for more information about preprocessors
+  preprocess: vitePreprocess(),
+}

coloco-0.1.1/src/coloco/templates/standard/+node/tsconfig.json-tpl

@@ -0,0 +1,43 @@
+{
+    "compilerOptions": {
+        "rootDirs": [
+            "..",
+            "../+app/.generated/client/api"
+        ],
+        "verbatimModuleSyntax": true,
+        "isolatedModules": true,
+        "lib": [
+            "esnext",
+            "DOM",
+            "DOM.Iterable"
+        ],
+        "moduleResolution": "bundler",
+        "module": "esnext",
+        "noEmit": true,
+        "target": "esnext",
+        // Project
+        "allowJs": true,
+        "checkJs": true,
+        "esModuleInterop": true,
+        "forceConsistentCasingInFileNames": true,
+        "resolveJsonModule": true,
+        "skipLibCheck": true,
+        "sourceMap": true,
+        "strict": true,
+        "paths": {
+            "@api/*": [
+                "../+app/.generated/client/api/*"
+            ]
+        },
+    },
+    "include": [
+        "../**/*.ts",
+        "../**/*.js",
+        "../**/*.svelte",
+        "./vite.config.ts"
+    ],
+    "exclude": [
+        "../node_modules/**",
+        "../dist/**"
+    ]
+}

coloco-0.1.1/src/coloco/templates/standard/+node/vite-env.d.ts-tpl

@@ -0,0 +1,2 @@
+/// <reference types="svelte" />
+/// <reference types="vite/client" />

coloco-0.1.1/src/coloco/templates/standard/+node/vite.config.ts-tpl

@@ -0,0 +1,34 @@
+import path, { dirname, resolve, relative } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { defineConfig } from 'vite'
+import { svelte } from '@sveltejs/vite-plugin-svelte'
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const root = resolve(__dirname, '../');
+
+// https://vite.dev/config/
+export default defineConfig({
+  plugins: [svelte()],
+  root: resolve(root, '+app'),
+  server: {
+    host: "0.0.0.0",
+    port: 5172,
+  },
+  clearScreen: false,
+  resolve: {
+    // @ts-ignore
+    alias: [{
+      find: './api',
+      customResolver: (_, filePath: string) => {
+        const subFolder = path.relative(root, dirname(filePath));
+        const apiFile = resolve(root, `+app/.generated/client/api/${subFolder}/api.ts`);
+        return apiFile;
+      }
+    },
+    // @ts-ignore
+    {
+      find: '@api',
+      replacement: '/.generated/client/api'
+    }]
+  }
+})

coloco-0.1.1/src/coloco/templates/standard/.gitignore-tpl

@@ -0,0 +1,6 @@
+.env
+node_modules
+dist
++app/.generated
+.vite
+__pycache__

coloco-0.1.1/src/coloco/templates/standard/README.md-tpl

@@ -0,0 +1,3 @@
+# {{ project_name }}
+
+A kit for creating FastAPI + Svelte applications

coloco-0.1.1/src/coloco/templates/standard/example/api.py-tpl

@@ -0,0 +1,6 @@
+from coloco import api
+
+
+@api
+def test(name: str) -> str:
+    return f"Hello {name}"

coloco-0.1.1/src/coloco/templates/standard/example/index.svelte-tpl

@@ -0,0 +1,7 @@
+<script lang="ts">
+  import { test } from "./api";
+
+  const results = test({ query: { name: "Testy McTesterson" } });
+</script>
+
+Calling server... {$results.loading} - {$results.data} - {$results.error}

coloco-0.1.1/src/coloco/templates/standard/main.py-tpl

@@ -0,0 +1,3 @@
+from coloco import create_app
+
+app = create_app(name="{{ project_name }}")

coloco-0.1.1/src/coloco/templates/standard/requirements.txt-tpl

@@ -0,0 +1 @@
+coloco

coloco-0.1.1/src/coloco/templates/standard/tsconfig.json-tpl

@@ -0,0 +1,3 @@
+{
+    "extends": "./+node/tsconfig.json"
+}