zrb 0.9.2__py3-none-any.whl → 0.15.0__py3-none-any.whl

zrb/builtin/project/add/fastapp/crud/template/src/kebab-zrb-app-name/src/module/snake_zrb_module_name/entity/snake_zrb_entity_name/api.py

@@ -0,0 +1,167 @@
+from logging import Logger
+
+from component.error import HTTPAPIException
+from component.messagebus import Publisher
+from component.rpc import Caller
+from fastapi import Depends, FastAPI
+from module.auth.component import Authorizer
+from module.auth.integration import access_token_scheme
+from module.auth.schema.token import AccessTokenData
+from module.snake_zrb_module_name.schema.snake_zrb_entity_name import (
+    PascalZrbEntityName,
+    PascalZrbEntityNameData,
+    PascalZrbEntityNameResult,
+)
+from opentelemetry import trace
+
+tracer = trace.get_tracer(__name__)
+
+
+def register_api(
+    logger: Logger,
+    app: FastAPI,
+    authorizer: Authorizer,
+    rpc_caller: Caller,
+    publisher: Publisher,
+):
+    logger.info('🥪 Register API for "snake_zrb_module_name.snake_zrb_entity_name"')
+
+    @app.get(
+        "/api/v1/kebab-zrb-module-name/kebab-zrb-plural-entity-name",
+        response_model=PascalZrbEntityNameResult,
+    )
+    async def get_snake_zrb_entity_names(
+        keyword: str = "",
+        limit: int = 100,
+        offset: int = 0,
+        user_token_data: AccessTokenData = Depends(access_token_scheme),
+    ):
+        with tracer.start_as_current_span("authorizer.is_having_permission"):
+            if not await authorizer.is_having_permission(
+                user_token_data.user_id,
+                "snake_zrb_module_name:snake_zrb_entity_name:get",
+            ):
+                raise HTTPAPIException(403, "Unauthorized")
+        try:
+            with tracer.start_as_current_span(
+                "snake_zrb_module_name.rpc.snake_zrb_module_name_get_snake_zrb_entity_name"  # noqa
+            ):
+                result_dict = await rpc_caller.call(
+                    "snake_zrb_module_name_get_snake_zrb_entity_name",
+                    keyword=keyword,
+                    criterion={},
+                    limit=limit,
+                    offset=offset,
+                    user_token_data=user_token_data.model_dump(),
+                )
+                return PascalZrbEntityNameResult(**result_dict)
+        except Exception as e:
+            raise HTTPAPIException(error=e)
+
+    @app.get(
+        "/api/v1/kebab-zrb-module-name/kebab-zrb-plural-entity-name/{id}",
+        response_model=PascalZrbEntityName,
+    )
+    async def get_snake_zrb_entity_name_by_id(
+        id: str, user_token_data: AccessTokenData = Depends(access_token_scheme)
+    ):
+        with tracer.start_as_current_span("authorizer.is_having_permission"):
+            if not await authorizer.is_having_permission(
+                user_token_data.user_id,
+                "snake_zrb_module_name:snake_zrb_entity_name:get_by_id",
+            ):
+                raise HTTPAPIException(403, "Unauthorized")
+        try:
+            with tracer.start_as_current_span(
+                "snake_zrb_module_name.rpc.snake_zrb_module_name_get_snake_zrb_entity_name_by_id"  # noqa
+            ):
+                result_dict = await rpc_caller.call(
+                    "snake_zrb_module_name_get_snake_zrb_entity_name_by_id",
+                    id=id,
+                    user_token_data=user_token_data.model_dump(),
+                )
+                return PascalZrbEntityName(**result_dict)
+        except Exception as e:
+            raise HTTPAPIException(error=e)
+
+    @app.post(
+        "/api/v1/kebab-zrb-module-name/kebab-zrb-plural-entity-name",
+        response_model=PascalZrbEntityName,
+    )
+    async def insert_snake_zrb_entity_name(
+        data: PascalZrbEntityNameData,
+        user_token_data: AccessTokenData = Depends(access_token_scheme),
+    ):
+        with tracer.start_as_current_span("authorizer.is_having_permission"):
+            if not await authorizer.is_having_permission(
+                user_token_data.user_id,
+                "snake_zrb_module_name:snake_zrb_entity_name:insert",
+            ):
+                raise HTTPAPIException(403, "Unauthorized")
+        try:
+            with tracer.start_as_current_span(
+                "snake_zrb_module_name.rpc.snake_zrb_module_name_insert_snake_zrb_entity_name"  # noqa
+            ):
+                result_dict = await rpc_caller.call(
+                    "snake_zrb_module_name_insert_snake_zrb_entity_name",
+                    data=data.model_dump(),
+                    user_token_data=user_token_data.model_dump(),
+                )
+                return PascalZrbEntityName(**result_dict)
+        except Exception as e:
+            raise HTTPAPIException(error=e)
+
+    @app.put(
+        "/api/v1/kebab-zrb-module-name/kebab-zrb-plural-entity-name/{id}",
+        response_model=PascalZrbEntityName,
+    )
+    async def update_snake_zrb_entity_name(
+        id: str,
+        data: PascalZrbEntityNameData,
+        user_token_data: AccessTokenData = Depends(access_token_scheme),
+    ):
+        with tracer.start_as_current_span("authorizer.is_having_permission"):
+            if not await authorizer.is_having_permission(
+                user_token_data.user_id,
+                "snake_zrb_module_name:snake_zrb_entity_name:update",
+            ):
+                raise HTTPAPIException(403, "Unauthorized")
+        try:
+            with tracer.start_as_current_span(
+                "snake_zrb_module_name.rpc.snake_zrb_module_name_update_snake_zrb_entity_name"  # noqa
+            ):
+                result_dict = await rpc_caller.call(
+                    "snake_zrb_module_name_update_snake_zrb_entity_name",
+                    id=id,
+                    data=data.model_dump(),
+                    user_token_data=user_token_data.model_dump(),
+                )
+                return PascalZrbEntityName(**result_dict)
+        except Exception as e:
+            raise HTTPAPIException(error=e)
+
+    @app.delete(
+        "/api/v1/kebab-zrb-module-name/kebab-zrb-plural-entity-name/{id}",
+        response_model=PascalZrbEntityName,
+    )
+    async def delete_snake_zrb_entity_name(
+        id: str, user_token_data: AccessTokenData = Depends(access_token_scheme)
+    ):
+        with tracer.start_as_current_span("authorizer.is_having_permission"):
+            if not await authorizer.is_having_permission(
+                user_token_data.user_id,
+                "snake_zrb_module_name:snake_zrb_entity_name:delete",
+            ):
+                raise HTTPAPIException(403, "Unauthorized")
+        try:
+            with tracer.start_as_current_span(
+                "snake_zrb_module_name.rpc.snake_zrb_module_name_delete_snake_zrb_entity_name"  # noqa
+            ):
+                result_dict = await rpc_caller.call(
+                    "snake_zrb_module_name_delete_snake_zrb_entity_name",
+                    id=id,
+                    user_token_data=user_token_data.model_dump(),
+                )
+                return PascalZrbEntityName(**result_dict)
+        except Exception as e:
+            raise HTTPAPIException(error=e)

zrb/builtin/project/add/fastapp/crud/template/src/kebab-zrb-app-name/src/module/snake_zrb_module_name/schema/snake_zrb_entity_name.py

@@ -0,0 +1,18 @@
+from typing import List, Optional
+
+from component.schema import BaseCountSchema, BaseDateTimeSchema
+
+
+class PascalZrbEntityNameData(BaseDateTimeSchema):
+    snake_zrb_column_name: str
+
+
+class PascalZrbEntityName(PascalZrbEntityNameData):
+    id: str
+
+    class Config:
+        from_attributes = True
+
+
+class PascalZrbEntityNameResult(BaseCountSchema):
+    data: List[PascalZrbEntityName]

zrb/builtin/project/add/fastapp/field/__init__.py

@@ -0,0 +1,3 @@
+from zrb.builtin.project.add.fastapp.field.field import add_fastapp_field
+
+assert add_fastapp_field

zrb/builtin/project/add/fastapp/field/_helper.py

@@ -0,0 +1,342 @@
+import os
+import re
+
+from zrb.helper.codemod.add_key_value_to_dict import add_key_value_to_dict
+from zrb.helper.codemod.add_property_to_class import add_property_to_class
+from zrb.helper.file.text import read_text_file_async, write_text_file_async
+from zrb.helper.typecheck import typechecked
+from zrb.task.task import Task
+
+
+@typechecked
+async def add_column_to_insert_page(
+    task: Task,
+    project_dir: str,
+    kebab_app_name: str,
+    kebab_module_name: str,
+    kebab_entity_name: str,
+    kebab_column_name: str,
+    snake_column_name: str,
+    capitalized_human_readable_column_name: str,
+):
+    list_page_file_path = os.path.join(
+        project_dir,
+        "src",
+        kebab_app_name,
+        "src",
+        "frontend",
+        "src",
+        "routes",
+        kebab_module_name,
+        kebab_entity_name,
+        "new",
+        "+page.svelte",
+    )
+    task.print_out(f"Read HTML from: {list_page_file_path}")
+    html_content = await read_text_file_async(list_page_file_path)
+    task.print_out("Add default value to insert page")
+    default_value_regex = r"(.*)(// DON'T DELETE: set field default value here)"  # noqa
+    default_value_subst = "\\n".join([f"\\1row.{snake_column_name} = '';", "\\1\\2"])
+    html_content = re.sub(
+        default_value_regex, default_value_subst, html_content, 0, re.MULTILINE
+    )
+    task.print_out("Add field to insert page")
+    field_regex = r"(.*)(<!-- DON'T DELETE: insert new field here-->)"
+    field_subst = "\\n".join(
+        [
+            '\\1<div class="mb-4">',
+            f'\\1    <label class="block text-gray-700 font-bold mb-2" for="{kebab_column_name}">{capitalized_human_readable_column_name}</label>',  # noqa
+            f'\\1    <input type="text" class="input w-full" id="{kebab_column_name}" placeholder="{capitalized_human_readable_column_name}" bind:value='
+            + "{row."
+            + snake_column_name
+            + "} />",  # noqa
+            "\\1</div>",
+            "\\1\\2",
+        ]
+    )
+    html_content = re.sub(field_regex, field_subst, html_content, 0, re.MULTILINE)
+    task.print_out(f"Write modified HTML to: {list_page_file_path}")
+    await write_text_file_async(list_page_file_path, html_content)
+
+
+@typechecked
+async def add_column_to_update_page(
+    task: Task,
+    project_dir: str,
+    kebab_app_name: str,
+    kebab_module_name: str,
+    kebab_entity_name: str,
+    kebab_column_name: str,
+    snake_column_name: str,
+    capitalized_human_readable_column_name: str,
+):
+    list_page_file_path = os.path.join(
+        project_dir,
+        "src",
+        kebab_app_name,
+        "src",
+        "frontend",
+        "src",
+        "routes",
+        kebab_module_name,
+        kebab_entity_name,
+        "update",
+        "[id]",
+        "+page.svelte",
+    )
+    task.print_out(f"Read HTML from: {list_page_file_path}")
+    html_content = await read_text_file_async(list_page_file_path)
+    task.print_out("Add field to update page")
+    regex = r"(.*)(<!-- DON'T DELETE: insert new field here-->)"
+    subst = "\\n".join(
+        [
+            '\\1<div class="mb-4">',
+            f'\\1    <label class="block text-gray-700 font-bold mb-2" for="{kebab_column_name}">{capitalized_human_readable_column_name}</label>',  # noqa
+            f'\\1    <input type="text" class="input w-full" id="{kebab_column_name}" placeholder="{capitalized_human_readable_column_name}" bind:value='
+            + "{row."
+            + snake_column_name
+            + "} />",  # noqa
+            "\\1</div>",
+            "\\1\\2",
+        ]
+    )
+    html_content = re.sub(regex, subst, html_content, 0, re.MULTILINE)
+    task.print_out(f"Write modified HTML to: {list_page_file_path}")
+    await write_text_file_async(list_page_file_path, html_content)
+
+
+@typechecked
+async def add_column_to_delete_page(
+    task: Task,
+    project_dir: str,
+    kebab_app_name: str,
+    kebab_module_name: str,
+    kebab_entity_name: str,
+    kebab_column_name: str,
+    snake_column_name: str,
+    capitalized_human_readable_column_name: str,
+):
+    list_page_file_path = os.path.join(
+        project_dir,
+        "src",
+        kebab_app_name,
+        "src",
+        "frontend",
+        "src",
+        "routes",
+        kebab_module_name,
+        kebab_entity_name,
+        "delete",
+        "[id]",
+        "+page.svelte",
+    )
+    task.print_out(f"Read HTML from: {list_page_file_path}")
+    html_content = await read_text_file_async(list_page_file_path)
+    task.print_out("Add field to delete page")
+    regex = r"(.*)(<!-- DON'T DELETE: insert new field here-->)"
+    subst = "\\n".join(
+        [
+            '\\1<div class="mb-4">',
+            f'\\1    <label class="block text-gray-700 font-bold mb-2" for="{kebab_column_name}">{capitalized_human_readable_column_name}</label>',  # noqa
+            f'\\1    <span id="{kebab_column_name}">'
+            + "{row."
+            + snake_column_name
+            + "}</span>",  # noqa
+            "\\1</div>",
+            "\\1\\2",
+        ]
+    )
+    html_content = re.sub(regex, subst, html_content, 0, re.MULTILINE)
+    task.print_out(f"Write modified HTML to: {list_page_file_path}")
+    await write_text_file_async(list_page_file_path, html_content)
+
+
+@typechecked
+async def add_column_to_detail_page(
+    task: Task,
+    project_dir: str,
+    kebab_app_name: str,
+    kebab_module_name: str,
+    kebab_entity_name: str,
+    kebab_column_name: str,
+    snake_column_name: str,
+    capitalized_human_readable_column_name: str,
+):
+    list_page_file_path = os.path.join(
+        project_dir,
+        "src",
+        kebab_app_name,
+        "src",
+        "frontend",
+        "src",
+        "routes",
+        kebab_module_name,
+        kebab_entity_name,
+        "detail",
+        "[id]",
+        "+page.svelte",
+    )
+    task.print_out(f"Read HTML from: {list_page_file_path}")
+    html_content = await read_text_file_async(list_page_file_path)
+    task.print_out("Add field to detail page")
+    regex = r"(.*)(<!-- DON'T DELETE: insert new field here-->)"
+    subst = "\\n".join(
+        [
+            '\\1<div class="mb-4">',
+            f'\\1    <label class="block text-gray-700 font-bold mb-2" for="{kebab_column_name}">{capitalized_human_readable_column_name}</label>',  # noqa
+            f'\\1    <span id="{kebab_column_name}">'
+            + "{row."
+            + snake_column_name
+            + "}</span>",  # noqa
+            "\\1</div>",
+            "\\1\\2",
+        ]
+    )
+    html_content = re.sub(regex, subst, html_content, 0, re.MULTILINE)
+    task.print_out(f"Write modified HTML to: {list_page_file_path}")
+    await write_text_file_async(list_page_file_path, html_content)
+
+
+@typechecked
+async def add_column_to_list_page(
+    task: Task,
+    project_dir: str,
+    kebab_app_name: str,
+    kebab_module_name: str,
+    kebab_entity_name: str,
+    snake_column_name: str,
+    capitalized_human_readable_column_name: str,
+):
+    list_page_file_path = os.path.join(
+        project_dir,
+        "src",
+        kebab_app_name,
+        "src",
+        "frontend",
+        "src",
+        "routes",
+        kebab_module_name,
+        kebab_entity_name,
+        "+page.svelte",
+    )
+    task.print_out(f"Read HTML from: {list_page_file_path}")
+    html_content = await read_text_file_async(list_page_file_path)
+    # process header
+    task.print_out("Add column header to table")
+    header_regex = r"(.*)(<!-- DON'T DELETE: insert new column header here-->)"
+    header_subst = "\\n".join(
+        [f"\\1<th>{capitalized_human_readable_column_name}</th>", "\\1\\2"]
+    )
+    html_content = re.sub(header_regex, header_subst, html_content, 0, re.MULTILINE)
+    # process column
+    task.print_out("Add column to table")
+    column_regex = r"(.*)(<!-- DON'T DELETE: insert new column here-->)"
+    column_subst = "\\n".join(["\\1<td>{row." + snake_column_name + "}</td>", "\\1\\2"])
+    html_content = re.sub(column_regex, column_subst, html_content, 0, re.MULTILINE)
+    task.print_out(f"Write modified HTML to: {list_page_file_path}")
+    await write_text_file_async(list_page_file_path, html_content)
+
+
+@typechecked
+async def add_column_to_test(
+    task: Task,
+    project_dir: str,
+    kebab_app_name: str,
+    snake_module_name: str,
+    snake_entity_name: str,
+    snake_column_name: str,
+    column_type: str,
+):
+    test_file_path = os.path.join(
+        project_dir,
+        "src",
+        kebab_app_name,
+        "test",
+        snake_module_name,
+        f"test_{snake_entity_name}.py",
+    )
+    task.print_out(f"Read code from: {test_file_path}")
+    code = await read_text_file_async(test_file_path)
+    task.print_out(f'Add column "{snake_column_name}" to the test')
+    dict_names = [
+        "inserted_success_data",
+        "to_be_updated_success_data",
+        "updated_success_data",
+        "to_be_deleted_success_data",
+    ]
+    for dict_name in dict_names:
+        code = add_key_value_to_dict(
+            code=code, dict_name=dict_name, key=f"'{snake_column_name}'", value="''"
+        )
+    task.print_out(f"Write modified code to: {test_file_path}")
+    await write_text_file_async(test_file_path, code)
+
+
+@typechecked
+async def add_column_to_schema(
+    task: Task,
+    project_dir: str,
+    kebab_app_name: str,
+    snake_module_name: str,
+    snake_entity_name: str,
+    pascal_entity_name: str,
+    snake_column_name: str,
+    column_type: str,
+):
+    schema_file_path = os.path.join(
+        project_dir,
+        "src",
+        kebab_app_name,
+        "src",
+        "module",
+        snake_module_name,
+        "schema",
+        f"{snake_entity_name}.py",
+    )
+    task.print_out(f"Read code from: {schema_file_path}")
+    code = await read_text_file_async(schema_file_path)
+    task.print_out(f'Add column "{snake_column_name}" to the schema')
+    code = add_property_to_class(
+        code=code,
+        class_name=f"{pascal_entity_name}Data",
+        property_name=snake_column_name,
+        property_type="Optional[str]",
+    )
+    task.print_out(f"Write modified code to: {schema_file_path}")
+    await write_text_file_async(schema_file_path, code)
+
+
+@typechecked
+async def add_column_to_repo(
+    task: Task,
+    project_dir: str,
+    kebab_app_name: str,
+    snake_module_name: str,
+    snake_entity_name: str,
+    pascal_entity_name: str,
+    snake_column_name: str,
+    column_type: str,
+):
+    repo_file_path = os.path.join(
+        project_dir,
+        "src",
+        kebab_app_name,
+        "src",
+        "module",
+        snake_module_name,
+        "entity",
+        snake_entity_name,
+        "repo.py",
+    )
+    task.print_out(f"Read code from: {repo_file_path}")
+    code = await read_text_file_async(repo_file_path)
+    task.print_out(f'Add column "{snake_column_name}" to the repo')
+    code = add_property_to_class(
+        code=code,
+        class_name=f"DBEntity{pascal_entity_name}",
+        property_name=snake_column_name,
+        property_type="Column",
+        property_value="Column(String)",
+    )
+    task.print_out(f"Write modified code to: {repo_file_path}")
+    await write_text_file_async(repo_file_path, code)

zrb/builtin/project/add/fastapp/field/_input.py

@@ -0,0 +1,17 @@
+from zrb.task_input.str_input import StrInput
+
+column_name_input = StrInput(
+    name="column-name",
+    shortcut="c",
+    description="Column name",
+    prompt="Column name",
+    default="title",
+)
+
+column_type_input = StrInput(
+    name="column-type",
+    shortcut="t",
+    description="Column type",
+    prompt="Column type",
+    default="str",
+)