zrb 1.0.0b10__tar.gz → 1.1.0__tar.gz

{zrb-1.0.0b10 → zrb-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: zrb
-Version: 1.0.0b10
+Version: 1.1.0
 Summary: Your Automation Powerhouse
 Home-page: https://github.com/state-alchemists/zrb
 License: AGPL-3.0-or-later
@@ -26,7 +26,7 @@ Requires-Dist: pdfplumber (>=0.11.4,<0.12.0) ; extra == "rag"
 Requires-Dist: psutil (>=6.1.1,<7.0.0)
 Requires-Dist: pydantic-ai (>=0.0.19,<0.0.20)
 Requires-Dist: python-dotenv (>=1.0.1,<2.0.0)
-Requires-Dist: python-jose[cryptography] (>=3.3.0,<4.0.0)
+Requires-Dist: python-jose[cryptography] (>=3.4.0,<4.0.0)
 Requires-Dist: requests (>=2.32.3,<3.0.0)
 Requires-Dist: ulid-py (>=1.1.0,<2.0.0)
 Project-URL: Documentation, https://github.com/state-alchemists/zrb

{zrb-1.0.0b10 → zrb-1.1.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "zrb"
-version = "1.0.0b10"
+version = "1.1.0"
 description = "Your Automation Powerhouse"
 authors = ["Go Frendi Gunawan <gofrendiasgard@gmail.com>"]
 license = "AGPL-3.0-or-later"
@@ -48,7 +48,7 @@ chromadb = {version = "^0.5.20", optional = true}
 pdfplumber = {version = "^0.11.4", optional = true}
 beautifulsoup4 = "^4.12.3"
 fastapi = {extras = ["standard"], version = "^0.115.6"}
-python-jose = {extras = ["cryptography"], version = "^3.3.0"}
+python-jose = {extras = ["cryptography"], version = "^3.4.0"}
 ulid-py = "^1.1.0"
 pydantic-ai = "^0.0.19"
 fastembed = "^0.5.1"

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

@@ -0,0 +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_module_names, get_existing_schema_names
+
+from zrb import AnyContext, Task, make_task
+
+
+@make_task(
+    name="validate-add-fastapp-column",
+    input=[
+        existing_module_input,
+        existing_entity_input,
+    ],
+    retries=0,
+)
+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}")
+
+
+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_fastapp_column,
+)
+
+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,
+)
+
+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-fastapp-column",
+        description="📊 Create new column on an entity",
+        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",
+)

zrb-1.1.0/src/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-1.0.0b10 → zrb-1.1.0}/src/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-1.0.0b10 → zrb-1.1.0}/src/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,
+        ],
+    )