zrb 1.0.0a21__py3-none-any.whl → 1.0.0b3__py3-none-any.whl

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

@@ -8,7 +8,7 @@ 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.file import read_file, write_file
-from zrb.util.string.conversion import to_pascal_case, to_snake_case
+from zrb.util.string.conversion import to_kebab_case, to_pascal_case, to_snake_case
 
 
 def is_in_app_schema_dir(ctx: AnyContext, file_path: str) -> bool:
@@ -49,13 +49,13 @@ def is_module_migration_metadata_file(ctx: AnyContext, file_path: str) -> bool:
     return file_path == module_migration_metadata_file
 
 
-def is_module_any_client_file(ctx: AnyContext, file_path: str) -> bool:
+def is_module_client_file(ctx: AnyContext, file_path: str) -> bool:
     module_any_client_file = os.path.join(
         APP_DIR,
         "module",
         to_snake_case(ctx.input.module),
         "client",
-        "any_client.py",
+        f"{to_snake_case(ctx.input.module)}_client.py",
     )
     return file_path == module_any_client_file
 
@@ -66,7 +66,7 @@ def is_module_api_client_file(ctx: AnyContext, file_path: str) -> bool:
         "module",
         to_snake_case(ctx.input.module),
         "client",
-        "api_client.py",
+        f"{to_snake_case(ctx.input.module)}_api_client.py",
     )
     return file_path == module_api_client_file
 
@@ -77,29 +77,40 @@ def is_module_direct_client_file(ctx: AnyContext, file_path: str) -> bool:
         "module",
         to_snake_case(ctx.input.module),
         "client",
-        "direct_client.py",
+        f"{to_snake_case(ctx.input.module)}_direct_client.py",
     )
     return file_path == module_direct_client_file
 
 
-def update_migration_metadata(ctx: AnyContext, migration_metadata_file_path: str):
+def is_module_gateway_subroute_file(ctx: AnyContext, file_path: str) -> bool:
+    module_gateway_subroute_file = os.path.join(
+        APP_DIR,
+        "module",
+        "gateway",
+        "subroute",
+        f"{to_snake_case(ctx.input.module)}.py",
+    )
+    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)
     write_file(
         file_path=migration_metadata_file_path,
         content=[
-            _get_import_schema_code(
+            _get_migration_import_schema_code(
                 existing_migration_metadata_code, app_name, ctx.input.entity
             ),
             existing_migration_metadata_code.strip(),
-            _get_entity_metadata_assignment_code(
+            _get_migration_entity_metadata_assignment_code(
                 existing_migration_metadata_code, ctx.input.entity
             ),
         ],
     )
 
 
-def _get_import_schema_code(
+def _get_migration_import_schema_code(
     existing_code: str, app_name: str, entity_name: str
 ) -> str | None:
     snake_entity_name = to_snake_case(entity_name)
@@ -111,7 +122,7 @@ def _get_import_schema_code(
     return import_schema_code
 
 
-def _get_entity_metadata_assignment_code(
+def _get_migration_entity_metadata_assignment_code(
     existing_code: str, entity_name: str
 ) -> str | None:
     pascal_entity_name = to_pascal_case(entity_name)
@@ -126,76 +137,105 @@ def _get_entity_metadata_assignment_code(
     return entity_metadata_assignment_code
 
 
-def update_any_client(ctx: AnyContext, any_client_file_path: str):
-    existing_any_client_code = read_file(any_client_file_path)
-    app_name = os.path.basename(APP_DIR)
+def update_client_file(ctx: AnyContext, client_file_path: str):
+    existing_client_code = read_file(client_file_path)
+    pascal_module_name = to_pascal_case(ctx.input.module)
     snake_entity_name = to_snake_case(ctx.input.entity)
     snake_plural_entity_name = to_snake_case(ctx.input.plural)
     pascal_entity_name = to_pascal_case(ctx.input.entity)
-    any_client_method = read_file(
-        file_path=os.path.join(
-            os.path.dirname(__file__), "template", "any_client_method.py"
-        ),
-        replace_map={
-            "my_entity": snake_entity_name,
-            "my_entities": snake_plural_entity_name,
-            "MyEntity": pascal_entity_name,
-        },
-    )
-    new_code = append_code_to_class(
-        existing_any_client_code, "AnyClient", any_client_method
-    )
     write_file(
-        file_path=any_client_file_path,
+        file_path=client_file_path,
         content=[
-            f"from {app_name}.schema.{snake_entity_name}.{snake_entity_name} import (",
-            f"    {pascal_entity_name}CreateWithAudit, {pascal_entity_name}Response, {pascal_entity_name}UpdateWithAudit",  # noqa
-            ")",
-            new_code.strip(),
+            _get_import_schema_for_client_code(
+                existing_code=existing_client_code, entity_name=ctx.input.entity
+            ),
+            append_code_to_class(
+                original_code=existing_client_code,
+                class_name=f"{pascal_module_name}Client",
+                new_code=read_file(
+                    file_path=os.path.join(
+                        os.path.dirname(__file__), "template", "client_method.py"
+                    ),
+                    replace_map={
+                        "my_entity": snake_entity_name,
+                        "my_entities": snake_plural_entity_name,
+                        "MyEntity": pascal_entity_name,
+                    },
+                ),
+            ),
         ],
     )
 
 
-def update_api_client(ctx: AnyContext, api_client_file_path: str):
+def _get_import_schema_for_client_code(
+    existing_code: str, entity_name: str
+) -> str | None:
+    snake_entity_name = to_snake_case(entity_name)
+    pascal_entity_name = to_pascal_case(entity_name)
+    schema_import_path = f"my_app_name.schema.{snake_entity_name}"
+    new_code = "\n".join(
+        [
+            f"from {schema_import_path} import (",
+            f"   Multiple{pascal_entity_name}Response,",
+            f"   {pascal_entity_name}Create,",
+            f"   {pascal_entity_name}CreateWithAudit,",
+            f"   {pascal_entity_name}Response,",
+            f"   {pascal_entity_name}Update,",
+            f"   {pascal_entity_name}UpdateWithAudit,",
+            ")",
+        ]
+    )
+    if new_code in existing_code:
+        return None
+    return new_code
+
+
+def update_api_client_file(ctx: AnyContext, api_client_file_path: str):
     existing_api_client_code = read_file(api_client_file_path)
     upper_snake_module_name = to_snake_case(ctx.input.module).upper()
     app_name = os.path.basename(APP_DIR)
     snake_entity_name = to_snake_case(ctx.input.entity)
     snake_module_name = to_snake_case(ctx.input.module)
+    pascal_module_name = to_pascal_case(ctx.input.module)
     write_file(
         file_path=api_client_file_path,
         content=[
-            f"from {app_name}.module.{snake_module_name}.service.{snake_entity_name}.{snake_entity_name}_usecase import {snake_entity_name}_usecase",  # noqa
+            f"from {app_name}.module.{snake_module_name}.service.{snake_entity_name}.{snake_entity_name}_service_factory import {snake_entity_name}_service",  # noqa
             prepend_code_to_module(
                 prepend_parent_class(
-                    existing_api_client_code, "APIClient", "user_api_client"
+                    original_code=existing_api_client_code,
+                    class_name=f"{pascal_module_name}APIClient",
+                    parent_class_name=f"{snake_entity_name}_api_client",
                 ),
-                f"user_api_client = user_usecase.as_api_client(base_url=APP_{upper_snake_module_name}_BASE_URL)",  # noqa
+                f"{snake_entity_name}_api_client = {snake_entity_name}_service.as_api_client(base_url=APP_{upper_snake_module_name}_BASE_URL)",  # noqa
             ),
         ],
     )
 
 
-def update_direct_client(ctx: AnyContext, direct_client_file_path: str):
+def update_direct_client_file(ctx: AnyContext, direct_client_file_path: str):
     existing_direct_client_code = read_file(direct_client_file_path)
     app_name = os.path.basename(APP_DIR)
     snake_entity_name = to_snake_case(ctx.input.entity)
     snake_module_name = to_snake_case(ctx.input.module)
+    pascal_module_name = to_pascal_case(ctx.input.module)
     write_file(
         file_path=direct_client_file_path,
         content=[
-            f"from {app_name}.module.{snake_module_name}.service.{snake_entity_name}.{snake_entity_name}_usecase import {snake_entity_name}_usecase",  # noqa
+            f"from {app_name}.module.{snake_module_name}.service.{snake_entity_name}.{snake_entity_name}_service_factory import {snake_entity_name}_service",  # noqa
             prepend_code_to_module(
                 prepend_parent_class(
-                    existing_direct_client_code, "DirectClient", "user_direct_client"
+                    original_code=existing_direct_client_code,
+                    class_name=f"{pascal_module_name}DirectClient",
+                    parent_class_name=f"{snake_entity_name}_direct_client",
                 ),
-                "user_direct_client = user_usecase.as_direct_client()",
+                f"{snake_entity_name}_direct_client = {snake_entity_name}_service.as_direct_client()",  # noqa
             ).strip(),
         ],
     )
 
 
-def update_route(ctx: AnyContext, route_file_path: str):
+def update_route_file(ctx: AnyContext, route_file_path: str):
     existing_route_code = read_file(route_file_path)
     entity_name = to_snake_case(ctx.input.entity)
     app_name = os.path.basename(APP_DIR)
@@ -203,11 +243,79 @@ def update_route(ctx: AnyContext, route_file_path: str):
     write_file(
         file_path=route_file_path,
         content=[
-            f"from {app_name}.module.{module_name}.service.{entity_name}.{entity_name}_usecase import {entity_name}_usecase",  # noqa
+            f"from {app_name}.module.{module_name}.service.{entity_name}.{entity_name}_service_factory import {entity_name}_service",  # noqa
             append_code_to_function(
                 existing_route_code,
                 "serve_route",
-                f"{entity_name}_usecase.serve_route(app)",
+                f"{entity_name}_service.serve_route(app)",
+            ),
+        ],
+    )
+
+
+def update_gateway_subroute_file(ctx: AnyContext, module_gateway_subroute_path: str):
+    snake_module_name = to_snake_case(ctx.input.module)
+    snake_entity_name = to_snake_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)
+    existing_gateway_subroute_code = read_file(module_gateway_subroute_path)
+    write_file(
+        file_path=module_gateway_subroute_path,
+        content=[
+            _get_import_client_for_gateway_subroute_code(
+                existing_gateway_subroute_code, module_name=ctx.input.module
+            ),
+            _get_import_schema_for_gateway_subroute_code(
+                existing_gateway_subroute_code, entity_name=ctx.input.entity
+            ),
+            append_code_to_function(
+                original_code=existing_gateway_subroute_code,
+                function_name=f"serve_{snake_module_name}_route",
+                new_code=read_file(
+                    file_path=os.path.join(
+                        os.path.dirname(__file__), "template", "gateway_subroute.py"
+                    ),
+                    replace_map={
+                        "my_module": snake_module_name,
+                        "my_entity": snake_entity_name,
+                        "my_entities": snake_plural_entity_name,
+                        "my-entities": kebab_plural_entity_name,
+                        "MyEntity": pascal_entity_name,
+                    },
+                ),
             ),
         ],
     )
+
+
+def _get_import_client_for_gateway_subroute_code(
+    existing_code: str, module_name: str
+) -> str | None:
+    snake_module_name = to_snake_case(module_name)
+    client_import_path = f"my_app_name.module.{snake_module_name}.client.{snake_module_name}_client_factory"  # noqa
+    new_code = f"from {client_import_path} import {snake_module_name}_client"
+    if new_code in existing_code:
+        return None
+    return new_code
+
+
+def _get_import_schema_for_gateway_subroute_code(
+    existing_code: str, entity_name: str
+) -> str | None:
+    snake_entity_name = to_snake_case(entity_name)
+    pascal_entity_name = to_pascal_case(entity_name)
+    schema_import_path = f"my_app_name.schema.{snake_entity_name}"
+    new_code = "\n".join(
+        [
+            f"from {schema_import_path} import (",
+            f"   Multiple{pascal_entity_name}Response,",
+            f"   {pascal_entity_name}Create,",
+            f"   {pascal_entity_name}Response,",
+            f"   {pascal_entity_name}Update,",
+            ")",
+        ]
+    )
+    if new_code in existing_code:
+        return None
+    return new_code

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/_zrb/entity/template/app_template/module/my_module/service/my_entity/my_entity_service.py

@@ -0,0 +1,113 @@
+from logging import Logger
+
+from my_app_name.common.base_service import BaseService
+from my_app_name.module.my_module.service.my_entity.repository.my_entity_repository import (
+    MyEntityRepository,
+)
+from my_app_name.schema.my_entity import (
+    MultipleMyEntityResponse,
+    MyEntityCreateWithAudit,
+    MyEntityResponse,
+    MyEntityUpdateWithAudit,
+)
+
+
+class MyEntityService(BaseService):
+
+    def __init__(self, logger: Logger, my_entity_repository: MyEntityRepository):
+        super().__init__(logger)
+        self.my_entity_repository = my_entity_repository
+
+    @BaseService.route(
+        "/api/v1/my-entities/{my_entity_id}",
+        methods=["get"],
+        response_model=MyEntityResponse,
+    )
+    async def get_my_entity_by_id(self, my_entity_id: str) -> MyEntityResponse:
+        return await self.my_entity_repository.get_by_id(my_entity_id)
+
+    @BaseService.route(
+        "/api/v1/my-entities",
+        methods=["get"],
+        response_model=MultipleMyEntityResponse,
+    )
+    async def get_my_entities(
+        self,
+        page: int = 1,
+        page_size: int = 10,
+        sort: str | None = None,
+        filter: str | None = None,
+    ) -> MultipleMyEntityResponse:
+        my_entities = await self.my_entity_repository.get(page, page_size, filter, sort)
+        count = await self.my_entity_repository.count(filter)
+        return MultipleMyEntityResponse(data=my_entities, count=count)
+
+    @BaseService.route(
+        "/api/v1/my-entities/bulk",
+        methods=["post"],
+        response_model=list[MyEntityResponse],
+    )
+    async def create_my_entity_bulk(
+        self, data: list[MyEntityCreateWithAudit]
+    ) -> list[MyEntityResponse]:
+        my_entities = await self.my_entity_repository.create_bulk(data)
+        return await self.my_entity_repository.get_by_ids(
+            [my_entity.id for my_entity in my_entities]
+        )
+
+    @BaseService.route(
+        "/api/v1/my-entities",
+        methods=["post"],
+        response_model=MyEntityResponse,
+    )
+    async def create_my_entity(self, data: MyEntityCreateWithAudit) -> MyEntityResponse:
+        my_entity = await self.my_entity_repository.create(data)
+        return await self.my_entity_repository.get_by_id(my_entity.id)
+
+    @BaseService.route(
+        "/api/v1/my-entities/bulk",
+        methods=["put"],
+        response_model=MyEntityResponse,
+    )
+    async def update_my_entity_bulk(
+        self, my_entity_ids: list[str], data: MyEntityUpdateWithAudit
+    ) -> MyEntityResponse:
+        my_entities = await self.my_entity_repository.update_bulk(my_entity_ids, data)
+        return await self.my_entity_repository.get_by_ids(
+            [my_entity.id for my_entity in my_entities]
+        )
+
+    @BaseService.route(
+        "/api/v1/my-entities/{my_entity_id}",
+        methods=["put"],
+        response_model=MyEntityResponse,
+    )
+    async def update_my_entity(
+        self, my_entity_id: str, data: MyEntityUpdateWithAudit
+    ) -> MyEntityResponse:
+        my_entity = await self.my_entity_repository.update(my_entity_id, data)
+        return await self.my_entity_repository.get_by_id(my_entity.id)
+
+    @BaseService.route(
+        "/api/v1/my-entities/{my_entity_id}",
+        methods=["delete"],
+        response_model=MyEntityResponse,
+    )
+    async def delete_my_entity_bulk(
+        self, my_entity_ids: list[str], deleted_by: str
+    ) -> MyEntityResponse:
+        my_entities = await self.my_entity_repository.delete_bulk(my_entity_ids)
+        return await self.my_entity_repository.get_by_ids(
+            [my_entity.id for my_entity in my_entities]
+        )
+
+    @BaseService.route(
+        "/api/v1/my-entities/{my_entity_id}",
+        methods=["delete"],
+        response_model=MyEntityResponse,
+    )
+    async def delete_my_entity(
+        self, my_entity_id: str, deleted_by: str
+    ) -> MyEntityResponse:
+        my_entity = await self.my_entity_repository.delete(my_entity_id)
+        return await self.my_entity_repository.get_by_id(my_entity.id)

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/_zrb/entity/template/app_template/module/my_module/service/my_entity/my_entity_service_factory.py

@@ -0,0 +1,9 @@
+from my_app_name.common.logger_factory import logger
+from my_app_name.module.my_module.service.my_entity.my_entity_service import (
+    MyEntityService,
+)
+from my_app_name.module.my_module.service.my_entity.repository.my_entity_repository_factory import (
+    my_entity_repository,
+)
+
+my_entity_service = MyEntityService(logger, my_entity_repository=my_entity_repository)

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/_zrb/entity/template/app_template/module/my_module/service/my_entity/repository/my_entity_db_repository.py

@@ -1,5 +1,4 @@
 from my_app_name.common.base_db_repository import BaseDBRepository
-from my_app_name.common.error import NotFoundError
 from my_app_name.module.my_module.service.my_entity.repository.my_entity_repository import (
     MyEntityRepository,
 )
@@ -10,15 +9,6 @@ from my_app_name.schema.my_entity import (
     MyEntityUpdateWithAudit,
 )
 from passlib.context import CryptContext
-from sqlalchemy.ext.asyncio import AsyncSession
-from sqlmodel import Session, select
-
-# Password hashing context
-pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
-
-
-def hash_password(password: str) -> str:
-    return pwd_context.hash(password)
 
 
 class MyEntityDBRepository(

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/_zrb/entity/template/app_template/module/my_module/service/my_entity/repository/my_entity_repository.py

@@ -9,30 +9,51 @@ from my_app_name.schema.my_entity import (
 
 
 class MyEntityRepository(ABC):
+
+    @abstractmethod
+    async def get_by_id(self, id: str) -> MyEntityResponse:
+        """Get my entity by id"""
+
+    @abstractmethod
+    async def get_by_ids(self, id_list: list[str]) -> MyEntityResponse:
+        """Get my entities by ids"""
+
+    @abstractmethod
+    async def get(
+        self,
+        page: int = 1,
+        page_size: int = 10,
+        filter: str | None = None,
+        sort: str | None = None,
+    ) -> list[MyEntity]:
+        """Get my entities by filter and sort"""
+
+    @abstractmethod
+    async def count(self, filter: str | None = None) -> int:
+        """Count my entities by filter"""
+
     @abstractmethod
-    async def create(self, my_entity_data: MyEntityCreateWithAudit) -> MyEntityResponse:
-        pass
+    async def create(self, data: MyEntityCreateWithAudit) -> MyEntity:
+        """Create a new my entity"""
 
     @abstractmethod
-    async def get_by_id(self, my_entity_id: str) -> MyEntity:
-        pass
+    async def create_bulk(self, data: list[MyEntityCreateWithAudit]) -> list[MyEntity]:
+        """Create some my entities"""
 
     @abstractmethod
-    async def get_all(self) -> list[MyEntity]:
-        pass
+    async def delete(self, id: str) -> MyEntity:
+        """Delete a my entity"""
 
     @abstractmethod
-    async def update(
-        self, my_entity_id: str, my_entity_data: MyEntityUpdateWithAudit
-    ) -> MyEntity:
-        pass
+    async def delete_bulk(self, id_list: list[str]) -> list[MyEntity]:
+        """Delete some my entities"""
 
     @abstractmethod
-    async def delete(self, my_entity_id: str) -> MyEntity:
-        pass
+    async def update(self, id: str, data: MyEntityUpdateWithAudit) -> MyEntity:
+        """Update a my entity"""
 
     @abstractmethod
-    async def create_bulk(
-        self, my_entity_data_list: list[MyEntityCreateWithAudit]
-    ) -> list[MyEntityResponse]:
-        pass
+    async def update_bulk(
+        self, id_list: list[str], data: MyEntityUpdateWithAudit
+    ) -> list[MyEntity]:
+        """Update some my entities"""

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/_zrb/entity/template/app_template/module/my_module/service/my_entity/repository/{factory.py → my_entity_repository_factory.py}

@@ -1,4 +1,4 @@
-from my_app_name.common.db_engine import engine
+from my_app_name.common.db_engine_factory import db_engine
 from my_app_name.config import APP_REPOSITORY_TYPE
 from my_app_name.module.my_module.service.my_entity.repository.my_entity_db_repository import (
     MyEntityDBRepository,
@@ -8,6 +8,6 @@ from my_app_name.module.my_module.service.my_entity.repository.my_entity_reposit
 )
 
 if APP_REPOSITORY_TYPE == "db":
-    my_entity_repository: MyEntityRepository = MyEntityDBRepository(engine)
+    my_entity_repository: MyEntityRepository = MyEntityDBRepository(db_engine)
 else:
     my_entity_repository: MyEntityRepository = None

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

@@ -1,6 +1,7 @@
 import datetime
 
 import ulid
+from pydantic import BaseModel
 from sqlmodel import Field, SQLModel
 
 
@@ -9,7 +10,8 @@ class MyEntityBase(SQLModel):
 
 
 class MyEntityCreate(MyEntityBase):
-    pass
+    def with_audit(self, created_by: str) -> "MyEntityCreateWithAudit":
+        return MyEntityCreateWithAudit(**self.model_dump(), created_by=created_by)
 
 
 class MyEntityCreateWithAudit(MyEntityCreate):
@@ -19,6 +21,9 @@ class MyEntityCreateWithAudit(MyEntityCreate):
 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)
+
 
 class MyEntityUpdateWithAudit(MyEntityUpdate):
     updated_by: str
@@ -28,10 +33,15 @@ class MyEntityResponse(MyEntityBase):
     id: str
 
 
+class MultipleMyEntityResponse(BaseModel):
+    data: list[MyEntityResponse]
+    count: int
+
+
 class MyEntity(SQLModel, table=True):
     id: str = Field(default_factory=lambda: ulid.new().str, primary_key=True)
-    created_at: datetime.datetime
-    created_by: str
-    updated_at: datetime.datetime
-    updated_by: str
-    my_column: str
+    created_at: datetime.datetime = Field(index=True)
+    created_by: str = Field(index=True)
+    updated_at: datetime.datetime | None = Field(index=True)
+    updated_by: str | None = Field(index=True)
+    my_column: str = Field(index=True)

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

@@ -0,0 +1,57 @@
+# MyEntity related methods
+
+
+@abstractmethod
+async def get_my_entity_by_id(self, my_entity_id: str) -> MyEntityResponse:
+    """Get my entity by id"""
+
+
+@abstractmethod
+async def get_my_entities(
+    self,
+    page: int = 1,
+    page_size: int = 10,
+    sort: str | None = None,
+    filter: str | None = None,
+) -> MultipleMyEntityResponse:
+    """Get my entities by filter and sort"""
+
+
+@abstractmethod
+async def create_my_entity_bulk(
+    self, data: list[MyEntityCreateWithAudit]
+) -> list[MyEntityResponse]:
+    """Create new my entities"""
+
+
+@abstractmethod
+async def create_my_entity(self, data: MyEntityCreateWithAudit) -> MyEntityResponse:
+    """Create a new my entities"""
+
+
+@abstractmethod
+async def update_my_entity_bulk(
+    self, my_entity_ids: list[str], data: MyEntityUpdateWithAudit
+) -> MyEntityResponse:
+    """Update some my entities"""
+
+
+@abstractmethod
+async def update_my_entity(
+    self, my_entity_id: str, data: MyEntityUpdateWithAudit
+) -> MyEntityResponse:
+    """Update a my entity"""
+
+
+@abstractmethod
+async def delete_my_entity_bulk(
+    self, my_entity_ids: str, deleted_by: str
+) -> MyEntityResponse:
+    """Delete some my entities"""
+
+
+@abstractmethod
+async def delete_my_entity(
+    self, my_entity_id: str, deleted_by: str
+) -> MyEntityResponse:
+    """Delete a my entity"""