skeleton-framework 0.1.0__py3-none-any.whl

skeleton/infrastructure/bootstrap/src/templates/app/frontend/skeleton-config.json

@@ -0,0 +1,29 @@
+{
+    "entry": {
+        "main": "main",
+        "index": "index"
+    },
+    "lib": {
+        "src": "src",
+        "dist": "dist",
+        "static": "static"
+    },
+    "devServer": {
+        "open": false,
+        "historyApiFallback": true,
+        "host": "127.0.0.1",
+        "port": 80,
+        "hot": true,
+        "overlay": true
+    },
+    "proxy": {
+        "on": false,
+        "host": "127.0.0.1",
+        "port": 8888,
+        "changeOrigin": true,
+        "secure": false
+    },
+    "tsconfig": {
+        "configFile": "./tsconfig.json"
+    }
+}

skeleton/infrastructure/bootstrap/src/templates/app/frontend/src/index.html

@@ -0,0 +1,16 @@
+<!DOCTYPE html>
+<html lang="en">
+    <head>
+        
+        <meta charset="UTF-8">
+        <meta name="viewport" content="width=device-width, initial-scale=1.0">
+        
+        <title>Skeleton</title>
+
+        <link
+            rel="icon"
+            type="image/x-icon"
+            href="/static/img/skeleton.png"
+        >
+    </head>
+</html>

skeleton/infrastructure/bootstrap/src/templates/app/frontend/src/main.tsx

@@ -0,0 +1,15 @@
+import { createRoot } from "react-dom/client";
+
+const body = document.querySelector("body");
+
+if (!body) {
+    throw new Error("Body element not found");
+}
+
+const root = document.createElement("div");
+
+body.appendChild(root);
+
+createRoot(root).render(
+    <h1>Skeleton + FastAPI + React + WebPack</h1>
+);

skeleton/infrastructure/bootstrap/src/templates/app/frontend/src/static/css/styles.css

@@ -0,0 +1,28 @@
+/*%*%*%*%*%*%*%*%*%*%*%*%*%*%*%*%*%*%*/
+
+/*
+    disregard ANY/ALL padding, margin
+    & border when computing width/height
+*/
+
+* {
+    box-sizing: border-box;
+}
+
+body, html {
+    height: 100vh;
+}
+
+#root {
+    min-height: 100vh;
+}
+
+.demo {
+    background-color: red;
+}
+
+.alt {
+    background-color: blue;
+}
+
+/*%*%*%*%*%*%*%*%*%*%*%*%*%*%*%*%*%*%*/

skeleton/infrastructure/bootstrap/src/templates/app/frontend/src/static/js/script.js

@@ -0,0 +1 @@
+console.log("@scripts/script.js");

skeleton/infrastructure/bootstrap/src/templates/app/frontend/tsconfig.json

@@ -0,0 +1,90 @@
+{
+    "compilerOptions": {
+
+        /* use modern automatic JSX transform! */
+        "jsx": "react-jsx",
+
+        "target": "ES2022", // emit as-is
+        "module": "ES2022", // modern import/export syntax
+
+        /**
+         * Using a bundler, like webpack or vite!
+         * Don't treat module imports like node!
+         * Consume ESM packages like @skeleton/core
+         * Enable extensionless imports!
+         */
+        "moduleResolution": "bundler",
+        
+        /** Declare which global API's exit in env! */
+        "lib": ["DOM", "ES2022"],
+
+        /*
+         * save information about project graph from last compilation by detecting
+         * smallest set of files to re-emit instead of recompiling the entire project,
+         * enabling significantly faster subsequent builds by caching metadata
+         * This generates a .tsbuildinfo file (add to .gitignore!)
+         */
+        "incremental": true,
+
+        /**
+         * Fix module compatibility between
+         * CommonJS (require) & ES Modules (import)
+         */
+        // "esModuleInterop": true,
+
+        /**
+         * enable imports like ./config.json
+         */
+        "resolveJsonModule": true,
+
+        /**
+         * Each file to be compiled independently!
+         */
+        "isolatedModules": true,
+
+        /* webpack handles build! */
+        "noEmit": true,
+        "noEmitOnError": true,
+        "sourceMap": true,
+        
+        /**
+         * skip type checking .d.ts files in node_modules
+         * Many packages have imperfect/conflicting/legacy types!
+         */
+        "skipLibCheck": true,
+
+        "strict": true,
+        "noImplicitAny": true,
+        // "noUnusedLocals": true,
+        "noImplicitReturns": true,
+        // "noUnusedParameters": true,
+
+        "forceConsistentCasingInFileNames": true,
+        // "disableSourceOfProjectReferenceRedirect": true,
+        
+        "removeComments": true,
+
+        /**
+         * Decorators & typescript metadata!
+         */
+        /* @decorator/annotation syntax */
+        "experimentalDecorators": true,
+        "emitDecoratorMetadata": true,
+        // "useDefineForClassFields": true,
+
+        /* uses tsconfig-paths-webpack-plugin */
+        "paths": {
+
+            // common aliases!
+            "@styles/*": ["./src/static/css/*"],
+            "@scripts/*": ["./src/static/js/*"],
+            "@img/*": ["./src/static/img/*"],
+        },
+    },
+
+    "include": ["./src/**/*",],
+    "exclude": [
+        "dist",
+        "node_modules"
+    ],
+}

skeleton/infrastructure/bootstrap/src/templates/config/.gitignore

@@ -0,0 +1,21 @@
+# Skeleton local package artifacts
+.skeleton/
+
+# node, js, ts & webpack
+node_modules/
+dist/
+build/
+coverage/
+*.tsbuildinfo
+
+# Python
+__pycache__/
+.mypy_cache/
+*.pyc
+.venv/
+venv/
+env/
+
+# misc
+.DS_Store
+.vscode

skeleton/infrastructure/bootstrap/src/templates/config/skeleton-dependencies.json

@@ -0,0 +1,21 @@
+{
+    "frontend": {
+        "packages": {
+            "dependencies": {
+                "react": "^19.3.1",
+                "react-dom": "^19.3.1"
+            },
+            "devDependencies": {
+                "@types/react": "^19.3.0",
+                "@types/react-dom": "^19.3.0"
+            }
+        }
+    },
+    "backend": {
+        "requirements": {
+            "uvicorn": ">=0.34,<1.0",
+            "pydantic": ">=2.10,<3.0",
+            "sqlalchemy": ">=2.0,<2.1"
+        }
+    }
+}

skeleton/infrastructure/bootstrap/src/templates/config/skeleton-layout.json

@@ -0,0 +1,11 @@
+{
+    "project": {
+        "app": "app"
+    },
+    "frontend": {
+        "directory": "frontend"
+    },
+    "backend": {
+        "directory": "backend"
+    }
+}

skeleton/infrastructure/bootstrap/src/templates/config/skeleton-schemas.json

@@ -0,0 +1,20 @@
+{
+    "schemas": {
+        "http": {
+            "backend": {
+                "prefix": "/api",
+                "strip": true
+            },
+            "frontend": {
+                "prefix": "/",
+                "strip": false
+            }
+        },
+        "ws": {
+            "backend": {
+                "prefix": "/ws",
+                "strip": true
+            }
+        }
+    }
+}

skeleton/infrastructure/bootstrap/src/templates/config/skeleton-servers.json

@@ -0,0 +1,16 @@
+{
+    "servers": {
+        "backend": {
+            "host": "127.0.0.1",
+            "port": 8080
+        },
+        "frontend": {
+            "host": "127.0.0.1",
+            "port": 3000
+        },
+        "gateway": {
+            "host": "127.0.0.1",
+            "port": 8000
+        }
+    }
+}

skeleton/infrastructure/common/__init__.py

@@ -0,0 +1 @@
+from skeleton.infrastructure.common import *

skeleton/infrastructure/common/config.json

@@ -0,0 +1,8 @@
+{
+    "config": {
+        "servers": "skeleton-servers.json",
+        "schemas": "skeleton-schemas.json",
+        "proxy": "skeleton/infrastructure/gateway/settings/proxy.json",
+        "services": "skeleton/infrastructure/gateway/settings/services.json"
+    }
+}

skeleton/infrastructure/common/src/config.py

@@ -0,0 +1,37 @@
+from pathlib import Path
+
+from skeleton.infrastructure.common.src.loader import load
+from skeleton.infrastructure.common.src.layout import ProjectLayout
+from skeleton.infrastructure.common.src.repository import ConfigRepository
+
+def load_runtime_config(
+    path: Path,
+    project_root: Path,
+    framework_root: Path,
+    layout: ProjectLayout,
+) -> ConfigRepository:
+
+    CONFIG = load(path)["config"]
+
+    data: dict = {}
+
+    for name, config in CONFIG.items():
+
+        root = (
+            project_root
+            if name in ("servers", "schemas")
+            else framework_root
+        )
+
+        data[name] = load(root / config)
+
+    frontend_config = layout.frontend / "skeleton-config.json"
+    data["frontend"] = load(frontend_config)
+
+    return ConfigRepository(
+        servers=data["servers"],
+        schemas=data["schemas"],
+        frontend=data["frontend"],
+        proxy=data["proxy"],
+        services=data["services"],
+    )

skeleton/infrastructure/common/src/constants.py

@@ -0,0 +1,4 @@
+class Bootstrap:
+    LAYOUT: str = "skeleton-layout.json"
+    GATEWAY_MODULE: str = "skeleton.infrastructure.gateway.src.main"
+    CONFIG_FILE_EXT = "config.json"

skeleton/infrastructure/common/src/context.py

@@ -0,0 +1,15 @@
+from pathlib import Path
+from dataclasses import dataclass
+
+from skeleton.infrastructure.common.src.layout import ProjectLayout
+from skeleton.infrastructure.common.src.repository import ConfigRepository
+
+@dataclass(frozen=True, kw_only=True)
+class RuntimeContext:
+    root: Path
+    mode: str
+    args: list[str]
+    env: dict[str, str]
+    options: dict[str, str | bool]
+    config: ConfigRepository
+    layout: ProjectLayout

skeleton/infrastructure/common/src/env.py

@@ -0,0 +1,12 @@
+import os
+from pathlib import Path
+
+def build_env(ROOT: Path, MODE: str):
+    base_env = os.environ.copy()
+    runtime_env = {
+        "APP_MODE": MODE,
+        "APP_ROOT": str(ROOT),
+        "PYTHONPATH": str(ROOT),
+    }
+    env = base_env | runtime_env
+    return env

skeleton/infrastructure/common/src/layout.py

@@ -0,0 +1,68 @@
+import json
+
+from pathlib import Path
+from dataclasses import dataclass
+
+@dataclass(frozen=True, kw_only=True)
+class ProjectLayout:
+    frontend: Path
+    backend: Path
+    infrastructure: Path
+    gateway: Path
+    runners: Path
+    common: Path
+    packages: Path
+
+def build_layout(
+    path: Path,
+    project_root: Path,
+    framework_root: Path,
+) -> ProjectLayout:
+
+    if not path.is_file():
+        raise FileNotFoundError(
+            f"Project layout configuration not found: {path}"
+        )
+
+    with path.open("r", encoding="utf-8") as file:
+        config = json.load(file)
+
+    try:
+        frontend = config["frontend"]["directory"]
+        backend = config["backend"]["directory"]
+
+    except (KeyError, TypeError) as error:
+        raise ValueError(
+            f"Invalid project layout configuration: {path}"
+        ) from error
+
+    for key, value in {
+        "frontend.directory": frontend,
+        "backend.directory": backend,
+    }.items():
+
+        if (
+            not isinstance(value, str)
+            or not value.strip()
+            or Path(value).is_absolute()
+            or len(Path(value).parts) != 1
+            or value in (".", "..")
+        ):
+            raise ValueError(
+                f"Invalid directory name for '{key}': {value!r}"
+            )
+
+    project_root = project_root.resolve()
+    framework_root = framework_root.resolve()
+
+    infrastructure = framework_root / "skeleton" / "infrastructure"
+
+    return ProjectLayout(
+        frontend=project_root / frontend,
+        backend=project_root / backend,
+        infrastructure=infrastructure,
+        gateway=infrastructure / "gateway",
+        runners=infrastructure / "runners",
+        common=infrastructure / "common",
+        packages=framework_root / "skeleton" / "packages",
+    )

skeleton/infrastructure/common/src/loader.py

@@ -0,0 +1,8 @@
+import json
+from pathlib import Path
+
+# json.load wrapper utility!
+def load(path: Path) -> dict:
+    with open(path, "r", encoding="utf-8") as config:
+        data = json.load(config)
+    return data

skeleton/infrastructure/common/src/repository.py

@@ -0,0 +1,12 @@
+from dataclasses import dataclass
+
+# come back to this, to ensure only
+# load what's needed in each layer
+# store runtime/boostrap confiugration settings!
+@dataclass(frozen=True, kw_only=True)
+class ConfigRepository:
+    servers: dict # only gateway
+    schemas: dict # only gateway
+    frontend: dict # only gateway
+    proxy: dict # only gateway
+    services: dict # only gateway

skeleton/infrastructure/common/src/utils.py

@@ -0,0 +1,26 @@
+import os
+from pathlib import Path
+
+def resolve_executable_path(path) -> Path:
+    if os.name == "nt":
+        return Path(path)/".venv"/"Scripts"/"python.exe"
+    else:
+        return Path(path)/".venv"/"bin"/"python"
+    
+def check_file_exists(filename: str, path: Path):
+
+    if not path.exists():
+        raise FileNotFoundError(
+            f"{filename}: file does not exist {path}"
+        )
+    
+    if not path.is_file():
+        raise IsADirectoryError(
+            f"{filename}: path is not a file {path}"
+        )
+
+def module_to_path(module: str) -> Path:
+    return Path(module.replace(".", "/")).with_suffix(".py")
+
+def path_to_module(path: Path) -> str:
+    return ".".join(path.with_suffix("").parts)

skeleton/infrastructure/gateway/settings/proxy.json

@@ -0,0 +1,24 @@
+{
+    "settings": {
+        "defaultTimeout": 15.0,
+        "followRedirects": false
+    },
+    
+    "cors": {
+        "allowOrigins": [
+            "http://localhost:8000",
+            "http://127.0.0.1:8000",
+            "http://localhost:3000",
+            "http://127.0.0.1:3000"
+        ],
+        "allowCredentials": true,
+        "allowMethods": ["*"],
+        "allowHeaders": ["*"]
+    },
+    
+    "methods": [
+        "GET", "POST", "PUT",
+        "PATCH", "DELETE", "HEAD",
+        "OPTIONS"
+    ]
+}

skeleton/infrastructure/gateway/settings/services.json

@@ -0,0 +1,10 @@
+{
+    "services": {
+        "backend": {
+            "name": "app",
+            "ext": [".py", ".json"],
+            "reload": true,
+            "docs": "docs"
+        }
+    }
+}

skeleton/infrastructure/gateway/src/app.py

@@ -0,0 +1,98 @@
+from uuid import uuid4
+
+from fastapi import FastAPI, Request
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+
+from skeleton.infrastructure.common.src.context import RuntimeContext
+
+from skeleton.infrastructure.gateway.src.router import ProxyRouter
+from skeleton.infrastructure.gateway.src.client import ProxyClient
+from skeleton.infrastructure.gateway.src.reverseproxy import ReverseProxy
+from skeleton.infrastructure.gateway.src.lifespan import HTTPAsyncClientManager
+
+from contextlib import asynccontextmanager
+
+from skeleton.infrastructure.gateway.src.utils import build_static_dir
+
+def create_app(context: RuntimeContext) -> FastAPI:
+
+    # print(context.config.frontend["lib"]["static"])
+    http = HTTPAsyncClientManager(
+        context.config.proxy["settings"]
+    )
+
+    @asynccontextmanager
+    async def lifespan(app: FastAPI):
+        await http.startup()
+        yield
+        await http.shutdown()
+
+    reverseproxy = FastAPI(
+        # name="Reverse Proxy Dev Gateway",
+        title="Reverse Proxy Dev Gateway",
+        description="Reverse Proxy Dev Gateway",
+        version="1.0.0",
+        lifespan=lifespan,
+        swagger_ui_parameters={
+            "docExpansion": "none",
+            "displayRequestDuration": True,
+            "defaultModelsExpandDepth": -1
+        },
+    )
+
+    CORS = context.config.proxy["cors"]
+    # set cors headers dynamically!
+    reverseproxy.add_middleware(
+        CORSMiddleware,
+        allow_origins=CORS["allowOrigins"],
+        allow_credentials=CORS["allowCredentials"],
+        allow_methods=CORS["allowMethods"],
+        allow_headers=CORS["allowHeaders"],
+    )
+
+    router = ProxyRouter(context=context)
+
+    client = ProxyClient(http)
+    proxy = ReverseProxy(router, client)
+
+    from fastapi.staticfiles import StaticFiles
+    static_dir = build_static_dir(context)
+
+    print("Mounting static directory:")
+    print("  URL:      ", f"/{context.config.frontend['lib']['static']}")
+    print("  directory:", static_dir)
+    
+    reverseproxy.mount(
+        f"/{context.config.frontend["lib"]["static"]}",
+        StaticFiles(
+            directory=str(static_dir),
+            check_dir=True
+            ),
+        name="static"
+    )
+
+    devtools_uuid = str(uuid4())
+
+    @reverseproxy.get("/.well-known/appspecific/com.chrome.devtools.json")
+    async def chrome_devtools():
+        return JSONResponse(
+            {
+                "workspace": {
+                    "root": str(context.root),
+                    "uuid": devtools_uuid,
+                },
+            }
+        )
+
+    METHODS = context.config.proxy["methods"]
+    @reverseproxy.api_route(
+        "/{path:path}",
+        methods=METHODS,
+        summary="http",
+        tags=["http"],
+    )
+    async def http_gateway(request: Request):
+        return await proxy.handle_http_request(request=request)
+    
+    return reverseproxy