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/add_entity_task.py

@@ -2,17 +2,26 @@ import os
 
 from my_app_name._zrb.config import ACTIVATE_VENV_SCRIPT, APP_DIR
 from my_app_name._zrb.entity.add_entity_util import (
+    get_add_permission_migration_script,
+    get_auth_migration_version_dir,
+    get_existing_auth_migration_file_names,
+    get_existing_auth_migration_xcom_key,
+    get_remove_permission_migration_script,
+    is_gateway_navigation_config_file,
     is_in_app_schema_dir,
     is_in_module_entity_dir,
+    is_in_module_entity_test_dir,
     is_module_api_client_file,
     is_module_client_file,
     is_module_direct_client_file,
     is_module_gateway_subroute_file,
+    is_module_gateway_subroute_view_file,
     is_module_migration_metadata_file,
     is_module_route_file,
     update_api_client_file,
     update_client_file,
     update_direct_client_file,
+    update_gateway_navigation_config_file,
     update_gateway_subroute_file,
     update_migration_metadata_file,
     update_route_file,
@@ -42,8 +51,11 @@ from zrb import (
     EnvFile,
     Scaffolder,
     Task,
+    Xcom,
     make_task,
 )
+from zrb.util.codemod.modify_function import replace_function_code
+from zrb.util.file import read_file, write_file
 from zrb.util.string.conversion import to_snake_case
 
 
@@ -79,7 +91,9 @@ scaffold_my_app_name_entity = Scaffolder(
     destination_path=APP_DIR,
     transform_path={
         "my_module": "{to_snake_case(ctx.input.module)}",
+        "my-module": "{to_kebab_case(ctx.input.module)}",
         "my_entity": "{to_snake_case(ctx.input.entity)}",
+        "my-entity": "{to_kebab_case(ctx.input.entity)}",
     },
     transform_content=[
         # Schema tranformation (my_app_name/schema/snake_entity_name)
@@ -105,6 +119,18 @@ scaffold_my_app_name_entity = Scaffolder(
                 "my-entities": "{to_kebab_case(ctx.input.plural)}",
             },
         ),
+        # Test transformation (my_app_name/test/my_module/my_entity)
+        ContentTransformer(
+            name="transform-module-entity-test-dir",
+            match=is_in_module_entity_test_dir,
+            transform={
+                "my_module": "{to_snake_case(ctx.input.module)}",
+                "my_entity": "{to_snake_case(ctx.input.entity)}",
+                "my-entity": "{to_kebab_case(ctx.input.entity)}",
+                "my-entities": "{to_kebab_case(ctx.input.plural)}",
+                "my_column": "{to_snake_case(ctx.input.column)}",
+            },
+        ),
         # Add entity to migration metadata
         # (my_app_name/module/snake_module_name/migration_metadata.py)
         ContentTransformer(
@@ -146,6 +172,24 @@ scaffold_my_app_name_entity = Scaffolder(
             match=is_module_gateway_subroute_file,
             transform=update_gateway_subroute_file,
         ),
+        # Update module gateway subroute view
+        # (my_app_name/module/gateway/view/content/kebab-module-name/kebab-entity-name.py)
+        ContentTransformer(
+            name="transform-module-gateway-subroute-view",
+            match=is_module_gateway_subroute_view_file,
+            transform={
+                "My Entity": "{to_human_case(ctx.input.entity).title()}",
+                "my-entities": "{to_kebab_case(ctx.input.plural)}",
+                "My Column": "{to_human_case(ctx.input.column).title()}",
+                "my_column": "{to_snake_case(ctx.input.column)}",
+            },
+        ),
+        # Register entity'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_entity,
@@ -177,11 +221,96 @@ create_my_app_name_entity_migration = CmdTask(
     ],
 )
 
+
+@make_task(
+    name="inspect-my-app-name-auth-migration",
+    input=new_entity_input,
+    retries=0,
+    upstream=scaffold_my_app_name_entity,
+)
+def inspect_my_app_name_auth_migration(ctx: AnyContext):
+    """Getting existing migration files in auth module"""
+    migration_file_names = get_existing_auth_migration_file_names()
+    xcom_key = get_existing_auth_migration_xcom_key(ctx)
+    if xcom_key not in ctx.xcom:
+        ctx.xcom[xcom_key] = Xcom([])
+    ctx.xcom[xcom_key].push(migration_file_names)
+
+
+create_my_app_name_entity_permission = CmdTask(
+    name="create-my-app-name-entity-permission",
+    input=[
+        new_entity_input,
+    ],
+    env=EnvFile(path=os.path.join(APP_DIR, "template.env")),
+    cwd=APP_DIR,
+    cmd=[
+        ACTIVATE_VENV_SCRIPT,
+        Cmd(lambda ctx: set_create_migration_db_url_env("auth")),
+        Cmd(lambda ctx: set_env("MY_APP_NAME_MODULES", "auth")),
+        Cmd(lambda ctx: cd_module_script("auth")),
+        "alembic upgrade head",
+        Cmd(
+            'alembic revision --autogenerate -m "create_{to_snake_case(ctx.input.entity)}_permission"',  # noqa
+        ),
+    ],
+    render_cmd=False,
+    retries=0,
+    upstream=[
+        prepare_venv,
+        inspect_my_app_name_auth_migration,
+    ],
+)
+
+
+@make_task(
+    name="update-my-app-name-entity-permission",
+    input=new_entity_input,
+    retries=0,
+    upstream=create_my_app_name_entity_permission,
+)
+def update_my_app_name_entity_permission(ctx: AnyContext):
+    xcom_key = get_existing_auth_migration_xcom_key(ctx)
+    existing_migration_file_names = ctx.xcom[xcom_key].pop()
+    current_migration_file_names = get_existing_auth_migration_file_names()
+    new_migration_file_names = [
+        file_name
+        for file_name in current_migration_file_names
+        if file_name not in existing_migration_file_names
+    ]
+    if len(new_migration_file_names) == 0:
+        raise Exception("No migration file created")
+    new_migration_file_path = os.path.join(
+        get_auth_migration_version_dir(), new_migration_file_names[0]
+    )
+    new_migration_code = read_file(
+        new_migration_file_path,
+        {
+            "from alembic import op": "\n".join(
+                [
+                    "from alembic import op",
+                    "from module.auth.migration_metadata import metadata",
+                ]
+            ),
+        },
+    )
+    new_migration_code = replace_function_code(
+        new_migration_code, "upgrade", get_add_permission_migration_script(ctx)
+    )
+    new_migration_code = replace_function_code(
+        new_migration_code, "downgrade", get_remove_permission_migration_script(ctx)
+    )
+    write_file(new_migration_file_path, new_migration_code)
+
+
 add_my_app_name_entity = app_create_group.add_task(
     Task(
         name="add-my-app-name-entity",
-        description="🏗️ Create new entity on a module",
-        upstream=create_my_app_name_entity_migration,
+        description="📦 Create new entity on a module",
+        upstream=[
+            create_my_app_name_entity_migration,
+            update_my_app_name_entity_permission,
+        ],
         successor=format_my_app_name_code,
         retries=0,
     ),

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

@@ -3,12 +3,75 @@ import os
 from my_app_name._zrb.config import APP_DIR
 
 from zrb.context.any_context import AnyContext
-from zrb.util.codemod.append_code_to_class import append_code_to_class
-from zrb.util.codemod.append_code_to_function import append_code_to_function
-from zrb.util.codemod.prepend_code_to_module import prepend_code_to_module
-from zrb.util.codemod.prepend_parent_to_class import prepend_parent_class
+from zrb.util.codemod.modify_class import append_code_to_class
+from zrb.util.codemod.modify_class_parent import prepend_parent_class
+from zrb.util.codemod.modify_function import append_code_to_function
+from zrb.util.codemod.modify_module import prepend_code_to_module
 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_gateway_navigation_config_file(ctx: AnyContext, file_path: str) -> bool:
+    return file_path == os.path.join(
+        APP_DIR, "module", "gateway", "config", "navigation.py"
+    )
+
+
+def get_add_permission_migration_script(ctx: AnyContext) -> str:
+    kebab_entity_name = to_kebab_case(ctx.input.entity)
+    return "\n".join(
+        [
+            "op.bulk_insert(",
+            '    metadata.tables["permissions"],',
+            "    [",
+            f'        {{"name": "{kebab_entity_name}:create", "description": "create {kebab_entity_name}"}},',  # noqa
+            f'        {{"name": "{kebab_entity_name}:read", "description": "read {kebab_entity_name}"}},',  # noqa
+            f'        {{"name": "{kebab_entity_name}:update", "description": "update {kebab_entity_name}"}},',  # noqa
+            f'        {{"name": "{kebab_entity_name}:delete", "description": "delete {kebab_entity_name}"}},',  # noqa
+            "    ]",
+            ")",
+        ]
+    )
+
+
+def get_remove_permission_migration_script(ctx: AnyContext) -> str:
+    kebab_entity_name = to_kebab_case(ctx.input.entity)
+    return "\n".join(
+        [
+            "op.execute(",
+            '    sa.delete(metadata.tables["permissions"])',
+            '    .where(metadata.tables["permissions"].c.name.in_(',
+            f'        "{kebab_entity_name}:create",',
+            f'        "{kebab_entity_name}:read",',
+            f'        "{kebab_entity_name}:update",',
+            f'        "{kebab_entity_name}:delete",',
+            "    ))",
+            ")",
+        ]
+    )
+
+
+def get_auth_migration_version_dir() -> str:
+    return os.path.join(APP_DIR, "module", "auth", "migration", "versions")
+
+
+def get_existing_auth_migration_file_names() -> list[str]:
+    migration_version_dir = get_auth_migration_version_dir()
+    return [
+        file_name
+        for file_name in os.listdir(migration_version_dir)
+        if file_name.endswith(".py")
+    ]
+
+
+def get_existing_auth_migration_xcom_key(ctx: AnyContext) -> str:
+    snake_entity_name = to_snake_case(ctx.input.entity)
+    return f"existing_my_app_name_auth_{snake_entity_name}_migration"
 
 
 def is_in_app_schema_dir(ctx: AnyContext, file_path: str) -> bool:
@@ -17,6 +80,17 @@ def is_in_app_schema_dir(ctx: AnyContext, file_path: str) -> bool:
     )
 
 
+def is_in_module_entity_test_dir(ctx: AnyContext, file_path: str) -> bool:
+    return file_path.startswith(
+        os.path.join(
+            APP_DIR,
+            "test",
+            to_snake_case(ctx.input.module),
+            to_snake_case(ctx.input.entity),
+        )
+    )
+
+
 def is_in_module_entity_dir(ctx: AnyContext, file_path: str) -> bool:
     return file_path.startswith(
         os.path.join(
@@ -93,6 +167,19 @@ def is_module_gateway_subroute_file(ctx: AnyContext, file_path: str) -> bool:
     return file_path == module_gateway_subroute_file
 
 
+def is_module_gateway_subroute_view_file(ctx: AnyContext, file_path: str) -> bool:
+    module_gateway_subroute_file = os.path.join(
+        APP_DIR,
+        "module",
+        "gateway",
+        "view",
+        "content",
+        f"{to_kebab_case(ctx.input.module)}",
+        f"{to_kebab_case(ctx.input.entity)}.html",
+    )
+    return file_path == module_gateway_subroute_file
+
+
 def update_migration_metadata_file(ctx: AnyContext, migration_metadata_file_path: str):
     app_name = os.path.basename(APP_DIR)
     existing_migration_metadata_code = read_file(migration_metadata_file_path)
@@ -255,7 +342,9 @@ def update_route_file(ctx: AnyContext, route_file_path: str):
 
 def update_gateway_subroute_file(ctx: AnyContext, module_gateway_subroute_path: str):
     snake_module_name = to_snake_case(ctx.input.module)
+    kebab_module_name = to_kebab_case(ctx.input.module)
     snake_entity_name = to_snake_case(ctx.input.entity)
+    kebab_entity_name = to_kebab_case(ctx.input.entity)
     snake_plural_entity_name = to_snake_case(ctx.input.plural)
     kebab_plural_entity_name = to_kebab_case(ctx.input.plural)
     pascal_entity_name = to_pascal_case(ctx.input.entity)
@@ -278,7 +367,9 @@ def update_gateway_subroute_file(ctx: AnyContext, module_gateway_subroute_path:
                     ),
                     replace_map={
                         "my_module": snake_module_name,
+                        "my-module": kebab_module_name,
                         "my_entity": snake_entity_name,
+                        "my-entity": kebab_entity_name,
                         "my_entities": snake_plural_entity_name,
                         "my-entities": kebab_plural_entity_name,
                         "MyEntity": pascal_entity_name,
@@ -319,3 +410,35 @@ def _get_import_schema_for_gateway_subroute_code(
     if new_code in existing_code:
         return None
     return new_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)
+    kebab_entity_name = to_kebab_case(ctx.input.entity)
+    human_entity_name = to_human_case(ctx.input.entity)
+    kebab_plural_name = to_kebab_case(ctx.input.plural)
+    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-entity": kebab_entity_name,
+            "My Entity": human_entity_name.title(),
+            "my-entities": kebab_plural_name,
+        },
+    ).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/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>