coloco 0.3.4__tar.gz → 0.3.6__tar.gz

{coloco-0.3.4 → coloco-0.3.6}/PKG-INFO

@@ -1,17 +1,17 @@
 Metadata-Version: 2.1
 Name: coloco
-Version: 0.3.4
+Version: 0.3.6
 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: type-less>=0.1.8
-Requires-Dist: typer==0.15.2
-Requires-Dist: uvicorn==0.31.0
+Requires-Python: >=3.12
+Requires-Dist: cyclopts>=3.18.0
+Requires-Dist: fastapi>=0.115.0
+Requires-Dist: PyJWT>=2.10.1
+Requires-Dist: tortoise-orm[asyncpg]>=0.24.0
+Requires-Dist: tortoise-pathway==0.1.6
+Requires-Dist: type-less>=0.1.16
+Requires-Dist: uvicorn>=0.31.0
 Description-Content-Type: text/markdown
 
 # Coloco
@@ -56,8 +56,8 @@ Serves the page `myapp.com/hello`, which calls `myapp.com/hello/test?name=Coloco
 # Running in Production
 
 - `coloco build`
-
-- `coloco serve`
+- Artifacts will be saved to `dist`
+- From dist, run `coloco serve`
 
 # Opinions
 
@@ -69,21 +69,28 @@ This framework is opinionated and combines the following excellent tools:
 - svelte5-router (file-based routing)
 - tortoise-orm (optional)
 
-# Plans
+# TBD Required features for launch
 
 - Deploy tools
-- ORM Support
-- SQLite/Postgres support
+- Swap migrations to `tortoise-pathway` once cross-app migrations are supported
+- Config with secrets encryption
 - Package/share modules with git
+- Docs
+
+# Features in development
+
+- CRUD
+- Caching
+- User module
+- Dev tools module
+- Admin panel module
 
 # Dreams
 
 - Move `node_modules` into `+node`
-- Somehow clean up litter from `uv`
 
-# TODO
+# Other TODO
 
-- Swap to `cyclopts` for CLI
 - Swap to `copier` for template creation
 - `Textual` CLI app / installer / dev tools?
-- Common dev `admin` module
+- Resolve duplicate types in openapi spec (due to model serializers)

{coloco-0.3.4 → coloco-0.3.6}/README.md

@@ -40,8 +40,8 @@ Serves the page `myapp.com/hello`, which calls `myapp.com/hello/test?name=Coloco
 # Running in Production
 
 - `coloco build`
-
-- `coloco serve`
+- Artifacts will be saved to `dist`
+- From dist, run `coloco serve`
 
 # Opinions
 
@@ -53,21 +53,28 @@ This framework is opinionated and combines the following excellent tools:
 - svelte5-router (file-based routing)
 - tortoise-orm (optional)
 
-# Plans
+# TBD Required features for launch
 
 - Deploy tools
-- ORM Support
-- SQLite/Postgres support
+- Swap migrations to `tortoise-pathway` once cross-app migrations are supported
+- Config with secrets encryption
 - Package/share modules with git
+- Docs
+
+# Features in development
+
+- CRUD
+- Caching
+- User module
+- Dev tools module
+- Admin panel module
 
 # Dreams
 
 - Move `node_modules` into `+node`
-- Somehow clean up litter from `uv`
 
-# TODO
+# Other TODO
 
-- Swap to `cyclopts` for CLI
 - Swap to `copier` for template creation
 - `Textual` CLI app / installer / dev tools?
-- Common dev `admin` module
+- Resolve duplicate types in openapi spec (due to model serializers)

{coloco-0.3.4 → coloco-0.3.6}/pyproject.toml

@@ -1,20 +1,20 @@
 [project]
 name = "coloco"
-version = "0.3.4"
+version = "0.3.6"
 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",
-    "type-less>=0.1.8",
-    "typer==0.15.2",
-    "uvicorn==0.31.0",
+    "cyclopts>=3.18.0",
+    "fastapi>=0.115.0",
+    "PyJWT>=2.10.1",
+    "tortoise-orm[asyncpg]>=0.24.0",
+    "tortoise-pathway==0.1.6",
+    "type-less>=0.1.16",
+    "uvicorn>=0.31.0",
 ]
-requires-python = ">=3.11"
+requires-python = ">=3.12"
 readme = "README.md"
 
 [project.license]
@@ -31,3 +31,7 @@ build-backend = "pdm.backend"
 
 [tool.pdm]
 distribution = true
+
+[tool.uv.sources.tortoise-pathway]
+git = "https://github.com/channelcat/tortoise-pathway"
+rev = "multi-app-support"

{coloco-0.3.4 → coloco-0.3.6}/src/coloco/__init__.py

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

{coloco-0.3.4 → coloco-0.3.6}/src/coloco/__main__.py

@@ -1,16 +1,16 @@
-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
 from .cli.build import build
 from .cli.serve import serve
+import cyclopts
 
-app = typer.Typer()
+app = cyclopts.App()
 
-app.command()(dev)
-app.add_typer(node_app, name="node")
-app.add_typer(api_app, name="api")
+app.command(dev, name="dev")
+app.command(node_app, name="node")
+app.command(api_app, name="api")
 app.command()(build)
 app.command()(createapp)
 app.command()(serve)
@@ -19,7 +19,7 @@ app.command()(serve)
 try:
     from .cli.db import app as db_app
 
-    app.add_typer(db_app, name="db")
+    app.command(db_app, name="db")
 except ImportError:
     pass
 

{coloco-0.3.4 → coloco-0.3.6}/src/coloco/api.py

@@ -4,20 +4,36 @@ from .codegen import (
     generate_openapi_schema,
 )
 from contextlib import asynccontextmanager
+from dataclasses import dataclass
 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
 from threading import Thread
+from type_less import fill_type_hints
+from typing import Callable, TypeVar
 
 
 logging.basicConfig(level=logging.INFO)
 
 
+T = TypeVar("T")
+
+
+@dataclass
+class ColocoRoute:
+    args: tuple
+    kwargs: dict
+    func: Callable
+    method: str
+    module_name: str
+
+
 def _generate_openapi_thread(app: FastAPI):
+    # TODO: diff check the schema json
+    # TODO: diff check not working
     logging.info("Generating OpenAPI schema in thread...")
     generate_openapi_schema(app)
     generate_openapi_code(host=f"http://localhost:5172", diff_files=True)
@@ -33,16 +49,17 @@ async def generate_openapi(app: FastAPI):
 
 
 def create_api(is_dev: bool = False):
+    kwargs = {
+        "lifespan": execute_lifespan,
+    }
     if not is_dev:
         kwargs = {
+            **kwargs,
             "openapi_url": None,
             "docs_url": None,
             "redoc_url": None,
         }
     else:
-        kwargs = {
-            "lifespan": execute_lifespan,
-        }
         register_lifespan(generate_openapi)
 
     api = FastAPI(
@@ -60,7 +77,6 @@ def create_api(is_dev: bool = False):
         allow_headers=["*"],
     )
 
-    # bind_static(api)
     bind_exceptions(api, debug=is_dev)
 
     return api
@@ -68,7 +84,7 @@ def create_api(is_dev: bool = False):
 
 # ========================= Global routing =========================
 
-global_router = APIRouter()
+global_routes: list[ColocoRoute] = []
 
 
 def api(func):
@@ -77,8 +93,6 @@ def api(func):
 
 
 def _add_global_route(args, kwargs, func, method: str):
-    fill_type_hints(func, use_literals=True)
-
     module_name = func.__module__.lstrip("src.app")
 
     # Prepend module name to path
@@ -87,7 +101,10 @@ def _add_global_route(args, kwargs, func, method: str):
         # TODO: Make this configurable
         "/api/"
         # TODO: Make this read project configuration, probably need to add routes after running
-        + module_name.rsplit(".", 1)[0].replace(".", "/")
+        + module_name.rsplit(".", 1)[0]
+        .replace(".", "/")
+        .replace(".-", ".")  # Strip - from folders (for dev only)
+        .lstrip("-")
         + ("" if path.startswith("/") else "/")
         + path
     )
@@ -96,18 +113,11 @@ def _add_global_route(args, kwargs, func, method: str):
     else:
         kwargs["path"] = path
 
-    return global_router.api_route(
-        *args,
-        **{
-            **kwargs,
-            "summary": (kwargs.get("summary", "") + f" ({module_name})").strip(),
-            "methods": [method],
-        },
-    )(func)
+    return global_routes.append(ColocoRoute(args, kwargs, func, method, module_name))
 
 
-def _make_route_decorator(method: str):
-    def route_wrapper(*args, **kwargs):
+def _make_route_decorator(method: str) -> Callable[..., Callable[[T], T]]:
+    def route_wrapper(*args, **kwargs) -> Callable[[T], T]:
         def handler_wrapper(func):
             return _add_global_route(args, kwargs, func, method)
 

{coloco-0.3.4 → coloco-0.3.6}/src/coloco/app.py

@@ -1,13 +1,17 @@
-from .api import create_api, global_router
+from .api import create_api, global_routes
 from dataclasses import dataclass
-from .db import get_orm_config, lifecycle_connect_database
-from fastapi import FastAPI
+from .db import (
+    get_orm_config,
+    inject_model_serializers,
+    register_db_lifecycle,
+)
+from fastapi import APIRouter, 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 type_less import fill_type_hints
 from typing import Literal
 
 
@@ -17,10 +21,10 @@ class ColocoApp:
     name: str
     database_url: str = None
     orm_config: dict = None
-    migrations_dir: str = "./+migrations"
+    migrations_dir: str = "+migrations"
 
 
-def discover_files(directory, name):
+def discover_files(directory, name, is_dev=False):
     api_files = []
     try:
         with os.scandir(directory) as entries:
@@ -29,12 +33,12 @@ def discover_files(directory, name):
                     # Skip directories starting with "+" and "node_modules"
                     if (
                         not entry.name.startswith("+")
-                        and not entry.name.startswith("-")
+                        and (not entry.name.startswith("-") or is_dev)
                         and not entry.name.startswith(".")
                         and not entry.name == "node_modules"
                         and not entry.name == "coloco"
                     ):
-                        api_files.extend(discover_files(entry.path, name))
+                        api_files.extend(discover_files(entry.path, name, is_dev))
                 elif entry.is_file() and entry.name == name:
                     api_files.append(entry.path)
     except (PermissionError, FileNotFoundError) as e:
@@ -53,8 +57,10 @@ def create_app(name: str, database_url: str = None) -> ColocoApp:
     mode: Literal["dev", "prod"] = os.environ.get("COLOCO_MODE", "dev")
     api = create_api(is_dev=mode == "dev")
 
+    src_path = "src"
+
     # Discover all api.py files from root, excluding node_modules and +app
-    api_files = discover_files(".", name="api.py")
+    api_files = discover_files(src_path, name="api.py", is_dev=mode == "dev")
     for api_file in api_files:
         # convert python file path to module path
         module_name = api_file.replace("./", "").replace(".py", "").replace("/", ".")
@@ -65,24 +71,47 @@ def create_app(name: str, database_url: str = None) -> ColocoApp:
             print(traceback.format_exc())
             continue
 
-    api.include_router(global_router)
-
-    # Production mode serves dist
-    if mode == "prod":
-        bind_static(api)
+    # Inject type hints
+    for route in global_routes:
+        fill_type_hints(route.func, use_literals=True)
 
     # Setup Database
-    if database_url:
+    # We need this first to grab the models for route type hints
+    has_database = bool(database_url)
+    if has_database:
         orm_config = get_orm_config(
-            database_url, model_files=discover_files(".", name="models.py")
+            database_url,
+            model_files=discover_files(src_path, name="models.py", is_dev=mode == "dev"),
         )
-        register_lifespan(lifecycle_connect_database)
+        inject_model_serializers(orm_config, global_routes)
     else:
         orm_config = None
 
-    CURRENT_APP = ColocoApp(
-        api=api, name=name, database_url=database_url, orm_config=orm_config
-    )
+    router = APIRouter()
+    for route in global_routes:
+        router.api_route(
+            *route.args,
+            **{
+                **route.kwargs,
+                **{
+                    "summary": (
+                        route.kwargs.get("summary", "") + f" ({route.module_name})"
+                    ).strip(),
+                    "methods": [route.method],
+                },
+            },
+        )(route.func)
+    api.include_router(router)
+
+    # Production mode serves dist
+    if mode == "prod":
+        bind_static(api)
+
+    CURRENT_APP = ColocoApp(api=api, name=name, database_url=database_url, orm_config=orm_config)
+
+    if database_url:
+        register_db_lifecycle(CURRENT_APP)
+
     return CURRENT_APP
 
 

{coloco-0.3.4 → coloco-0.3.6}/src/coloco/cli/api.py

@@ -1,15 +1,15 @@
 from ..app import ColocoApp
 from ..codegen import generate_openapi_schema, generate_openapi_code
+import cyclopts
 from importlib import import_module
 import os
 from rich import print
 import sys
-import typer
 from typing import Literal
 import uvicorn
 
 
-app = typer.Typer()
+app = cyclopts.App()
 
 
 def _verify_app(app: str = "src.main.app") -> ColocoApp:
@@ -17,7 +17,7 @@ def _verify_app(app: str = "src.main.app") -> ColocoApp:
         print(
             "[red]App should be the name of a variable in a python file, example: main.py -> api = main.api[/red]"
         )
-        raise typer.Abort()
+        raise SystemExit(1)
 
     module_name, var_name = app.rsplit(".", 1)
     try:
@@ -26,17 +26,17 @@ def _verify_app(app: str = "src.main.app") -> ColocoApp:
         module = import_module(module_name)
     except ModuleNotFoundError:
         print(f"[red]Module or python file {module_name} not found[/red]")
-        raise typer.Abort()
+        raise SystemExit(1)
 
     if not hasattr(module, var_name):
         print(f"[red]Variable {var_name} not found in module {module_name}[/red]")
-        raise typer.Abort()
+        raise SystemExit(1)
 
     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()
+        raise SystemExit(1)
 
     return var
 
@@ -50,12 +50,12 @@ def _verify_is_packaged():
         print(
             f"[red]Dist dir {dist_dir} does not exist.  Run [green]coloco build[/green] to package the app.[/red]"
         )
-        raise typer.Abort()
+        raise SystemExit(1)
     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()
+        raise SystemExit(1)
 
 
 def _serve(

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

@@ -0,0 +1,66 @@
+from .api import _verify_app, codegen
+from ..config import get_coloco_config
+from .node import build as build_node
+import os
+from pathlib import Path
+from rich import print
+import shutil
+
+
+def build(
+    app: str | None = None,
+):
+    if not app:
+        app = get_coloco_config().get("app") or "src.main.app"
+
+    _verify_app(app)
+
+    cwd = Path(os.getcwd())
+    source_dir = cwd / "src"
+    dist_dir = cwd / "dist"
+    api_dir = dist_dir / "src"
+    frontend_dir = dist_dir / "static"
+
+    print(f"Clearing {dist_dir}...")
+    shutil.rmtree(dist_dir, ignore_errors=True)
+
+    # # Codegen API
+    codegen(app)
+
+    # # Build node app
+    print(f"Packaging app...")
+    build_node(dir=frontend_dir)
+
+    print(f"Adding source files...")
+
+    api_dir.mkdir(parents=True, exist_ok=True)
+
+    # Collect backend files
+    package_api_files = get_coloco_config().get("package_api_files") or ["*.py"]
+    for glob_pattern in package_api_files:
+        # If glob_pattern starts with /, assume non-recursive
+        files = (
+            source_dir.glob(glob_pattern[1:])
+            if glob_pattern.startswith("/")
+            else source_dir.rglob(glob_pattern)
+        )
+        for file in files:
+            # Skip dev files
+            if "/-" in str(file):
+                continue
+
+            destination = api_dir / file.relative_to(source_dir)
+            destination.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy(file, destination)
+            print(f" |- {file.relative_to(cwd)}")
+
+    print(f"Adding project files...")
+    shutil.copy(cwd / "pyproject.toml", dist_dir / "pyproject.toml")
+    shutil.copy(cwd / "uv.lock", dist_dir / "uv.lock")
+
+    print(
+        f"App packaged into {dist_dir}.\n"
+        f"From the [yellow]{dist_dir}[/yellow] directory:\n"
+        f"  Run [green]uv sync --frozen[/green] to install dependencies.\n"
+        f"  Run [green]coloco serve[/green] to start the app in production mode.\n"
+    )

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

@@ -0,0 +1,144 @@
+from .api import _verify_app
+from ..app import ColocoApp, get_current_app
+from asyncio import run
+import cyclopts
+import functools
+import logging
+import os
+from pathlib import Path
+from rich import print
+from tortoise import Tortoise
+from tortoise.log import logger as tortoise_logger
+from tortoise_pathway.migration_manager import MigrationManager
+from typing import Callable, TypeVar
+
+
+T = TypeVar("T")
+
+
+app = cyclopts.App()
+
+
+def _get_model_apps(coloco_app: ColocoApp):
+    return [app for app in coloco_app.orm_config["apps"]]
+
+
+def _get_coloco_app():
+    _verify_app()
+    return get_current_app()
+
+
+def _get_app_migrations_path_func(migrations_dir: str) -> Callable[[str], Path]:
+    def _get_app_migrations_path(self, app) -> Path:
+        return Path(os.path.join("src", "app", app, migrations_dir))
+
+    return _get_app_migrations_path
+
+
+def db_command(func):
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        tortoise_logger.setLevel(logging.WARNING)
+        run(func(*args, **kwargs))
+        run(Tortoise.close_connections())
+
+    return app.command(name=func.__name__)(wrapper)
+
+
+async def get_migration_manager():
+    coloco_app = _get_coloco_app()
+    apps = _get_model_apps(coloco_app)
+    await Tortoise.init(config=coloco_app.orm_config)
+
+    # TODO: propose a patch for this
+    MigrationManager.get_migrations_dir = _get_app_migrations_path_func(coloco_app.migrations_dir)
+
+    manager = MigrationManager(apps, coloco_app.migrations_dir)
+    await manager.initialize()
+
+    return manager
+
+
+# ----------------------------- Commands -----------------------------
+
+
+@db_command
+async def makemigrations(
+    app: str | None = None, name: str | None = None, empty: bool = False
+) -> None:
+    """Create new migration(s) based on model changes."""
+    manager = await get_migration_manager()
+
+    print(f"Making migrations for {app or 'all apps'}...", end="", flush=True)
+
+    migrations = await manager.create_migration(name, app=app, auto=True)
+
+    if not migrations:
+        print("[gray]no changes[/gray]")
+        return
+
+    print()
+    for migration in migrations:
+        print(f" |- [yellow]{migration.display_name()}[/yellow] @ {migration.path()}")
+
+
+@db_command
+async def migrate(app: str | None = None) -> None:
+    """Apply migrations to the database."""
+    manager = await get_migration_manager()
+
+    pending = manager.get_pending_migrations(app=app)
+
+    if not pending:
+        print("[gray]No pending migrations.[/gray]")
+        return
+
+    s = "s" if len(pending) > 1 else ""
+    print(f"Applying [cyan]{len(pending)}[/cyan] migration{s}:")
+
+    applied = []
+    async for migration in manager.apply_migrations_async(app=app):
+        print(f" |- [cyan]{migration.display_name()}[/cyan]")
+        applied.append(migration)
+
+    if applied:
+        print(f"[green]Successfully applied {len(applied)} migration{s}[/green]")
+    else:
+        print("[gray]No migrations were applied.[/gray]")
+
+
+@db_command
+async def rollback(app: str | None = None, migration: str | None = None) -> None:
+    """Revert the most recent migration."""
+    manager = await get_migration_manager()
+
+    reverted = await manager.revert_migration(migration=migration, app=app)
+
+    if reverted:
+        print(f"Successfully reverted migration: [yellow]{reverted.display_name()}[/yellow]")
+    else:
+        print("[gray]No migration was reverted.[/gray]")
+
+
+@db_command
+async def showmigrations(app: str | None = None) -> None:
+    """Show migration status."""
+    manager = await get_migration_manager()
+
+    applied = manager.get_applied_migrations(app=app)
+    pending = manager.get_pending_migrations(app=app)
+
+    print(f"Migrations for {app}:" if app else "All Migrations:")
+    print("\nApplied migrations:")
+    if applied:
+        for migration in applied:
+            print(f"  [X] {migration.display_name()}")
+    else:
+        print("  (none)")
+
+    print("\nPending migrations:")
+    if pending:
+        for migration in pending:
+            print(f"  [ ] {migration.display_name()}")
+    else:
+        print("  (none)")

{coloco-0.3.4 → coloco-0.3.6}/src/coloco/cli/dev.py

@@ -1,24 +1,28 @@
 from .api import _verify_app, _serve
+import cyclopts
 from ..config import get_coloco_config
 from .node import install, _setup_dev_env
 import os
 from rich import print
 from subprocess import Popen
 
+app = cyclopts.App()
 
-def dev(app: str = None, host: str = "127.0.0.1"):
+
+@app.default()
+def dev(app: str | None = None, host: str = "127.0.0.1"):
     if not app:
         app = get_coloco_config().get("app") or "src.main.app"
 
     _verify_app(app)
 
-    # Check Node Modules
-    if not os.path.exists(os.path.join(os.getcwd(), "node_modules")):
-        print("[yellow]Node modules not found, installing...[/yellow]")
-        install()
+    # # Check Node Modules
+    # 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"], shell=True)
+    # _setup_dev_env()
+    # node = Popen([f"npm run dev"], shell=True)
     _serve(
         app=app,
         host=host,

{coloco-0.3.4 → coloco-0.3.6}/src/coloco/cli/node.py

@@ -1,10 +1,10 @@
-import typer
+import cyclopts
 import os
 from rich import print
 import shutil
 import subprocess
 
-app = typer.Typer()
+app = cyclopts.App()
 
 
 def _run_npm(command):
@@ -13,14 +13,14 @@ def _run_npm(command):
         print(
             "[red]Error: package.json not found.  Please ensure you are in a coloco project directory.[/red]"
         )
-        raise typer.Abort()
+        raise SystemExit(1)
 
     try:
         # run npm install
         subprocess.run(command, cwd=".")
     except Exception as e:
         print(f"[red]Error: {e}[/red]")
-        raise typer.Abort()
+        raise SystemExit(1)
 
 
 def _setup_dev_env():
@@ -63,8 +63,8 @@ def dev():
 
 
 @app.command()
-def build(dir: str = None):
+def build(dir: str | None = None):
     """Runs the node dev server"""
     print("[green]Building node app...[/green]")
 
-    subprocess.run(["npm", "run", "build"], cwd=".")
+    subprocess.run(["npm", "run", "build", *(["--", "--outDir", dir] if dir else [])], cwd=".")

{coloco-0.3.4 → coloco-0.3.6}/src/coloco/cli/serve.py

@@ -1,14 +1,14 @@
-from rich import print
 from .api import _serve
-import os
-import typer
-import uvicorn
+from ..config import get_coloco_config
 
 
 def serve(
-    app: str = "main.app",
+    app: str | None = None,
     port: int = 80,
     host: str = "0.0.0.0",
     log_level: str = "info",
 ):
+    if not app:
+        app = get_coloco_config().get("app") or "src.main.app"
+
     return _serve(app=app, host=host, port=port, log_level=log_level, mode="prod")

coloco-0.3.6/src/coloco/db.py

@@ -0,0 +1,143 @@
+from .api import ColocoRoute
+from contextlib import asynccontextmanager
+from collections import defaultdict
+from functools import wraps
+from .lifespan import register_lifespan
+from rich import print
+from type_less import replace_type_hint_map_deep
+from typing import Callable, Type, TypeVar, Optional, Any
+from pydantic import ConfigDict
+
+
+CLS = TypeVar("CLS")
+
+
+IMPORT_ERROR = (
+    "[red]Tortoise is not installed.  "
+    "Please install it with `uv add tortoise-orm`.  "
+    "If you intend to use anything other than sqlite, "
+    "you will need to install the appropriate database driver as well "
+    "(e.g. `uv add tortoise-orm[asyncpg]` for postgres).[/red]"
+)
+
+
+def app_class_to_table_name(cls):
+    try:
+        app_name = cls.__module__.split(".")[-2]
+    except IndexError:
+        raise ValueError(f"Could not determine app name for model {cls}")
+    return f"{app_name}_{cls.__name__.lower()}"
+
+
+def get_orm_config(database_url: str, model_files: list[str]):
+    model_modules = [
+        model_file.replace("./", "").replace("/", ".").replace(".py", "")
+        for model_file in model_files
+    ]
+    app_to_models = defaultdict(list)
+    for model_module in model_modules:
+        app = model_module.lstrip("src.app.").split(".")[0]
+        app_to_models[app].append(model_module)
+    return {
+        "connections": {"default": database_url},
+        "table_name_generator": app_class_to_table_name,
+        "apps": {
+            app: {
+                "models": [
+                    *models,
+                ],
+                "default_connection": "default",
+            }
+            for app, models in app_to_models.items()
+        },
+    }
+
+
+async def init_tortoise(app):
+    try:
+        from tortoise import Tortoise
+    except ImportError:
+        print(IMPORT_ERROR)
+        raise
+    await Tortoise.init(config=app.orm_config, table_name_generator=app_class_to_table_name)
+    return Tortoise.close_connections
+
+
+def register_db_lifecycle(app):
+    @asynccontextmanager
+    async def lifecycle_connect_database(api):
+        print("[green]Connecting to database...[/green]")
+        close_connections = await init_tortoise(app)
+        print("[green]Database ready[/green]")
+        yield
+        print("[yellow]Closing database connection...[/yellow]")
+        await close_connections()
+
+    # Register DB Connection
+    register_lifespan(lifecycle_connect_database)
+
+
+def inject_model_serializers(orm_config: dict, routes: list[ColocoRoute]):
+    try:
+        from tortoise import Tortoise
+        from tortoise.contrib.pydantic import pydantic_model_creator
+    except ImportError:
+        print(IMPORT_ERROR)
+        raise
+
+    # TODO: find out if we can init the config without initing the DB
+    Tortoise.table_name_generator = app_class_to_table_name
+    for label, _app in orm_config["apps"].items():
+        for model in _app["models"]:
+            Tortoise.init_models([model], label)
+
+    # Auto-create serializers
+    # TODO: configurable
+    model_classes = [cls for models in Tortoise.apps.values() for cls in models.values()]
+    model_to_serializer = {}
+    for model_class in model_classes:
+        # Wrapped with @serializable
+        if getattr(model_class, "__model_serializer_create", None):
+            model_class.__model_serializer = pydantic_model_creator(
+                model_class, **model_class.__model_serializer_create
+            )
+        # Create a general serializer
+        elif not getattr(model_class, "__model_serializer", None):
+            model_class.__model_serializer = pydantic_model_creator(model_class)
+        model_to_serializer[model_class] = model_class.__model_serializer
+
+    for route in routes:
+        route.func.__annotations__["return"], occurrences = replace_type_hint_map_deep(
+            route.func.__annotations__["return"],
+            model_to_serializer,
+        )
+
+        # Magical model adapting (when models detected)
+        # TODO: find a better way to do this than wrapping every route
+        # We need to async eval the serialization
+        # - Middleware - can't catch pre-serialized values
+        # - Pydantic - sync serialization only
+        # - JSON Encoder - sync serialization only, + happens after serialization
+        if occurrences:
+            route.func = _wrap_model_serializer(route.func)
+
+
+async def _serialize_models(obj):
+    """
+    Auto-runs the serializer for tortoise models
+    """
+    if hasattr(obj, "__model_serializer"):
+        return await obj.__model_serializer.from_tortoise_orm(obj)
+    elif isinstance(obj, list):
+        return [await _serialize_models(item) for item in obj]
+    elif isinstance(obj, dict):
+        return {k: await _serialize_models(v) for k, v in obj.items()}
+    return obj
+
+
+def _wrap_model_serializer(func):
+    @wraps(func)
+    async def wrapper(*args, **kwargs):
+        return await _serialize_models(await func(*args, **kwargs))
+
+    return wrapper

coloco-0.3.6/src/coloco/dependencies.py

@@ -0,0 +1,6 @@
+from fastapi import Depends
+from typing import Annotated
+
+from .app import ColocoApp as ColocoAppType, get_current_app
+
+ColocoApp = Annotated[ColocoAppType, Depends(get_current_app)]

{coloco-0.3.4 → coloco-0.3.6}/src/coloco/static.py

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

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

@@ -1,22 +0,0 @@
-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.4/src/coloco/cli/db.py

@@ -1,100 +0,0 @@
-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.3.4/src/coloco/db.py

@@ -1,39 +0,0 @@
-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()