Nexom 0.1.4__py3-none-any.whl → 1.0.1__py3-none-any.whl

nexom/buildTools/build.py

@@ -1,99 +1,319 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from importlib import resources
+from importlib import import_module, resources
 from pathlib import Path
+import re
 import shutil
 
 
 @dataclass(frozen=True)
-class ServerBuildOptions:
-    """Options used to fill generated config.py."""
+class AppBuildOptions:
     address: str = "0.0.0.0"
     port: int = 8080
     workers: int = 4
     reload: bool = False
 
 
+_NAME_RE = re.compile(r"^[A-Za-z0-9_]+$")
+
+
+class AppBuildError(RuntimeError):
+    """Raised when project generation fails for any reason."""
+
+
 def _copy_from_package(pkg: str, filename: str, dest: Path) -> None:
-    """
-    Copy a file from a package resource into the destination path.
-    """
     dest.parent.mkdir(parents=True, exist_ok=True)
-    with resources.files(pkg).joinpath(filename).open("rb") as src, dest.open("wb") as dst:
+    module = import_module(pkg)
+    with resources.files(module).joinpath(filename).open("rb") as src, dest.open("wb") as dst:
         shutil.copyfileobj(src, dst)
 
 
-def server(work_dir: str | Path, name: str, *, options: ServerBuildOptions | None = None) -> Path:
-    """
-    Generate a Nexom server project into `work_dir`.
+def _read_text_from_package(pkg: str, filename: str) -> str:
+    module = import_module(pkg)
+    return resources.files(module).joinpath(filename).read_text(encoding="utf-8")
 
-    This function copies template files bundled in the package (assets) and
-    writes a ready-to-run config.py.
 
-    Args:
-        work_dir: Output directory where project files are created.
-        name: Project name (reserved for future use; currently not used).
-        options: Config defaults for generated config.py.
+def _replace_many(text: str, repl: dict[str, str]) -> str:
+    out = text
+    for k, v in repl.items():
+        out = out.replace(k, v)
 
-    Returns:
-        The absolute path to the generated project directory.
+    unresolved = [k for k in repl.keys() if k in out]
+    if unresolved:
+        raise AppBuildError("Build template placeholder was not resolved.")
+    return out
+
+
+def _validate_app_name(name: str) -> None:
+    if not _NAME_RE.match(name):
+        raise ValueError("name must match [A-Za-z0-9_]+ (no dots, slashes, hyphens).")
 
-    Raises:
-        FileExistsError: If target directories/files already exist.
-        ModuleNotFoundError / FileNotFoundError: If bundled assets are missing.
-    """
-    _ = name  # reserved (keep signature stable for future)
-    options = options or ServerBuildOptions()
 
-    out_dir = Path(work_dir).expanduser().resolve()
-    out_dir.mkdir(parents=True, exist_ok=True)
+def _write_gateway_config(
+    gateway_dir: Path,
+    *,
+    kind: str,  # "nginx" | "apache"
+    app_name: str,
+    app_port: int,
+    domain: str,
+) -> Path:
+    if kind not in ("nginx", "apache"):
+        raise ValueError("kind must be nginx or apache.")
 
-    pages_dir = out_dir / "pages"
-    templates_dir = out_dir / "templates"
-    static_dir = out_dir / "static"
+    # domain placeholder
+    dom = domain.strip() or "YOUR_DOMAIN_HERE  # set --domain example.com"
 
-    # Make sure we don't accidentally overwrite a project
-    for d in (pages_dir, templates_dir, static_dir):
-        if d.exists():
-            raise FileExistsError(f"Already exists: {d}")
+    # wsgi import path (project root is PYTHONPATH in naxom run)
+    wsgi_target = f"{app_name}.wsgi:app"
+
+    pkg = "nexom.assets.gateway"
+    filename = "nginx_app.conf" if kind == "nginx" else "apache_app.conf"
+
+    text = _read_text_from_package(pkg, filename)
+    out = _replace_many(
+        text,
+        {
+            "__DOMAIN__": dom,
+            "__APP_PORT__": str(app_port),
+            "__APP_WSGI__": wsgi_target,
+            "__APP_NAME__": app_name,
+        },
+    )
 
+    gateway_dir.mkdir(parents=True, exist_ok=True)
+    out_path = gateway_dir / f"{app_name}.{kind}.conf"
+    out_path.write_text(out, encoding="utf-8")
+    return out_path
+
+
+def create_app(
+    project_dir: str | Path,
+    app_name: str,
+    *,
+    options: AppBuildOptions | None = None,
+    gateway_config: str | None = None,
+    domain: str = "",
+) -> Path:
+    _validate_app_name(app_name)
+    options = options or AppBuildOptions()
+
+    project_root = Path(project_dir).expanduser().resolve()
+    project_root.mkdir(parents=True, exist_ok=True)
+
+    app_root = project_root / app_name
+    if app_root.exists():
+        raise FileExistsError(f"Target app already exists: {app_root}")
+    app_root.mkdir(parents=True, exist_ok=False)
+
+    pages_dir = app_root / "pages"
+    templates_dir = app_root / "templates"
+    static_dir = app_root / "static"
     pages_dir.mkdir()
     templates_dir.mkdir()
     static_dir.mkdir()
 
-    # ---- Copy pages ----
-    pages_pkg = "nexom.assets.server.pages"
+    # pages
+    pages_pkg = "nexom.assets.app.pages"
     for fn in ("__init__.py", "_templates.py", "default.py", "document.py"):
         _copy_from_package(pages_pkg, fn, pages_dir / fn)
 
-    # ---- Copy templates ----
-    templates_pkg = "nexom.assets.server.templates"
+    # templates
+    templates_pkg = "nexom.assets.app.templates"
     for fn in ("base.html", "header.html", "footer.html", "default.html", "document.html"):
         _copy_from_package(templates_pkg, fn, templates_dir / fn)
 
-    # ---- Copy static ----
-    static_pkg = "nexom.assets.server.static"
+    # static
+    static_pkg = "nexom.assets.app.static"
     for fn in ("dog.jpeg", "style.css"):
         _copy_from_package(static_pkg, fn, static_dir / fn)
 
-    # ---- Copy app files ----
-    app_pkg = "nexom.assets.server"
-    for fn in ("gunicorn.conf.py", "router.py", "wsgi.py", "config.py"):
-        _copy_from_package(app_pkg, fn, out_dir / fn)
+    # app files
+    app_pkg = "nexom.assets.app"
+    for fn in ("__init__.py", "gunicorn.conf.py", "router.py", "wsgi.py", "config.py"):
+        _copy_from_package(app_pkg, fn, app_root / fn)
 
-    # ---- Enable settings (format config.py) ----
-    config_path = out_dir / "config.py"
+    # config.py
+    config_path = app_root / "config.py"
     config_text = config_path.read_text(encoding="utf-8")
+    config_enabled = _replace_many(
+        config_text,
+        {
+            "__prj_dir__": str(project_root),
+            "__app_name__": str(app_name),
+            "__app_dir__": str(app_root),
+            "__g_address__": options.address,
+            "__g_port__": str(options.port),
+            "__g_workers__": str(options.workers),
+            "__g_reload__": "True" if options.reload else "False",
+        },
+    )
+    config_path.write_text(config_enabled, encoding="utf-8")
+
+    # gunicorn.conf.py
+    gunicorn_conf_path = app_root / "gunicorn.conf.py"
+    gunicorn_conf_text = gunicorn_conf_path.read_text(encoding="utf-8")
+    gunicorn_conf_enabled = _replace_many(gunicorn_conf_text, {"__app_name__": app_name})
+    gunicorn_conf_path.write_text(gunicorn_conf_enabled, encoding="utf-8")
+
+    # wsgi.py
+    wsgi_path = app_root / "wsgi.py"
+    wsgi_text = wsgi_path.read_text(encoding="utf-8")
+    wsgi_enabled = _replace_many(wsgi_text, {"__app_name__": app_name})
+    wsgi_path.write_text(wsgi_enabled, encoding="utf-8")
+
+    # pages/_templates.py
+    pages_templates_path = pages_dir / "_templates.py"
+    pages_templates_text = pages_templates_path.read_text(encoding="utf-8")
+    pages_templates_enabled = _replace_many(pages_templates_text, {"__app_name__": app_name})
+    pages_templates_path.write_text(pages_templates_enabled, encoding="utf-8")
+
+    # gateway config (optional; only if gateway/ exists OR gateway_config explicitly given)
+    if gateway_config:
+        gw = project_root / "gateway"
+        if not gw.exists() or not gw.is_dir():
+            # ここは勝手に作らない（start-projectの責務に寄せる）
+            raise AppBuildError("gateway/ does not exist. Run start-project --gateway ... first.")
+        _write_gateway_config(
+            gw,
+            kind=gateway_config,
+            app_name=app_name,
+            app_port=options.port,
+            domain=domain,
+        )
+
+    return app_root
+
 
-    # NOTE: pwd_dir should be the generated project directory, not current cwd.
-    enabled = config_text.format(
-        pwd_dir=str(out_dir),
-        g_address=options.address,
-        g_port=options.port,
-        g_workers=options.workers,
-        g_reload=options.reload,
+def create_auth(
+    project_dir: str | Path,
+    *,
+    options: AppBuildOptions | None = None,
+) -> Path:
+    options = options or AppBuildOptions(port=7070)
+
+    project_root = Path(project_dir).expanduser().resolve()
+    project_root.mkdir(parents=True, exist_ok=True)
+
+    app_root = project_root / "auth"
+    if app_root.exists():
+        raise FileExistsError(f"Target auth app already exists: {app_root}")
+    app_root.mkdir(parents=True, exist_ok=False)
+
+    app_pkg = "nexom.assets.auth"
+    for fn in ("__init__.py", "gunicorn.conf.py", "wsgi.py", "config.py"):
+        _copy_from_package(app_pkg, fn, app_root / fn)
+
+    config_path = app_root / "config.py"
+    config_text = config_path.read_text(encoding="utf-8")
+    config_enabled = _replace_many(
+        config_text,
+        {
+            "__prj_dir__": str(project_root),
+            "__app_name__": "auth",
+            "__app_dir__": str(app_root),
+            "__g_address__": options.address,
+            "__g_port__": str(options.port),
+            "__g_workers__": str(options.workers),
+            "__g_reload__": "True" if options.reload else "False",
+        },
+    )
+    config_path.write_text(config_enabled, encoding="utf-8")
+
+    gunicorn_conf_path = app_root / "gunicorn.conf.py"
+    gunicorn_conf_text = gunicorn_conf_path.read_text(encoding="utf-8")
+    gunicorn_conf_enabled = _replace_many(gunicorn_conf_text, {"__app_name__": "auth"})
+    gunicorn_conf_path.write_text(gunicorn_conf_enabled, encoding="utf-8")
+
+    return app_root
+
+
+def start_project(
+    *,
+    project_root: Path,
+    main_name: str = "app",
+    auth_name: str = "auth",
+    main_options: AppBuildOptions | None = None,
+    auth_options: AppBuildOptions | None = None,
+    gateway: str = "none",  # none|nginx|apache
+    domain: str = "",
+) -> Path:
+    """
+    Assumption: user already created the project directory and cd'ed into it.
+    So we DO NOT create the project directory itself; we only populate inside.
+    """
+    _validate_app_name(main_name)
+    _validate_app_name(auth_name)
+
+    root = project_root.expanduser().resolve()
+    if not root.exists() or not root.is_dir():
+        raise AppBuildError("Project root must be an existing directory.")
+
+    # data/
+    data_dir = root / "data"
+    log_dir = data_dir / "log"
+    db_dir = data_dir / "db"
+    data_dir.mkdir(parents=True, exist_ok=True)
+    log_dir.mkdir(parents=True, exist_ok=True)
+    db_dir.mkdir(parents=True, exist_ok=True)
+
+    # main app + auth app
+    main_opt = main_options or AppBuildOptions()
+    auth_opt = auth_options or AppBuildOptions(port=7070)
+
+    # auth is usually fixed folder name "auth", but you asked folder name selectable.
+    # create_auth creates "auth" fixed, so we generate via create_app then remove extras?
+    # ここは仕様を守って assets/app の auth用テンプレを “auth_name” に生成する。
+    # => create_app を使ってから不要物を消す、よりは “auth専用生成” を auth_name 対応にする。
+    # なので start_project 内で auth側を “auth_name” に生成する専用処理を持つ。
+
+    # main
+    create_app(root, main_name, options=main_opt, gateway_config=None)
+
+    # auth (auth_name)
+    auth_root = root / auth_name
+    if auth_root.exists():
+        raise FileExistsError(f"Target app already exists: {auth_root}")
+    auth_root.mkdir(parents=True, exist_ok=False)
+
+    app_pkg = "nexom.assets.auth"
+    for fn in ("__init__.py", "gunicorn.conf.py", "wsgi.py", "config.py"):
+        _copy_from_package(app_pkg, fn, auth_root / fn)
+
+    # config.py
+    config_path = auth_root / "config.py"
+    config_text = config_path.read_text(encoding="utf-8")
+    config_enabled = _replace_many(
+        config_text,
+        {
+            "__prj_dir__": str(root),
+            "__app_name__": "auth",
+            "__app_dir__": str(auth_root),
+            "__g_address__": auth_opt.address,
+            "__g_port__": str(auth_opt.port),
+            "__g_workers__": str(auth_opt.workers),
+            "__g_reload__": "True" if auth_opt.reload else "False",
+        },
     )
-    config_path.write_text(enabled, encoding="utf-8")
+    config_path.write_text(config_enabled, encoding="utf-8")
+
+    # gunicorn.conf.py
+    gunicorn_conf_path = auth_root / "gunicorn.conf.py"
+    gunicorn_conf_text = gunicorn_conf_path.read_text(encoding="utf-8")
+    gunicorn_conf_enabled = _replace_many(gunicorn_conf_text, {"__app_name__": auth_name})
+    gunicorn_conf_path.write_text(gunicorn_conf_enabled, encoding="utf-8")
+
+    # gateway/
+    if gateway != "none":
+        gw = root / "gateway"
+        gw.mkdir(parents=True, exist_ok=True)
+
+        _write_gateway_config(
+            gw,
+            kind=gateway,
+            app_name=main_name,
+            app_port=main_opt.port,
+            domain=domain,
+        )
 
-    return out_dir
+    return root

nexom/buildTools/run.py

@@ -0,0 +1,185 @@
+from __future__ import annotations
+
+import os
+import platform
+import shutil
+import signal
+import subprocess
+import sys
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Iterable
+
+
+@dataclass(frozen=True)
+class DetectedApp:
+    name: str
+    dir: Path
+    wsgi: Path
+    gunicorn_conf: Path
+
+
+class RunError(RuntimeError):
+    """Raised when naxom run fails."""
+
+
+def _is_windows() -> bool:
+    return os.name == "nt" or platform.system().lower() == "windows"
+
+
+def _detect_apps(project_root: Path) -> list[DetectedApp]:
+    root = project_root.resolve()
+    if not root.exists() or not root.is_dir():
+        raise RunError("Project root is not a directory.")
+
+    apps: list[DetectedApp] = []
+    for p in root.iterdir():
+        if not p.is_dir():
+            continue
+        wsgi = p / "wsgi.py"
+        conf = p / "gunicorn.conf.py"
+        if wsgi.exists() and conf.exists():
+            apps.append(
+                DetectedApp(
+                    name=p.name,
+                    dir=p,
+                    wsgi=wsgi,
+                    gunicorn_conf=conf,
+                )
+            )
+    return sorted(apps, key=lambda a: a.name)
+
+
+def _require_gunicorn() -> str:
+    gunicorn = shutil.which("gunicorn")
+    if not gunicorn:
+        raise RunError("gunicorn not found in PATH. Install it (pip install gunicorn).")
+    return gunicorn
+
+
+def _build_cmd(gunicorn_bin: str, app: DetectedApp) -> list[str]:
+    # project root を PYTHONPATH に入れて、"appdir.wsgi:app" が import できる前提
+    target = f"{app.name}.wsgi:app"
+    return [gunicorn_bin, target, "--config", str(app.gunicorn_conf)]
+
+
+def run_project(
+    project_root: Path,
+    app_names: list[str] | None = None,
+    *,
+    dry_run: bool = False,
+) -> None:
+    """
+    Run WSGI apps in a Nexom project directory.
+
+    - Detect apps: directories that contain both wsgi.py and gunicorn.conf.py.
+    - If app_names is empty -> run all detected apps.
+    - Else -> run only the specified ones.
+
+    Notes:
+    - Uses subprocess to start gunicorn (stable + predictable).
+    - On Windows: gunicorn isn't supported (POSIX only) -> raise clear error.
+    """
+    if _is_windows():
+        raise RunError("naxom run is not supported on Windows (gunicorn is POSIX-only).")
+
+    root = project_root.resolve()
+    apps = _detect_apps(root)
+    if not apps:
+        raise RunError("No runnable apps found. (Need <app>/wsgi.py and <app>/gunicorn.conf.py)")
+
+    app_map = {a.name: a for a in apps}
+
+    selected: list[DetectedApp]
+    if not app_names:
+        selected = apps
+    else:
+        missing = [n for n in app_names if n not in app_map]
+        if missing:
+            raise RunError(f"App not found: {', '.join(missing)}")
+        selected = [app_map[n] for n in app_names]
+
+    gunicorn = _require_gunicorn()
+
+    # 重要: project root を import 解決に使う
+    env = os.environ.copy()
+    env["PYTHONPATH"] = str(root) + (os.pathsep + env["PYTHONPATH"] if env.get("PYTHONPATH") else "")
+
+    procs: list[subprocess.Popen[bytes]] = []
+    cmds: list[tuple[str, list[str]]] = []
+
+    for app in selected:
+        cmd = _build_cmd(gunicorn, app)
+        cmds.append((app.name, cmd))
+
+    if dry_run:
+        for name, cmd in cmds:
+            print(f"[dry-run] {name}: {' '.join(cmd)}")
+        return
+
+    # 起動
+    for name, cmd in cmds:
+        print(f"[run] starting {name}")
+        # 新しいプロセスグループにして、まとめて止めやすくする（POSIX）
+        p = subprocess.Popen(
+            cmd,
+            cwd=str(root),
+            env=env,
+            stdout=sys.stdout.buffer,
+            stderr=sys.stderr.buffer,
+            start_new_session=True,
+        )
+        procs.append(p)
+
+    def _terminate_all(sig: int) -> None:
+        # まず優しく
+        for p in procs:
+            if p.poll() is None:
+                try:
+                    os.killpg(p.pid, signal.SIGTERM)
+                except Exception:
+                    try:
+                        p.terminate()
+                    except Exception:
+                        pass
+
+        # 少し待つ
+        deadline = time.time() + 5.0
+        while time.time() < deadline:
+            if all(p.poll() is not None for p in procs):
+                return
+            time.sleep(0.05)
+
+        # 最後は強制
+        for p in procs:
+            if p.poll() is None:
+                try:
+                    os.killpg(p.pid, signal.SIGKILL)
+                except Exception:
+                    try:
+                        p.kill()
+                    except Exception:
+                        pass
+
+    # 親が落ちる/止まる時にまとめて止める
+    def _handle_signal(_signum: int, _frame) -> None:
+        _terminate_all(_signum)
+        raise KeyboardInterrupt
+
+    signal.signal(signal.SIGINT, _handle_signal)
+    signal.signal(signal.SIGTERM, _handle_signal)
+
+    # どれか1つ死んだら全体止める（中途半端が一番事故る）
+    try:
+        while True:
+            for p in procs:
+                code = p.poll()
+                if code is not None:
+                    raise RunError(f"Process exited (pid={p.pid}, code={code})")
+            time.sleep(0.2)
+    except KeyboardInterrupt:
+        _terminate_all(signal.SIGINT)
+    except Exception:
+        _terminate_all(signal.SIGTERM)
+        raise

nexom/core/__init__.py

@@ -1 +1,2 @@
-from . import error
+from . import error
+from . import object_html_render

nexom/core/error.py

@@ -128,7 +128,7 @@ class ObjectHTMLInsertValueError(NexomError):
 
     def __init__(self, name: str) -> None:
         super().__init__(
-            "OH01",
+            "OH02",
             f"This insert value is invalid. '{name}'",
         )
 class ObjectHTMLExtendsError(NexomError):
@@ -136,7 +136,7 @@ class ObjectHTMLExtendsError(NexomError):
 
     def __init__(self, name: str) -> None:
         super().__init__(
-            "OH02",
+            "OH03",
             f"This extends is invalid. '{name}'",
         )
 class ObjectHTMLImportError(NexomError):
@@ -144,6 +144,84 @@ class ObjectHTMLImportError(NexomError):
 
     def __init__(self, name: str) -> None:
         super().__init__(
-            "OH03",
+            "OH04",
             f"This import is invalid. '{name}'",
+        )
+class ObjectHTMLTypeError(NexomError):
+    """Raised when an set HTMLDoc for type is valid."""
+
+    def __init__(self) -> None:
+        super().__init__(
+            "OH05",
+            f"This doc is not HTMLDoc'",
+        )
+
+
+# =========================
+# DatabaseManager
+# =========================
+class DBMConnectionInvalidError(NexomError):
+    """Raised when an udbm connection is invalid."""
+
+    def __init__(self, message="Not started") -> None:
+        super().__init__(
+            "DBM01",
+            f"DBM connection is invalid. -> {message}",
+        )
+
+class DBError(NexomError):
+    """Raised when an udbm connection is invalid."""
+
+    def __init__(self, message) -> None:
+        super().__init__(
+            "DBM02",
+            f"DBM connection is invalid. -> {message}",
+        )
+
+# =========================
+# Auth
+# =========================
+
+class AuthMissingFieldError(NexomError):
+    """Raised when required auth fields are missing."""
+    def __init__(self, key: str) -> None:
+        super().__init__(
+            "A01", 
+            f"Missing field. '{key}'"
+        )
+
+
+class AuthInvalidCredentialsError(NexomError):
+    """Raised when user_id or password is invalid."""
+    def __init__(self) -> None:
+        super().__init__(
+            "A02", 
+            "Invalid credentials."
+        )
+
+
+class AuthUserDisabledError(NexomError):
+    """Raised when the user is inactive/disabled."""
+    def __init__(self) -> None:
+        super().__init__(
+            "A03", 
+            "This user is disabled."
+        )
+
+
+class AuthTokenInvalidError(NexomError):
+    """Raised when token is missing/invalid/expired/revoked."""
+    def __init__(self) -> None:
+        super().__init__(
+            "A04", 
+            "This token is invalid."
+        )
+
+
+class AuthServiceUnavailableError(NexomError):
+    """Raised when AuthService is unreachable or failed to respond."""
+    def __init__(self) -> None:
+        super().__init__(
+            "A05",
+            "Authentication service is currently unavailable."
         )