zrb 1.0.0b10__py3-none-any.whl → 1.1.0__py3-none-any.whl

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/_zrb/entity/template/app_template/module/gateway/view/content/my-module/my-entity.html

@@ -0,0 +1,297 @@
+<link rel="stylesheet" href="/static/crud/style.css">
+
+<main class="container">
+    <article>
+        <h1>My Entity</h1>
+
+        <fieldset id="crud-table-fieldset" role="group" class="grid">
+            <input id="crud-filter" onchange="applySearch()" placeholder="🔍 Filter" aria-label="Search" />
+            <button onclick="applySearch()">🔍 Search</button>
+            {% if allow_create %}
+            <button class="contrast" onclick="showCreateForm(event)">➕ Add</button>
+            {% endif %}
+        </fieldset>
+        <div id="crud-table-container">
+            <table id="crud-table" class="striped">
+                <thead>
+                    <tr>
+                        <th scope="col">ID</th>
+                        <th scope="col">My Column</th>
+                        <!-- Update this -->
+                        {% if allow_update or allow_delete %}
+                        <th scope="col">Actions</th>
+                        {% endif %}
+                    </tr>
+                </thead>
+                <tbody></tbody>
+            </table>
+        </div>
+        <div id="crud-pagination"></div>
+
+        {% if allow_create %}
+        <dialog id="crud-create-form-dialog">
+            <article>
+                <h2>New My Entity</h2>
+                <form id="crud-create-form">
+                    <label>
+                        My Column:
+                        <input type="text" name="my_column" required>
+                    </label>
+                    <!-- Update this -->
+                    <footer>
+                        <button onclick="createRow(event)">➕ Save</button>
+                        <button class="secondary" onclick="hideCreateForm(event)">❌ Cancel</button>
+                    </footer>
+                </form>
+            </article>
+        </dialog>
+        {% endif %}
+
+        {% if allow_update %}
+        <dialog id="crud-update-form-dialog">
+            <article>
+                <h2>Update My Entity</h2>
+                <form id="crud-update-form">
+                    <label>
+                        My Column:
+                        <input type="text" name="my_column" required>
+                    </label>
+                    <!-- Update this -->
+                    <footer>
+                        <button onclick="updateRow(event)">✏️ Save</button>
+                        <button class="secondary" onclick="hideUpdateForm(event)">❌ Cancel</button>
+                    </footer>
+                </form>
+            </article>
+        </dialog>
+        {% endif %}
+
+        {% if allow_delete %}
+        <dialog id="crud-delete-form-dialog">
+            <article>
+                <h2>Delete My Entity</h2>
+                <form id="crud-delete-form">
+                    <label>
+                        My Column:
+                        <input type="text" name="my_column" readonly>
+                    </label>
+                    <!-- Update this -->
+                    <footer>
+                        <button class="secondary" onclick="hideDeleteForm()">❌ Cancel</button>
+                        <button onclick="deleteRow()">🗑️ Delete</button>
+                    </footer>
+                </form>
+            </article>
+        </dialog>
+        {% endif %}
+
+        <dialog id="crud-alert-dialog">
+            <article>
+                <h2 id="crud-alert-title">Error</h2>
+                <pre id="crud-alert-message"></pre>
+                <footer>
+                    <button onclick="hideAlert(event)">Close</button>
+                </footer>
+            </article>
+        </dialog>
+
+    </article>
+</main>
+
+<script src="/static/crud/util.js"></script>
+<script>
+    const apiUrl = "/api/v1/my-entities";
+    const crudState = {
+        pageSize: {{page_size | tojson}},
+        currentPage: {{page | tojson}},
+        sort: {{sort | tojson}},
+        filter: {{filter | tojson}},
+        allowCreate: {{allow_create | tojson}},
+        allowUpdate: {{allow_update | tojson}},
+        allowDelete: {{allow_delete | tojson}},
+        updatedRowId: null,
+        deletedRowId: null,
+    };
+
+    async function applySearch() {
+        const filterInput = document.getElementById("crud-filter");
+        crudState.filter = filterInput.value;
+        return await fetchRows(crudState.currentPage);
+    }
+
+    async function fetchRows(page = null) {
+        try {
+            if (typeof page !== 'undefined' && page !== null) {
+                crudState.currentPage = page;
+            }
+            const defaultSearchColumn = "my_column"
+            // update address bar
+            const searchParam = CRUD_UTIL.getSearchParam(crudState, defaultSearchColumn, false);
+            const newUrl = `${window.location.pathname}?${searchParam}`;
+            window.history.pushState({ path: newUrl }, "", newUrl);
+            // update table and pagination
+            const apiSearchParam = CRUD_UTIL.getSearchParam(crudState, defaultSearchColumn, true);
+            const result = await UTIL.fetchAPI(
+                `${apiUrl}?${apiSearchParam}`, { method: "GET" }
+            );
+            renderRows(result.data);
+            const crudPagination = document.getElementById("crud-pagination");
+            CRUD_UTIL.renderPagination(
+                crudPagination, crudState, result.count, "fetchRows"
+            );
+        } catch (error) {
+            console.error("Error fetching items:", error);
+        }
+    }
+
+    function renderRows(rows) {
+        const tableBody = document.querySelector("#crud-table tbody");
+        tableBody.innerHTML = "";
+        rows.forEach(row => {
+            let rowComponent = getRowComponents(row);
+            actionColumn = "";
+            if (crudState.allowUpdate) {
+                actionColumn += `<button class="contrast" onclick="showUpdateForm('${row.id}')">✏️ Edit</button>`;
+            }
+            if (crudState.allowDelete) {
+                actionColumn += `<button class="secondary" onclick="showDeleteForm('${row.id}')">🗑️ Delete</button>`;
+            }
+            if (crudState.allowUpdate || crudState.allowDelete) {
+                actionColumn = `<td><fieldset class="grid" role="group">${actionColumn}</fieldset></td>`;
+            }
+            tableBody.innerHTML += `<tr>${rowComponent.join('')}${actionColumn}</tr>`;
+        });
+    }
+
+    function getRowComponents(row) {
+        let rowComponents = [];
+        rowComponents.push(`<td>${row.id}</td>`);
+        rowComponents.push(`<td>${row.my_column}</td>`);
+        // Update this
+        return rowComponents;
+    }
+
+    {% if allow_create %}
+    async function showCreateForm(id) {
+        const createFormDialog = document.getElementById("crud-create-form-dialog");
+        const createForm = document.getElementById("crud-create-form");
+        UTIL.clearFormData(createForm);
+        createFormDialog.showModal();
+    }
+
+    async function createRow(event = null) {
+        if (event != null) {
+            event.preventDefault();
+        }
+        try {
+            const createForm = document.getElementById("crud-create-form");
+            const formData = JSON.stringify(UTIL.getFormData(createForm));
+            await UTIL.fetchAPI(apiUrl, {method: "POST", body: formData});
+            await fetchRows();
+            hideCreateForm();
+        } catch(error) {
+            showAlert("Create My Entity Error", error);
+        }
+    }
+
+    function hideCreateForm(event = null) {
+        if (event != null) {
+            event.preventDefault();
+        }
+        const createFormDialog = document.getElementById("crud-create-form-dialog");
+        createFormDialog.close();
+    }
+    {% endif %}
+
+    {% if allow_update %}
+    async function showUpdateForm(id) {
+        crudState.updatedRowId = id;
+        const updateFormDialog = document.getElementById("crud-update-form-dialog");
+        const updateForm = document.getElementById("crud-update-form");
+        result = await UTIL.fetchAPI(`${apiUrl}/${id}`, { method: "GET" });
+        UTIL.setFormData(updateForm, result);
+        updateFormDialog.showModal();
+    }
+
+    async function updateRow(event = null) {
+        if (event != null) {
+            event.preventDefault();
+        }
+        try {
+            const updateForm = document.getElementById("crud-update-form");
+            const formData = JSON.stringify(UTIL.getFormData(updateForm));
+            await UTIL.fetchAPI(
+                `${apiUrl}/${crudState.updatedRowId}`, {method: "PUT", body: formData},
+            );
+            await fetchRows();
+            hideUpdateForm();
+        } catch(error) {
+            showAlert("Update My Entity Error", error);
+        }
+    }
+
+    function hideUpdateForm(event = null) {
+        if (event != null) {
+            event.preventDefault();
+        }
+        const updateFormDialog = document.getElementById("crud-update-form-dialog");
+        updateFormDialog.close();
+    }
+    {% endif %}
+
+    {% if allow_delete %}
+    async function showDeleteForm(id) {
+        crudState.deletedRowId = id;
+        const deleteFormDialog = document.getElementById("crud-delete-form-dialog");
+        const deleteForm = document.getElementById("crud-delete-form");
+        result = await UTIL.fetchAPI(`${apiUrl}/${id}`, { method: "GET" });
+        UTIL.setFormData(deleteForm, result);
+        deleteFormDialog.showModal();
+    }
+
+    async function deleteRow(event = null) {
+        if (event != null) {
+            event.preventDefault();
+        }
+        try {
+            await UTIL.fetchAPI(`${apiUrl}/${crudState.deletedRowId}`, {method: "DELETE",});
+            await fetchRows();
+            hideDeleteForm();
+        } catch(error) {
+            showAlert("Delete My Entity Error", error);
+        }
+    }
+
+    function hideDeleteForm(event = null) {
+        if (event != null) {
+            event.preventDefault();
+        }
+        const deleteFormDialog = document.getElementById("crud-delete-form-dialog");
+        deleteFormDialog.close();
+    }
+    {% endif %}
+
+    function showAlert(title, error) {
+        const alertDialog = document.getElementById("crud-alert-dialog");
+        const alertTitle = document.getElementById("crud-alert-title");
+        const alertMessage = document.getElementById("crud-alert-message");
+        const errorMessage = error.message ? error.message : String(error);
+        alertTitle.textContent = title;
+        alertMessage.textContent = errorMessage;
+        alertDialog.showModal();
+    }
+
+    function hideAlert(event = null) {
+        if (event != null) {
+            event.preventDefault();
+        }
+        const alertDialog = document.getElementById("crud-alert-dialog");
+        alertDialog.close();
+    }
+
+    document.addEventListener("DOMContentLoaded", () => {
+        const filterInput = document.getElementById("crud-filter");
+        filterInput.value = crudState.filter;
+        fetchRows(crudState.currentPage);
+    });
+</script>

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/_zrb/entity/template/gateway_subroute.py

@@ -1,6 +1,30 @@
 # MyEntity routes
 
 
+@app.get("/my-module/my-entities", include_in_schema=False)
+def my_entities_crud_ui(
+    current_user: Annotated[AuthUserResponse, Depends(get_current_user)],
+    page: int = 1,
+    page_size: int = 10,
+    sort: str | None = None,
+    filter: str | None = None,
+):
+    if not current_user.has_permission("my-entity:read"):
+        return render_error(error_message="Access denied", status_code=403)
+    return render_content(
+        view_path=os.path.join("my-module", "my-entity.html"),
+        current_user=current_user,
+        page_name="my-module.my-entity",
+        page=page,
+        page_size=page_size,
+        sort=sort,
+        filter=filter,
+        allow_create=current_user.has_permission("my-entity:create"),
+        allow_update=current_user.has_permission("my-entity:update"),
+        allow_delete=current_user.has_permission("my-entity:delete"),
+    )
+
+
 @app.get("/api/v1/my-entities", response_model=MultipleMyEntityResponse)
 async def get_my_entities(
     current_user: Annotated[AuthUserResponse, Depends(get_current_user)],

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/_zrb/entity/template/navigation_config_file.py

@@ -0,0 +1,8 @@
+my_module_menu.append_page(
+    Page(
+        name="my-module.my-entity",
+        caption="My Entity",
+        url="/my-module/my-entities",
+        permission="my-entity:read",
+    )
+)

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/_zrb/module/add_module_task.py

@@ -10,12 +10,14 @@ from my_app_name._zrb.module.add_module_util import (
     is_app_zrb_config_file,
     is_app_zrb_task_file,
     is_gateway_module_subroute_file,
+    is_gateway_navigation_config_file,
     is_gateway_route_file,
     is_in_module_dir,
     update_app_config_file,
     update_app_main_file,
     update_app_zrb_config_file,
     update_app_zrb_task_file,
+    update_gateway_navigation_config_file,
     update_gateway_route_file,
 )
 from my_app_name._zrb.util import get_existing_module_names
@@ -91,6 +93,12 @@ scaffold_my_app_name_module = Scaffolder(
             match=is_gateway_route_file,
             transform=update_gateway_route_file,
         ),
+        # Register module's page to my_app_name/gateway/config/navigation.py
+        ContentTransformer(
+            name="transform-gateway-navigation-config",
+            match=is_gateway_navigation_config_file,
+            transform=update_gateway_navigation_config_file,
+        ),
     ],
     retries=0,
     upstream=validate_add_my_app_name_module,

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/_zrb/module/add_module_util.py

@@ -7,7 +7,12 @@ from zrb.context.any_context import AnyContext
 from zrb.util.codemod.modify_dict import append_key_to_dict
 from zrb.util.codemod.modify_function import append_code_to_function
 from zrb.util.file import read_file, write_file
-from zrb.util.string.conversion import to_kebab_case, to_pascal_case, to_snake_case
+from zrb.util.string.conversion import (
+    to_human_case,
+    to_kebab_case,
+    to_pascal_case,
+    to_snake_case,
+)
 
 
 def is_app_config_file(ctx: AnyContext, file_path: str) -> bool:
@@ -22,6 +27,12 @@ def is_gateway_route_file(ctx: AnyContext, file_path: str) -> bool:
     return file_path == os.path.join(APP_DIR, "module", "gateway", "route.py")
 
 
+def is_gateway_navigation_config_file(ctx: AnyContext, file_path: str) -> bool:
+    return file_path == os.path.join(
+        APP_DIR, "module", "gateway", "config", "navigation.py"
+    )
+
+
 def is_app_zrb_task_file(ctx: AnyContext, file_path: str) -> bool:
     return file_path == os.path.join(APP_DIR, "_zrb", "task.py")
 
@@ -194,3 +205,31 @@ def _get_module_subroute_import(existing_code: str, module_name: str) -> str | N
     if import_code in existing_code:
         return None
     return import_code
+
+
+def update_gateway_navigation_config_file(
+    ctx: AnyContext, gateway_navigation_config_file_path: str
+):
+    existing_gateway_navigation_config_code = read_file(
+        gateway_navigation_config_file_path
+    )
+    snake_module_name = to_snake_case(ctx.input.module)
+    kebab_module_name = to_kebab_case(ctx.input.module)
+    human_module_name = to_human_case(ctx.input.module)
+    new_navigation_config_code = read_file(
+        file_path=os.path.join(
+            os.path.dirname(__file__), "template", "navigation_config_file.py"
+        ),
+        replace_map={
+            "my_module": snake_module_name,
+            "my-module": kebab_module_name,
+            "My Module": human_module_name.title(),
+        },
+    ).strip()
+    write_file(
+        file_path=gateway_navigation_config_file_path,
+        content=[
+            existing_gateway_navigation_config_code,
+            new_navigation_config_code,
+        ],
+    )

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/_zrb/module/template/app_template/module/gateway/subroute/my_module.py

@@ -1,8 +1,10 @@
+import os
 from typing import Annotated
 
 from fastapi import Depends, FastAPI
 from my_app_name.common.error import ForbiddenError
 from my_app_name.module.gateway.util.auth import get_current_user
+from my_app_name.module.gateway.util.view import render_content, render_error
 from my_app_name.schema.user import AuthUserResponse
 
 

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/_zrb/module/template/navigation_config_file.py

@@ -0,0 +1,6 @@
+my_module_menu = APP_NAVIGATION.append_page_group(
+    PageGroup(
+        name="my-module",
+        caption="My Module",
+    )
+)

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/common/util/parser.py

@@ -72,7 +72,7 @@ def create_default_filter_param_parser() -> (
             # Returns [UserModel.age >= 18, UserModel.name.like("John%"), UserModel.role.in_(["admin", "user"]), UserModel.address == "123, Main St."]
         """
         filters: list[ClauseElement] = []
-        filter_parts = split_by_comma(query)
+        filter_parts = split_unescaped(query)
         for part in filter_parts:
             match = re.match(r"(.+):(.+):(.+)", part)
             if match:
@@ -101,5 +101,5 @@ def create_default_filter_param_parser() -> (
     return parse_filter_param
 
 
-def split_by_comma(s: str, delimiter: str = ",") -> list[str]:
+def split_unescaped(s: str, delimiter: str = ",") -> list[str]:
     return re.split(r"(?<!\\)" + re.escape(delimiter), s)

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/common/util/view.py

@@ -27,7 +27,7 @@ def render_str(template_path: str, **data: Any) -> str:
 def render_page(
     template_path: str,
     status_code: int = 200,
-    headers: dict[str, str] = None,
+    headers: dict[str, str] | None = None,
     media_type: str | None = None,
     **data: Any
 ) -> HTMLResponse:

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/config.py

@@ -8,25 +8,35 @@ APP_VERSION = "0.1.0"
 
 APP_GATEWAY_VIEW_PATH = os.path.join(APP_PATH, "module", "gateway", "view")
 APP_GATEWAY_VIEW_DEFAULT_TEMPLATE_PATH = os.getenv(
-    "MY_APP_GATEWAY_VIEW_DEFAULT_TEMPLATE_PATH",
+    "MY_APP_NAME_GATEWAY_VIEW_DEFAULT_TEMPLATE_PATH",
     os.path.join("template", "default.html"),
 )
-_DEFAULT_CSS_PATH = "/static/pico-css/pico.min.css"
+APP_GATEWAY_PICO_CSS_COLOR = os.getenv("MY_APP_NAME_GATEWAY_PICO_CSS_COLOR", "")
+APP_GATEWAY_PICO_CSS_PATH = (
+    "/static/pico-css/pico.min.css"
+    if APP_GATEWAY_PICO_CSS_COLOR == ""
+    else f"/static/pico-css/pico.{APP_GATEWAY_PICO_CSS_COLOR}.min.css"
+)
 APP_GATEWAY_CSS_PATH_LIST = [
     path
-    for path in os.getenv("MY_APP_GATEWAY_CSS_PATH", _DEFAULT_CSS_PATH).split(":")
+    for path in os.getenv("MY_APP_NAME_GATEWAY_CSS_PATH", "").split(":")
     if path != ""
 ]
 APP_GATEWAY_JS_PATH_LIST = [
-    path for path in os.getenv("MY_APP_GATEWAY_JS_PATH", "").split(":") if path != ""
+    path
+    for path in os.getenv("MY_APP_NAME_GATEWAY_JS_PATH", "").split(":")
+    if path != ""
 ]
-APP_GATEWAY_TITLE = os.getenv("MY_APP_GATEWAY_TITLE", "My App Name")
-APP_GATEWAY_SUBTITLE = os.getenv("MY_APP_GATEWAY_SUBTITLE", "Just Another App")
+APP_GATEWAY_TITLE = os.getenv("MY_APP_NAME_GATEWAY_TITLE", "My App Name")
+APP_GATEWAY_SUBTITLE = os.getenv("MY_APP_NAME_GATEWAY_SUBTITLE", "Just Another App")
 APP_GATEWAY_LOGO_PATH = os.getenv(
-    "MY_APP_GATEWAY_LOGO", "/static/images/android-chrome-192x192.png"
+    "MY_APP_NAME_GATEWAY_LOGO", "/static/images/android-chrome-192x192.png"
+)
+APP_GATEWAY_FOOTER = os.getenv(
+    "MY_APP_NAME_GATEWAY_FOOTER", f"{APP_GATEWAY_TITLE} © 2025"
 )
 APP_GATEWAY_FAVICON_PATH = os.getenv(
-    "MY_APP_GATEWAY_FAVICON", "/static/images/favicon-32x32.png"
+    "MY_APP_NAME_GATEWAY_FAVICON", "/static/images/favicon-32x32.png"
 )
 
 APP_MODE = os.getenv("MY_APP_NAME_MODE", "monolith")

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/module/gateway/config/navigation.py

@@ -0,0 +1,39 @@
+from my_app_name.module.gateway.schema.navigation import Navigation, Page, PageGroup
+
+APP_NAVIGATION = Navigation()
+
+APP_NAVIGATION.append_page(Page(name="gateway.home", caption="Home", url="/"))
+
+auth_menu = APP_NAVIGATION.append_page_group(
+    PageGroup(
+        name="auth",
+        caption="Authorization",
+    )
+)
+
+auth_menu.append_page(
+    Page(
+        name="auth.permission",
+        caption="Permission",
+        url="/auth/permissions",
+        permission="permission:read",
+    )
+)
+
+auth_menu.append_page(
+    Page(
+        name="auth.role",
+        caption="Role",
+        url="/auth/roles",
+        permission="role:read",
+    )
+)
+
+auth_menu.append_page(
+    Page(
+        name="auth.user",
+        caption="User",
+        url="/auth/users",
+        permission="user:read",
+    )
+)

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/module/gateway/route.py

@@ -1,18 +1,21 @@
-import os
+from typing import Annotated
 
-from fastapi import FastAPI, HTTPException, Request
+from fastapi import Depends, FastAPI, HTTPException, Request
 from fastapi.exception_handlers import http_exception_handler
-from fastapi.responses import HTMLResponse
+from fastapi.responses import HTMLResponse, RedirectResponse
 from my_app_name.common.app_factory import app
 from my_app_name.common.schema import BasicResponse
 from my_app_name.config import (
-    APP_GATEWAY_VIEW_PATH,
+    APP_AUTH_ACCESS_TOKEN_COOKIE_NAME,
     APP_MAIN_MODULE,
     APP_MODE,
     APP_MODULES,
 )
+from my_app_name.module.auth.client.auth_client_factory import auth_client
 from my_app_name.module.gateway.subroute.auth import serve_auth_route
-from my_app_name.module.gateway.util.view import render, render_error
+from my_app_name.module.gateway.util.auth import get_current_user
+from my_app_name.module.gateway.util.view import render_content, render_error
+from my_app_name.schema.user import AuthUserResponse
 
 
 def serve_route(app: FastAPI):
@@ -21,18 +24,48 @@ def serve_route(app: FastAPI):
     if APP_MODE == "monolith" or APP_MAIN_MODULE == "gateway":
         _serve_health_check(app)
         _serve_readiness_check(app)
-        _serve_homepage(app)
+        _serve_common_pages(app)
         _handle_404(app)
 
     # Serve auth routes
     serve_auth_route(app)
 
 
-def _serve_homepage(app: FastAPI):
+def _serve_common_pages(app: FastAPI):
     @app.get("/", include_in_schema=False)
-    def home_page():
-        return render(
-            view_path=os.path.join(APP_GATEWAY_VIEW_PATH, "content", "homepage.html")
+    def home_page(
+        current_user: Annotated[AuthUserResponse, Depends(get_current_user)],
+    ):
+        return render_content(
+            view_path="homepage.html",
+            current_user=current_user,
+            page_name="gateway.home",
+        )
+
+    @app.get("/login", include_in_schema=False)
+    def login_page(
+        current_user: Annotated[AuthUserResponse, Depends(get_current_user)],
+    ):
+        if not current_user.is_guest:
+            return RedirectResponse("/")
+        return render_content(
+            view_path="login.html",
+            current_user=current_user,
+            page_name="gateway.home",
+            partials={"show_user_info": False},
+        )
+
+    @app.get("/logout", include_in_schema=False)
+    def logout_page(
+        current_user: Annotated[AuthUserResponse, Depends(get_current_user)],
+    ):
+        if current_user is None:
+            return RedirectResponse("/")
+        return render_content(
+            view_path="logout.html",
+            current_user=current_user,
+            page_name="gateway.home",
+            partials={"show_user_info": False},
         )
 
 
@@ -60,7 +93,15 @@ def _handle_404(app: FastAPI):
         if request.url.path.startswith("/api"):
             # Re-raise the exception to let FastAPI handle it
             return await http_exception_handler(request, exc)
-        return render_error(error_message="Not found", status_code=404)
+        # Get current user by cookies
+        current_user = None
+        cookie_access_token = request.cookies.get(APP_AUTH_ACCESS_TOKEN_COOKIE_NAME)
+        if cookie_access_token is not None and cookie_access_token != "":
+            current_user = await auth_client.get_current_user(cookie_access_token)
+        # Show error page
+        return render_error(
+            error_message="Not found", status_code=404, current_user=current_user
+        )
 
 
 serve_route(app)