zrb 1.0.0a12__tar.gz → 1.0.0a15__tar.gz

{zrb-1.0.0a12 → zrb-1.0.0a15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: zrb
-Version: 1.0.0a12
+Version: 1.0.0a15
 Summary: Your Automation Powerhouse
 Home-page: https://github.com/state-alchemists/zrb
 License: AGPL-3.0-or-later

{zrb-1.0.0a12 → zrb-1.0.0a15}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "zrb"
-version = "1.0.0a12"
+version = "1.0.0a15"
 description = "Your Automation Powerhouse"
 authors = ["Go Frendi Gunawan <gofrendiasgard@gmail.com>"]
 license = "AGPL-3.0-or-later"

{zrb-1.0.0a12 → zrb-1.0.0a15}/src/zrb/builtin/git.py

@@ -55,9 +55,11 @@ from zrb.util.git import (
     group=git_group,
     alias="diff",
 )
-def get_git_diff(ctx: AnyContext):
-    repo_dir = get_repo_dir()
-    diff = get_diff(repo_dir, ctx.input.source, ctx.input.current)
+async def get_git_diff(ctx: AnyContext):
+    repo_dir = await get_repo_dir(log_method=ctx.print)
+    diff = await get_diff(
+        repo_dir, ctx.input.source, ctx.input.current, log_method=ctx.print
+    )
     result = []
     decorated = []
     if ctx.input.created and diff.created:
@@ -83,16 +85,16 @@ def get_git_diff(ctx: AnyContext):
     group=git_branch_group,
     alias="prune",
 )
-def prune_local_branches(ctx: AnyContext):
-    repo_dir = get_repo_dir()
-    branches = get_branches(repo_dir)
-    current_branch = get_current_branch(repo_dir)
+async def prune_local_branches(ctx: AnyContext):
+    repo_dir = await get_repo_dir(log_method=ctx.print)
+    branches = await get_branches(repo_dir, log_method=ctx.print)
+    current_branch = await get_current_branch(repo_dir, log_method=ctx.print)
     for branch in branches:
         if branch == current_branch or branch == "main" or branch == "master":
             continue
         ctx.print(stylize_yellow(f"Removing local branch: {branch}"))
         try:
-            delete_branch(repo_dir, branch)
+            await delete_branch(repo_dir, branch, log_method=ctx.print)
         except Exception as e:
             ctx.log_error(e)
 
@@ -109,12 +111,12 @@ def prune_local_branches(ctx: AnyContext):
     group=git_group,
     alias="commit",
 )
-def git_commit(ctx: AnyContext):
-    repo_dir = get_repo_dir()
+async def git_commit(ctx: AnyContext):
+    repo_dir = await get_repo_dir(log_method=ctx.print)
     ctx.print("Add changes to staging")
-    add(repo_dir)
+    await add(repo_dir, log_method=ctx.print)
     ctx.print("Commit changes")
-    commit(repo_dir, ctx.input.message)
+    await commit(repo_dir, ctx.input.message, log_method=ctx.print)
 
 
 @make_task(
@@ -130,12 +132,12 @@ def git_commit(ctx: AnyContext):
     group=git_group,
     alias="pull",
 )
-def git_pull(ctx: AnyContext):
-    repo_dir = get_repo_dir()
+async def git_pull(ctx: AnyContext):
+    repo_dir = await get_repo_dir(log_method=ctx.print)
     remote = ctx.input.remote
-    current_branch = get_current_branch(repo_dir)
+    current_branch = await get_current_branch(repo_dir, log_method=ctx.print)
     ctx.print(f"Pulling from {remote}/{current_branch}")
-    pull(repo_dir, remote, current_branch)
+    await pull(repo_dir, remote, current_branch, log_method=ctx.print)
 
 
 @make_task(
@@ -151,9 +153,9 @@ def git_pull(ctx: AnyContext):
     group=git_group,
     alias="push",
 )
-def git_push(ctx: AnyContext):
-    repo_dir = get_repo_dir()
+async def git_push(ctx: AnyContext):
+    repo_dir = await get_repo_dir(log_method=ctx.print)
     remote = ctx.input.remote
-    current_branch = get_current_branch(repo_dir)
+    current_branch = await get_current_branch(repo_dir, log_method=ctx.print)
     ctx.print(f"Pushing to {remote}/{current_branch}")
-    push(repo_dir, remote, current_branch)
+    await push(repo_dir, remote, current_branch, log_method=ctx.print)

{zrb-1.0.0a12 → zrb-1.0.0a15}/src/zrb/builtin/git_subtree.py

@@ -32,14 +32,15 @@ from zrb.util.git_subtree import add_subtree, load_config, pull_subtree, push_su
     group=git_subtree_group,
     alias="add",
 )
-def git_add_subtree(ctx: AnyContext):
-    repo_dir = get_repo_dir()
-    add_subtree(
+async def git_add_subtree(ctx: AnyContext):
+    repo_dir = await get_repo_dir(log_method=ctx.print)
+    await add_subtree(
         repo_dir=repo_dir,
         name=ctx.input.name,
         repo_url=ctx.input["repo-url"],
         branch=ctx.input["repo-branch"],
         prefix=ctx.input["repo-prefix"],
+        log_method=ctx.print,
     )
 
 
@@ -50,8 +51,8 @@ def git_add_subtree(ctx: AnyContext):
     group=git_subtree_group,
     alias="pull",
 )
-def git_pull_subtree(ctx: AnyContext):
-    repo_dir = get_repo_dir()
+async def git_pull_subtree(ctx: AnyContext):
+    repo_dir = await get_repo_dir(log_method=ctx.print)
     config = load_config(repo_dir)
     if not config.data:
         raise ValueError("No subtree config found")
@@ -59,11 +60,12 @@ def git_pull_subtree(ctx: AnyContext):
     for name, detail in config.data.items():
         try:
             ctx.print(f"Pull from subtree {name}")
-            pull_subtree(
+            await pull_subtree(
                 repo_dir=repo_dir,
                 prefix=detail.prefix,
                 repo_url=detail.repo_url,
                 branch=detail.branch,
+                log_method=ctx.print,
             )
         except Exception as e:
             if first_err is None:
@@ -80,8 +82,8 @@ def git_pull_subtree(ctx: AnyContext):
     group=git_subtree_group,
     alias="push",
 )
-def git_push_subtree(ctx: AnyContext):
-    repo_dir = get_repo_dir()
+async def git_push_subtree(ctx: AnyContext):
+    repo_dir = await get_repo_dir(log_method=ctx.print)
     config = load_config(repo_dir)
     if not config.data:
         raise ValueError("No subtree config found")
@@ -89,11 +91,12 @@ def git_push_subtree(ctx: AnyContext):
     for name, detail in config.data.items():
         try:
             ctx.print(f"Push to subtree {name}")
-            push_subtree(
+            await push_subtree(
                 repo_dir=repo_dir,
                 prefix=detail.prefix,
                 repo_url=detail.repo_url,
                 branch=detail.branch,
+                log_method=ctx.print,
             )
         except Exception as e:
             if first_err is None:

{zrb-1.0.0a12 → zrb-1.0.0a15}/src/zrb/builtin/project/add/fastapp.py

@@ -6,7 +6,7 @@ from zrb.input.str_input import StrInput
 from zrb.task.make_task import make_task
 from zrb.task.scaffolder import Scaffolder
 from zrb.task.task import Task
-from zrb.util.string.conversion import double_quote
+from zrb.util.string.conversion import double_quote, to_snake_case
 from zrb.util.string.name import get_random_name
 
 _DIR = os.path.dirname(__file__)
@@ -22,25 +22,21 @@ scaffold_fastapp = Scaffolder(
             default_str=lambda _: os.getcwd(),
         ),
         StrInput(
-            name="app-name",
+            name="app",
             description="App name",
             prompt="App name",
-            default_str=lambda _: get_random_name(separator="_"),
         ),
     ],
     source_path=os.path.join(_DIR, "fastapp_template"),
     render_source_path=False,
-    destination_path=lambda ctx: os.path.join(
-        ctx.input["project-dir"], ctx.input["app-name"]
-    ),
+    destination_path=lambda ctx: os.path.join(ctx.input["project-dir"], ctx.input.app),
     transform_content={
-        "fastapp_template": "{to_snake_case(ctx.input['app-name'])}",
-        "App Name": "{ctx.input['app-name'].title()}",
-        "App name": "{ctx.input['app-name'].capitalize()}",
-        "app-name": "{to_kebab_case(ctx.input['app-name'])}",
-        "app_name": "{to_snake_case(ctx.input['app-name'])}",
-        "APP_NAME": "{to_snake_case(ctx.input['app-name']).upper()}",
-        "secure-password": lambda _: get_random_name(),
+        "fastapp_template": "{to_snake_case(ctx.input.app)}",
+        "My App Name": "{ctx.input.app.title()}",
+        "my-app-name": "{to_kebab_case(ctx.input.app)}",
+        "my_app_name": "{to_snake_case(ctx.input.app)}",
+        "MY_APP_NAME": "{to_snake_case(ctx.input.app).upper()}",
+        "my-secure-password": lambda _: get_random_name(),
     },
     retries=0,
 )
@@ -48,16 +44,34 @@ scaffold_fastapp = Scaffolder(
 
 @make_task(
     name="register-fastapp-automation",
+    retries=0,
 )
 def register_fastapp_automation(ctx: AnyContext):
     project_dir_path = ctx.input["project-dir"]
     zrb_init_path = os.path.join(project_dir_path, "zrb_init.py")
-    app_dir_path = ctx.input["app-name"]
-    app_automation_file_part = ", ".join(
+    app_dir_path = ctx.input.app
+    app_name = to_snake_case(ctx.input.app)
+    with open(zrb_init_path, "r") as f:
+        file_content = f.read().strip()
+    # Assemble new content
+    new_content_list = [file_content]
+    # Check if import load_file is exists, if not exists, add
+    import_load_file_script = "from zrb import load_file"
+    if import_load_file_script not in file_content:
+        new_content_list = [import_load_file_script] + new_content_list
+    # Add fastapp-automation script
+    automation_file_part = ", ".join(
         [double_quote(part) for part in [app_dir_path, "_zrb", "main.py"]]
     )
-    with open(zrb_init_path, "+a") as f:
-        f.write(f"load_file(os.path.join(_DIR, {app_automation_file_part}))\n")
+    new_content_list = new_content_list + [
+        f"{app_name} = load_file(os.path.join(_DIR, {automation_file_part}))",
+        f"assert {app_name}",
+        "",
+    ]
+    new_content = "\n".join(new_content_list)
+    # Write new content
+    with open(zrb_init_path, "w") as f:
+        f.write(new_content)
 
 
 scaffold_fastapp >> register_fastapp_automation
@@ -66,6 +80,7 @@ add_fastapp_to_project = add_to_project_group.add_task(
     Task(
         name="add-fastapp",
         description="🚀 Add FastApp to project",
+        retries=0,
     ),
     alias="fastapp",
 )

zrb-1.0.0a15/src/zrb/builtin/project/add/fastapp_template/_zrb/column/create_column_task.py

@@ -0,0 +1,11 @@
+from fastapp_template._zrb.group import app_create_group
+
+from zrb import Task
+
+create_my_app_name_column = app_create_group.add_task(
+    Task(
+        name="create-my-app-name-column",
+        description="📊 Create new column on an entity",
+    ),
+    alias="column",
+)

{zrb-1.0.0a12 → zrb-1.0.0a15}/src/zrb/builtin/project/add/fastapp_template/_zrb/config.py

@@ -6,12 +6,12 @@ APP_DIR = os.path.dirname(DIR)
 APP_MODULE_NAME = os.path.basename(APP_DIR)
 
 MICROSERVICES_ENV_VARS = {
-    "APP_NAME_MODE": "microservices",
-    "APP_NAME_AUTH_BASE_URL": "http://localhost:3002",
+    "MY_APP_NAME_MODE": "microservices",
+    "MY_APP_NAME_AUTH_BASE_URL": "http://localhost:3002",
 }
-MONOLITH_ENV_VARS = {"APP_NAME_MODE": "monolith"}
+MONOLITH_ENV_VARS = {"MY_APP_NAME_MODE": "monolith"}
 
 if platform.system() == "Windows":
-    ACTIVATE_VENV_SCRIPT = "Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser; . .venv\Scripts\Activate"  # noqa
+    ACTIVATE_VENV_SCRIPT = "Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser; . .venv\\Scripts\\Activate"  # noqa
 else:
     ACTIVATE_VENV_SCRIPT = "source .venv/bin/activate"

zrb-1.0.0a15/src/zrb/builtin/project/add/fastapp_template/_zrb/entity/create_entity_task.py

@@ -0,0 +1,196 @@
+import os
+
+from fastapp_template._zrb.config import APP_DIR
+from fastapp_template._zrb.group import app_create_group
+from fastapp_template._zrb.helper import (
+    get_existing_module_names,
+    get_existing_schema_names,
+)
+from fastapp_template._zrb.input import (
+    existing_module_input,
+    new_entity_column_input,
+    new_entity_input,
+    plural_entity_input,
+)
+
+from zrb import AnyContext, Scaffolder, Task, make_task
+from zrb.util.codemod.add_code_to_module import add_code_to_module
+from zrb.util.codemod.add_parent_to_class import add_parent_to_class
+from zrb.util.string.conversion import to_pascal_case, to_snake_case
+
+
+@make_task(
+    name="validate-create-my-app-name-entity",
+    input=[
+        existing_module_input,
+        new_entity_input,
+        plural_entity_input,
+        new_entity_column_input,
+    ],
+    retries=0,
+)
+async def validate_create_my_app_name_entity(ctx: AnyContext):
+    module_name = to_snake_case(ctx.input.module)
+    if module_name not in get_existing_module_names():
+        raise ValueError(f"Module not exist: {module_name}")
+    schema_name = to_snake_case(ctx.input.entity)
+    if schema_name in get_existing_schema_names():
+        raise ValueError(f"Schema already exists: {schema_name}")
+
+
+scaffold_my_app_name_schema = Scaffolder(
+    name="scaffold-my-app-name-schema",
+    input=[
+        existing_module_input,
+        new_entity_input,
+        new_entity_column_input,
+    ],
+    source_path=os.path.join(os.path.dirname(__file__), "schema.template.py"),
+    render_source_path=False,
+    destination_path=lambda ctx: os.path.join(
+        APP_DIR,
+        "schema",
+        f"{to_snake_case(ctx.input.entity)}.py",
+    ),
+    transform_content={
+        "MyEntity": "{to_pascal_case(ctx.input.entity)}",
+        "my_column": "{to_snake_case(ctx.input.column)}",
+    },
+    retries=0,
+    upstream=validate_create_my_app_name_entity,
+)
+
+scaffold_my_app_name_module_entity = Scaffolder(
+    name="scaffold-my-app-name-schema",
+    input=[
+        existing_module_input,
+        new_entity_input,
+        plural_entity_input,
+    ],
+    source_path=os.path.join(os.path.dirname(__file__), "module_template"),
+    render_source_path=False,
+    destination_path=lambda ctx: os.path.join(
+        APP_DIR,
+        "module",
+        f"{to_snake_case(ctx.input.module)}",
+    ),
+    transform_content={
+        "my_module": "{to_snake_case(ctx.input.module)}",
+        "MyEntity": "{to_pascal_case(ctx.input.entity)}",
+        "my_entity": "{to_snake_case(ctx.input.entity)}",
+        "my_entities": "{to_snake_case(ctx.input.plural)}",
+        "my-entities": "{to_kebab_case(ctx.input.plural)}",
+    },
+    retries=0,
+    upstream=validate_create_my_app_name_entity,
+)
+
+
+@make_task(
+    name="register-my-app-name-migration",
+    input=[existing_module_input, new_entity_input],
+    retries=0,
+    upstream=validate_create_my_app_name_entity,
+)
+async def register_my_app_name_migration(ctx: AnyContext):
+    migration_metadata_file_path = os.path.join(
+        APP_DIR, "module", to_snake_case(ctx.input.module), "migration_metadata.py"
+    )
+    app_name = os.path.basename(APP_DIR)
+    with open(migration_metadata_file_path, "r") as f:
+        file_content = f.read()
+    entity_name = to_snake_case(ctx.input.entity)
+    entity_class = to_pascal_case(ctx.input.entity)
+    new_file_content_list = (
+        [f"from {app_name}.schema.{entity_name} import {entity_class}"]
+        + file_content.strip()
+        + [
+            f"{entity_class}.metadata = metadata",
+            f"{entity_class}.__table__.tometadata(metadata)",
+            "",
+        ]
+    )
+    with open(migration_metadata_file_path, "w") as f:
+        f.write("\n".join(new_file_content_list))
+
+
+@make_task(
+    name="register-my-app-name-api-client",
+    input=[existing_module_input, new_entity_input],
+    retries=0,
+    upstream=validate_create_my_app_name_entity,
+)
+async def register_my_app_name_api_client(ctx: AnyContext):
+    api_client_file_path = os.path.join(
+        APP_DIR, "module", to_snake_case(ctx.input.module), "client", "api_client.py"
+    )
+    with open(api_client_file_path, "r") as f:
+        file_content = f.read()
+    module_config_name = to_snake_case(ctx.input.module).upper()
+    new_code = add_code_to_module(
+        file_content,
+        f"user_api_client = user_usecase.as_api_client(base_url=APP_{module_config_name}_BASE_URL)",  # noqa
+    )
+    new_code = add_parent_to_class(
+        original_code=new_code,
+        class_name="APIClient",
+        parent_class_name="user_api_client",
+    )
+    app_name = os.path.basename(APP_DIR)
+    entity_name = to_snake_case(ctx.input.entity)
+    module_name = to_snake_case(ctx.input.module)
+    new_file_content_list = [
+        f"from {app_name}.module.{module_name}.service.{entity_name} import {entity_name}_usecase",  # noqa
+        new_code.strip(),
+        "",
+    ]
+    with open(api_client_file_path, "w") as f:
+        f.write("\n".join(new_file_content_list))
+
+
+@make_task(
+    name="register-my-app-name-direct-client",
+    input=[existing_module_input, new_entity_input],
+    retries=0,
+    upstream=validate_create_my_app_name_entity,
+)
+async def register_my_app_name_direct_client(ctx: AnyContext):
+    direct_client_file_path = os.path.join(
+        APP_DIR, "module", to_snake_case(ctx.input.module), "client", "direct_client.py"
+    )
+    with open(direct_client_file_path, "r") as f:
+        file_content = f.read()
+    new_code = add_code_to_module(
+        file_content, "user_direct_client = user_usecase.as_direct_client()"
+    )
+    new_code = add_parent_to_class(
+        original_code=new_code,
+        class_name="DirectClient",
+        parent_class_name="user_direct_client",
+    )
+    app_name = os.path.basename(APP_DIR)
+    entity_name = to_snake_case(ctx.input.entity)
+    module_name = to_snake_case(ctx.input.module)
+    new_file_content_list = [
+        f"from {app_name}.module.{module_name}.service.{entity_name} import {entity_name}_usecase",  # noqa
+        new_code.strip(),
+        "",
+    ]
+    with open(direct_client_file_path, "w") as f:
+        f.write("\n".join(new_file_content_list))
+
+
+create_my_app_name_entity = app_create_group.add_task(
+    Task(
+        name="create-my-app-name-entity",
+        description="🏗️ Create new entity on a module",
+        successor="",
+    ),
+    alias="entity",
+)
+create_my_app_name_entity << [
+    scaffold_my_app_name_schema,
+    scaffold_my_app_name_module_entity,
+    register_my_app_name_api_client,
+    register_my_app_name_direct_client,
+]

zrb-1.0.0a15/src/zrb/builtin/project/add/fastapp_template/_zrb/entity/module_template/service/my_entity/my_entity_usecase.py

@@ -0,0 +1,66 @@
+from fastapp_template.common.base_usecase import BaseUsecase
+from fastapp_template.module.my_module.service.my_entity.repository.factory import (
+    my_entity_repository,
+)
+from fastapp_template.module.my_module.service.my_entity.repository.repository import (
+    MyEntityRepository,
+)
+from fastapp_template.schema.my_entity import (
+    MyEntityCreate,
+    MyEntityResponse,
+    MyEntityUpdate,
+)
+
+
+class MyEntityUsecase(BaseUsecase):
+
+    def __init__(self, my_entity_repository: MyEntityRepository):
+        super().__init__()
+        self.my_entity_repository = my_entity_repository
+
+    @BaseUsecase.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)
+
+    @BaseUsecase.route(
+        "/api/v1/my-entities", methods=["get"], response_model=list[MyEntityResponse]
+    )
+    async def get_all_my_entities(self) -> list[MyEntityResponse]:
+        return await self.my_entity_repository.get_all()
+
+    @BaseUsecase.route(
+        "/api/v1/my-entities",
+        methods=["post"],
+        response_model=MyEntityResponse | list[MyEntityResponse],
+    )
+    async def create_my_entity(
+        self, data: MyEntityCreate | list[MyEntityCreate]
+    ) -> MyEntityResponse | list[MyEntityResponse]:
+        if isinstance(data, MyEntityCreate):
+            return await self.my_entity_repository.create(data)
+        return await self.my_entity_repository.create_bulk(data)
+
+    @BaseUsecase.route(
+        "/api/v1/my-entities/{my_entity_id}",
+        methods=["put"],
+        response_model=MyEntityResponse,
+    )
+    async def update_my_entity(
+        self, my_entity_id: str, data: MyEntityUpdate
+    ) -> MyEntityResponse:
+        return await self.my_entity_repository.update(my_entity_id, data)
+
+    @BaseUsecase.route(
+        "/api/v1/my-entities/{my_entity_id}",
+        methods=["delete"],
+        response_model=MyEntityResponse,
+    )
+    async def delete_my_entity(self, my_entity_id: str) -> MyEntityResponse:
+        return await self.my_entity_repository.delete(my_entity_id)
+
+
+my_entity_usecase = MyEntityUsecase(my_entity_repository=my_entity_repository)

zrb-1.0.0a15/src/zrb/builtin/project/add/fastapp_template/_zrb/entity/module_template/service/my_entity/repository/factory.py

@@ -0,0 +1,13 @@
+from fastapp_template.common.db_engine import engine
+from fastapp_template.config import APP_REPOSITORY_TYPE
+from fastapp_template.module.my_module.service.my_entity.repository.my_entity_db_repository import (
+    MyEntityDBRepository,
+)
+from fastapp_template.module.my_module.service.my_entity.repository.my_entity_repository import (
+    MyEntityRepository,
+)
+
+if APP_REPOSITORY_TYPE == "db":
+    my_entity_repository: MyEntityRepository = MyEntityDBRepository(engine)
+else:
+    my_entity_repository: MyEntityRepository = None

zrb-1.0.0a15/src/zrb/builtin/project/add/fastapp_template/_zrb/entity/module_template/service/my_entity/repository/my_entity_db_repository.py

@@ -0,0 +1,33 @@
+from fastapp_template.common.base_db_repository import BaseDBRepository
+from fastapp_template.common.error import NotFoundError
+from fastapp_template.module.my_module.service.my_entity.repository.my_entity_repository import (
+    MyEntityRepository,
+)
+from fastapp_template.schema.my_entity import (
+    MyEntity,
+    MyEntityCreate,
+    MyEntityResponse,
+    MyEntityUpdate,
+)
+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(
+    BaseDBRepository[MyEntity, MyEntityResponse, MyEntityCreate, MyEntityUpdate],
+    MyEntityRepository,
+):
+    db_model = MyEntity
+    response_model = MyEntityResponse
+    create_model = MyEntityCreate
+    update_model = MyEntityUpdate
+    entity_name = "my_entity"
+    column_preprocessors = {}

zrb-1.0.0a15/src/zrb/builtin/project/add/fastapp_template/_zrb/entity/module_template/service/my_entity/repository/my_entity_repository.py

@@ -0,0 +1,39 @@
+from abc import ABC, abstractmethod
+
+from fastapp_template.schema.my_entity import (
+    MyEntity,
+    MyEntityCreate,
+    MyEntityResponse,
+    MyEntityUpdate,
+)
+
+
+class MyEntityRepository(ABC):
+
+    @abstractmethod
+    async def create(self, my_entity_data: MyEntityCreate) -> MyEntityResponse:
+        pass
+
+    @abstractmethod
+    async def get_by_id(self, my_entity_id: str) -> MyEntity:
+        pass
+
+    @abstractmethod
+    async def get_all(self) -> list[MyEntity]:
+        pass
+
+    @abstractmethod
+    async def update(
+        self, my_entity_id: str, my_entity_data: MyEntityUpdate
+    ) -> MyEntity:
+        pass
+
+    @abstractmethod
+    async def delete(self, my_entity_id: str) -> MyEntity:
+        pass
+
+    @abstractmethod
+    async def create_bulk(
+        self, my_entity_data_list: list[MyEntityCreate]
+    ) -> list[MyEntityResponse]:
+        pass

zrb-1.0.0a15/src/zrb/builtin/project/add/fastapp_template/_zrb/entity/schema.template.py

@@ -0,0 +1,29 @@
+import datetime
+
+import ulid
+from sqlmodel import Field, SQLModel
+
+
+class MyEntityBase(SQLModel):
+    my_column: str
+
+
+class MyEntityCreate(MyEntityBase):
+    pass
+
+
+class MyEntityUpdate(SQLModel):
+    my_column: str | None = None
+
+
+class MyEntityResponse(MyEntityBase):
+    id: str
+
+
+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