zrb 1.0.0b9__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/test/my_module/my_entity/test_create_my_entity.py

@@ -0,0 +1,53 @@
+from fastapi.testclient import TestClient
+from my_app_name.main import app
+from my_app_name.test._util.access_token import get_admin_access_token
+
+
+def test_create_my_entity():
+    client = TestClient(app, base_url="http://localhost")
+    access_token = get_admin_access_token()
+    new_my_entity_data = {
+        "my_column": "new-my-entity",
+    }
+    response = client.post(
+        "/api/v1/my-entities",
+        json=new_my_entity_data,
+        headers={"Authorization": f"Bearer {access_token}"},
+    )
+    assert response.status_code == 200
+    response_data = response.json()
+    assert response_data.get("id") is not None
+    assert response_data.get("id") != ""
+    assert response_data.get("my_column") == "new-my-entity"
+
+
+def test_create_my_entity_bulk():
+    client = TestClient(app, base_url="http://localhost")
+    access_token = get_admin_access_token()
+    new_first_my_entity_data = {
+        "my_column": "new-my-entity-bulk-1",
+    }
+    new_second_my_entity_data = {
+        "my_column": "new-my-entity-bulk-2",
+    }
+    new_my_entity_data = [new_first_my_entity_data, new_second_my_entity_data]
+    response = client.post(
+        "/api/v1/my-entities/bulk",
+        json=new_my_entity_data,
+        headers={"Authorization": f"Bearer {access_token}"},
+    )
+    assert response.status_code == 200
+    response_data = response.json()
+    assert len(response_data) == 2
+    # Id should not be empty
+    assert response_data[0] is not None
+    assert response_data[0] != ""
+    assert response_data[1] is not None
+    assert response_data[1] != ""
+    # Data should match
+    assert new_first_my_entity_data["my_column"] in [
+        row["my_column"] for row in response_data
+    ]
+    assert new_second_my_entity_data["my_column"] in [
+        row["my_column"] for row in response_data
+    ]

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/_zrb/entity/template/app_template/test/my_module/my_entity/test_delete_my_entity.py

@@ -0,0 +1,62 @@
+from fastapi.testclient import TestClient
+from my_app_name.main import app
+from my_app_name.test._util.access_token import get_admin_access_token
+
+
+def test_delete_my_entity():
+    client = TestClient(app, base_url="http://localhost")
+    access_token = get_admin_access_token()
+    new_my_entity_data = {
+        "my_column": "to-be-deleted-my-entity",
+    }
+    insert_response = client.post(
+        "/api/v1/my-entities",
+        json=new_my_entity_data,
+        headers={"Authorization": f"Bearer {access_token}"},
+    )
+    assert insert_response.status_code == 200
+    id = insert_response.json().get("id")
+    # deleting
+    response = client.delete(
+        f"/api/v1/my-entities/{id}", headers={"Authorization": f"Bearer {access_token}"}
+    )
+    assert response.status_code == 200
+    response_data = response.json()
+    assert response_data.get("id") == id
+    assert response_data.get("my_column") == "to-be-deleted-my-entity"
+
+
+def test_delete_my_entity_bulk():
+    client = TestClient(app, base_url="http://localhost")
+    access_token = get_admin_access_token()
+    new_first_my_entity_data = {
+        "my_column": "to-be-deleted-my-entity-bulk-1",
+    }
+    new_second_my_entity_data = {
+        "my_column": "to-be-deleted-my-entity-bulk-2",
+    }
+    new_my_entity_data = [new_first_my_entity_data, new_second_my_entity_data]
+    insert_response = client.post(
+        "/api/v1/my-entities/bulk",
+        json=new_my_entity_data,
+        headers={"Authorization": f"Bearer {access_token}"},
+    )
+    assert insert_response.status_code == 200
+    ids = [row["id"] for row in insert_response.json()]
+    # deleting (use client.request since client.delete doesn't support json param)
+    response = client.request(
+        "DELETE",
+        f"/api/v1/my-entities/bulk",
+        json=ids,
+        headers={"Authorization": f"Bearer {access_token}"},
+    )
+    assert response.status_code == 200
+    response_data = response.json()
+    # Data should match
+    assert len([row["id"] for row in response_data if row["id"] in ids]) == 2
+    assert new_first_my_entity_data["my_column"] in [
+        row["my_column"] for row in response_data
+    ]
+    assert new_second_my_entity_data["my_column"] in [
+        row["my_column"] for row in response_data
+    ]

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/_zrb/entity/template/app_template/test/my_module/my_entity/test_read_my_entity.py

@@ -0,0 +1,65 @@
+from fastapi.testclient import TestClient
+from my_app_name.main import app
+from my_app_name.test._util.access_token import get_admin_access_token
+
+
+def test_read_my_entity_by_id():
+    client = TestClient(app, base_url="http://localhost")
+    access_token = get_admin_access_token()
+    new_my_entity_data = {
+        "my_column": "to-be-read-my-entity",
+    }
+    insert_response = client.post(
+        "/api/v1/my-entities",
+        json=new_my_entity_data,
+        headers={"Authorization": f"Bearer {access_token}"},
+    )
+    assert insert_response.status_code == 200
+    id = insert_response.json().get("id")
+    # fetching
+    response = client.get(
+        f"/api/v1/my-entities/{id}", headers={"Authorization": f"Bearer {access_token}"}
+    )
+    assert response.status_code == 200
+    response_data = response.json()
+    assert response_data.get("id") == id
+    assert response_data.get("my_column") == "to-be-read-my-entity"
+
+
+def test_read_my_entity_bulk():
+    client = TestClient(app, base_url="http://localhost")
+    access_token = get_admin_access_token()
+    new_first_my_entity_data = {
+        "my_column": "to-be-read-my-entity-bulk-1",
+    }
+    new_second_my_entity_data = {
+        "my_column": "to-be-read-my-entity-bulk-2",
+    }
+    new_my_entity_data = [new_first_my_entity_data, new_second_my_entity_data]
+    insert_response = client.post(
+        "/api/v1/my-entities/bulk",
+        json=new_my_entity_data,
+        headers={"Authorization": f"Bearer {access_token}"},
+    )
+    assert insert_response.status_code == 200
+    ids = [row["id"] for row in insert_response.json()]
+    # fetching
+    response = client.get(
+        f"/api/v1/my-entities",
+        params={
+            "filter": "my_column:like:to-be-read-my-entity-bulk-%",
+        },
+        headers={"Authorization": f"Bearer {access_token}"},
+    )
+    assert response.status_code == 200
+    response_data_count = response.json()["count"]
+    assert response_data_count == 2
+    response_data = response.json()["data"]
+    # Data should match
+    assert len([row["id"] for row in response_data if row["id"] in ids]) == 2
+    assert new_first_my_entity_data["my_column"] in [
+        row["my_column"] for row in response_data
+    ]
+    assert new_second_my_entity_data["my_column"] in [
+        row["my_column"] for row in response_data
+    ]

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/_zrb/entity/template/app_template/test/my_module/my_entity/test_update_my_entity.py

@@ -0,0 +1,61 @@
+from fastapi.testclient import TestClient
+from my_app_name.main import app
+from my_app_name.test._util.access_token import get_admin_access_token
+
+
+def test_update_my_entity():
+    client = TestClient(app, base_url="http://localhost")
+    access_token = get_admin_access_token()
+    new_my_entity_data = {
+        "my_column": "to-be-updated-my-entity",
+    }
+    insert_response = client.post(
+        "/api/v1/my-entities",
+        json=new_my_entity_data,
+        headers={"Authorization": f"Bearer {access_token}"},
+    )
+    assert insert_response.status_code == 200
+    id = insert_response.json().get("id")
+    # updating
+    updated_my_entity_data = {
+        "my_column": "updated-my-entity",
+    }
+    response = client.put(
+        f"/api/v1/my-entities/{id}",
+        json=updated_my_entity_data,
+        headers={"Authorization": f"Bearer {access_token}"},
+    )
+    assert response.status_code == 200
+    response_data = response.json()
+    assert response_data.get("id") == id
+    assert response_data.get("my_column") == "updated-my-entity"
+
+
+def test_update_my_entity_bulk():
+    client = TestClient(app, base_url="http://localhost")
+    access_token = get_admin_access_token()
+    new_first_my_entity_data = {
+        "my_column": "to-be-updated-my-entity-bulk-1",
+    }
+    insert_response = client.post(
+        "/api/v1/my-entities/bulk",
+        json=[new_first_my_entity_data],
+        headers={"Authorization": f"Bearer {access_token}"},
+    )
+    assert insert_response.status_code == 200
+    ids = [row["id"] for row in insert_response.json()]
+    # updating (we only test with one data)
+    updated_my_entity_data = {"my_column": "updated-my-entity-bulk-1"}
+    response = client.put(
+        f"/api/v1/my-entities/bulk",
+        json={
+            "my_entity_ids": ids,
+            "data": updated_my_entity_data,
+        },
+        headers={"Authorization": f"Bearer {access_token}"},
+    )
+    assert response.status_code == 200
+    response_data = response.json()
+    assert len(response_data) == 1
+    response_data[0].get("id") == ids[0]
+    response_data[0].get("my_column") == updated_my_entity_data["my_column"]

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

@@ -1,20 +1,52 @@
 # 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)],
     page: int = 1,
     page_size: int = 10,
     sort: str | None = None,
     filter: str | None = None,
 ) -> MultipleMyEntityResponse:
+    if not current_user.has_permission("my-entity:read"):
+        raise ForbiddenError("Access denied")
     return await my_module_client.get_my_entities(
         page=page, page_size=page_size, sort=sort, filter=filter
     )
 
 
 @app.get("/api/v1/my-entities/{my_entity_id}", response_model=MyEntityResponse)
-async def get_my_entity_by_id(my_entity_id: str) -> MyEntityResponse:
+async def get_my_entity_by_id(
+    current_user: Annotated[AuthUserResponse, Depends(get_current_user)],
+    my_entity_id: str,
+) -> MyEntityResponse:
+    if not current_user.has_permission("my-entity:read"):
+        raise ForbiddenError("Access denied")
     return await my_module_client.get_my_entity_by_id(my_entity_id)
 
 
@@ -22,9 +54,14 @@ async def get_my_entity_by_id(my_entity_id: str) -> MyEntityResponse:
     "/api/v1/my-entities/bulk",
     response_model=list[MyEntityResponse],
 )
-async def create_my_entity_bulk(data: list[MyEntityCreate]):
+async def create_my_entity_bulk(
+    current_user: Annotated[AuthUserResponse, Depends(get_current_user)],
+    data: list[MyEntityCreate],
+) -> list[MyEntityResponse]:
+    if not current_user.has_permission("my-entity:create"):
+        raise ForbiddenError("Access denied")
     return await my_module_client.create_my_entity_bulk(
-        [row.with_audit(created_by="system") for row in data]
+        [row.with_audit(created_by=current_user.id) for row in data]
     )
 
 
@@ -32,17 +69,30 @@ async def create_my_entity_bulk(data: list[MyEntityCreate]):
     "/api/v1/my-entities",
     response_model=MyEntityResponse,
 )
-async def create_my_entity(data: MyEntityCreate):
-    return await my_module_client.create_my_entity(data.with_audit(created_by="system"))
+async def create_my_entity(
+    current_user: Annotated[AuthUserResponse, Depends(get_current_user)],
+    data: MyEntityCreate,
+) -> MyEntityResponse:
+    if not current_user.has_permission("my-entity:create"):
+        raise ForbiddenError("Access denied")
+    return await my_module_client.create_my_entity(
+        data.with_audit(created_by=current_user.id)
+    )
 
 
 @app.put(
     "/api/v1/my-entities/bulk",
     response_model=list[MyEntityResponse],
 )
-async def update_my_entity_bulk(my_entity_ids: list[str], data: MyEntityUpdate):
+async def update_my_entity_bulk(
+    current_user: Annotated[AuthUserResponse, Depends(get_current_user)],
+    my_entity_ids: list[str],
+    data: MyEntityUpdate,
+) -> list[MyEntityResponse]:
+    if not current_user.has_permission("my-entity:update"):
+        raise ForbiddenError("Access denied")
     return await my_module_client.update_my_entity_bulk(
-        my_entity_ids, data.with_audit(updated_by="system")
+        my_entity_ids, data.with_audit(updated_by=current_user.id)
     )
 
 
@@ -50,9 +100,15 @@ async def update_my_entity_bulk(my_entity_ids: list[str], data: MyEntityUpdate):
     "/api/v1/my-entities/{my_entity_id}",
     response_model=MyEntityResponse,
 )
-async def update_my_entity(my_entity_id: str, data: MyEntityUpdate):
+async def update_my_entity(
+    current_user: Annotated[AuthUserResponse, Depends(get_current_user)],
+    my_entity_id: str,
+    data: MyEntityUpdate,
+) -> MyEntityResponse:
+    if not current_user.has_permission("my-entity:update"):
+        raise ForbiddenError("Access denied")
     return await my_module_client.update_my_entity(
-        my_entity_id, data.with_audit(updated_by="system")
+        my_entity_id, data.with_audit(updated_by=current_user.id)
     )
 
 
@@ -60,9 +116,14 @@ async def update_my_entity(my_entity_id: str, data: MyEntityUpdate):
     "/api/v1/my-entities/bulk",
     response_model=list[MyEntityResponse],
 )
-async def delete_my_entity_bulk(my_entity_ids: list[str]):
+async def delete_my_entity_bulk(
+    current_user: Annotated[AuthUserResponse, Depends(get_current_user)],
+    my_entity_ids: list[str],
+) -> list[MyEntityResponse]:
+    if not current_user.has_permission("my-entity:delete"):
+        raise ForbiddenError("Access denied")
     return await my_module_client.delete_my_entity_bulk(
-        my_entity_ids, deleted_by="system"
+        my_entity_ids, deleted_by=current_user.id
     )
 
 
@@ -70,5 +131,12 @@ async def delete_my_entity_bulk(my_entity_ids: list[str]):
     "/api/v1/my-entities/{my_entity_id}",
     response_model=MyEntityResponse,
 )
-async def delete_my_entity(my_entity_id: str):
-    return await my_module_client.delete_my_entity(my_entity_id, deleted_by="system")
+async def delete_my_entity(
+    current_user: Annotated[AuthUserResponse, Depends(get_current_user)],
+    my_entity_id: str,
+) -> MyEntityResponse:
+    if not current_user.has_permission("my-entity:delete"):
+        raise ForbiddenError("Access denied")
+    return await my_module_client.delete_my_entity(
+        my_entity_id, deleted_by=current_user.id
+    )

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

@@ -4,10 +4,15 @@ from my_app_name._zrb.config import APP_DIR
 from my_app_name._zrb.util import get_existing_module_names
 
 from zrb.context.any_context import AnyContext
-from zrb.util.codemod.append_code_to_function import append_code_to_function
-from zrb.util.codemod.append_key_to_dict import append_key_to_dict
+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,4 +1,11 @@
-from fastapi import FastAPI
+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
 
 
 def serve_my_module_route(app: FastAPI):

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

@@ -1,26 +1,30 @@
 # 🔐 Run/Migrate My Module ==========================================================
 
 run_my_module = app_run_group.add_task(
-    run_microservice("my-module", 3000, "my_module"), alias="svc-my_module"
+    run_microservice("my_module", 3000), alias="svc-my-module"
 )
 prepare_venv >> run_my_module >> run_microservices
 
 create_my_module_migration = app_create_migration_group.add_task(
-    create_migration("my-module", "my_module"), alias="my_module"
+    create_migration("my_module"), alias="my_module"
 )
 prepare_venv >> create_my_module_migration >> create_all_migration
 
-migrate_monolith_my_module = migrate_module(
-    "my_module", "my_module", as_microservices=False
-)
+migrate_monolith_my_module = migrate_module("my_module", as_microservices=False)
 prepare_venv >> migrate_monolith_my_module >> [migrate_monolith, run_monolith]
 
 migrate_microservices_my_module = app_migrate_group.add_task(
-    migrate_module("my-module", "my_module", as_microservices=True),
+    migrate_module("my_module", as_microservices=True),
     alias="svc-my-module",
 )
+
 (
     prepare_venv
     >> migrate_microservices_my_module
     >> [migrate_microservices, run_my_module]
 )
+
+migrate_test_my_module = migrate_module(
+    "my_module", as_microservices=False, additional_env_vars=TEST_ENV_VARS
+)
+prepare_venv >> migrate_test_my_module >> migrate_test

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",
+    )
+)