skeleton-framework 0.1.0__py3-none-any.whl

skeleton/infrastructure/bootstrap/src/commands/dev/init.py

@@ -0,0 +1,80 @@
+import os
+import sys
+import subprocess
+
+from pathlib import Path
+def dev_init(
+    framework_root: Path,
+) -> None:
+
+    framework_root = framework_root.resolve()
+
+    # ---------------------------------------------------------
+    # Validate framework package configuration
+    # ---------------------------------------------------------
+
+    pyproject = framework_root / "pyproject.toml"
+
+    if not pyproject.is_file():
+
+        raise FileNotFoundError(
+            f"Framework Python package configuration not found: "
+            f"{pyproject}"
+        )
+
+    # ---------------------------------------------------------
+    # Generate framework development requirements
+    # ---------------------------------------------------------
+
+    requirements = framework_root / "requirements.txt"
+
+    if not requirements.is_file():
+
+        print(
+            f"INFO: Creating framework requirements file: "
+            f"{requirements}"
+        )
+
+        requirements.write_text(
+            "build\n"
+            "twine\n",
+            encoding="utf-8",
+        )
+
+    # ---------------------------------------------------------
+    # Create framework root virtual environment
+    # ---------------------------------------------------------
+
+    venv = framework_root / ".venv"
+
+    if not venv.is_dir():
+
+        print(
+            f"INFO: Creating framework virtual environment: "
+            f"{venv}"
+        )
+
+        subprocess.run(
+            [
+                sys.executable,
+                "-m",
+                "venv",
+                str(venv),
+            ],
+            cwd=framework_root,
+            check=True,
+        )
+
+    python = (
+        venv / "Scripts" / "python.exe"
+        if os.name == "nt"
+        else venv / "bin" / "python"
+    )
+
+    if not python.is_file():
+
+        raise FileNotFoundError(
+            f"Framework Python executable not found: {python}"
+        )
+
+    print("INFO: Framework development initialization complete")

skeleton/infrastructure/bootstrap/src/commands/dev/install.py

@@ -0,0 +1,168 @@
+import os, sys
+import subprocess
+
+from pathlib import Path
+
+def dev_install(
+    framework_root: Path,
+) -> None:
+
+    framework_root = framework_root.resolve()
+
+    # ---------------------------------------------------------
+    # Install framework root development requirements
+    # ---------------------------------------------------------
+
+    requirements = framework_root / "requirements.txt"
+
+    if not requirements.is_file():
+
+        raise FileNotFoundError(
+            f"Framework Python requirements not found: "
+            f"{requirements}"
+        )
+
+    venv = framework_root / ".venv"
+
+    if not venv.is_dir():
+
+        raise FileNotFoundError(
+            f"Framework virtual environment not found: {venv}. "
+            "Run --dev-init first."
+        )
+
+    python = (
+        venv / "Scripts" / "python.exe"
+        if os.name == "nt"
+        else venv / "bin" / "python"
+    )
+
+    if not python.is_file():
+
+        raise FileNotFoundError(
+            f"Framework Python executable not found: {python}"
+        )
+
+    print(
+        f"INFO: Installing framework Python requirements: "
+        f"{requirements}"
+    )
+
+    subprocess.run(
+        [
+            str(python),
+            "-m",
+            "pip",
+            "install",
+            "-r",
+            str(requirements),
+        ],
+        cwd=framework_root,
+        check=True,
+    )
+
+    # ---------------------------------------------------------
+    # Validate framework package configuration
+    # ---------------------------------------------------------
+
+    pyproject = framework_root / "pyproject.toml"
+
+    if not pyproject.is_file():
+
+        raise FileNotFoundError(
+            f"Framework Python package configuration not found: "
+            f"{pyproject}"
+        )
+
+    # ---------------------------------------------------------
+    # Create framework gateway environment
+    # ---------------------------------------------------------
+
+    gateway_root = (
+        framework_root
+        / "skeleton"
+        / "infrastructure"
+        / "gateway"
+    )
+
+    venv = gateway_root / ".venv"
+
+    if not venv.is_dir():
+
+        print(f"INFO: Creating framework virtual environment: {venv}")
+
+        subprocess.run(
+            [
+                sys.executable,
+                "-m",
+                "venv",
+                str(venv),
+            ],
+            cwd=framework_root,
+            check=True,
+        )
+
+    python = (
+        venv / "Scripts" / "python.exe"
+        if os.name == "nt"
+        else venv / "bin" / "python"
+    )
+
+    if not python.is_file():
+
+        raise FileNotFoundError(
+            f"Framework Python executable not found: {python}"
+        )
+
+    # ---------------------------------------------------------
+    # Install Skeleton and its declared Python dependencies
+    # ---------------------------------------------------------
+
+    print(
+        f"INFO: Installing Skeleton framework in editable mode: "
+        f"{framework_root}"
+    )
+
+    subprocess.run(
+        [
+            str(python),
+            "-m",
+            "pip",
+            "install",
+            "-e",
+            str(framework_root),
+        ],
+        cwd=framework_root,
+        check=True,
+    )
+
+    # ---------------------------------------------------------
+    # Install framework Node.js development dependencies
+    # ---------------------------------------------------------
+
+    package_json = framework_root / "package.json"
+
+    if not package_json.is_file():
+
+        raise FileNotFoundError(
+            f"Framework package manifest not found: {package_json}"
+        )
+
+    npm = (
+        "npm.cmd"
+        if os.name == "nt"
+        else "npm"
+    )
+
+    print(
+        f"INFO: Installing framework Node.js dependencies: "
+        f"{framework_root}"
+    )
+
+    subprocess.run(
+        [npm, "install"],
+        cwd=framework_root,
+        check=True,
+    )
+
+    print("INFO: Framework development installation complete")

skeleton/infrastructure/bootstrap/src/commands/dev/pack.py

@@ -0,0 +1,55 @@
+import os, shutil
+import subprocess
+
+from pathlib import Path
+
+def dev_pack(framework_root: Path) -> None:
+
+    framework_root = framework_root.resolve()
+
+    packages_root = framework_root / "skeleton" / "packages"
+    artifacts_root = packages_root / ".skeleton"
+
+    npm = "npm.cmd" if os.name == "nt" else "npm"
+
+    # 1. Build both packages from the framework root.
+    subprocess.run(
+        [npm, "run", "packages:build"],
+        cwd=framework_root,
+        check=True,
+    )
+
+    # 2. Recreate the predictable output directory.
+    if artifacts_root.exists():
+        
+        shutil.rmtree(artifacts_root)
+
+    artifacts_root.mkdir(parents=True)
+
+    # 3. Pack webpack first, then the CLI.
+    for name in ("webpack", "cli"):
+
+        package_root = packages_root / name
+
+        if not (package_root / "package.json").is_file():
+
+            raise FileNotFoundError(
+                f"Package manifest not found: "
+                f"{package_root / 'package.json'}"
+            )
+
+        subprocess.run(
+            [
+                npm,
+                "pack",
+                "--pack-destination",
+                str(artifacts_root),
+            ],
+            cwd=package_root,
+            check=True,
+        )
+
+    print(
+        f"\nSkeleton packages created in:\n"
+        f"{artifacts_root}"
+    )

skeleton/infrastructure/bootstrap/src/config.py

@@ -0,0 +1,54 @@
+import shutil
+
+from pathlib import Path
+
+def config(
+    framework_root: Path,
+    project_root: Path,
+) -> None:
+
+    templates = (
+        framework_root
+        / "skeleton"
+        / "infrastructure"
+        / "bootstrap"
+        / "src"
+        / "templates"
+        / "config"
+    )
+
+    if not templates.is_dir():
+        
+        raise FileNotFoundError(
+            f"Configuration templates not found: {templates}"
+        )
+
+    project_root = project_root.resolve()
+
+    project_root.mkdir(
+        parents=True,
+        exist_ok=True,
+    )
+
+    for template in templates.iterdir():
+
+        destination = project_root / template.name
+
+        if destination.exists():
+
+            print(
+                f"INFO: Preserving existing file: {destination}"
+            )
+            continue
+
+        if template.is_dir():
+
+            shutil.copytree(template, destination)
+
+        else:
+
+            shutil.copy2(template, destination)
+
+        print(f"INFO: Created: {destination}")
+
+    print("INFO: Configuration complete")

skeleton/infrastructure/bootstrap/src/copy.py

@@ -0,0 +1,56 @@
+import shutil
+
+from pathlib import Path
+
+def copy_template(source: Path, target: Path) -> None:
+
+    target.mkdir(parents=True, exist_ok=True)
+
+    for item in source.iterdir():
+
+        destination = target / item.name
+
+        if destination.exists():
+
+            if item.is_dir() and destination.is_dir():
+                copy_template(item, destination)
+
+            continue
+
+        if item.is_dir():
+            shutil.copytree(item, destination)
+
+        else:
+            shutil.copy2(item, destination)
+
+def copy_app_template(
+    source: Path,
+    target: Path,
+    frontend: str,
+    backend: str,
+) -> None:
+
+    target.mkdir(parents=True, exist_ok=True)
+
+    directories = {
+        "frontend": frontend,
+        "backend": backend,
+    }
+
+    for item in source.iterdir():
+
+        name = directories.get(item.name, item.name)
+        destination = target / name
+
+        if destination.exists():
+
+            if item.is_dir() and destination.is_dir():
+                copy_template(item, destination)
+
+            continue
+
+        if item.is_dir():
+            shutil.copytree(item, destination)
+
+        else:
+            shutil.copy2(item, destination)

skeleton/infrastructure/bootstrap/src/load.py

@@ -0,0 +1,221 @@
+import json
+
+from pathlib import Path
+
+def load_layout(path: Path) -> dict[str, str]:
+
+    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:
+
+        app = config["project"]["app"]
+        frontend = config["frontend"]["directory"]
+        backend = config["backend"]["directory"]
+
+    except (KeyError, TypeError) as error:
+        raise ValueError(
+            f"Invalid project layout configuration: {path}"
+        ) from error
+
+    values = {
+        "project.app": app,
+        "frontend.directory": frontend,
+        "backend.directory": backend,
+    }
+
+    for key, value in values.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}"
+            )
+
+    return {
+        "app": app,
+        "frontend": frontend,
+        "backend": backend,
+    }
+
+# def load_dependencies(path: Path) -> dict:
+
+#     if not path.is_file():
+#         raise FileNotFoundError(
+#             f"Dependencies configuration not found: {path}"
+#         )
+
+#     with path.open(
+#         "r",
+#         encoding="utf-8",
+#     ) as file:
+#         config = json.load(file)
+
+#     if not isinstance(config, dict):
+#         raise ValueError(
+#             f"Invalid dependencies configuration: {path}"
+#         )
+
+#     frontend = config.get("frontend")
+#     backend = config.get("backend")
+
+#     if not isinstance(frontend, dict):
+#         raise ValueError(
+#             f"Invalid frontend configuration: {path}"
+#         )
+
+#     packages = frontend.get("packages")
+
+#     if not isinstance(packages, dict):
+#         raise ValueError(
+#             f"Invalid frontend package configuration: {path}"
+#         )
+
+#     for group in ("dependencies", "devDependencies"):
+
+#         values = packages.get(group, {})
+
+#         if not isinstance(values, dict):
+#             raise ValueError(
+#                 f"Invalid frontend '{group}' configuration: {path}"
+#             )
+
+#         if not all(
+#             isinstance(name, str)
+#             and isinstance(version, str)
+#             for name, version in values.items()
+#         ):
+#             raise ValueError(
+#                 f"Invalid package entries in frontend '{group}': "
+#                 f"{path}"
+#             )
+
+#     requirements = (
+#         backend.get("requirements")
+#         if isinstance(backend, dict)
+#         else None
+#     )
+
+#     if not isinstance(requirements, list) or not all(
+#         isinstance(requirement, str)
+#         for requirement in requirements
+#     ):
+#         raise ValueError(
+#             f"Invalid backend requirements configuration: {path}"
+#         )
+
+#     return {
+#         "frontend": packages,
+#         "backend": requirements,
+#     }
+
+
+def load_dependencies(path: Path) -> dict:
+
+    if not path.is_file():
+        raise FileNotFoundError(
+            f"Dependencies configuration not found: {path}"
+        )
+
+    with path.open(
+        "r",
+        encoding="utf-8",
+    ) as file:
+        config = json.load(file)
+
+    if not isinstance(config, dict):
+        raise ValueError(
+            f"Invalid dependencies configuration: {path}"
+        )
+
+    # ---------------------------------------------------------
+    # Validate frontend configuration
+    # ---------------------------------------------------------
+
+    frontend = config.get("frontend")
+
+    if not isinstance(frontend, dict):
+        raise ValueError(
+            f"Invalid frontend configuration: {path}"
+        )
+
+    packages = frontend.get("packages")
+
+    if not isinstance(packages, dict):
+        raise ValueError(
+            f"Invalid frontend package configuration: {path}"
+        )
+
+    for group in ("dependencies", "devDependencies"):
+
+        values = packages.get(group, {})
+
+        if not isinstance(values, dict):
+            raise ValueError(
+                f"Invalid frontend '{group}' configuration: {path}"
+            )
+
+        if not all(
+            isinstance(name, str)
+            and name.strip()
+            and isinstance(version, str)
+            and version.strip()
+            for name, version in values.items()
+        ):
+            raise ValueError(
+                f"Invalid package entries in frontend "
+                f"'{group}': {path}"
+            )
+
+    # ---------------------------------------------------------
+    # Validate backend configuration
+    # ---------------------------------------------------------
+
+    backend = config.get("backend")
+
+    if not isinstance(backend, dict):
+        raise ValueError(
+            f"Invalid backend configuration: {path}"
+        )
+
+    requirements = backend.get("requirements")
+
+    if not isinstance(requirements, dict):
+        raise ValueError(
+            f"Invalid backend requirements configuration: "
+            f"'backend.requirements' must be an object: {path}"
+        )
+
+    if not all(
+        isinstance(name, str)
+        and name.strip()
+        and isinstance(specifier, str)
+        and specifier.strip()
+        for name, specifier in requirements.items()
+    ):
+        raise ValueError(
+            f"Invalid backend requirements entries: {path}. "
+            "Expected package names mapped to non-empty "
+            "version specification strings."
+        )
+
+    # ---------------------------------------------------------
+    # Return the normalized configuration
+    # ---------------------------------------------------------
+
+    return {
+        "frontend": packages,
+        "backend": requirements,
+    }

skeleton/infrastructure/bootstrap/src/templates/app/backend/requirements.txt

@@ -0,0 +1 @@
+fastapi>=0.145,<0.146

skeleton/infrastructure/bootstrap/src/templates/app/backend/routes.json

@@ -0,0 +1,10 @@
+{
+    "routes": {
+        "test": {
+            "methods": ["GET"],
+            "route": "/test",
+            "summary": "Demo test Endpoint",
+            "tags": ["test"]
+        }
+    }
+}

skeleton/infrastructure/bootstrap/src/templates/app/backend/src/main.py

@@ -0,0 +1,35 @@
+import json
+from pathlib import Path
+from fastapi import FastAPI
+# from pydantic import BaseModel
+
+app = FastAPI(
+    # name="Backend API Docs",
+    title="Backend API Docs",
+    description="Backend API Docs",
+    version="1.0.0",
+    # lifespan=lifespan,
+    swagger_ui_parameters={
+        "docExpansion": "none",
+        "displayRequestDuration": True,
+        "defaultModelsExpandDepth": -1
+    },
+)
+
+# dynamically load routes.json to creat
+# endpoints or access using json indexing
+BASE = Path(__file__).resolve().parents[1]
+with open(BASE/"routes.json") as endpoints:
+    ROUTES = json.load(endpoints)["routes"]
+
+# html response example!
+from fastapi.responses import HTMLResponse
+@app.get(
+    ROUTES["test"]["route"],
+    summary=ROUTES["test"]["summary"],
+    tags=ROUTES["test"]["tags"],
+    response_class=HTMLResponse
+)
+def page():
+    html = "<h1>FastAPI!</h1>"
+    return HTMLResponse(content=html)

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

@@ -0,0 +1,21 @@
+{
+    "name": "skeleton-app",
+    "version": "1.0.0",
+    "description": "skeleton-app",
+    "author": "client-author",
+    "license": "ISC",
+    "main": "dist/index.js",
+    "type": "module",
+    "devDependencies": {
+        "typescript": "^6.0.3",
+        "@skeleton/cli": "file:../.skeleton/packages/skeleton-cli-1.0.0.tgz",
+        "@skeleton/webpack": "file:../.skeleton/packages/skeleton-webpack-1.0.0.tgz"
+    },
+    "scripts": {
+        "serve": "skeleton serve",
+        "build": "skeleton build",
+        "preview": "skeleton preview",
+        "clean": "skeleton clean",
+        "purge": "skeleton purge"
+    }
+}