zrb 1.2.1__py3-none-any.whl → 1.3.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

@@ -1,23 +1,31 @@
 <link rel="stylesheet" href="/static/crud/style.css">
 
-<main class="container">
+<main id="crud-app" 
+    class="container"
+    data-page-size='{{ page_size | tojson }}'
+    data-page='{{ page | tojson }}'
+    data-sort='{{ sort | tojson }}'
+    data-filter='{{ filter | tojson }}'
+    data-allow-create='{{ allow_create | tojson }}'
+    data-allow-update='{{ allow_update | tojson }}'
+    data-allow-delete='{{ allow_delete | tojson }}'>
     <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>
+            <input id="crud-filter-input" placeholder="🔍 Filter" aria-label="Search" />
+            <button id="crud-search-button">🔍 Search</button>
             {% if allow_create %}
-            <button class="contrast" onclick="showCreateForm(event)">➕ Add</button>
+            <button id="crud-show-create-button" class="contrast">➕ 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 %}
@@ -37,10 +45,9 @@
                         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>
+                        <button id="crud-create-button">➕ Save</button>
+                        <button id="crud-cancel-create-button" class="secondary">❌ Cancel</button>
                     </footer>
                 </form>
             </article>
@@ -56,10 +63,9 @@
                         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>
+                        <button id="crud-update-button">✏️ Save</button>
+                        <button id="crud-cancel-update-button" class="secondary">❌ Cancel</button>
                     </footer>
                 </form>
             </article>
@@ -75,10 +81,9 @@
                         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>
+                        <button id="crud-cancel-delete-button" class="secondary">❌ Cancel</button>
+                        <button id="crud-delete-button">🗑️ Delete</button>
                     </footer>
                 </form>
             </article>
@@ -90,208 +95,231 @@
                 <h2 id="crud-alert-title">Error</h2>
                 <pre id="crud-alert-message"></pre>
                 <footer>
-                    <button onclick="hideAlert(event)">Close</button>
+                    <button id="crud-alert-close-button">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,
-    };
+    class CrudApp {
+        constructor(apiUrl, initialState) {
+            this.apiUrl = apiUrl;
+            this.state = { ...initialState };
+            this.init();
+        }
 
-    async function applySearch() {
-        const filterInput = document.getElementById("crud-filter");
-        crudState.filter = filterInput.value;
-        return await fetchRows(crudState.currentPage);
-    }
+        init() {
+            // Cache common elements
+            this.filterInput = document.getElementById("crud-filter-input");
+            this.searchButton = document.getElementById("crud-search-button");
+            this.filterInput.value = this.state.filter;
 
-    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);
+            this.filterInput.addEventListener("change", (e) => this.applySearch(e));
+            this.searchButton.addEventListener("click", (e) => this.applySearch(e));
+
+            // Attach optional events if elements exist
+            this.attachEvent("crud-show-create-button", this.showCreateForm.bind(this));
+            this.attachEvent("crud-create-button", this.createRow.bind(this));
+            this.attachEvent("crud-cancel-create-button", this.hideCreateForm.bind(this));
+            this.attachEvent("crud-update-button", this.updateRow.bind(this));
+            this.attachEvent("crud-cancel-update-button", this.hideUpdateForm.bind(this));
+            this.attachEvent("crud-delete-button", this.deleteRow.bind(this));
+            this.attachEvent("crud-cancel-delete-button", this.hideDeleteForm.bind(this));
+            this.attachEvent("crud-alert-close-button", this.hideAlert.bind(this));
+
+            // Initial data fetch
+            this.fetchRows(this.state.currentPage);
         }
-    }
 
-    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>`;
+        attachEvent(elementId, handler) {
+            const el = document.getElementById(elementId);
+            if (el) el.addEventListener("click", handler);
+        }
+
+        async applySearch(event) {
+            if (event) event.preventDefault();
+            this.state.filter = this.filterInput.value;
+            await this.fetchRows(this.state.currentPage);
+        }
+
+        async fetchRows(page = null) {
+            try {
+                if (page !== null) {
+                    this.state.currentPage = page;
+                }
+                const defaultSearchColumn = "my_column";
+                // Update address bar
+                const searchParam = CRUD_UTIL.getSearchParam(this.state, defaultSearchColumn, false);
+                const newUrl = `${window.location.pathname}?${searchParam}`;
+                window.history.pushState({ path: newUrl }, "", newUrl);
+
+                // Fetch table data
+                const apiSearchParam = CRUD_UTIL.getSearchParam(this.state, defaultSearchColumn, true);
+                const result = await UTIL.fetchAPI(`${this.apiUrl}?${apiSearchParam}`, { method: "GET" });
+                this.renderRows(result.data);
+                const crudPagination = document.getElementById("crud-pagination");
+                CRUD_UTIL.renderPagination(crudPagination, this, result.count);
+            } catch (error) {
+                console.error("Error fetching items:", error);
             }
-            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;
-    }
+        renderRows(rows) {
+            const tableBody = document.querySelector("#crud-table tbody");
+            let tableBodyHTML = "";
+            rows.forEach(row => {
+                const rowComponents = this.getRowComponents(row);
+                let actionColumn = "";
+                if (this.state.allowUpdate) {
+                    actionColumn += `<button class="contrast" data-id="${row.id}" data-action="edit">✏️ Edit</button>`;
+                }
+                if (this.state.allowDelete) {
+                    actionColumn += `<button class="secondary" data-id="${row.id}" data-action="delete">🗑️ Delete</button>`;
+                }
+                if (this.state.allowUpdate || this.state.allowDelete) {
+                    actionColumn = `<td><fieldset class="grid" role="group">${actionColumn}</fieldset></td>`;
+                }
+                tableBodyHTML += `<tr>${rowComponents.join('')}${actionColumn}</tr>`;
+            });
+            tableBody.innerHTML = tableBodyHTML;
+            this.attachRowActionListeners();
+        }
 
-    {% 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();
-    }
+        attachRowActionListeners() {
+            document.querySelectorAll('button[data-action="edit"]').forEach(button => {
+                button.addEventListener("click", () => {
+                    this.showUpdateForm(button.getAttribute("data-id"));
+                });
+            });
+            document.querySelectorAll('button[data-action="delete"]').forEach(button => {
+                button.addEventListener("click", () => {
+                    this.showDeleteForm(button.getAttribute("data-id"));
+                });
+            });
+        }
 
-    async function createRow(event = null) {
-        if (event != null) {
-            event.preventDefault();
+        getRowComponents(row) {
+            const rowComponents = [`<td>${row.id}</td>`, `<td>${row.my_column}</td>`];
+            return rowComponents; 
         }
-        try {
+
+        // Create methods
+        showCreateForm(event = null) {
+            if (event) event.preventDefault();
+            const createDialog = document.getElementById("crud-create-form-dialog");
             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);
+            UTIL.clearFormData(createForm);
+            createDialog.showModal();
         }
-    }
 
-    function hideCreateForm(event = null) {
-        if (event != null) {
-            event.preventDefault();
+        async createRow(event = null) {
+            if (event) event.preventDefault();
+            try {
+                const createForm = document.getElementById("crud-create-form");
+                const formData = UTIL.getFormData(createForm);
+                await UTIL.fetchAPI(this.apiUrl, { method: "POST", body: JSON.stringify(formData) });
+                await this.fetchRows();
+                this.hideCreateForm();
+            } catch (error) {
+                console.error(error);
+                this.showAlert("Create My Entity Error", error);
+            }
         }
-        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();
+        hideCreateForm(event = null) {
+            if (event) event.preventDefault();
+            document.getElementById("crud-create-form-dialog").close();
         }
-        try {
+
+        // Update methods
+        async showUpdateForm(id) {
+            this.state.updatedRowId = id;
+            const updateDialog = document.getElementById("crud-update-form-dialog");
             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);
+            const formData = await UTIL.fetchAPI(`${this.apiUrl}/${id}`, { method: "GET" });
+            UTIL.setFormData(updateForm, formData);
+            updateDialog.showModal();
         }
-    }
 
-    function hideUpdateForm(event = null) {
-        if (event != null) {
-            event.preventDefault();
+        async updateRow(event = null) {
+            if (event) event.preventDefault();
+            try {
+                const updateForm = document.getElementById("crud-update-form");
+                const formData = UTIL.getFormData(updateForm);
+                await UTIL.fetchAPI(`${this.apiUrl}/${this.state.updatedRowId}`, {
+                    method: "PUT",
+                    body: JSON.stringify(formData)
+                });
+                await this.fetchRows();
+                this.hideUpdateForm();
+            } catch (error) {
+                console.error(error);
+                this.showAlert("Update My Entity Error", error);
+            }
         }
-        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();
-    }
+        hideUpdateForm(event = null) {
+            if (event) event.preventDefault();
+            document.getElementById("crud-update-form-dialog").close();
+        }
 
-    async function deleteRow(event = null) {
-        if (event != null) {
-            event.preventDefault();
+        // Delete methods
+        async showDeleteForm(id) {
+            this.state.deletedRowId = id;
+            const deleteDialog = document.getElementById("crud-delete-form-dialog");
+            const deleteForm = document.getElementById("crud-delete-form");
+            const formData = await UTIL.fetchAPI(`${this.apiUrl}/${id}`, { method: "GET" });
+            UTIL.setFormData(deleteForm, formData);
+            deleteDialog.showModal();
         }
-        try {
-            await UTIL.fetchAPI(`${apiUrl}/${crudState.deletedRowId}`, {method: "DELETE",});
-            await fetchRows();
-            hideDeleteForm();
-        } catch(error) {
-            showAlert("Delete My Entity Error", error);
+
+        async deleteRow(event = null) {
+            if (event) event.preventDefault();
+            try {
+                await UTIL.fetchAPI(`${this.apiUrl}/${this.state.deletedRowId}`, { method: "DELETE" });
+                await this.fetchRows();
+                this.hideDeleteForm();
+            } catch (error) {
+                console.error(error);
+                this.showAlert("Delete My Entity Error", error);
+            }
         }
-    }
 
-    function hideDeleteForm(event = null) {
-        if (event != null) {
-            event.preventDefault();
+        hideDeleteForm(event = null) {
+            if (event) event.preventDefault();
+            document.getElementById("crud-delete-form-dialog").close();
         }
-        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();
-    }
+        // Alert methods
+        showAlert(title, error) {
+            const alertDialog = document.getElementById("crud-alert-dialog");
+            document.getElementById("crud-alert-title").textContent = title;
+            document.getElementById("crud-alert-message").textContent = error.message || String(error);
+            alertDialog.showModal();
+        }
 
-    function hideAlert(event = null) {
-        if (event != null) {
-            event.preventDefault();
+        hideAlert(event = null) {
+            if (event) event.preventDefault();
+            document.getElementById("crud-alert-dialog").close();
         }
-        const alertDialog = document.getElementById("crud-alert-dialog");
-        alertDialog.close();
     }
 
+    // Initialize the CrudApp on DOM ready
     document.addEventListener("DOMContentLoaded", () => {
-        const filterInput = document.getElementById("crud-filter");
-        filterInput.value = crudState.filter;
-        fetchRows(crudState.currentPage);
+        const app = document.getElementById("crud-app");
+        new CrudApp("/api/v1/my-entities", {
+            pageSize: JSON.parse(app.dataset.pageSize),
+            currentPage: JSON.parse(app.dataset.page),
+            sort: JSON.parse(app.dataset.sort),
+            filter: JSON.parse(app.dataset.filter),
+            allowCreate: JSON.parse(app.dataset.allowCreate),
+            allowUpdate: JSON.parse(app.dataset.allowUpdate),
+            allowDelete: JSON.parse(app.dataset.allowDelete),
+            updatedRowId: null,
+            deletedRowId: null,
+        });
     });
 </script>

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/_zrb/entity/template/app_template/schema/my_entity.py

@@ -22,7 +22,9 @@ class MyEntityUpdate(SQLModel):
     my_column: str | None = None
 
     def with_audit(self, updated_by: str) -> "MyEntityUpdateWithAudit":
-        return MyEntityUpdateWithAudit(**self.model_dump(), updated_by=updated_by)
+        return MyEntityUpdateWithAudit(
+            **self.model_dump(exclude_none=True), updated_by=updated_by
+        )
 
 
 class MyEntityUpdateWithAudit(MyEntityUpdate):

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/module/auth/service/role/repository/role_db_repository.py

@@ -3,6 +3,7 @@ from typing import Any
 
 import ulid
 from my_app_name.common.base_db_repository import BaseDBRepository
+from my_app_name.common.error import InvalidValueError
 from my_app_name.module.auth.service.role.repository.role_repository import (
     RoleRepository,
 )
@@ -65,6 +66,20 @@ class RoleDBRepository(
             for data in role_map.values()
         ]
 
+    async def validate_permission_names(self, permission_names: list[str]):
+        async with self._session_scope() as session:
+            result = await self._execute_statement(
+                session,
+                select(Permission.name).where(Permission.name.in_(permission_names)),
+            )
+            existing_permissions = {row[0] for row in result.all()}
+            # Identify any missing permission names
+            missing_permissions = set(permission_names) - existing_permissions
+            if missing_permissions:
+                raise InvalidValueError(
+                    f"Permission(s) not found: {', '.join(missing_permissions)}"
+                )
+
     async def add_permissions(self, data: dict[str, list[str]], created_by: str):
         now = datetime.datetime.now(datetime.timezone.utc)
         # get mapping from perrmission names to permission ids
@@ -94,6 +109,8 @@ class RoleDBRepository(
                         )
                     )
                 )
+        if len(data_dict_list) == 0:
+            return
         # Insert rolePermissions
         async with self._session_scope() as session:
             await self._execute_statement(
@@ -104,5 +121,5 @@ class RoleDBRepository(
         async with self._session_scope() as session:
             await self._execute_statement(
                 session,
-                delete(RolePermission).where(RolePermission.role_id._in(role_ids)),
+                delete(RolePermission).where(RolePermission.role_id.in_(role_ids)),
             )

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/module/auth/service/role/repository/role_repository.py

@@ -18,6 +18,10 @@ class RoleRepository(ABC):
     async def get_by_ids(self, id_list: list[str]) -> RoleResponse:
         """Get roles by ids"""
 
+    @abstractmethod
+    async def validate_permission_names(self, permission_names: list[str]):
+        """Validate Permission names"""
+
     @abstractmethod
     async def add_permissions(self, data: dict[str, list[str]], created_by: str):
         """Adding permissions to roles"""

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/module/auth/service/role/role_service.py

@@ -50,13 +50,17 @@ class RoleService(BaseService):
     async def create_role_bulk(
         self, data: list[RoleCreateWithPermissionsAndAudit]
     ) -> list[RoleResponse]:
-        permission_names = [row.get_permission_names() for row in data]
-        data = [row.get_role_create_with_audit() for row in data]
-        roles = await self.role_repository.create_bulk(data)
+        bulk_permission_names = [row.get_permission_names() for row in data]
+        for permission_names in bulk_permission_names:
+            await self.role_repository.validate_permission_names(permission_names)
+        bulk_role_data = [row.get_role_create_with_audit() for row in data]
+        roles = await self.role_repository.create_bulk(bulk_role_data)
         if len(roles) > 0:
             created_by = roles[0].created_by
             await self.role_repository.add_permissions(
-                data={role.id: permission_names[i] for i, role in enumerate(roles)},
+                data={
+                    role.id: bulk_permission_names[i] for i, role in enumerate(roles)
+                },
                 created_by=created_by,
             )
         return await self.role_repository.get_by_ids([role.id for role in roles])
@@ -70,8 +74,9 @@ class RoleService(BaseService):
         self, data: RoleCreateWithPermissionsAndAudit
     ) -> RoleResponse:
         permission_names = data.get_permission_names()
-        data = data.get_role_create_with_audit()
-        role = await self.role_repository.create(data)
+        await self.role_repository.validate_permission_names(permission_names)
+        role_data = data.get_role_create_with_audit()
+        role = await self.role_repository.create(role_data)
         await self.role_repository.add_permissions(
             data={role.id: permission_names}, created_by=role.created_by
         )
@@ -85,15 +90,18 @@ class RoleService(BaseService):
     async def update_role_bulk(
         self, role_ids: list[str], data: RoleUpdateWithPermissionsAndAudit
     ) -> list[RoleResponse]:
-        permission_names = [row.get_permission_names() for row in data]
-        data = [row.get_role_update_with_audit() for row in data]
-        await self.role_repository.update_bulk(role_ids, data)
+        bulk_permission_names = [row.get_permission_names() for row in data]
+        for permission_names in bulk_permission_names:
+            await self.role_repository.validate_permission_names(permission_names)
+        bulk_role_data = [row.get_role_update_with_audit() for row in data]
+        await self.role_repository.update_bulk(role_ids, bulk_role_data)
         if len(role_ids) > 0:
-            updated_by = data[0].updated_by
+            updated_by = bulk_role_data[0].updated_by
             await self.role_repository.remove_all_permissions(role_ids)
             await self.role_repository.add_permissions(
                 data={
-                    role_id: permission_names[i] for i, role_id in enumerate(role_ids)
+                    role_id: bulk_permission_names[i]
+                    for i, role_id in enumerate(role_ids)
                 },
                 created_by=updated_by,
             )
@@ -108,6 +116,7 @@ class RoleService(BaseService):
         self, role_id: str, data: RoleUpdateWithPermissionsAndAudit
     ) -> RoleResponse:
         permission_names = data.get_permission_names()
+        await self.role_repository.validate_permission_names(permission_names)
         role_data = data.get_role_update_with_audit()
         await self.role_repository.update(role_id, role_data)
         await self.role_repository.remove_all_permissions([role_id])

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/module/auth/service/user/repository/user_db_repository.py

@@ -3,7 +3,7 @@ from typing import Any
 
 import ulid
 from my_app_name.common.base_db_repository import BaseDBRepository
-from my_app_name.common.error import NotFoundError, UnauthorizedError
+from my_app_name.common.error import InvalidValueError, NotFoundError, UnauthorizedError
 from my_app_name.module.auth.service.user.repository.user_repository import (
     UserRepository,
 )
@@ -87,6 +87,19 @@ class UserDBRepository(
             for data in user_map.values()
         ]
 
+    async def validate_role_names(self, role_names: list[str]):
+        async with self._session_scope() as session:
+            result = await self._execute_statement(
+                session, select(Role.name).where(Role.name.in_(role_names))
+            )
+            existing_roles = {row[0] for row in result.all()}
+            # Identify any missing role names
+            missing_roles = set(role_names) - existing_roles
+            if missing_roles:
+                raise InvalidValueError(
+                    f"Role(s) not found: {', '.join(missing_roles)}"
+                )
+
     async def add_roles(self, data: dict[str, list[str]], created_by: str):
         now = datetime.datetime.now(datetime.timezone.utc)
         # get mapping from role names to role ids
@@ -111,6 +124,8 @@ class UserDBRepository(
                         )
                     )
                 )
+        if len(data_dict_list) == 0:
+            return
         async with self._session_scope() as session:
             await self._execute_statement(
                 session, insert(UserRole).values(data_dict_list)
@@ -120,7 +135,7 @@ class UserDBRepository(
         async with self._session_scope() as session:
             await self._execute_statement(
                 session,
-                delete(UserRole).where(UserRole.user_id._in(user_ids)),
+                delete(UserRole).where(UserRole.user_id.in_(user_ids)),
             )
 
     async def get_by_credentials(self, username: str, password: str) -> UserResponse: