zrb 1.0.0b10__py3-none-any.whl → 1.1.0__py3-none-any.whl

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/_zrb/column/add_column_task.py

@@ -1,93 +1,137 @@
 import os
 
+from my_app_name._zrb.column.add_column_util import (
+    update_fastapp_schema,
+    update_fastapp_test_create,
+    update_fastapp_test_delete,
+    update_fastapp_test_read,
+    update_fastapp_test_update,
+    update_fastapp_ui,
+)
 from my_app_name._zrb.config import APP_DIR
 from my_app_name._zrb.format_task import format_my_app_name_code
 from my_app_name._zrb.group import app_create_group
 from my_app_name._zrb.input import (
     existing_entity_input,
+    existing_module_input,
     new_column_input,
     new_column_type_input,
 )
-from my_app_name._zrb.util import get_existing_schema_names
+from my_app_name._zrb.util import get_existing_module_names, get_existing_schema_names
 
 from zrb import AnyContext, Task, make_task
-from zrb.util.codemod.modify_class_property import append_property_to_class
-from zrb.util.file import read_file, write_file
-from zrb.util.string.conversion import to_pascal_case, to_snake_case
 
 
 @make_task(
-    name="validate-add-my-app-name-column",
-    input=existing_entity_input,
+    name="validate-add-fastapp-column",
+    input=[
+        existing_module_input,
+        existing_entity_input,
+    ],
     retries=0,
 )
-async def validate_add_my_app_name_column(ctx: AnyContext):
+async def validate_add_fastapp_column(ctx: AnyContext):
+    module_name = ctx.input.module
+    if module_name not in get_existing_module_names():
+        raise ValueError(f"Module not exist: {module_name}")
     schema_name = ctx.input.entity
     if schema_name not in get_existing_schema_names():
         raise ValueError(f"Schema not exist: {schema_name}")
 
 
-@make_task(
-    name="update-my-app-name-schema",
+update_fastapp_schema_task = Task(
+    name="update-fastapp-schema",
+    input=[
+        existing_module_input,
+        existing_entity_input,
+        new_column_input,
+        new_column_type_input,
+    ],
+    action=update_fastapp_schema,
+    retries=0,
+    upstream=validate_add_fastapp_column,
+)
+
+update_fastapp_ui_task = Task(
+    name="update-fastapp-ui",
     input=[
+        existing_module_input,
         existing_entity_input,
         new_column_input,
         new_column_type_input,
     ],
+    action=update_fastapp_ui,
     retries=0,
-    upstream=validate_add_my_app_name_column,
+    upstream=validate_add_fastapp_column,
 )
-def update_my_app_name_schema(ctx: AnyContext):
-    snake_entity_name = to_snake_case(ctx.input.entity)
-    pascal_entity_name = to_pascal_case(ctx.input.entity)
-    schema_file_path = os.path.join(APP_DIR, "schema", f"{snake_entity_name}.py")
-    existing_code = read_file(schema_file_path)
-    snake_column_name = to_snake_case(ctx.input.column)
-    column_type = ctx.input.type
-    # Base
-    new_code = append_property_to_class(
-        original_code=existing_code,
-        class_name=f"{pascal_entity_name}Base",
-        property_name=snake_column_name,
-        annotation=column_type,
-        default_value=_get_default_value(column_type),
-    )
-    # Update
-    new_code = append_property_to_class(
-        original_code=new_code,
-        class_name=f"{pascal_entity_name}Update",
-        property_name=snake_column_name,
-        annotation=f"{column_type} | None",
-        default_value="None",
-    )
-    # Table
-    new_code = append_property_to_class(
-        original_code=new_code,
-        class_name=f"{pascal_entity_name}",
-        property_name=snake_column_name,
-        annotation=f"{column_type} | None",
-        default_value="Field(index=False)",
-    )
-    write_file(schema_file_path, new_code)
 
+update_fastapp_test_create_task = Task(
+    name="update-fastapp-test-create",
+    input=[
+        existing_module_input,
+        existing_entity_input,
+        new_column_input,
+        new_column_type_input,
+    ],
+    action=update_fastapp_test_create,
+    retries=0,
+    upstream=validate_add_fastapp_column,
+)
 
-add_my_app_name_column = app_create_group.add_task(
+update_fastapp_test_read_task = Task(
+    name="update-fastapp-test-read",
+    input=[
+        existing_module_input,
+        existing_entity_input,
+        new_column_input,
+        new_column_type_input,
+    ],
+    action=update_fastapp_test_read,
+    retries=0,
+    upstream=validate_add_fastapp_column,
+)
+
+update_fastapp_test_update_task = Task(
+    name="update-fastapp-test-update",
+    input=[
+        existing_module_input,
+        existing_entity_input,
+        new_column_input,
+        new_column_type_input,
+    ],
+    action=update_fastapp_test_update,
+    retries=0,
+    upstream=validate_add_fastapp_column,
+)
+
+update_fastapp_test_delete_task = Task(
+    name="update-fastapp-test-delete",
+    input=[
+        existing_module_input,
+        existing_entity_input,
+        new_column_input,
+        new_column_type_input,
+    ],
+    action=update_fastapp_test_delete,
+    retries=0,
+    upstream=validate_add_fastapp_column,
+)
+
+
+add_fastapp_column = app_create_group.add_task(
     Task(
-        name="add-my-app-name-column",
+        name="add-fastapp-column",
         description="📊 Create new column on an entity",
-        upstream=update_my_app_name_schema,
+        upstream=[
+            update_fastapp_schema_task,
+            update_fastapp_ui_task,
+            update_fastapp_test_create_task,
+            update_fastapp_test_read_task,
+            update_fastapp_test_update_task,
+            update_fastapp_test_delete_task,
+        ],
         successor=format_my_app_name_code,
         retries=0,
     ),
     alias="column",
 )
-
-
-def _get_default_value(data_type: str) -> str:
-    if data_type == "str":
-        return '""'
-    if data_type in ("int", "float"):
-        return "0"
-    if data_type == "bool":
-        return "True"
-    return "None"

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/_zrb/column/add_column_util.py

@@ -0,0 +1,301 @@
+import os
+import re
+import textwrap
+
+from bs4 import BeautifulSoup, formatter
+from my_app_name._zrb.config import APP_DIR
+
+from zrb.context.any_context import AnyContext
+from zrb.util.codemod.modify_class import append_code_to_class
+from zrb.util.codemod.modify_class_parent import prepend_parent_class
+from zrb.util.codemod.modify_class_property import append_property_to_class
+from zrb.util.codemod.modify_function import append_code_to_function
+from zrb.util.codemod.modify_module import prepend_code_to_module
+from zrb.util.file import read_file, write_file
+from zrb.util.string.conversion import (
+    to_human_case,
+    to_kebab_case,
+    to_pascal_case,
+    to_snake_case,
+)
+
+
+def update_fastapp_schema(ctx: AnyContext):
+    snake_entity_name = to_snake_case(ctx.input.entity)
+    pascal_entity_name = to_pascal_case(ctx.input.entity)
+    snake_column_name = to_snake_case(ctx.input.column)
+    column_type = ctx.input.type
+    schema_file_path = os.path.join(APP_DIR, "schema", f"{snake_entity_name}.py")
+    existing_code = read_file(schema_file_path)
+    # Base
+    new_code = append_property_to_class(
+        original_code=existing_code,
+        class_name=f"{pascal_entity_name}Base",
+        property_name=snake_column_name,
+        annotation=column_type,
+        default_value=_get_default_column_value(column_type),
+    )
+    # Update
+    new_code = append_property_to_class(
+        original_code=new_code,
+        class_name=f"{pascal_entity_name}Update",
+        property_name=snake_column_name,
+        annotation=f"{column_type} | None",
+        default_value="None",
+    )
+    # Table
+    new_code = append_property_to_class(
+        original_code=new_code,
+        class_name=f"{pascal_entity_name}",
+        property_name=snake_column_name,
+        annotation=f"{column_type} | None",
+        default_value="Field(index=False)",
+    )
+    write_file(schema_file_path, new_code)
+
+
+def _get_default_column_value(data_type: str) -> str:
+    if data_type == "str":
+        return '""'
+    if data_type in ("int", "float"):
+        return "0"
+    if data_type == "bool":
+        return "True"
+    return "None"
+
+
+def update_fastapp_ui(ctx: AnyContext):
+    kebab_module_name = to_kebab_case(ctx.input.module)
+    kebab_entity_name = to_kebab_case(ctx.input.entity)
+    snake_column_name = to_snake_case(ctx.input.column)
+    human_column_name = to_human_case(ctx.input.column).title()
+    subroute_file_path = os.path.join(
+        APP_DIR,
+        "module",
+        "gateway",
+        "view",
+        "content",
+        kebab_module_name,
+        f"{kebab_entity_name}.html",
+    )
+    existing_code = read_file(subroute_file_path)
+    # Add table header
+    new_code = _add_th_before_last(
+        existing_code, table_id="crud-table", th_content=human_column_name
+    )
+    # Forms
+    new_code = _add_input_to_form(
+        new_code,
+        form_id="crud-create-form",
+        column_label=human_column_name,
+        column_name=snake_column_name,
+    )
+    new_code = _add_input_to_form(
+        new_code,
+        form_id="crud-update-form",
+        column_label=human_column_name,
+        column_name=snake_column_name,
+    )
+    new_code = _add_input_to_form(
+        new_code,
+        form_id="crud-delete-form",
+        column_label=human_column_name,
+        column_name=snake_column_name,
+    )
+    # JS Function
+    new_code = _alter_js_function_returned_array(
+        new_code,
+        js_function_name="getRowComponents",
+        js_array_name="rowComponents",
+        js_new_value=f"`<td>${{row.{snake_column_name}}}</td>`",
+    )
+    write_file(subroute_file_path, new_code)
+
+
+def _add_th_before_last(html_str, table_id, th_content):
+    # Use the html.parser; you might try html5lib if you find that it preserves formatting better.
+    soup = BeautifulSoup(html_str, "html.parser")
+    # Locate the table with the specified id
+    table = soup.find("table", id=table_id)
+    if not table:
+        # Table not found; return original HTML unchanged.
+        return html_str
+    # Find the thead element in the table.
+    thead = table.find("thead")
+    if not thead:
+        return html_str
+    # For this example, we assume there's a single row (<tr>) in the thead.
+    row = thead.find("tr")
+    if not row:
+        return html_str
+    # Find all existing th elements in the row.
+    th_elements = row.find_all("th")
+    if not th_elements:
+        return html_str
+    # Create a new th element and set its content.
+    new_th = soup.new_tag("th")
+    new_th.string = th_content
+    # Insert the new th right before the last existing th.
+    th_elements[-1].insert_before(new_th)
+    # Return the modified HTML as a string.
+    return soup.prettify(
+        formatter=formatter.HTMLFormatter(indent=_infer_html_indent_width(html_str))
+    )
+
+
+def _add_input_to_form(
+    html_str: str, form_id: str, column_label: str, column_name: str
+) -> str:
+    soup = BeautifulSoup(html_str, "html.parser")
+    # Find the form by id.
+    form = soup.find("form", id=form_id)
+    if not form:
+        return html_str  # Return unchanged if no matching form is found.
+    # Create a new label element with the provided column label.
+    new_label = soup.new_tag("label")
+    new_label.append(f"{column_label}: ")
+    # Create a new input element with the provided column name.
+    new_input = soup.new_tag(
+        "input", attrs={"type": "text", "name": column_name, "required": "required"}
+    )
+    new_label.append(new_input)
+    # Look for a footer element inside the form.
+    footer = form.find("footer")
+    if footer:
+        # Insert the new label before the footer.
+        footer.insert_before(new_label)
+    else:
+        # If no footer exists, simply append the new label to the form.
+        form.append(new_label)
+    return soup.prettify(
+        formatter=formatter.HTMLFormatter(indent=_infer_html_indent_width(html_str))
+    )
+
+
+def _infer_html_indent_width(html_str: str) -> int:
+    """
+    Infer the indentation width (number of spaces) from the HTML string.
+    It looks for the first non-empty line that starts with whitespace
+    followed by '<' and returns the number of leading spaces.
+    If none is found, defaults to 2.
+    """
+    for line in textwrap.dedent(html_str).splitlines():
+        stripped = line.lstrip()
+        if stripped.startswith("<") and line != stripped:
+            return len(line) - len(stripped)
+    return 2
+
+
+def _alter_js_function_returned_array(
+    html_str: str, js_function_name: str, js_array_name: str, js_new_value: str
+) -> str:
+    """
+    Inserts a new push into the specified JavaScript function.
+
+    It finds the function definition with the given js_function_name,
+    then looks for the first return statement inside the function body,
+    and inserts a new line that pushes js_new_value into js_arr_name.
+
+    Parameters:
+        html_str (str): The HTML containing the JavaScript.
+        js_function_name (str): The name of the JavaScript function to modify.
+        js_arr_name (str): The name of the array inside that function.
+        js_new_value (str): The new value to push. (Pass the JS literal as a string,
+                            e.g. "`<td>NEW</td>`" or '"<td>NEW</td>"'.)
+
+    Returns:
+        str: The modified HTML.
+    """
+    # This pattern finds:
+    #  1. The function signature and opening brace.
+    #  2. All content (non-greedily) until we hit a newline containing a return statement.
+    #  3. Captures the newline and leading whitespace (indent) of the return statement.
+    #  4. Captures the rest of the return line.
+    pattern = (
+        r"(function\s+"
+        + re.escape(js_function_name)
+        + r"\s*\([^)]*\)\s*\{)"  # group1: function header
+        r"([\s\S]*?)"  # group2: code before return
+        r"(\n(\s*)return\s+[^;]+;)"  # group3: newline+return line, group4: indent
+    )
+
+    def replacer(match):
+        header = match.group(1)
+        before_return = match.group(2)
+        return_line = match.group(3)
+        indent = match.group(4)
+        # Create the new push statement. We add a newline plus the same indent.
+        # The resulting line will be, e.g.,
+        # "        rowComponents.push(`<td>NEW</td>`);"
+        injection = f"\n{indent}{js_array_name}.push({js_new_value});"
+        return header + before_return + injection + return_line
+
+    # Use re.sub to replace only the first occurrence of the function
+    new_html, count = re.subn(
+        pattern, replacer, html_str, count=1, flags=re.MULTILINE | re.DOTALL
+    )
+    return new_html
+
+
+def update_fastapp_test_create(ctx: AnyContext):
+    snake_module_name = to_snake_case(ctx.input.module)
+    snake_entity_name = to_snake_case(ctx.input.entity)
+    test_file_path = os.path.join(
+        APP_DIR,
+        "test",
+        snake_module_name,
+        snake_entity_name,
+        f"test_create_{snake_entity_name}.py",
+    )
+    existing_code = read_file(test_file_path)
+    new_code = existing_code
+    # TODO: update test
+    write_file(test_file_path, new_code)
+
+
+def update_fastapp_test_read(ctx: AnyContext):
+    snake_module_name = to_snake_case(ctx.input.module)
+    snake_entity_name = to_snake_case(ctx.input.entity)
+    test_file_path = os.path.join(
+        APP_DIR,
+        "test",
+        snake_module_name,
+        snake_entity_name,
+        f"test_read_{snake_entity_name}.py",
+    )
+    existing_code = read_file(test_file_path)
+    new_code = existing_code
+    # TODO: update test
+    write_file(test_file_path, new_code)
+
+
+def update_fastapp_test_update(ctx: AnyContext):
+    snake_module_name = to_snake_case(ctx.input.module)
+    snake_entity_name = to_snake_case(ctx.input.entity)
+    test_file_path = os.path.join(
+        APP_DIR,
+        "test",
+        snake_module_name,
+        snake_entity_name,
+        f"test_update_{snake_entity_name}.py",
+    )
+    existing_code = read_file(test_file_path)
+    new_code = existing_code
+    # TODO: update test
+    write_file(test_file_path, new_code)
+
+
+def update_fastapp_test_delete(ctx: AnyContext):
+    snake_module_name = to_snake_case(ctx.input.module)
+    snake_entity_name = to_snake_case(ctx.input.entity)
+    test_file_path = os.path.join(
+        APP_DIR,
+        "test",
+        snake_module_name,
+        snake_entity_name,
+        f"test_delete_{snake_entity_name}.py",
+    )
+    existing_code = read_file(test_file_path)
+    new_code = existing_code
+    # TODO: update test
+    write_file(test_file_path, new_code)

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

@@ -7,6 +7,7 @@ from my_app_name._zrb.entity.add_entity_util import (
     get_existing_auth_migration_file_names,
     get_existing_auth_migration_xcom_key,
     get_remove_permission_migration_script,
+    is_gateway_navigation_config_file,
     is_in_app_schema_dir,
     is_in_module_entity_dir,
     is_in_module_entity_test_dir,
@@ -14,11 +15,13 @@ from my_app_name._zrb.entity.add_entity_util import (
     is_module_client_file,
     is_module_direct_client_file,
     is_module_gateway_subroute_file,
+    is_module_gateway_subroute_view_file,
     is_module_migration_metadata_file,
     is_module_route_file,
     update_api_client_file,
     update_client_file,
     update_direct_client_file,
+    update_gateway_navigation_config_file,
     update_gateway_subroute_file,
     update_migration_metadata_file,
     update_route_file,
@@ -88,7 +91,9 @@ scaffold_my_app_name_entity = Scaffolder(
     destination_path=APP_DIR,
     transform_path={
         "my_module": "{to_snake_case(ctx.input.module)}",
+        "my-module": "{to_kebab_case(ctx.input.module)}",
         "my_entity": "{to_snake_case(ctx.input.entity)}",
+        "my-entity": "{to_kebab_case(ctx.input.entity)}",
     },
     transform_content=[
         # Schema tranformation (my_app_name/schema/snake_entity_name)
@@ -167,6 +172,24 @@ scaffold_my_app_name_entity = Scaffolder(
             match=is_module_gateway_subroute_file,
             transform=update_gateway_subroute_file,
         ),
+        # Update module gateway subroute view
+        # (my_app_name/module/gateway/view/content/kebab-module-name/kebab-entity-name.py)
+        ContentTransformer(
+            name="transform-module-gateway-subroute-view",
+            match=is_module_gateway_subroute_view_file,
+            transform={
+                "My Entity": "{to_human_case(ctx.input.entity).title()}",
+                "my-entities": "{to_kebab_case(ctx.input.plural)}",
+                "My Column": "{to_human_case(ctx.input.column).title()}",
+                "my_column": "{to_snake_case(ctx.input.column)}",
+            },
+        ),
+        # Register entity's page to my_app_name/gateway/config/navigation.py
+        ContentTransformer(
+            name="transform-gateway-navigation-config",
+            match=is_gateway_navigation_config_file,
+            transform=update_gateway_navigation_config_file,
+        ),
     ],
     retries=0,
     upstream=validate_add_my_app_name_entity,
@@ -283,7 +306,7 @@ def update_my_app_name_entity_permission(ctx: AnyContext):
 add_my_app_name_entity = app_create_group.add_task(
     Task(
         name="add-my-app-name-entity",
-        description="🏗️ Create new entity on a module",
+        description="📦 Create new entity on a module",
         upstream=[
             create_my_app_name_entity_migration,
             update_my_app_name_entity_permission,

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

@@ -8,7 +8,18 @@ from zrb.util.codemod.modify_class_parent import prepend_parent_class
 from zrb.util.codemod.modify_function import append_code_to_function
 from zrb.util.codemod.modify_module import prepend_code_to_module
 from zrb.util.file import read_file, write_file
-from zrb.util.string.conversion import to_kebab_case, to_pascal_case, to_snake_case
+from zrb.util.string.conversion import (
+    to_human_case,
+    to_kebab_case,
+    to_pascal_case,
+    to_snake_case,
+)
+
+
+def is_gateway_navigation_config_file(ctx: AnyContext, file_path: str) -> bool:
+    return file_path == os.path.join(
+        APP_DIR, "module", "gateway", "config", "navigation.py"
+    )
 
 
 def get_add_permission_migration_script(ctx: AnyContext) -> str:
@@ -156,6 +167,19 @@ def is_module_gateway_subroute_file(ctx: AnyContext, file_path: str) -> bool:
     return file_path == module_gateway_subroute_file
 
 
+def is_module_gateway_subroute_view_file(ctx: AnyContext, file_path: str) -> bool:
+    module_gateway_subroute_file = os.path.join(
+        APP_DIR,
+        "module",
+        "gateway",
+        "view",
+        "content",
+        f"{to_kebab_case(ctx.input.module)}",
+        f"{to_kebab_case(ctx.input.entity)}.html",
+    )
+    return file_path == module_gateway_subroute_file
+
+
 def update_migration_metadata_file(ctx: AnyContext, migration_metadata_file_path: str):
     app_name = os.path.basename(APP_DIR)
     existing_migration_metadata_code = read_file(migration_metadata_file_path)
@@ -318,7 +342,9 @@ def update_route_file(ctx: AnyContext, route_file_path: str):
 
 def update_gateway_subroute_file(ctx: AnyContext, module_gateway_subroute_path: str):
     snake_module_name = to_snake_case(ctx.input.module)
+    kebab_module_name = to_kebab_case(ctx.input.module)
     snake_entity_name = to_snake_case(ctx.input.entity)
+    kebab_entity_name = to_kebab_case(ctx.input.entity)
     snake_plural_entity_name = to_snake_case(ctx.input.plural)
     kebab_plural_entity_name = to_kebab_case(ctx.input.plural)
     pascal_entity_name = to_pascal_case(ctx.input.entity)
@@ -341,7 +367,9 @@ def update_gateway_subroute_file(ctx: AnyContext, module_gateway_subroute_path:
                     ),
                     replace_map={
                         "my_module": snake_module_name,
+                        "my-module": kebab_module_name,
                         "my_entity": snake_entity_name,
+                        "my-entity": kebab_entity_name,
                         "my_entities": snake_plural_entity_name,
                         "my-entities": kebab_plural_entity_name,
                         "MyEntity": pascal_entity_name,
@@ -382,3 +410,35 @@ def _get_import_schema_for_gateway_subroute_code(
     if new_code in existing_code:
         return None
     return new_code
+
+
+def update_gateway_navigation_config_file(
+    ctx: AnyContext, gateway_navigation_config_file_path: str
+):
+    existing_gateway_navigation_config_code = read_file(
+        gateway_navigation_config_file_path
+    )
+    snake_module_name = to_snake_case(ctx.input.module)
+    kebab_module_name = to_kebab_case(ctx.input.module)
+    kebab_entity_name = to_kebab_case(ctx.input.entity)
+    human_entity_name = to_human_case(ctx.input.entity)
+    kebab_plural_name = to_kebab_case(ctx.input.plural)
+    new_navigation_config_code = read_file(
+        file_path=os.path.join(
+            os.path.dirname(__file__), "template", "navigation_config_file.py"
+        ),
+        replace_map={
+            "my_module": snake_module_name,
+            "my-module": kebab_module_name,
+            "my-entity": kebab_entity_name,
+            "My Entity": human_entity_name.title(),
+            "my-entities": kebab_plural_name,
+        },
+    ).strip()
+    write_file(
+        file_path=gateway_navigation_config_file_path,
+        content=[
+            existing_gateway_navigation_config_code,
+            new_navigation_config_code,
+        ],
+    )