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

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/.coveragerc

@@ -0,0 +1,11 @@
+[run]
+omit =
+    _zrb/*
+
+[report]
+# Show missing lines in the terminal report
+show_missing = True
+
+[html]
+# Set the output directory for HTML reports (optional)
+directory = htmlcov 

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/.gitignore

@@ -2,3 +2,7 @@ __pycache__
 .venv
 .env
 *.db
+
+htmlcov
+.coverage
+.pytest_cache

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.prepend_property_to_class import prepend_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 = prepend_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 = prepend_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 = prepend_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/config.py

@@ -13,6 +13,11 @@ MONOLITH_ENV_VARS = {
     "MY_APP_NAME_MODE": "monolith",
     "MY_APP_NAME_MODULES": "",
 }
+TEST_ENV_VARS = {
+    "MY_APP_NAME_DB_URL": f"sqlite:///{APP_DIR}/test.db",
+    "MY_APP_NAME_AUTH_PRIORITIZE_NEW_SESSION": "1",  # Need this because we will launch a new user session for each test
+    "MY_APP_NAME_AUTH_GUEST_USER_PERMISSIONs": "",  # Guest user should not has any privilege for testing
+}
 
 if platform.system() == "Windows":
     ACTIVATE_VENV_SCRIPT = "Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser; . .venv\\Scripts\\Activate"  # noqa