coloco 0.2.0__tar.gz → 0.3.0__tar.gz

{coloco-0.2.0 → coloco-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: coloco
-Version: 0.2.0
+Version: 0.3.0
 Summary: A kit for creating FastAPI + Svelte applications
 Author-Email: Channel Cat <channelcat@gmail.com>
 License: MIT
@@ -9,17 +9,19 @@ 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: type-less==0.1.4
 Requires-Dist: typer==0.15.2
 Requires-Dist: uvicorn==0.31.0
 Description-Content-Type: text/markdown
 
 # Coloco
 
-A kit for creating full-stack apps with co-located code, built on FastAPI and Svelte.  Bundle your front-end and back-end code and easily tie them together with codegen.
+A kit for creating full-stack apps with co-located code, built on FastAPI and Svelte. Bundle your front-end and back-end code and easily tie them together with codegen.
 
 Example:
 
 `hello/api.py`
+
 ```python
 from coloco import api
 
@@ -30,36 +32,58 @@ def test(name: str) -> str:
 ```
 
 `hello/index.svelte`
+
 ```svelte
 <script lang="ts">
   import { test } from "./api";
-
-  const response = test({ query: { name: "Coloco" } });
 </script>
 
-{#if $response.loading}
-    Loading...
-{:else}
-    The server says {$response.data}
-{/if}
+{#await test({ name: "Coloco" })}
+	Loading...
+{:then result}
+	The server says {result}
+{/await}
 ```
 
 Serves the page `myapp.com/hello`, which calls `myapp.com/hello/test?name=Coloco` and prints the message `Hello Coloco!`
 
+# Getting Started
+
+- `pip install coloco`
+- `coloco createapp myapp`
+- From `myapp` - `coloco dev`
+
+# Running in Production
+
+- `coloco build`
+
+- `coloco serve`
+
 # Opinions
 
 This framework is opinionated and combines the following excellent tools:
- * FastAPI
- * Svelte
- * openapi-ts (codegen)
- * svelte5-router (file-based routing)
- * tortoise-orm (optional)
+
+- FastAPI
+- Svelte
+- openapi-ts (codegen)
+- svelte5-router (file-based routing)
+- tortoise-orm (optional)
 
 # Plans
- * Deploy tools
- * ORM Support
- * SQLite/Postgres support
+
+- Deploy tools
+- ORM Support
+- SQLite/Postgres support
+- Package/share modules with git
 
 # Dreams
- * Move `node_modules` into `+node`
- * Remove the need for `query`, `params`, `body` for simple REST requests (maybe use legacy client but support the new one?)
+
+- Move `node_modules` into `+node`
+- Somehow clean up litter from `uv`
+
+# TODO
+
+- Swap to `cyclopts` for CLI
+- Swap to `copier` for template creation
+- `Textual` CLI app / installer / dev tools?
+- Common dev `admin` module

coloco-0.3.0/README.md

@@ -0,0 +1,73 @@
+# Coloco
+
+A kit for creating full-stack apps with co-located code, built on FastAPI and Svelte. Bundle your front-end and back-end code and easily tie them together with codegen.
+
+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";
+</script>
+
+{#await test({ name: "Coloco" })}
+	Loading...
+{:then result}
+	The server says {result}
+{/await}
+```
+
+Serves the page `myapp.com/hello`, which calls `myapp.com/hello/test?name=Coloco` and prints the message `Hello Coloco!`
+
+# Getting Started
+
+- `pip install coloco`
+- `coloco createapp myapp`
+- From `myapp` - `coloco dev`
+
+# Running in Production
+
+- `coloco build`
+
+- `coloco serve`
+
+# Opinions
+
+This framework is opinionated and combines the following excellent tools:
+
+- FastAPI
+- Svelte
+- openapi-ts (codegen)
+- svelte5-router (file-based routing)
+- tortoise-orm (optional)
+
+# Plans
+
+- Deploy tools
+- ORM Support
+- SQLite/Postgres support
+- Package/share modules with git
+
+# Dreams
+
+- Move `node_modules` into `+node`
+- Somehow clean up litter from `uv`
+
+# TODO
+
+- Swap to `cyclopts` for CLI
+- Swap to `copier` for template creation
+- `Textual` CLI app / installer / dev tools?
+- Common dev `admin` module

{coloco-0.2.0 → coloco-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "coloco"
-version = "0.2.0"
+version = "0.3.0"
 description = "A kit for creating FastAPI + Svelte applications"
 authors = [
     { name = "Channel Cat", email = "channelcat@gmail.com" },
@@ -10,6 +10,7 @@ dependencies = [
     "fastapi==0.115.0",
     "PyJWT==2.10.1",
     "tortoise-orm[asyncpg]==0.24.0",
+    "type-less==0.1.4",
     "typer==0.15.2",
     "uvicorn==0.31.0",
 ]

{coloco-0.2.0 → coloco-0.3.0}/src/coloco/__main__.py

@@ -3,13 +3,25 @@ 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
+from .cli.build import build
+from .cli.serve import serve
 
 app = typer.Typer()
 
 app.command()(dev)
 app.add_typer(node_app, name="node")
 app.add_typer(api_app, name="api")
+app.command()(build)
 app.command()(createapp)
+app.command()(serve)
+
+# Add DB if tortoise/aerich are installed
+try:
+    from .cli.db import app as db_app
+
+    app.add_typer(db_app, name="db")
+except ImportError:
+    pass
 
 if __name__ == "__main__":
     app()

{coloco-0.2.0 → coloco-0.3.0}/src/coloco/api.py

@@ -1,16 +1,16 @@
-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 contextlib import asynccontextmanager
 from .exceptions import bind_exceptions
+from fastapi import APIRouter, FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from .lifespan import execute_lifespan, register_lifespan
+import logging
+from os import environ
+from type_less import fill_type_hints
 
 
 logging.basicConfig(level=logging.INFO)
@@ -54,7 +54,7 @@ def create_api(is_dev: bool = False):
     )
 
     # bind_static(api)
-    bind_exceptions(api)
+    bind_exceptions(api, debug=is_dev)
 
     return api
 
@@ -70,6 +70,8 @@ def api(func):
 
 
 def _add_global_route(args, kwargs, func, method: str):
+    fill_type_hints(func, use_literals=True)
+
     # Prepend module name to path
     path = args[0] if args else kwargs.get("path", "")
     path = (

coloco-0.3.0/src/coloco/app.py

@@ -0,0 +1,95 @@
+from .api import create_api, global_router
+from dataclasses import dataclass
+from .db import get_orm_config, lifecycle_connect_database
+from fastapi import FastAPI
+from importlib import import_module
+from .lifespan import register_lifespan
+import os
+from rich import print
+from .static import bind_static
+import traceback
+from typing import Literal
+
+
+@dataclass
+class ColocoApp:
+    api: FastAPI
+    name: str
+    database_url: str = None
+    orm_config: dict = None
+    migrations_dir: str = "./+migrations"
+
+
+def discover_files(directory, name):
+    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.startswith("-")
+                        and not entry.name.startswith(".")
+                        and not entry.name == "node_modules"
+                        and not entry.name == "coloco"
+                    ):
+                        api_files.extend(discover_files(entry.path, name))
+                elif entry.is_file() and entry.name == name:
+                    api_files.append(entry.path)
+    except (PermissionError, FileNotFoundError) as e:
+        print(f"Error accessing {directory}: {e}")
+    return api_files
+
+
+CURRENT_APP = None
+
+
+def create_app(name: str, database_url: str = None) -> ColocoApp:
+    global CURRENT_APP
+    if CURRENT_APP:
+        raise ValueError("Coloco app already created")
+
+    mode: Literal["dev", "prod"] = os.environ.get("COLOCO_MODE", "dev")
+    api = create_api(is_dev=mode == "dev")
+
+    # Discover all api.py files from root, excluding node_modules and +app
+    api_files = discover_files(".", name="api.py")
+    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]")
+            print(traceback.format_exc())
+            continue
+
+    api.include_router(global_router)
+    from fastapi.staticfiles import StaticFiles
+
+    api.mount("/assets", StaticFiles(directory="dist/app/assets"), name="assets")
+
+    # Production mode serves dist
+    if mode == "prod":
+        bind_static(api)
+
+    # Setup Database
+    if database_url:
+        orm_config = get_orm_config(
+            database_url, model_files=discover_files(".", name="models.py")
+        )
+        register_lifespan(lifecycle_connect_database)
+    else:
+        orm_config = None
+
+    CURRENT_APP = ColocoApp(
+        api=api, name=name, database_url=database_url, orm_config=orm_config
+    )
+    return CURRENT_APP
+
+
+def get_current_app() -> ColocoApp:
+    if not CURRENT_APP:
+        raise ValueError("Coloco app not created")
+    return CURRENT_APP

{coloco-0.2.0 → coloco-0.3.0}/src/coloco/cli/api.py

@@ -1,22 +1,24 @@
 from ..app import ColocoApp
+from ..codegen import generate_openapi_schema, generate_openapi_code
 from importlib import import_module
 import os
 from rich import print
 import sys
 import typer
+from typing import Literal
 import uvicorn
 
 
 app = typer.Typer()
 
 
-def _verify_app(app: str):
+def _verify_app(app: str = "main.app") -> ColocoApp:
     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:
         # Needed for when running the binary
@@ -35,17 +37,37 @@ def _verify_app(app: str):
     if not isinstance(var, ColocoApp):
         print(f"[red]{var_name} is not a ColocoApp.  Please use create_app[/red]")
         raise typer.Abort()
-    
-    return True
+
+    return var
+
+
+def _verify_is_packaged():
+    dist_dir = os.path.join(os.getcwd(), "dist")
+    app_dir = os.path.join(dist_dir, "app")
+
+    # Verify dist dir exists
+    if not os.path.exists(dist_dir):
+        print(
+            f"[red]Dist dir {dist_dir} does not exist.  Run [green]coloco build[/green] to package the app.[/red]"
+        )
+        raise typer.Abort()
+    if not os.path.exists(app_dir):
+        print(
+            f"[red]App is missing from package directory {app_dir}.  Run [green]coloco build[/green] to package the app.[/red]"
+        )
+        raise typer.Abort()
+
 
 def _serve(
     app: str = "main.app",
     host: str = "127.0.0.1",
     port: int = 80,
     log_level: str = "info",
+    mode: Literal["dev", "prod"] = "prod",
     reload=False,
 ):
     module_name, var_name = app.rsplit(".", 1)
+    os.environ["COLOCO_MODE"] = mode
     uvicorn.run(
         f"{module_name}:{var_name}.api.service",
         host=host,
@@ -54,13 +76,28 @@ def _serve(
         log_level=log_level,
     )
 
+
 @app.command()
 def serve(
     app: str = "main.app",
     host: str = "127.0.0.1",
     port: int = 80,
     log_level: str = "info",
-    reload=False,
+    mode="prod",
+    reload: bool = False,
 ):
     _verify_app(app)
-    _serve(app=app, host=host, port=port, log_level=log_level, reload=reload)
+    if mode == "prod":
+        _verify_is_packaged()
+    _serve(app=app, host=host, port=port, log_level=log_level, mode=mode, reload=reload)
+
+
+@app.command()
+def codegen(
+    app: str = "main.app",
+):
+    coloco_app = _verify_app(app)
+    print("Generating OpenAPI code...")
+    generate_openapi_schema(coloco_app.api)
+    generate_openapi_code(host="http://localhost:5172")
+    print("[green]OpenAPI code generated successfully.[/green]")

coloco-0.3.0/src/coloco/cli/build.py

@@ -0,0 +1,22 @@
+from rich import print
+from .api import _verify_app, codegen
+from .node import build as build_node
+import os
+
+
+def build(
+    app: str = "main.app",
+):
+    _verify_app(app)
+    dist_dir = f"{os.getcwd()}/dist"
+    print(f"Packaging {app}...")
+
+    # Codegen API
+    codegen(app)
+    # Build node app
+    build_node(dir=dist_dir)
+
+    print(
+        f"App packaged into {dist_dir}.\n"
+        f"Run [green]coloco serve[/green] to start the app in production mode."
+    )

coloco-0.3.0/src/coloco/cli/db.py

@@ -0,0 +1,100 @@
+from aerich import Command
+from .api import _verify_app
+from ..app import ColocoApp, get_current_app
+from asyncio import run
+import functools
+import os
+from rich import print
+from tortoise import Tortoise
+import typer
+
+app = typer.Typer()
+
+def get_app():
+    _verify_app()
+    return get_current_app()
+
+async def get_command(app: ColocoApp = None, init: bool = True):
+    app = app or get_app()
+    command = Command(
+        tortoise_config=app.orm_config,
+        app="models",
+        location=app.migrations_dir,
+    )
+    if init:
+        await command.init()
+    return command
+
+def migrations_dir_exists(migrations_dir: str):
+    migrations_dir = os.path.join(migrations_dir, "models")
+    return os.path.exists(migrations_dir)
+
+def ensure_migrations_dir(migrations_dir: str):
+    if not migrations_dir_exists(migrations_dir):
+        print("[red]Please run `coloco db init` first to initialize the database.[/red]")
+        raise typer.Exit(code=1)
+
+def db_command(func):
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        run(func(*args, **kwargs))
+        run(Tortoise.close_connections())
+    return wrapper
+
+@app.command()
+@db_command
+async def makemigrations():
+    app = get_app()
+    ensure_migrations_dir(app.migrations_dir)
+    command = await get_command(app)
+    migrations = await command.migrate(name="update", empty=False)
+    if migrations:
+        print("[green]Migrations created successfully.[/green]")
+    else:
+        print("[gray]No database changes detected.[/gray]")
+
+@app.command()
+@db_command
+async def migrate():
+    app = get_app()
+    ensure_migrations_dir(app.migrations_dir)
+    command = await get_command(app)
+    migrations = await command.upgrade(run_in_transaction=True)
+    if migrations:
+        print("[green]Database migrated successfully.[/green]")
+    else:
+        print("[gray]No database changes detected.[/gray]")
+
+@app.command()
+@db_command
+async def init():
+    app = get_app()
+    if migrations_dir_exists(app.migrations_dir):
+        print("[red]Migrations directory already exists.  You may want to run `coloco db migrate` instead.[/red]")
+        raise typer.Exit(code=1)
+    command = await get_command(app, init=False)
+    await command.init_db(safe=True)
+    print("[green]Database initialized successfully.[/green]")
+
+@app.command()
+@db_command
+async def revert(version: str, fake: bool = False):
+    app = get_app()
+    ensure_migrations_dir(app.migrations_dir)
+    command = await get_command(app)
+    await command.downgrade(version=version, delete=False, fake=fake)
+
+
+@app.command()
+@db_command
+async def heads():
+    command = await get_command()
+    await command.heads()
+
+@app.command()
+@db_command
+async def history():
+    command = await get_command()
+    await command.history()
+
+

{coloco-0.2.0 → coloco-0.3.0}/src/coloco/cli/dev.py

@@ -1,5 +1,5 @@
 from .api import _verify_app, _serve
-from .node import install
+from .node import install, _setup_dev_env
 import os
 from rich import print
 from subprocess import Popen
@@ -12,14 +12,16 @@ def dev(app: str = "main.app", host: str = "127.0.0.1"):
     if not os.path.exists(os.path.join(os.getcwd(), "node_modules")):
         print("[yellow]Node modules not found, installing...[/yellow]")
         install()
-    
+
+    _setup_dev_env()
     node = Popen([f"npm run dev"], cwd="+node", shell=True)
     _serve(
         app=app,
         host=host,
         port=5172,
-        reload=True,
         log_level="debug",
+        mode="dev",
+        reload=True,
     )
     node.terminate()
     node.wait()

{coloco-0.2.0 → coloco-0.3.0}/src/coloco/cli/node.py

@@ -7,10 +7,7 @@ import subprocess
 app = typer.Typer()
 
 
-@app.command()
-def install():
-    """Installs node dependencies for the project"""
-
+def _run_npm(command):
     # if not exists +node/package.json, raise error
     if not os.path.exists("+node/package.json"):
         print(
@@ -25,13 +22,13 @@ def install():
 
     try:
         # run npm install
-        subprocess.run(["npm", "install"], cwd=".")
+        subprocess.run(command, 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]")
+        print(f"[red]Error: {e}[/red]")
         try:
             os.remove("package.json")
             os.remove("package-lock.json")
@@ -39,11 +36,49 @@ def install():
             pass
         raise typer.Abort()
 
+
+def _setup_dev_env():
+    os.environ["API_HOST"] = "http://localhost:5172"
+
+
+@app.command()
+def install():
+    """Installs node dependencies for the project"""
+
+    _run_npm(["npm", "install"])
+
     print("[green]Packages installed successfully.[/green]")
 
 
+@app.command()
+def add(package: str):
+    """Adds a node dependency to the project"""
+
+    _run_npm(["npm", "add", "-D", package])
+
+    print("[green]Package added successfully.[/green]")
+
+
+@app.command()
+def link(package: str):
+    """Links a node dependency to the project"""
+
+    _run_npm(["npm", "link", package])
+
+    print("[green]Package linked successfully.[/green]")
+
+
 @app.command()
 def dev():
     """Runs the node dev server"""
     print("[green]Running node dev server...[/green]")
+    _setup_dev_env()
     subprocess.run(["npm", "run", "dev"], cwd="+node")
+
+
+@app.command()
+def build(dir: str = None):
+    """Runs the node dev server"""
+    print("[green]Building node app...[/green]")
+
+    subprocess.run(["npm", "run", "build"], cwd="+node")

coloco-0.3.0/src/coloco/cli/serve.py

@@ -0,0 +1,14 @@
+from rich import print
+from .api import _serve
+import os
+import typer
+import uvicorn
+
+
+def serve(
+    app: str = "main.app",
+    port: int = 80,
+    host: str = "0.0.0.0",
+    log_level: str = "info",
+):
+    return _serve(app=app, host=host, port=port, log_level=log_level, mode="prod")

coloco-0.3.0/src/coloco/db.py

@@ -0,0 +1,39 @@
+from contextlib import asynccontextmanager
+from rich import print
+
+def get_orm_config(database_url: str, model_files: list[str]):
+    return {
+        "connections": {
+            "default": database_url
+        },
+        "apps": {
+            "models": {
+                "models": [
+                    *[model_file.replace("./", "").replace("/", ".").replace(".py", "") for model_file in model_files],
+                    "aerich.models",
+                ],
+                "default_connection": "default",
+            },
+        },
+    }
+
+@asynccontextmanager
+async def lifecycle_connect_database(api):
+    from .app import get_current_app
+    app = get_current_app()
+
+    try:
+        from tortoise import Tortoise
+    except ImportError:
+        print("[red]Tortoise is not installed.  "
+              "Please install it with `pip install tortoise-orm`.  "
+              "If you intend to use anything other than sqlite, "
+              "you will need to install the appropriate database driver as well "
+              "(e.g. `pip install tortoise-orm[asyncpg]` for postgres).[/red]")
+        raise
+    print("[green]Connecting to database...[/green]")
+    await Tortoise.init(config=app.orm_config)
+    print("[green]Database ready[/green]")
+    yield
+    print("[yellow]Closing database connection...[/yellow]")
+    await Tortoise.close_connections()

{coloco-0.2.0 → coloco-0.3.0}/src/coloco/exceptions.py

@@ -1,6 +1,7 @@
 from fastapi import FastAPI
 from fastapi.responses import JSONResponse
 from fastapi.requests import Request
+from traceback import format_list, extract_tb
 
 
 class UserError(Exception):
@@ -16,17 +17,24 @@ class ServerError(Exception):
     pass
 
 
-def bind_exceptions(api: FastAPI):
+def _get_error_json(exception: Exception, debug: bool = False):
+    error = {"name": getattr(exception, "code", "api_error"), "message": f"{exception}"}
+    if debug:
+        error["stack"] = format_list(extract_tb(exception.__traceback__))
+    return error
+
+
+def bind_exceptions(api: FastAPI, debug: bool = False):
     @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}"}},
+            content=_get_error_json(exc, debug=debug),
         )
 
     @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}"}},
+            content=_get_error_json(exc, debug=debug),
         )

{coloco-0.2.0 → coloco-0.3.0}/src/coloco/lifespan.py

@@ -14,8 +14,10 @@ async def execute_lifespan(app: FastAPI):
         contexts.append(generator)
         if hasattr(generator, "__aenter__"):
             await generator.__aenter__()
-        else:
+        elif hasattr(generator, "__enter__"):
             next(generator)
+        else:
+            raise ValueError(f"Invalid lifespan handler: {lifespan_handler}.  Must be an sync/async context manager.")
 
     yield
 

coloco-0.3.0/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, dist_dir: str = "dist"):
+    api.mount("/assets", StaticFiles(directory=f"{dist_dir}/app/assets"), name="static")
+
+    @api.get("/{all_paths:path}")
+    async def serve_app(all_paths: str):
+        return FileResponse(f"{dist_dir}/app/index.html")

{coloco-0.2.0 → coloco-0.3.0}/src/coloco/templates/standard/+app/app.svelte-tpl

@@ -1,17 +1,17 @@
 <script lang="ts">
-  import { setupClient } from "@coloco/api-client-svelte";
+  import { makeClient, setDefaultClient } from "@coloco/api-client-svelte";
   import { route, Router, getRoutes } from "@coloco/router";
 
   import Index from "./index.svelte";
   import NotFound from "./404.svelte";
 
-  setupClient({
-    baseUrl: "http://localhost:5172",
-  });
+  const client = makeClient({ baseUrl: import.meta.env.API_HOST });
   const routes = getRoutes({
     index: Index,
     notFound: NotFound,
   });
+  
+  setDefaultClient(client);
 </script>
 
 <main>

{coloco-0.2.0 → coloco-0.3.0}/src/coloco/templates/standard/+node/package.json-tpl

@@ -10,8 +10,8 @@
     "check": "svelte-check --tsconfig ./tsconfig.app.json && tsc -p tsconfig.node.json"
   },
   "devDependencies": {
-    "@coloco/api-client-svelte": "^0.1.1",
-    "@coloco/router": "^0.1.2",
+    "@coloco/api-client-svelte": "^0.3.0",
+    "@coloco/router": "^0.1.5",
     "@hey-api/client-fetch": "^0.8.2",
     "@hey-api/openapi-ts": "^0.64.7",
     "@sveltejs/vite-plugin-svelte": "^5.0.3",

{coloco-0.2.0 → coloco-0.3.0}/src/coloco/templates/standard/+node/vite.config.ts-tpl

@@ -14,6 +14,10 @@ export default defineConfig({
     host: "0.0.0.0",
     port: 5173,
   },
+  build: {
+    outDir: '../dist/app',
+    emptyOutDir: true, // also necessary
+  },
   clearScreen: false,
   resolve: {
     // @ts-ignore
@@ -29,6 +33,16 @@ export default defineConfig({
     {
       find: '@api',
       replacement: '/.generated/client/api'
+    },
+    // @ts-ignore
+    {
+      find: '@app/',
+      replacement: '/'
+    },
+    // @ts-ignore
+    {
+      find: '@root',
+      replacement: '/..'
     }]
   }
 })

coloco-0.3.0/src/coloco/templates/standard/pyproject.toml-tpl

@@ -0,0 +1,13 @@
+[project]
+name = "{{ project_name }}"
+version = "0.1.0"
+description = "Your project description here"
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+    "coloco>=0.2.0",
+]
+
+[tool.coloco]
+app = "main.app"
+migrations_dir = "./+migrations"

coloco-0.2.0/README.md

@@ -1,50 +0,0 @@
-# Coloco
-
-A kit for creating full-stack apps with co-located code, built on FastAPI and Svelte.  Bundle your front-end and back-end code and easily tie them together with codegen.
-
-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 response = test({ query: { name: "Coloco" } });
-</script>
-
-{#if $response.loading}
-    Loading...
-{:else}
-    The server says {$response.data}
-{/if}
-```
-
-Serves the page `myapp.com/hello`, which calls `myapp.com/hello/test?name=Coloco` and prints the message `Hello Coloco!`
-
-# Opinions
-
-This framework is opinionated and combines the following excellent tools:
- * FastAPI
- * Svelte
- * openapi-ts (codegen)
- * svelte5-router (file-based routing)
- * tortoise-orm (optional)
-
-# Plans
- * Deploy tools
- * ORM Support
- * SQLite/Postgres support
-
-# Dreams
- * Move `node_modules` into `+node`
- * Remove the need for `query`, `params`, `body` for simple REST requests (maybe use legacy client but support the new one?)

coloco-0.2.0/src/coloco/app.py

@@ -1,58 +0,0 @@
-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.2.0/src/coloco/requirements.txt

@@ -1,6 +0,0 @@
-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.2.0/src/coloco/static.py

@@ -1,12 +0,0 @@
-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.2.0/src/coloco/templates/standard/requirements.txt-tpl

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