FastAPI-fastkit 1.4.0__py3-none-any.whl → 1.4.1__py3-none-any.whl

fastapi_fastkit/__init__.py

@@ -1 +1 @@
-__version__ = 'v1.4.0'
+__version__ = 'v1.4.1'

fastapi_fastkit/backend/inspection/context.py

@@ -43,6 +43,10 @@ class InspectionContext:
     warnings: List[str] = field(default_factory=list)
     #: Populated by a test strategy so later checks can reuse the environment.
     venv_path: Optional[str] = None
+    #: Populated when a test strategy already exercised the app's HTTP surface
+    #: (the Docker strategy probes the running container), so the Smoke Test
+    #: step reuses that verdict instead of booting a second server.
+    smoke_result: Optional[bool] = None
 
     def add_error(self, message: str) -> None:
         """Record a fatal finding."""

fastapi_fastkit/backend/inspection/core.py

@@ -252,8 +252,12 @@ class TemplateInspector:
             ("Configuration Consistency", self._check_configuration_consistency),
             ("FastAPI Implementation", self._check_fastapi_implementation),
             ("Placeholder Substitution", self._check_no_placeholder_residue),
-            ("Template Tests", self._test_template),
+            # Compile Check is a pure static check: it runs before the (much
+            # heavier) Template Tests so a syntax error is reported without
+            # waiting for an environment, and so it never observes files a
+            # containerised test run left behind.
             ("Compile Check", self._check_compileall),
+            ("Template Tests", self._test_template),
             ("Type Check", self._check_mypy),
             ("Smoke Test", self._check_smoke_test),
             ("Dependency Freshness", self._check_dependency_freshness),

fastapi_fastkit/backend/inspection/docker.py

@@ -7,6 +7,7 @@
 # @author bnbong
 # --------------------------------------------------------------------------
 import json
+import os
 import subprocess
 import time
 from typing import Any, Dict, List, Optional, Sequence
@@ -14,6 +15,12 @@ from typing import Any, Dict, List, Optional, Sequence
 from fastapi_fastkit.utils.logging import debug_log
 
 COMPOSE_COMMAND = "docker-compose"
+#: Fallback for hosts that only ship the ``docker compose`` CLI plugin.
+COMPOSE_PLUGIN_COMMAND = ["docker", "compose"]
+#: Resolved compose invocation, switched by :meth:`DockerCompose.is_available`.
+_compose_prefix: List[str] = [COMPOSE_COMMAND]
+#: Throwaway image used to give bind-mounted files back to the host user.
+RECLAIM_IMAGE = "alpine:3.20"
 SHORT_TIMEOUT = 10
 STATUS_TIMEOUT = 30
 CLEANUP_TIMEOUT = 60
@@ -43,27 +50,49 @@ class DockerCompose:
             debug_log(f"Command {' '.join(args)} failed: {e}", "warning")
             return None
 
+    @staticmethod
+    def compose_command() -> List[str]:
+        """Return the compose invocation resolved by :meth:`is_available`."""
+        return list(_compose_prefix)
+
     def _compose(
         self, args: Sequence[str], timeout: int
     ) -> Optional[subprocess.CompletedProcess[str]]:
         """Run a docker-compose subcommand against the configured compose file."""
         return self._run(
-            [COMPOSE_COMMAND, "-f", self.compose_file, *args], timeout=timeout
+            [*self.compose_command(), "-f", self.compose_file, *args], timeout=timeout
         )
 
+    @staticmethod
+    def _probe(command: Sequence[str]) -> bool:
+        """Return whether ``command`` exits successfully."""
+        try:
+            result = subprocess.run(
+                list(command), capture_output=True, text=True, timeout=SHORT_TIMEOUT
+            )
+        except (subprocess.TimeoutExpired, OSError):
+            return False
+        return result.returncode == 0
+
     @staticmethod
     def is_available() -> bool:
-        """Check that both docker and docker-compose respond."""
-        for command in (["docker", "--version"], [COMPOSE_COMMAND, "--version"]):
-            try:
-                result = subprocess.run(
-                    command, capture_output=True, text=True, timeout=SHORT_TIMEOUT
-                )
-            except (subprocess.TimeoutExpired, OSError):
-                return False
-            if result.returncode != 0:
-                return False
-        return True
+        """Check that docker responds and a compose implementation exists.
+
+        ``docker-compose`` stays the preferred command; hosts that only ship
+        the ``docker compose`` CLI plugin fall back to it.
+        """
+        global _compose_prefix
+
+        if not DockerCompose._probe(["docker", "--version"]):
+            return False
+        if DockerCompose._probe([COMPOSE_COMMAND, "--version"]):
+            _compose_prefix = [COMPOSE_COMMAND]
+            return True
+        if DockerCompose._probe([*COMPOSE_PLUGIN_COMMAND, "version"]):
+            debug_log("Falling back to the 'docker compose' CLI plugin", "info")
+            _compose_prefix = list(COMPOSE_PLUGIN_COMMAND)
+            return True
+        return False
 
     def _services(self, timeout: int) -> List[Dict[str, Any]]:
         """Return the parsed ``docker-compose ps --format json`` entries."""
@@ -71,8 +100,34 @@ class DockerCompose:
         if result is None or result.returncode != 0:
             return []
 
+        # Compose sometimes interleaves ``time="..." level=warning`` log lines
+        # with the JSON payload, so only JSON-looking lines are considered.
+        payload = "\n".join(
+            line
+            for line in result.stdout.splitlines()
+            if line.strip().startswith(("[", "{"))
+        ).strip()
+        if not payload:
+            return []
+
+        # Compose < v2.21 prints a single JSON array, newer versions print one
+        # JSON object per line (NDJSON).
+        try:
+            document = json.loads(payload)
+        except json.JSONDecodeError:
+            return DockerCompose._parse_json_lines(payload)
+
+        if isinstance(document, dict):
+            return [document]
+        if isinstance(document, list):
+            return [entry for entry in document if isinstance(entry, dict)]
+        return []
+
+    @staticmethod
+    def _parse_json_lines(payload: str) -> List[Dict[str, Any]]:
+        """Parse NDJSON output, skipping malformed or non-object lines."""
         services: List[Dict[str, Any]] = []
-        for line in result.stdout.strip().split("\n"):
+        for line in payload.split("\n"):
             if not line.strip():
                 continue
             try:
@@ -109,7 +164,7 @@ class DockerCompose:
         """Build and start the compose services in the background."""
         result = self._compose(["up", "-d", "--build"], timeout=timeout)
         if result is None:
-            raise subprocess.TimeoutExpired(COMPOSE_COMMAND, timeout)
+            raise subprocess.TimeoutExpired(" ".join(self.compose_command()), timeout)
         return result
 
     def wait_until_healthy(self, timeout: int) -> None:
@@ -166,6 +221,50 @@ class DockerCompose:
         debug_log("All required services are running", "info")
         return None
 
+    def published_port(self, service_hint: str = "app") -> Optional[int]:
+        """Return the host port the app container publishes, if any.
+
+        ``docker-compose ps --format json`` reports a ``Publishers`` list per
+        service; an entry with a non-zero ``PublishedPort`` is a port bound on
+        the host, which is what a smoke test can reach. Services whose name
+        contains ``service_hint`` are preferred, so a database that happens to
+        publish a port is never mistaken for the application.
+        """
+        services = self._services(timeout=STATUS_TIMEOUT)
+        if not services:
+            return None
+
+        def _matches(service: Dict[str, Any]) -> bool:
+            name = f"{service.get('Service', '')} {service.get('Name', '')}"
+            return service_hint in name
+
+        for candidate in (
+            [entry for entry in services if _matches(entry)],
+            services,
+        ):
+            for service in candidate:
+                port = self._first_published_port(service)
+                if port is not None:
+                    return port
+        return None
+
+    @staticmethod
+    def _first_published_port(service: Dict[str, Any]) -> Optional[int]:
+        """Extract the first host-bound port from one ``ps`` entry."""
+        publishers = service.get("Publishers")
+        if not isinstance(publishers, list):
+            return None
+        for publisher in publishers:
+            if not isinstance(publisher, dict):
+                continue
+            try:
+                port = int(publisher.get("PublishedPort", 0))
+            except (TypeError, ValueError):
+                continue
+            if port > 0:
+                return port
+        return None
+
     def exec_tests(
         self, use_test_script: bool
     ) -> Optional[subprocess.CompletedProcess[str]]:
@@ -176,10 +275,46 @@ class DockerCompose:
             command = ["exec", "-T", "app", "python", "-m", "pytest", "tests/", "-v"]
         return self._compose(command, timeout=TEST_TIMEOUT)
 
+    def reclaim_bind_mount_ownership(self) -> None:
+        """Give the bind-mounted project directory back to the host user.
+
+        Containers run as root, so a test run inside the stack leaves
+        root-owned artefacts (``__pycache__``, ``.pytest_cache``, ...) in the
+        mounted project. Later host-side steps and the temp directory cleanup
+        cannot touch those and fail with a PermissionError, so the ownership
+        is reset from inside a throwaway container. Best effort: a failure
+        here is never worth failing an inspection over.
+        """
+        if not hasattr(os, "getuid"):  # pragma: no cover - Windows hosts
+            return
+
+        uid, gid = os.getuid(), os.getgid()
+        if uid == 0:
+            return
+
+        debug_log("Reclaiming ownership of bind-mounted project files", "info")
+        self._run(
+            [
+                "docker",
+                "run",
+                "--rm",
+                "-v",
+                f"{self.project_dir}:/mnt",
+                RECLAIM_IMAGE,
+                "chown",
+                "-R",
+                f"{uid}:{gid}",
+                "/mnt",
+            ],
+            timeout=CLEANUP_TIMEOUT,
+        )
+
     def cleanup(self) -> None:
         """Tear down services and volumes, ignoring any failure."""
         debug_log("Cleaning up Docker services", "info")
+        self.reclaim_bind_mount_ownership()
         self._run(
-            [COMPOSE_COMMAND, "down", "-v", "--remove-orphans"], timeout=CLEANUP_TIMEOUT
+            [*self.compose_command(), "down", "-v", "--remove-orphans"],
+            timeout=CLEANUP_TIMEOUT,
         )
         self._run(["docker", "system", "prune", "-f"], timeout=STATUS_TIMEOUT)

fastapi_fastkit/backend/inspection/lint.py

@@ -1,12 +1,17 @@
 # --------------------------------------------------------------------------
 # Static analysis of the generated project.
 #
-# ``compileall`` is mandatory - a template that cannot be byte-compiled is
-# broken beyond argument. ``mypy`` is opt-in because it needs the template's
-# own dependencies installed and is far slower.
+# The compile check is mandatory - a template that cannot be compiled is
+# broken beyond argument. It is performed in-process with ``compile()`` and
+# deliberately writes nothing to disk: a Docker test run beforehand can leave
+# root-owned ``__pycache__`` directories in the bind-mounted project, and
+# ``compileall`` would then fail with a PermissionError that says nothing
+# about the template. ``mypy`` is opt-in because it needs the template's own
+# dependencies installed and is far slower.
 #
 # @author bnbong
 # --------------------------------------------------------------------------
+import os
 import subprocess
 import sys
 from typing import List
@@ -15,43 +20,52 @@ from fastapi_fastkit.utils.logging import debug_log
 
 from .context import InspectionContext
 
-COMPILE_TIMEOUT = 120
 MYPY_TIMEOUT = 300
 
+#: Directories never worth compiling - third party code and build artefacts.
+EXCLUDED_DIRS = {".venv", "venv", "__pycache__", "node_modules"}
+
 
 def _interpreter(ctx: InspectionContext) -> str:
     """Prefer the inspection venv interpreter, falling back to the host one."""
     return ctx.python_executable() or sys.executable
 
 
+def _iter_python_files(root: str) -> List[str]:
+    """Collect every ``.py`` file below ``root``, skipping excluded directories."""
+    python_files: List[str] = []
+    for dirpath, dirnames, filenames in os.walk(root):
+        dirnames[:] = [name for name in dirnames if name not in EXCLUDED_DIRS]
+        for file_name in sorted(filenames):
+            if file_name.endswith(".py"):
+                python_files.append(os.path.join(dirpath, file_name))
+    return python_files
+
+
 def check_compileall(ctx: InspectionContext) -> bool:
-    """Byte-compile every Python file of the generated project."""
-    command: List[str] = [
-        _interpreter(ctx),
-        "-m",
-        "compileall",
-        "-q",
-        "-x",
-        r"(\.venv|venv|node_modules)",
-        ctx.temp_dir,
-    ]
-    try:
-        result = subprocess.run(
-            command,
-            cwd=ctx.temp_dir,
-            capture_output=True,
-            text=True,
-            timeout=COMPILE_TIMEOUT,
-        )
-    except subprocess.TimeoutExpired:
-        ctx.add_error("compileall timed out")
-        return False
-    except OSError as e:
-        ctx.add_error(f"Failed to run compileall: {e}")
-        return False
+    """Compile every Python file of the generated project, in memory.
 
-    if result.returncode != 0:
-        detail = (result.stderr or result.stdout or "").strip()
+    Nothing is written to disk - no ``__pycache__`` is created - so the check
+    stays a pure syntax gate that cannot trip over file ownership left behind
+    by a containerised test run.
+    """
+    failures: List[str] = []
+
+    for path in _iter_python_files(ctx.temp_dir):
+        try:
+            with open(path, "rb") as f:
+                source = f.read()
+        except OSError as e:
+            failures.append(f"{path}: could not be read ({e})")
+            continue
+
+        try:
+            compile(source, path, "exec", dont_inherit=True)
+        except (SyntaxError, ValueError) as e:
+            failures.append(f"{path}: {e}")
+
+    if failures:
+        detail = "\n".join(failures)
         ctx.add_error(f"Generated project failed to compile:\n{detail}")
         return False
 

fastapi_fastkit/backend/inspection/smoke.py

@@ -115,12 +115,17 @@ def _probe(url: str, timeout: int = 5) -> Optional[int]:
 
 
 def _wait_for_server(
-    process: "subprocess.Popen[bytes]", base_url: str, timeout: int
+    process: Optional["subprocess.Popen[bytes]"], base_url: str, timeout: int
 ) -> Tuple[bool, str]:
-    """Poll ``/docs`` until the server answers, the process dies or time runs out."""
+    """Poll ``/docs`` until the server answers, the process dies or time runs out.
+
+    ``process`` is ``None`` when the server is not ours to watch - a container
+    started by the Docker strategy, for one - in which case only the timeout
+    bounds the wait.
+    """
     deadline = time.time() + timeout
     while time.time() < deadline:
-        if process.poll() is not None:
+        if process is not None and process.poll() is not None:
             return False, "server process exited before becoming reachable"
         status = _probe(f"{base_url}/docs")
         if status is not None:
@@ -228,14 +233,70 @@ def _read_log_tail(log_file: IO[bytes]) -> str:
         return ""
 
 
+def _check_health_endpoint(ctx: InspectionContext, base_url: str) -> Optional[str]:
+    """Probe ``/health``; return a failure message, or ``None`` when acceptable.
+
+    A template without a ``/health`` route answers 404, which is fine; an
+    unreachable endpoint is only worth a warning, but a route that exists and
+    answers with anything other than 200 is a real failure.
+    """
+    health_status = _probe(f"{base_url}/health")
+    if health_status is None:
+        ctx.add_warning("Smoke test: /health did not respond")
+    elif health_status == 404:
+        debug_log("Template exposes no /health endpoint, skipping", "info")
+    elif health_status != 200:
+        return (
+            f"Smoke test failed: /health returned HTTP {health_status} (expected 200)"
+        )
+    return None
+
+
+def run_http_smoke(ctx: InspectionContext, base_url: str) -> bool:
+    """Verify the HTTP surface of a server someone else already started.
+
+    Used by the Docker strategy, which has the real application running in a
+    container: probing its published port is more honest than booting a second
+    copy on the host, and templates that require Docker never get a host venv
+    to boot one with in the first place.
+    """
+    debug_log(f"Running smoke test against {base_url}", "info")
+    reachable, reason = _wait_for_server(None, base_url, ctx.options.smoke_timeout)
+    if not reachable:
+        ctx.add_error(f"Smoke test failed: {reason}")
+        return False
+
+    failure = _check_health_endpoint(ctx, base_url)
+    if failure:
+        ctx.add_error(failure)
+        return False
+
+    debug_log("Smoke test passed", "info")
+    return True
+
+
+def _requires_docker(ctx: InspectionContext) -> bool:
+    """Whether the template declares that it can only run under Docker."""
+    return bool((ctx.template_config or {}).get("requires_docker", False))
+
+
 def check_smoke_test(ctx: InspectionContext) -> bool:
     """Boot the generated project and verify its HTTP surface."""
     if not ctx.options.run_smoke_test:
         debug_log("Smoke test disabled", "info")
         return True
 
+    if ctx.smoke_result is not None:
+        debug_log("Reusing the smoke test result recorded while testing", "info")
+        return ctx.smoke_result
+
     python_executable = ctx.python_executable()
     if not python_executable or not os.path.exists(python_executable):
+        if _requires_docker(ctx):
+            ctx.add_warning(
+                "smoke test skipped: Docker template without published port"
+            )
+            return True
         ctx.add_error(
             "Smoke test requires an installed environment, but no virtual "
             "environment was prepared for the generated project"
@@ -306,16 +367,9 @@ def check_smoke_test(ctx: InspectionContext) -> bool:
                     ctx.add_error(last_failure)
                     return False
 
-                health_status = _probe(f"{base_url}/health")
-                if health_status is None:
-                    ctx.add_warning("Smoke test: /health did not respond")
-                elif health_status == 404:
-                    debug_log("Template exposes no /health endpoint, skipping", "info")
-                elif health_status != 200:
-                    ctx.add_error(
-                        f"Smoke test failed: /health returned HTTP {health_status} "
-                        "(expected 200)\n" + _read_log_tail(log_file)
-                    )
+                failure = _check_health_endpoint(ctx, base_url)
+                if failure:
+                    ctx.add_error(f"{failure}\n{_read_log_tail(log_file)}".rstrip())
                     return False
             finally:
                 _terminate(process)

fastapi_fastkit/backend/inspection/strategies.py

@@ -16,6 +16,7 @@ from typing import Any, Dict, List
 from fastapi_fastkit.backend.main import create_venv, install_dependencies_with_manager
 from fastapi_fastkit.utils.logging import debug_log
 
+from . import smoke
 from .context import InspectionContext
 from .docker import DockerCompose
 from .fsutils import fix_all_script_line_endings, fix_script_line_endings
@@ -278,7 +279,15 @@ class DockerStrategy(TestStrategy):
                 self.ctx.add_error(verification_error)
                 return False
 
-            return self._run_tests(compose)
+            if not self._run_tests(compose):
+                return False
+
+            # The application is running right here, in a container with a
+            # published port: probing that is the only way a Docker-only
+            # template gets a smoke test, since no host venv is ever built for
+            # it. Done before the ``finally`` below tears the stack down.
+            self._run_smoke_test(compose)
+            return True
         except subprocess.TimeoutExpired:
             self.ctx.add_error("Docker Compose setup timed out")
             return False
@@ -307,6 +316,28 @@ class DockerStrategy(TestStrategy):
         debug_log("Docker tests passed successfully", "info")
         return True
 
+    def _run_smoke_test(self, compose: DockerCompose) -> None:
+        """Probe the running container's HTTP surface and record the verdict.
+
+        The result lands on the context so the pipeline's Smoke Test step
+        reuses it instead of trying (and failing) to boot the project from a
+        virtual environment that a Docker run never creates.
+        """
+        if not self.ctx.options.run_smoke_test:
+            return
+
+        port = compose.published_port()
+        if port is None:
+            self.ctx.add_warning(
+                "smoke test skipped: Docker template without published port"
+            )
+            self.ctx.smoke_result = True
+            return
+
+        self.ctx.smoke_result = smoke.run_http_smoke(
+            self.ctx, f"http://127.0.0.1:{port}"
+        )
+
 
 def select_fallback_strategy(ctx: InspectionContext) -> TestStrategy:
     """Pick the fallback strategy, or the standard one when none is configured."""

fastapi_fastkit/backend/transducer.py

@@ -22,6 +22,104 @@ logger = get_logger(__name__)
 #: here are the *converted* names (the ``-tpl`` marker already stripped).
 TEMPLATE_ONLY_FILES = frozenset({"template-config.yml"})
 
+#: Extensions of files that are known to be text and therefore safe to rewrite
+#: with Unix line endings. Anything outside this list is copied byte for byte,
+#: so an image or an archive shipped inside a template survives untouched.
+TEXT_FILE_EXTENSIONS = frozenset(
+    {
+        ".bash",
+        ".cfg",
+        ".css",
+        ".env",
+        ".html",
+        ".ini",
+        ".js",
+        ".json",
+        ".mako",
+        ".md",
+        ".py",
+        ".rst",
+        ".sh",
+        ".sql",
+        ".toml",
+        ".ts",
+        ".txt",
+        ".yaml",
+        ".yml",
+    }
+)
+
+#: Extension-less file names that are text as well.
+TEXT_FILE_NAMES = frozenset(
+    {
+        ".dockerignore",
+        ".env",
+        ".gitignore",
+        "CHANGELOG",
+        "Dockerfile",
+        "LICENSE",
+        "Makefile",
+        "Procfile",
+        "README",
+    }
+)
+
+#: How much of a file is sampled when looking for a NUL byte. A NUL in the
+#: first chunk is the same heuristic Git uses to call a blob binary.
+BINARY_SNIFF_BYTES = 8192
+
+
+def _looks_like_text_file(file_path: str, file_name: str) -> bool:
+    """
+    Decide whether a copied file may have its line endings normalised.
+
+    The check is deliberately conservative: the name has to be on the text
+    whitelist *and* the content must carry no NUL byte, so a mislabelled
+    binary is left alone rather than corrupted.
+
+    :param file_path: Path of the file to inspect
+    :param file_name: File name used for the extension/name whitelist
+    :return: True when the file is safe to rewrite as text
+    """
+    _, extension = os.path.splitext(file_name)
+    if (
+        extension.lower() not in TEXT_FILE_EXTENSIONS
+        and file_name not in TEXT_FILE_NAMES
+    ):
+        return False
+
+    try:
+        with open(file_path, "rb") as f:
+            return b"\x00" not in f.read(BINARY_SNIFF_BYTES)
+    except OSError as e:
+        debug_log(f"Could not sniff {file_path} for binary content: {e}", "warning")
+        return False
+
+
+def _normalize_line_endings(file_path: str, file_name: str) -> None:
+    """
+    Rewrite a copied text file with Unix line endings.
+
+    Templates checked out on Windows (or with ``core.autocrlf=true``) carry
+    CRLF, which makes a generated project's shell scripts unusable inside a
+    Linux container: ``env: 'bash\r': No such file or directory``. The rewrite
+    happens in place through :func:`fix_script_line_endings`, which truncates
+    rather than recreates the file and therefore keeps the executable bit
+    ``shutil.copy2`` just carried over.
+
+    :param file_path: Path of the copied file
+    :param file_name: File name used for the text/binary decision
+    """
+    if not _looks_like_text_file(file_path, file_name):
+        return
+
+    # Imported lazily: ``fastapi_fastkit.backend.inspection`` pulls in the
+    # scaffolder, which imports this module, so a top-level import would be
+    # circular.
+    from fastapi_fastkit.backend.inspection.fsutils import fix_script_line_endings
+
+    fix_script_line_endings(file_path)
+
 
 def copy_and_convert_template(
     template_dir: str, target_dir: str, project_name: str = ""
@@ -130,6 +228,7 @@ def _copy_template_file(
 
     try:
         shutil.copy2(src_file, dst_file)
+        _normalize_line_endings(dst_file, dst_file_name)
         debug_log(f"Copied {src_file} to {dst_file}", "debug")
         return dst_file
 
@@ -223,8 +322,8 @@ def _write_target_file(target_file: str, content: str, source_file: str) -> bool
         target_dir = os.path.dirname(target_file)
         os.makedirs(target_dir, exist_ok=True)
 
-        with open(target_file, "w", encoding="utf-8") as f:
-            f.write(content)
+        with open(target_file, "w", encoding="utf-8", newline="\n") as f:
+            f.write(content.replace("\r\n", "\n").replace("\r", "\n"))
 
         debug_log(
             f"Successfully copied template file from {source_file} to {target_file}",

fastapi_fastkit/core/settings.py

@@ -257,13 +257,13 @@ class FastkitConfig:
             DatabaseChoice.NONE: [],
         },
         FeatureAxis.AUTHENTICATION: {
-            AuthChoice.JWT: ["python-jose[cryptography]", "passlib[bcrypt]"],
+            AuthChoice.JWT: ["pyjwt[crypto]", "pwdlib[argon2]"],
             # SessionMiddleware (used by the OAuth2 login flow) needs itsdangerous.
             AuthChoice.OAUTH2: ["authlib", "itsdangerous", "httpx"],
             AuthChoice.FASTAPI_USERS: [
                 "fastapi-users[sqlalchemy]",
-                "python-jose[cryptography]",
-                "passlib[bcrypt]",
+                "pyjwt[crypto]",
+                "pwdlib[argon2]",
             ],
             AuthChoice.SESSION: ["itsdangerous"],
             AuthChoice.NONE: [],

fastapi_fastkit/fastapi_project_template/fastapi-mcp/.env-tpl

@@ -21,7 +21,7 @@ MCP_TITLE=FastAPI MCP Server
 MCP_DESCRIPTION=FastAPI endpoints exposed as MCP tools
 
 # Authentication Settings
-SECRET_KEY=changethis
+SECRET_KEY=changethis-please-use-openssl-rand-hex-32
 ALGORITHM=HS256
 ACCESS_TOKEN_EXPIRE_MINUTES=30
 

fastapi_fastkit/fastapi_project_template/fastapi-mcp/README.md-tpl

@@ -75,7 +75,7 @@ MCP_TITLE=FastAPI MCP Server
 MCP_DESCRIPTION=FastAPI endpoints exposed as MCP tools
 
 # Authentication Settings
-SECRET_KEY=changethis
+SECRET_KEY=changethis-please-use-openssl-rand-hex-32
 ALGORITHM=HS256
 ACCESS_TOKEN_EXPIRE_MINUTES=30
 

fastapi_fastkit/fastapi_project_template/fastapi-mcp/pyproject.toml-tpl

@@ -17,9 +17,8 @@ dependencies = [
     "python-dotenv>=1.2.3",
     "fastapi-mcp>=0.3.7,<0.4.0",
     "mcp>=1.29.1,<2.0.0",
-    "bcrypt>=4.0.1,<4.1.0",
-    "passlib>=1.7.4",
-    "python-jose>=3.5.0",
+    "pwdlib[argon2]>=0.3.1",
+    "PyJWT[crypto]>=2.13.0",
     "python-multipart>=0.0.32",
 ]
 

fastapi_fastkit/fastapi_project_template/fastapi-mcp/requirements.txt-tpl

@@ -1,9 +1,10 @@
 annotated-doc==0.0.5
 annotated-types==0.8.0
 anyio==4.15.0
+argon2-cffi==25.1.0
+argon2-cffi-bindings==26.1.0
 ast-serialize==0.9.0
 attrs==26.1.0
-bcrypt==4.0.1
 black==26.5.1
 certifi==2026.7.22
 cffi==2.1.1
@@ -11,7 +12,6 @@ charset-normalizer==3.5.1
 click==8.5.0
 coverage==7.16.0
 cryptography==50.0.1
-ecdsa==0.19.2
 fastapi==0.141.1
 fastapi-mcp==0.3.7
 h11==0.16.0
@@ -31,21 +31,19 @@ mdurl==0.1.2
 mypy==2.3.1
 mypy-extensions==1.1.0
 packaging==26.3
-passlib==1.7.4
 pathspec==1.1.1
 platformdirs==4.11.7
 pluggy==1.6.0
-pyasn1==0.6.4
+pwdlib==0.3.1
 pycparser==3.0
 pydantic==2.13.5
 pydantic-core==2.46.5
 pydantic-settings==2.15.0
 pygments==2.21.0
-pyjwt==2.13.0
+PyJWT==2.13.0
 pytest==9.1.1
 pytest-cov==7.1.0
 python-dotenv==1.2.3
-python-jose==3.5.0
 python-multipart==0.0.32
 pytokens==0.4.1
 PyYAML==6.0.3
@@ -53,9 +51,7 @@ referencing==0.37.0
 requests==2.34.2
 rich==15.0.0
 rpds-py==2026.6.3
-rsa==4.9.1
 shellingham==1.5.4
-six==1.17.0
 SQLAlchemy==2.0.52
 sse-starlette==3.4.10
 starlette==1.6.0

fastapi_fastkit/fastapi_project_template/fastapi-mcp/setup.cfg-tpl

@@ -29,9 +29,8 @@ install_requires =
     pydantic>=2.10.6
     pydantic-settings>=2.7.1
     python-dotenv>=1.0.1
-    python-jose>=3.3.0
-    passlib>=1.7.4
-    bcrypt>=4.1.2
+    PyJWT[crypto]>=2.10.0
+    pwdlib[argon2]>=0.3.1
     python-multipart>=0.0.17
 
 [options.extras_require]

fastapi_fastkit/fastapi_project_template/fastapi-mcp/src/api/routes/auth.py-tpl

@@ -3,10 +3,10 @@ Authentication-related API endpoints.
 """
 from datetime import datetime, timedelta, timezone
 
+import jwt
 from fastapi import APIRouter, Depends, HTTPException, status
 from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
-from jose import jwt
-from passlib.context import CryptContext
+from pwdlib import PasswordHash
 
 from src.auth.dependencies import get_current_active_user
 from src.core.config import settings
@@ -14,8 +14,8 @@ from src.schemas.items import AuthToken, UserInfo, UserLogin
 
 router = APIRouter()
 
-# Password hashing
-pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+# Password hashing — argon2id, the recommended default for new applications.
+password_hash = PasswordHash.recommended()
 
 # OAuth2 scheme
 oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
@@ -25,19 +25,19 @@ mock_users = {
     "user1": {
         "user_id": "user1",
         "username": "user1",
-        "hashed_password": pwd_context.hash("password123"),
+        "hashed_password": password_hash.hash("password123"),
         "active": True,
     },
     "user2": {
         "user_id": "user2",
         "username": "user2",
-        "hashed_password": pwd_context.hash("password456"),
+        "hashed_password": password_hash.hash("password456"),
         "active": True,
     },
     "admin": {
         "user_id": "admin",
         "username": "admin",
-        "hashed_password": pwd_context.hash("admin123"),
+        "hashed_password": password_hash.hash("admin123"),
         "active": True,
     },
 }
@@ -45,12 +45,12 @@ mock_users = {
 
 def verify_password(plain_password: str, hashed_password: str) -> bool:
     """Verify a password against its hash."""
-    return pwd_context.verify(plain_password, hashed_password)
+    return password_hash.verify(plain_password, hashed_password)
 
 
 def get_password_hash(password: str) -> str:
     """Generate password hash."""
-    return pwd_context.hash(password)
+    return password_hash.hash(password)
 
 
 def authenticate_user(username: str, password: str) -> dict | None:

fastapi_fastkit/fastapi_project_template/fastapi-mcp/src/auth/dependencies.py-tpl

@@ -2,9 +2,9 @@
 Authentication dependencies for API and MCP endpoints.
 """
 
+import jwt
 from fastapi import Depends, HTTPException, status
 from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
-from jose import JWTError, jwt
 
 from src.core.config import settings
 
@@ -16,7 +16,7 @@ def verify_token(token: str) -> dict:
     try:
         payload = jwt.decode(token, settings.SECRET_KEY, algorithms=[settings.ALGORITHM])
         return payload
-    except JWTError:
+    except jwt.PyJWTError:
         raise HTTPException(
             status_code=status.HTTP_401_UNAUTHORIZED,
             detail="Could not validate credentials",

fastapi_fastkit/fastapi_project_template/fastapi-mcp/src/core/config.py-tpl

@@ -28,7 +28,7 @@ class Settings(BaseSettings):
     MCP_DESCRIPTION: str = "FastAPI endpoints exposed as MCP tools"
 
     # Authentication settings
-    SECRET_KEY: str = "your-secret-key-here"
+    SECRET_KEY: str = "your-secret-key-here-change-in-production"
     ALGORITHM: str = "HS256"
     ACCESS_TOKEN_EXPIRE_MINUTES: int = 30
 

fastapi_fastkit/fastapi_project_template/fastapi-psql-orm/.env-tpl

@@ -1,4 +1,6 @@
 # Backend
+# Must be one of the values accepted by src/core/config.py: development | production
+ENVIRONMENT=development
 SECRET_KEY=changethis
 
 # Postgres

fastapi_fastkit/fragments/auth/jwt.py.j2

@@ -1,8 +1,8 @@
 {% include "header.j2" %}
 from datetime import UTC, datetime, timedelta
 
-from jose import jwt
-from passlib.context import CryptContext
+import jwt
+from pwdlib import PasswordHash
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
 
@@ -18,18 +18,18 @@ class AuthSettings(BaseSettings):
 
 settings = AuthSettings()
 
-# Password hashing
-pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+# Password hashing — argon2id, the recommended default for new applications.
+password_hash = PasswordHash.recommended()
 
 
 def verify_password(plain_password: str, hashed_password: str) -> bool:
     """Verify a password against a hash."""
-    return pwd_context.verify(plain_password, hashed_password)
+    return password_hash.verify(plain_password, hashed_password)
 
 
 def get_password_hash(password: str) -> str:
     """Hash a password."""
-    return pwd_context.hash(password)
+    return password_hash.hash(password)
 
 
 def create_access_token(

{fastapi_fastkit-1.4.0.dist-info → fastapi_fastkit-1.4.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: FastAPI-fastkit
-Version: 1.4.0
+Version: 1.4.1
 Summary: Fast, easy-to-use starter kit for new users of Python and FastAPI
 Author-Email: bnbong <bbbong9@gmail.com>
 License: MIT
@@ -82,7 +82,9 @@ $ pip install FastAPI-fastkit
 ```console
 fastkit init [OPTIONS]
 ```
-- What it does: Scaffolds an empty FastAPI project, creates a virtual environment, installs dependencies
+> [!TIP]
+> Scaffolds an empty FastAPI project, creates a virtual environment, installs dependencies
+
 - Key options:
   - `--project-name`, `--author`, `--author-email`, `--description`
   - `--package-manager` [pip|uv|pdm|poetry]
@@ -98,7 +100,9 @@ fastkit init [OPTIONS]
 ```console
 fastkit init --interactive
 ```
-- What it does: Guided step-by-step project setup with intelligent feature selection
+> [!TIP]
+> Guided step-by-step project setup with intelligent feature selection
+
 - Features:
   - **Architecture preset**: `minimal` | `single-module` | `classic-layered` | `domain-starter` (default)
   - **Database selection**: PostgreSQL, MySQL, MongoDB, Redis, SQLite
@@ -114,7 +118,7 @@ fastkit init --interactive
   - **Deployment**: Docker, docker-compose with auto-generated configs
   - **Package manager**: pip, uv, pdm, poetry
   - **Custom packages**: Add your own dependencies
-- Auto-generates (varies by preset — see [the matrix](https://bnbong.github.io/FastAPI-fastkit/reference/preset-feature-matrix/) for details):
+- Auto-generates (varies by preset - see [the matrix](https://bnbong.github.io/FastAPI-fastkit/reference/preset-feature-matrix/) for details):
   - `main.py` regenerated from selected features for `minimal` / `single-module`; preserved as-shipped for `classic-layered` / `domain-starter`
   - Database and authentication configuration files at preset-specific paths
   - Docker deployment files (`Dockerfile`, `docker-compose.yml`) with the preset's correct uvicorn entrypoint
@@ -127,7 +131,9 @@ fastkit init --interactive
 ```console
 fastkit startdemo [TEMPLATE] [OPTIONS]
 ```
-- What it does: Creates a project from a template (e.g., `fastapi-default`) and installs dependencies
+> [!TIP]
+> Creates a project from a template (e.g., `fastapi-default`) and installs dependencies
+
 - Key options:
   - `--project-name`, `--author`, `--author-email`, `--description`
   - `--package-manager` [pip|uv|pdm|poetry]
@@ -135,12 +141,6 @@ fastkit startdemo [TEMPLATE] [OPTIONS]
   - Refuses to run if the target project directory already exists (`--dry-run` excepted)
 - Tip: List available templates with `fastkit list-templates`
 
-New in v1.4.0: `fastapi-auth-jwt` (JWT auth with refresh rotation),
-`fastapi-sqlmodel` (async SQLModel + Alembic + generic CRUD), and
-`fastapi-llm-agent` (streaming Claude agent with a tool loop).
-`fastapi-dockerized` and `fastapi-async-crud` are deprecated — they still
-work, but are no longer recommended starting points.
-
 ### Add a new route
 ```console
 fastkit addroute <project_name> <route_name>
@@ -160,6 +160,25 @@ fastkit runserver [OPTIONS]
 fastkit list-templates
 ```
 
+Available templates:
+
+| Template | Description | Notes |
+|---|---|---|
+| [`fastapi-default`](src/fastapi_fastkit/fastapi_project_template/fastapi-default/README.md-tpl) | Simple FastAPI project with a classic layered layout | Good first choice |
+| [`fastapi-empty`](src/fastapi_fastkit/fastapi_project_template/fastapi-empty/README.md-tpl) | Minimal FastAPI template | Base for `minimal` preset |
+| [`fastapi-single-module`](src/fastapi_fastkit/fastapi_project_template/fastapi-single-module/README.md-tpl) | Single-file FastAPI app | Base for `single-module` preset |
+| [`fastapi-domain-starter`](src/fastapi_fastkit/fastapi_project_template/fastapi-domain-starter/README.md-tpl) | Domain-oriented, pyproject-first starter for medium-sized APIs | Base for `domain-starter` preset |
+| [`fastapi-auth-jwt`](src/fastapi_fastkit/fastapi_project_template/fastapi-auth-jwt/README.md-tpl) | JWT authentication with refresh-token rotation, argon2 hashing and scopes | New in v1.4.0 |
+| [`fastapi-sqlmodel`](src/fastapi_fastkit/fastapi_project_template/fastapi-sqlmodel/README.md-tpl) | Async SQLModel + Alembic migrations + generic CRUD with pagination | New in v1.4.0 |
+| [`fastapi-llm-agent`](src/fastapi_fastkit/fastapi_project_template/fastapi-llm-agent/README.md-tpl) | Streaming Claude chat agent (SSE) with a tool-call loop | New in v1.4.0 |
+| [`fastapi-mcp`](src/fastapi_fastkit/fastapi_project_template/fastapi-mcp/README.md-tpl) | FastAPI app exposed as an MCP server | |
+| [`fastapi-psql-orm`](src/fastapi_fastkit/fastapi_project_template/fastapi-psql-orm/README.md-tpl) | Item management API with PostgreSQL, SQLModel, Alembic and docker-compose | Requires Docker |
+| [`fastapi-custom-response`](src/fastapi_fastkit/fastapi_project_template/fastapi-custom-response/README.md-tpl) | Item management API with a custom response envelope, error handling and pagination | |
+| [`fastapi-async-crud`](src/fastapi_fastkit/fastapi_project_template/fastapi-async-crud/README.md-tpl) | Async item management API | **Deprecated** — use `fastapi-sqlmodel` |
+| [`fastapi-dockerized`](src/fastapi_fastkit/fastapi_project_template/fastapi-dockerized/README.md-tpl) | Dockerized item management API | **Deprecated** — use `fastapi-default` with the Docker option in `init --interactive` |
+
+Deprecated templates still work but are no longer recommended starting points. See [Which starter should I choose?](https://bnbong.github.io/FastAPI-fastkit/user-guide/choosing-a-starter/) for a decision guide.
+
 ### Delete a project
 ```console
 fastkit deleteproject <project_name>

{fastapi_fastkit-1.4.0.dist-info → fastapi_fastkit-1.4.1.dist-info}/RECORD

@@ -1,22 +1,22 @@
-fastapi_fastkit-1.4.0.dist-info/METADATA,sha256=wedGfADPNstm5uSxEkzj-L1R8aN_bT7ssYM3ObJ-b3o,11905
-fastapi_fastkit-1.4.0.dist-info/WHEEL,sha256=VP-D4TPS230sME9Z3vb3INXvo1yt0924YRm5AOsk_dE,90
-fastapi_fastkit-1.4.0.dist-info/entry_points.txt,sha256=IONmgb7zWPnJWsCOcpF3u1yP6AWnPjrgWIv49mr1DZE,76
-fastapi_fastkit-1.4.0.dist-info/licenses/LICENSE,sha256=2a9cYM3Uy8DW-so6zpYaqUafYT1Dznd3OCWCFe5CKNA,1066
-fastapi_fastkit/__init__.py,sha256=Fc7Dma-w6Qol1wV5ZlHolbiRE3Am7eHtFGZvbNRu_8E,23
+fastapi_fastkit-1.4.1.dist-info/METADATA,sha256=KRHsuGhz10aD8Nckit_OsoJwMcSiwKbYM9zcfZttGak,14058
+fastapi_fastkit-1.4.1.dist-info/WHEEL,sha256=VP-D4TPS230sME9Z3vb3INXvo1yt0924YRm5AOsk_dE,90
+fastapi_fastkit-1.4.1.dist-info/entry_points.txt,sha256=IONmgb7zWPnJWsCOcpF3u1yP6AWnPjrgWIv49mr1DZE,76
+fastapi_fastkit-1.4.1.dist-info/licenses/LICENSE,sha256=2a9cYM3Uy8DW-so6zpYaqUafYT1Dznd3OCWCFe5CKNA,1066
+fastapi_fastkit/__init__.py,sha256=muhECMM1myXdjnRz3xB2_5q1rOYCUaw2jAkKMCZqrJ8,23
 fastapi_fastkit/__main__.py,sha256=-FS9yUe4IEgDbJjFC1xso-pFCxRzUJ447j6bYpsBTBM,271
 fastapi_fastkit/backend/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fastapi_fastkit/backend/inspection/__init__.py,sha256=hIw6MIOrt5GI52kQtYWsW1INbuVd64vG_OGU_rvfXXE,1088
 fastapi_fastkit/backend/inspection/checks.py,sha256=rW-CfDaPXejo1Hvoy7LskOKTdInZMK1wPj4hhl1z380,11946
 fastapi_fastkit/backend/inspection/consistency.py,sha256=kmW9D4eN2qCpiygezM4JpqFZ7SC7-wUImGt53ej4Vu4,4941
-fastapi_fastkit/backend/inspection/context.py,sha256=K5GsITSMsa-Pgl6eOmU1C5BqRcaq0Doc0pNEbt33F1E,2582
-fastapi_fastkit/backend/inspection/core.py,sha256=AB1eZLIcmdZWJ96XeO1Cs4pNzMbduWja_do1krrPEHs,13454
-fastapi_fastkit/backend/inspection/docker.py,sha256=fI6NvGnIdOh-HOItPRgM8hn6OeaAmZJnzcUSmgTJWIU,7112
+fastapi_fastkit/backend/inspection/context.py,sha256=p0KBW6SaKZ2eHn8xY8zcF6mLOqi-4aHp6SCc9_Jz4yE,2846
+fastapi_fastkit/backend/inspection/core.py,sha256=mg8LqrrhfOl5UZGRPEDIiPo5frTTimzBpytdwsRgTUc,13732
+fastapi_fastkit/backend/inspection/docker.py,sha256=pMMSf7_sP83sq4Ibr4l6SLUjRtfoRloDHh5neGIEFLc,12305
 fastapi_fastkit/backend/inspection/freshness.py,sha256=CVpoV6IwrRTdSP9leaHD8CJU2OKZs-y_HcHiZ9Nbx7w,5418
 fastapi_fastkit/backend/inspection/fsutils.py,sha256=Vt_FNVBcJuU7qsR71lgQZrFy2WRqo056y7f5Up-D6Ds,4758
-fastapi_fastkit/backend/inspection/lint.py,sha256=Lu9rUQL-26VbqzMf_BA6L0llnQmOpuOaeCxue1XnOVY,2664
+fastapi_fastkit/backend/inspection/lint.py,sha256=BEkrghyDY4Sl5NPsHzDi_3Trcjw4SvMTT3tSV_2DBgU,3591
 fastapi_fastkit/backend/inspection/report.py,sha256=BYkGkotGYXJIEnlolT1g8TxmZRg422ryEXGU2pLnEpI,1930
-fastapi_fastkit/backend/inspection/smoke.py,sha256=hDCv4BtFUs6urjOGE3vto9xh7qBwEQeyvM227z_6xAQ,12187
-fastapi_fastkit/backend/inspection/strategies.py,sha256=0rfESk2Vet5_-j3uWAZR86urUQEju9LskKEZVtdip-A,12329
+fastapi_fastkit/backend/inspection/smoke.py,sha256=fkEp9l2R3DhkUpwr8qhGCRiYa6GSDvuiuSZfgHq9uIs,14203
+fastapi_fastkit/backend/inspection/strategies.py,sha256=fyOBAcYk9iYUFNRmDE8VVfPLwMvdodUyj719byvZhF8,13546
 fastapi_fastkit/backend/inspector.py,sha256=73ZY7PQGQvxbbBwWPxfuudJcxOrLKvWkkzBUcS6YgGc,1002
 fastapi_fastkit/backend/interactive/__init__.py,sha256=wuCVfyaulyjGiG77X0C9sUwY2zr2S6rAGeCeh_17MVA,1873
 fastapi_fastkit/backend/interactive/config_builder.py,sha256=LKqmUiBw2-Dk5OPk4Ut8D2eYRQvWAfcNP0LyCzAVykE,6928
@@ -37,11 +37,11 @@ fastapi_fastkit/backend/project_builder/config_schema.py,sha256=Vj4Mmkr35MnoVbST
 fastapi_fastkit/backend/project_builder/dependency_collector.py,sha256=vj0NYAi3KdvZ5jjgUxFSoP5J5KAHvqIsGdlU5H7xH48,7582
 fastapi_fastkit/backend/project_builder/preset_layout.py,sha256=E-I8JP3goHW5QwpACBC6LC7XX00c-5BNsPjVlDYOhVQ,16319
 fastapi_fastkit/backend/scaffolder.py,sha256=dduEeBN1cdwt_V3JxSxSepHEUMuEB0j-8Sq5FU8KnJ0,21702
-fastapi_fastkit/backend/transducer.py,sha256=ZWh5D9o-sBPpLoJYm1l_mT_ppcXYdSIlIdJe0iefDBk,8827
+fastapi_fastkit/backend/transducer.py,sha256=t0tHVNUpPgbQcwF6Ms9WhQ8ALl6MR1zL8CVbvKgD2rs,11977
 fastapi_fastkit/cli.py,sha256=UxwJcLOkCspwVFnNgJQkbYQyTjsrcNdRpjNnRTE3Rgk,35305
 fastapi_fastkit/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fastapi_fastkit/core/exceptions.py,sha256=W29lbDlKE_yKdS-m_QHaWdDB1j3yGge6mVx5mo_jLrU,972
-fastapi_fastkit/core/settings.py,sha256=uIOpO0ZUdUcwpZAUAMHXpJfgYw70TNfZAwSG-lPjJDM,15701
+fastapi_fastkit/core/settings.py,sha256=v9IiAyU4bIYf8haTCAupr_qiDFscAGlc4g_XqyZ0jrU,15675
 fastapi_fastkit/fastapi_project_template/PROJECT_README_TEMPLATE.md,sha256=5lT_ZY1QItTDbhKYNY6KlOoGlbSTBSrs9DJthcle3D4,1529
 fastapi_fastkit/fastapi_project_template/README.md,sha256=rXwDDK5rGNVd7xWuNkjuu5KWBE27Yz0v-EW1FNxldXA,6637
 fastapi_fastkit/fastapi_project_template/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -286,25 +286,25 @@ fastapi_fastkit/fastapi_project_template/fastapi-llm-agent/tests/test_chat.py-tp
 fastapi_fastkit/fastapi_project_template/fastapi-llm-agent/tests/test_health.py-tpl,sha256=JZwOjpKM_1R4vwTY41VbYgD0pNIxnXl_HUy7oWPqFAg,484
 fastapi_fastkit/fastapi_project_template/fastapi-llm-agent/tests/test_memory.py-tpl,sha256=MiQGVgEX0WdeMp7qFB31CFautIoYdHcOtHKm7eiO6e8,1272
 fastapi_fastkit/fastapi_project_template/fastapi-llm-agent/tests/test_tools.py-tpl,sha256=lDzyV70_YxpuymCOThFkNqXApYu4yd_tIk7lX6LJlLA,1439
-fastapi_fastkit/fastapi_project_template/fastapi-mcp/.env-tpl,sha256=mmBW2Rz0aEIEuU6qDmr1jC5WF2vhU1u-A_7xsQe7iEc,664
-fastapi_fastkit/fastapi_project_template/fastapi-mcp/README.md-tpl,sha256=V10bwMeygQPaNZZBkOxAZW0r7CDyDuiSXQK_FtMj8vA,6395
-fastapi_fastkit/fastapi_project_template/fastapi-mcp/pyproject.toml-tpl,sha256=q6fg_Yua0MYlSZX8j3R8CyhYoVvN9Ex1d6wMZFo97WY,1750
-fastapi_fastkit/fastapi_project_template/fastapi-mcp/requirements.txt-tpl,sha256=Q1_ZimB8ErrkwtzSWFudYrfsI8K2HcB8IphL74u5kNU,1208
+fastapi_fastkit/fastapi_project_template/fastapi-mcp/.env-tpl,sha256=3styxb-X8yguh-V7-XjTWmd95fmnFf2AtLt2Q1kPn_w,695
+fastapi_fastkit/fastapi_project_template/fastapi-mcp/README.md-tpl,sha256=zIyfUG1S80WDsdqQVqpR6sxH_QLi7GY3hHT6SdwEfHQ,6426
+fastapi_fastkit/fastapi_project_template/fastapi-mcp/pyproject.toml-tpl,sha256=arYdZzGNJSjCouTAQKnmaeorVf-d4P98xqIItELedFA,1732
+fastapi_fastkit/fastapi_project_template/fastapi-mcp/requirements.txt-tpl,sha256=yaOrA-JiT_UrNPyFCYxp3rL7ifVrZ__549Wh-3EmXvg,1172
 fastapi_fastkit/fastapi_project_template/fastapi-mcp/scripts/format.sh-tpl,sha256=lMHoGl8naqGqYnW3WQ5zKJSkFFrWa4EvooA3xyj5Duk,215
 fastapi_fastkit/fastapi_project_template/fastapi-mcp/scripts/lint.sh-tpl,sha256=TbnPdvBtO-k4XfAnYxUatrsXn4QniW6THmR0gwqshfs,397
 fastapi_fastkit/fastapi_project_template/fastapi-mcp/scripts/run-server.sh-tpl,sha256=Uuti1QOukxvii8ss9RjTf8DzkyJ0V7HyJDGRPhjtazA,195
 fastapi_fastkit/fastapi_project_template/fastapi-mcp/scripts/test.sh-tpl,sha256=FwcP6i9GGhAiUjyrvczr89z7zT4OEAGVOYQUOVM8vXU,185
-fastapi_fastkit/fastapi_project_template/fastapi-mcp/setup.cfg-tpl,sha256=bJLOPvYv39uHfebufJHfXoc5tl9FOXIY37pOGZwWxO0,1940
+fastapi_fastkit/fastapi_project_template/fastapi-mcp/setup.cfg-tpl,sha256=PsOhp-z9fEJFlHJI99AX3Gh6Ub0mZt52puvOf_r6ZLs,1932
 fastapi_fastkit/fastapi_project_template/fastapi-mcp/src/__init__.py-tpl,sha256=bhmTXfHwW_cFBb18cxepy6TQxHYAI1swxEHxIlf15z4,78
 fastapi_fastkit/fastapi_project_template/fastapi-mcp/src/api/__init__.py-tpl,sha256=BDaEDKpisCteGve4mGQWkAsrRPsPToytMgcdyF1IS30,46
 fastapi_fastkit/fastapi_project_template/fastapi-mcp/src/api/api.py-tpl,sha256=MQknnIJ25KUX_nFgjWZR7bsNHsWWw9pLaus_0hL2b0Q,381
 fastapi_fastkit/fastapi_project_template/fastapi-mcp/src/api/routes/__init__.py-tpl,sha256=MgQT6uitMAu1OybStW9h3rZcq7OHreYo4oIvaI0skhM,27
-fastapi_fastkit/fastapi_project_template/fastapi-mcp/src/api/routes/auth.py-tpl,sha256=KgbkjuERg_5SWL39uAiSkrcby3aE8Ir6Ay_R-zdf8EY,4452
+fastapi_fastkit/fastapi_project_template/fastapi-mcp/src/api/routes/auth.py-tpl,sha256=9uHoB275h3bcqr5O5aeV5pmoN57GhRrWk-dauc1ZnJU,4480
 fastapi_fastkit/fastapi_project_template/fastapi-mcp/src/api/routes/items.py-tpl,sha256=MSw3t3356SMy5sazaju_6dacPTiDInfUshe_EhjtXPw,5127
 fastapi_fastkit/fastapi_project_template/fastapi-mcp/src/auth/__init__.py-tpl,sha256=G-psNiJfSbhWd8POcbLnjkPee8zgCCGFzNYTP1w94d0,53
-fastapi_fastkit/fastapi_project_template/fastapi-mcp/src/auth/dependencies.py-tpl,sha256=WUA9UJoTnEObRSUJeEZm0qngFYhQsBmzTjsQG49rlnw,2977
+fastapi_fastkit/fastapi_project_template/fastapi-mcp/src/auth/dependencies.py-tpl,sha256=1sd-wEiOyhYF7xPGood1Muz2w-VswuEmQ5ajJm_bGHc,2963
 fastapi_fastkit/fastapi_project_template/fastapi-mcp/src/core/__init__.py-tpl,sha256=mZUgAUouQG-XnGGliTe99fH7bQE9EKkVMAMyKXZdODE,37
-fastapi_fastkit/fastapi_project_template/fastapi-mcp/src/core/config.py-tpl,sha256=aRlKfb4pbSfU0vgr4DNAgb1zBLcThuP_l0t_1jvlCvc,1587
+fastapi_fastkit/fastapi_project_template/fastapi-mcp/src/core/config.py-tpl,sha256=PKO2kx5--UZ0xfDh_oVBM6iNJhFu_1rUZkmWDmv4eWY,1608
 fastapi_fastkit/fastapi_project_template/fastapi-mcp/src/main.py-tpl,sha256=f88-HGszl41NivIau0VsUoG8QmB69hDDADViVhvZv6A,1867
 fastapi_fastkit/fastapi_project_template/fastapi-mcp/src/mcp_server/__init__.py-tpl,sha256=TC8tYJfqKT5hx6jucPcYUH2scDDSFCruCcU51_HOLEM,61
 fastapi_fastkit/fastapi_project_template/fastapi-mcp/src/mcp_server/router.py-tpl,sha256=UDPdWPBRaPiQmvfvBfJBl73vcBuBXDQqOHKMB6mbaa8,2257
@@ -315,7 +315,7 @@ fastapi_fastkit/fastapi_project_template/fastapi-mcp/tests/conftest.py-tpl,sha25
 fastapi_fastkit/fastapi_project_template/fastapi-mcp/tests/test_auth.py-tpl,sha256=cmxKuioHgRF2YhbpRji0pl8_kF97WQML6v0rYYdOinc,3801
 fastapi_fastkit/fastapi_project_template/fastapi-mcp/tests/test_items.py-tpl,sha256=dIb_zyUVq_H-zQYqJvrhK2psaYdhLsKlOIiHTONuaeo,3280
 fastapi_fastkit/fastapi_project_template/fastapi-mcp/tests/test_mcp.py-tpl,sha256=noeUozEtFqNw3R3oSMMbmtBxDiUZhBwTWWZrI17qLmg,2641
-fastapi_fastkit/fastapi_project_template/fastapi-psql-orm/.env-tpl,sha256=9aEuqkEeGGT_rJTV7HBmjCSqQDgr6BBaWOiAcWH9hyg,152
+fastapi_fastkit/fastapi_project_template/fastapi-psql-orm/.env-tpl,sha256=tCVg1X0u5jkrafMbnXulu8IDfbI9s7-hh9eZXveoAxw,261
 fastapi_fastkit/fastapi_project_template/fastapi-psql-orm/.gitignore-tpl,sha256=8QwgyX8vpYhDtg1bcrBjf99yiLQRRO1OkBsGMRfggKY,269
 fastapi_fastkit/fastapi_project_template/fastapi-psql-orm/Dockerfile-tpl,sha256=mwwhgtBVu94p4ke7Re0lg28G5vhKpeid1xttMvHwLls,325
 fastapi_fastkit/fastapi_project_template/fastapi-psql-orm/README.md-tpl,sha256=959SSsG-ZCZ7edlWW817Sp6OlNkEARmQ0DogjsJ4iWo,3779
@@ -415,7 +415,7 @@ fastapi_fastkit/fastapi_project_template/modules/schemas/__init__.py-tpl,sha256=
 fastapi_fastkit/fastapi_project_template/modules/schemas/new_route.py-tpl,sha256=f83oXEj2wJ5lg620Bc0vRmpcjOTIpfMgejzzrHeerGk,569
 fastapi_fastkit/fragments/README.md,sha256=-Ch-2ZEbSkL6oXUkhaIkn3joR81E0ZLSJj1FaBPghW8,4962
 fastapi_fastkit/fragments/auth/fastapi_users.py.j2,sha256=ZFR7pdk4KLtSl9MxO5HzFRDMZU7QqN-6V7F6MI3P6GY,265
-fastapi_fastkit/fragments/auth/jwt.py.j2,sha256=0eZFVbsx_RS_gGSTMBwBeicQ_a3mZz3w_hZRE7Rxsw8,1299
+fastapi_fastkit/fragments/auth/jwt.py.j2,sha256=DNWxo78LpvQQR7Iw_eu75uh-dn2ki5ZYJg5hiC7qXLY,1321
 fastapi_fastkit/fragments/auth/oauth2.py.j2,sha256=1k8bhiX8cmCmBSOaUwN7sIGNYbVLsEGYVj50D2EQmpE,3496
 fastapi_fastkit/fragments/auth/session.py.j2,sha256=ffaoUN4f6LvPTUTjWZXzbrOpCUJF1OmumiW1I6tlEOU,2176
 fastapi_fastkit/fragments/db/mongodb.py.j2,sha256=TKhvGbVK2eAO3qo-ogwNyR3529_a-mW5d7AXYe_CFr8,530
@@ -481,4 +481,4 @@ fastapi_fastkit/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3h
 fastapi_fastkit/utils/config_file.py,sha256=0rZEwCJblHabZlFibjYn2iycNZ8Rp4scOdZpfYtjU4g,9654
 fastapi_fastkit/utils/logging.py,sha256=oU7BnWInxzl_Gk8kGQ0f6cKdNHZcOVVcSHY4I9MTmR8,6431
 fastapi_fastkit/utils/main.py,sha256=dCuTSYCME7oCqlvicn-QFGEwA9MeNvMtfKcmThGewyU,13204
-fastapi_fastkit-1.4.0.dist-info/RECORD,,
+fastapi_fastkit-1.4.1.dist-info/RECORD,,