zrb 0.23.4__py3-none-any.whl → 0.24.0__py3-none-any.whl

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/test/auth/test_user_login.py

@@ -2,7 +2,7 @@ from typing import AsyncIterator
 
 import pytest
 from httpx import AsyncClient
-from src.config import app_auth_admin_password, app_auth_admin_username
+from src.config import APP_AUTH_ADMIN_PASSWORD, APP_AUTH_ADMIN_USERNAME
 
 
 @pytest.mark.asyncio
@@ -13,8 +13,8 @@ async def test_admin_user_login_success(
         login_response = await client.post(
             "/api/v1/auth/login",
             json={
-                "identity": app_auth_admin_username,
-                "password": app_auth_admin_password,
+                "identity": APP_AUTH_ADMIN_USERNAME,
+                "password": APP_AUTH_ADMIN_PASSWORD,
             },
         )
         assert login_response.status_code == 200
@@ -30,7 +30,7 @@ async def test_admin_user_login_empty_identity_failed(
     async for client in test_client_generator:
         login_response = await client.post(
             "/api/v1/auth/login",
-            json={"identity": "", "password": app_auth_admin_password},
+            json={"identity": "", "password": APP_AUTH_ADMIN_PASSWORD},
         )
         assert login_response.status_code == 422
 
@@ -42,7 +42,7 @@ async def test_admin_user_login_invalid_identity_failed(
     async for client in test_client_generator:
         login_response = await client.post(
             "/api/v1/auth/login",
-            json={"identity": "invalid-identity", "password": app_auth_admin_password},
+            json={"identity": "invalid-identity", "password": APP_AUTH_ADMIN_PASSWORD},
         )
         assert login_response.status_code == 404
 
@@ -54,7 +54,7 @@ async def test_admin_user_failed_invalid_password(
     async for client in test_client_generator:
         login_response = await client.post(
             "/api/v1/auth/login",
-            json={"identity": app_auth_admin_username, "password": "invalid-password"},
+            json={"identity": APP_AUTH_ADMIN_USERNAME, "password": "invalid-password"},
         )
         assert login_response.status_code == 404
 
@@ -68,8 +68,8 @@ async def test_create_normal_user_and_login_with_username_success(
         login_admin_response = await client.post(
             "/api/v1/auth/login",
             json={
-                "identity": app_auth_admin_username,
-                "password": app_auth_admin_password,
+                "identity": APP_AUTH_ADMIN_USERNAME,
+                "password": APP_AUTH_ADMIN_PASSWORD,
             },
         )
         assert login_admin_response.status_code == 200
@@ -113,8 +113,8 @@ async def test_create_normal_user_and_login_with_phone_success(
         login_admin_response = await client.post(
             "/api/v1/auth/login",
             json={
-                "identity": app_auth_admin_username,
-                "password": app_auth_admin_password,
+                "identity": APP_AUTH_ADMIN_USERNAME,
+                "password": APP_AUTH_ADMIN_PASSWORD,
             },
         )
         assert login_admin_response.status_code == 200
@@ -155,8 +155,8 @@ async def test_create_normal_user_and_login_with_email_success(
         login_admin_response = await client.post(
             "/api/v1/auth/login",
             json={
-                "identity": app_auth_admin_username,
-                "password": app_auth_admin_password,
+                "identity": APP_AUTH_ADMIN_USERNAME,
+                "password": APP_AUTH_ADMIN_PASSWORD,
             },
         )
         assert login_admin_response.status_code == 200
@@ -200,8 +200,8 @@ async def test_create_normal_user_and_login_failed(
         login_admin_response = await client.post(
             "/api/v1/auth/login",
             json={
-                "identity": app_auth_admin_username,
-                "password": app_auth_admin_password,
+                "identity": APP_AUTH_ADMIN_USERNAME,
+                "password": APP_AUTH_ADMIN_PASSWORD,
             },
         )
         assert login_admin_response.status_code == 200

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/test/test_liveness_and_readiness.py

@@ -2,7 +2,7 @@ from typing import AsyncIterator
 
 import pytest
 from httpx import AsyncClient
-from src.config import zrb_app_name
+from src.config import APP_NAME
 
 
 @pytest.mark.asyncio
@@ -10,7 +10,7 @@ async def test_get_liveness(test_client_generator: AsyncIterator[AsyncClient]):
     async for client in test_client_generator:
         response = await client.get("/liveness")
         assert response.status_code == 200
-        assert response.json() == {"app": zrb_app_name, "alive": True}
+        assert response.json() == {"app": APP_NAME, "alive": True}
 
 
 @pytest.mark.asyncio
@@ -25,7 +25,7 @@ async def test_get_readiness(test_client_generator: AsyncIterator[AsyncClient]):
     async for client in test_client_generator:
         response = await client.get("/readiness")
         assert response.status_code == 200
-        assert response.json() == {"app": zrb_app_name, "ready": True}
+        assert response.json() == {"app": APP_NAME, "ready": True}
 
 
 @pytest.mark.asyncio

zrb/builtin/project/add/fastapp/crud/_helper/__init__.py

@@ -0,0 +1,7 @@
+from .register_api import register_api
+from .register_permission import register_permission
+from .register_rpc import register_rpc
+
+assert register_api
+assert register_permission
+assert register_rpc

zrb/builtin/project/add/fastapp/crud/_helper/_common.py

@@ -0,0 +1,8 @@
+import os
+
+from zrb.helper.util import to_kebab_case
+
+
+def get_app_module_dir(project_dir: str, app_name: str) -> str:
+    kebab_app_name = to_kebab_case(app_name)
+    return os.path.join(project_dir, "src", kebab_app_name, "src", "module")

zrb/builtin/project/add/fastapp/crud/_helper/register_api.py

@@ -0,0 +1,45 @@
+import os
+
+from zrb.helper.codemod.add_import_module import add_import_module
+from zrb.helper.codemod.append_code_to_function import append_code_to_function
+from zrb.helper.file.text import read_text_file_async, write_text_file_async
+from zrb.helper.typecheck import typechecked
+from zrb.helper.util import to_snake_case
+from zrb.task.task import Task
+
+from ._common import get_app_module_dir
+
+
+@typechecked
+async def register_api(
+    task: Task, project_dir: str, app_name: str, module_name: str, entity_name: str
+):
+    snake_module_name = to_snake_case(module_name)
+    snake_entity_name = to_snake_case(entity_name)
+    module_api_file_path = os.path.join(
+        get_app_module_dir(project_dir, app_name), snake_module_name, "api.py"
+    )
+    register_function_path = ".".join(
+        ["module", snake_module_name, "entity", snake_entity_name, "api"]
+    )
+    register_function = f"register_{snake_entity_name}_api"
+    task.print_out(f"Read code from: {module_api_file_path}")
+    code = await read_text_file_async(module_api_file_path)
+    task.print_out(
+        f'Add import "register_api" as "{register_function}" '
+        + f'from "{register_function_path}" to the code'
+    )
+    code = add_import_module(
+        code=code,
+        module_path=register_function_path,
+        resource="register_api",
+        alias=register_function,
+    )
+    task.print_out(f'Add "{register_function}" call to the code')
+    code = append_code_to_function(
+        code=code,
+        function_name="register_api",
+        new_code=f"{register_function}(logger, app, authorizer, rpc_caller, publisher)",  # noqa
+    )
+    task.print_out(f"Write modified code to: {module_api_file_path}")
+    await write_text_file_async(module_api_file_path, code)

zrb/builtin/project/add/fastapp/crud/_helper/register_permission.py

@@ -0,0 +1,40 @@
+import os
+
+from zrb.helper.codemod.append_code_to_function import append_code_to_function
+from zrb.helper.file.text import read_text_file_async, write_text_file_async
+from zrb.helper.typecheck import typechecked
+from zrb.helper.util import to_snake_case
+from zrb.task.task import Task
+
+from ._common import get_app_module_dir
+
+
+@typechecked
+async def register_permission(
+    task: Task, project_dir: str, app_name: str, module_name: str, entity_name: str
+):
+    snake_module_name = to_snake_case(module_name)
+    snake_entity_name = to_snake_case(entity_name)
+    module_register_permission_file_path = os.path.join(
+        get_app_module_dir(project_dir, app_name),
+        "auth",
+        "register_permission.py",
+    )
+    task.print_out(f"Read code from: {module_register_permission_file_path}")
+    code = await read_text_file_async(module_register_permission_file_path)
+    code = append_code_to_function(
+        code=code,
+        function_name="register_permission",
+        new_code="\n".join(
+            [
+                "await ensure_entity_permission(",
+                f"    module_name='{snake_module_name}', entity_name='{snake_entity_name}'",  # noqa
+                ")",
+            ]
+        ),
+    )
+    task.print_out(
+        f'Add "ensure_entity_permission" call for {snake_entity_name} ' + "to the code"
+    )
+    task.print_out(f"Write modified code to: {module_register_permission_file_path}")
+    await write_text_file_async(module_register_permission_file_path, code)

zrb/builtin/project/add/fastapp/crud/_helper/register_rpc.py

@@ -0,0 +1,45 @@
+import os
+
+from zrb.helper.codemod.add_import_module import add_import_module
+from zrb.helper.codemod.append_code_to_function import append_code_to_function
+from zrb.helper.file.text import read_text_file_async, write_text_file_async
+from zrb.helper.typecheck import typechecked
+from zrb.helper.util import to_snake_case
+from zrb.task.task import Task
+
+from ._common import get_app_module_dir
+
+
+@typechecked
+async def register_rpc(
+    task: Task, project_dir: str, app_name: str, module_name: str, entity_name: str
+):
+    snake_module_name = to_snake_case(module_name)
+    snake_entity_name = to_snake_case(entity_name)
+    module_rpc_file_path = os.path.join(
+        get_app_module_dir(project_dir, app_name), snake_module_name, "rpc.py"
+    )
+    register_function_path = ".".join(
+        ["module", snake_module_name, "entity", snake_entity_name, "rpc"]
+    )
+    register_function = f"register_{snake_entity_name}_rpc"
+    task.print_out(f"Read code from: {module_rpc_file_path}")
+    code = await read_text_file_async(module_rpc_file_path)
+    task.print_out(
+        f'Add import "register_rpc" as "{register_function}" '
+        + f'from "{register_function_path}" to the code'
+    )
+    code = add_import_module(
+        code=code,
+        module_path=register_function_path,
+        resource="register_rpc",
+        alias=register_function,
+    )
+    task.print_out(f'Add "{register_function}" call to the code')
+    code = append_code_to_function(
+        code=code,
+        function_name="register_rpc",
+        new_code=f"{register_function}(logger, rpc_server, rpc_caller, publisher)",  # noqa
+    )
+    task.print_out(f"Write modified code to: {module_rpc_file_path}")
+    await write_text_file_async(module_rpc_file_path, code)

zrb/builtin/project/add/fastapp/crud/crud.py

@@ -107,36 +107,15 @@ async def register_crud(*args: Any, **kwargs: Any):
     app_name = kwargs.get("app_name")
     module_name = kwargs.get("module_name")
     entity_name = kwargs.get("entity_name")
-    kebab_app_name = util.to_kebab_case(app_name)
-    snake_module_name = util.to_snake_case(module_name)
-    snake_entity_name = util.to_snake_case(entity_name)
     await asyncio.gather(
         asyncio.create_task(
-            register_api(
-                task=task,
-                project_dir=project_dir,
-                kebab_app_name=kebab_app_name,
-                snake_module_name=snake_module_name,
-                snake_entity_name=snake_entity_name,
-            )
+            register_api(task, project_dir, app_name, module_name, entity_name)
         ),
         asyncio.create_task(
-            register_rpc(
-                task=task,
-                project_dir=project_dir,
-                kebab_app_name=kebab_app_name,
-                snake_module_name=snake_module_name,
-                snake_entity_name=snake_entity_name,
-            )
+            register_rpc(task, project_dir, app_name, module_name, entity_name)
         ),
         asyncio.create_task(
-            register_permission(
-                task=task,
-                project_dir=project_dir,
-                kebab_app_name=kebab_app_name,
-                snake_module_name=snake_module_name,
-                snake_entity_name=snake_entity_name,
-            )
+            register_permission(task, project_dir, app_name, module_name, entity_name)
         ),
     )
 

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

@@ -4,7 +4,18 @@ from module.snake_zrb_module_name.schema.snake_zrb_entity_name import (
     PascalZrbEntityName,
     PascalZrbEntityNameData,
 )
-from sqlalchemy import Column, String
+from sqlalchemy import (
+    Boolean,
+    Column,
+    Date,
+    DateTime,
+    Double,
+    Float,
+    Integer,
+    String,
+    Text,
+    Time,
+)
 
 
 class DBEntityPascalZrbEntityName(Base, DBEntityMixin):

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

@@ -1,3 +1,4 @@
+from datetime import date, datetime, time
 from typing import List, Optional
 
 from component.schema import BaseCountSchema, BaseDateTimeSchema

zrb/builtin/project/add/fastapp/crud/template/src/kebab-zrb-app-name/test/snake_zrb_module_name/test_snake_zrb_entity_name.py

@@ -1,8 +1,9 @@
+from datetime import date, datetime, time
 from typing import AsyncIterator
 
 import pytest
+from config import APP_AUTH_ADMIN_PASSWORD, APP_AUTH_ADMIN_USERNAME
 from httpx import AsyncClient
-from src.config import app_auth_admin_password, app_auth_admin_username
 
 inserted_success_data = {
     "snake_zrb_column_name": "test-kebab-create-entity-name-success"
@@ -27,8 +28,8 @@ async def test_insert_snake_zrb_entity_name_and_get_success(
         login_admin_response = await client.post(
             "/api/v1/auth/login",
             json={
-                "identity": app_auth_admin_username,
-                "password": app_auth_admin_password,
+                "identity": APP_AUTH_ADMIN_USERNAME,
+                "password": APP_AUTH_ADMIN_PASSWORD,
             },
         )
         assert login_admin_response.status_code == 200
@@ -80,8 +81,8 @@ async def test_update_snake_zrb_entity_name_and_get_success(
         login_admin_response = await client.post(
             "/api/v1/auth/login",
             json={
-                "identity": app_auth_admin_username,
-                "password": app_auth_admin_password,
+                "identity": APP_AUTH_ADMIN_USERNAME,
+                "password": APP_AUTH_ADMIN_PASSWORD,
             },
         )
         assert login_admin_response.status_code == 200
@@ -147,8 +148,8 @@ async def test_delete_snake_zrb_entity_name_and_get_success(
         login_admin_response = await client.post(
             "/api/v1/auth/login",
             json={
-                "identity": app_auth_admin_username,
-                "password": app_auth_admin_password,
+                "identity": APP_AUTH_ADMIN_USERNAME,
+                "password": APP_AUTH_ADMIN_PASSWORD,
             },
         )
         assert login_admin_response.status_code == 200

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

@@ -0,0 +1,17 @@
+from .inject_delete_page import inject_delete_page
+from .inject_detail_page import inject_detail_page
+from .inject_insert_page import inject_insert_page
+from .inject_list_page import inject_list_page
+from .inject_repo import inject_repo
+from .inject_schema import inject_schema
+from .inject_test import inject_test
+from .inject_update_page import inject_update_page
+
+assert inject_list_page
+assert inject_detail_page
+assert inject_insert_page
+assert inject_update_page
+assert inject_delete_page
+assert inject_repo
+assert inject_schema
+assert inject_test

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

@@ -0,0 +1,102 @@
+import os
+
+from zrb.helper.string.parse_replacement import parse_replacement
+from zrb.helper.util import to_kebab_case, to_snake_case
+
+
+def replace_marker(text: str, marker: str, code: str) -> str:
+    return parse_replacement(text, {marker: "\n".join([code, marker])})
+
+
+def get_app_frontend_routes_dir(project_dir: str, app_name: str) -> str:
+    return os.path.join(
+        get_app_dir(project_dir, app_name), "src", "frontend", "src", "routes"
+    )
+
+
+def get_app_dir(project_dir: str, app_name: str) -> str:
+    kebab_app_name = to_kebab_case(app_name)
+    return os.path.join(project_dir, "src", kebab_app_name)
+
+
+def get_sqlalchemy_column_type(column_type: str) -> str:
+    default_value = "String"
+    type_map = {
+        "string": default_value,
+        "text": "Text",
+        "boolean": "Boolean",
+        "integer": "Integer",
+        "float": "Float",
+        "double": "Double",
+        "date": "Date",
+        "datetime": "DateTime",
+        "time": "Time",
+    }
+    column_type = column_type.lower()
+    return type_map.get(column_type.lower(), default_value)
+
+
+def get_python_column_type(column_type: str) -> str:
+    default_value = "str"
+    type_map = {
+        "string": default_value,
+        "text": "str",
+        "boolean": "bool",
+        "integer": "int",
+        "float": "float",
+        "double": "double",
+        "date": "date",
+        "datetime": "datetime",
+        "time": "time",
+    }
+    return type_map.get(column_type.lower(), default_value)
+
+
+def get_python_value_for_testing(column_type: str) -> str:
+    default_value = '"A string"'
+    type_map = {
+        "string": default_value,
+        "text": '"A text"',
+        "boolean": "True",
+        "integer": "42",
+        "float": "3.14",
+        "double": "3.14",
+        "date": "date(2024, 8, 10)",
+        "datetime": "datetime(2024, 8, 10, 14, 30)",
+        "time": "time(14, 30)",
+    }
+    return type_map.get(column_type.lower(), default_value)
+
+
+def get_default_js_value(column_type: str) -> str:
+    default_value = '""'
+    type_map = {
+        "string": default_value,
+        "text": '""',
+        "boolean": "true",
+        "integer": "0",
+        "float": "0.0",
+        "double": "0.0",
+        "date": "new Date()",
+        "datetime": "new Date()",
+        "time": "new Date().toLocaleTimeString('en-US', { hour12: false })",
+    }
+    return type_map.get(column_type.lower(), default_value)
+
+
+def get_html_input(column_type: str, column_name: str, column_caption: str) -> str:
+    snake_column_name = to_snake_case(column_name)
+    kebab_column_name = to_kebab_case(column_name)
+    default_value = f'<input type="text" class="input w-full" id="{kebab_column_name}" placeholder="{column_caption}" bind:value="{{row.{snake_column_name}}}" />'  # noqa
+    type_map = {
+        "string": default_value,
+        "text": f'<textarea class="textarea w-full" id="{kebab_column_name}" placeholder="{column_caption}" bind:value="{{row.{snake_column_name}}}"></textarea>',  # noqa
+        "boolean": f'<input type="checkbox" class="checkbox" id="{kebab_column_name}" bind:checked="{{row.{snake_column_name}}}" />',  # noqa
+        "integer": f'<input type="number" class="input w-full" id="{kebab_column_name}" placeholder="{column_caption}" bind:value="{{row.{snake_column_name}}}" />',  # noqa
+        "float": f'<input type="number" step="0.01" class="input w-full" id="{kebab_column_name}" placeholder="{column_caption}" bind:value="{{row.{snake_column_name}}}" />',  # noqa
+        "double": f'<input type="number" step="0.01" class="input w-full" id="{kebab_column_name}" placeholder="{column_caption}" bind:value="{{row.{snake_column_name}}}" />',  # noqa
+        "date": f'<input type="date" class="input w-full" id="{kebab_column_name}" placeholder="{column_caption}" bind:value="{{row.{snake_column_name}}}" />',  # noqa
+        "datetime": f'<input type="datetime-local" class="input w-full" id="{kebab_column_name}" placeholder="{column_caption}" bind:value="{{row.{snake_column_name}}}" />',  # noqa
+        "time": f'<input type="time" class="input w-full" id="{kebab_column_name}" placeholder="{column_caption}" bind:value="{{row.{snake_column_name}}}" />',  # noqa
+    }
+    return type_map.get(column_type.lower(), default_value)

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

@@ -0,0 +1,49 @@
+import os
+
+from zrb.helper.file.text import read_text_file_async, write_text_file_async
+from zrb.helper.typecheck import typechecked
+from zrb.helper.util import to_capitalized_human_readable, to_kebab_case, to_snake_case
+from zrb.task.task import Task
+
+from ._common import get_app_frontend_routes_dir, replace_marker
+
+
+@typechecked
+async def inject_delete_page(
+    task: Task,
+    project_dir: str,
+    app_name: str,
+    module_name: str,
+    entity_name: str,
+    column_name: str,
+):
+    kebab_module_name = to_kebab_case(module_name)
+    kebab_entity_name = to_kebab_case(entity_name)
+    snake_column_name = to_snake_case(column_name)
+    kebab_column_name = to_kebab_case(column_name)
+    column_caption = to_capitalized_human_readable(column_name)
+    file_path = os.path.join(
+        get_app_frontend_routes_dir(project_dir, app_name),
+        kebab_module_name,
+        kebab_entity_name,
+        "delete",
+        "[id]",
+        "+page.svelte",
+    )
+    task.print_out(f"Read HTML from: {file_path}")
+    html_content = await read_text_file_async(file_path)
+    task.print_out("Add field to delete page")
+    html_content = replace_marker(
+        html_content,
+        marker="<!-- DON'T DELETE: insert new field here-->",
+        code="\n".join(
+            [
+                '<div class="mb-4">',
+                f'    <label class="block text-gray-700 font-bold mb-2" for="{kebab_column_name}">{column_caption}</label>',  # noqa
+                f'    <span id="{kebab_column_name}">{{row.{snake_column_name}}}</span>',
+                "</div>",
+            ]
+        ),
+    )
+    task.print_out(f"Write modified HTML to: {file_path}")
+    await write_text_file_async(file_path, html_content)

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

@@ -0,0 +1,49 @@
+import os
+
+from zrb.helper.file.text import read_text_file_async, write_text_file_async
+from zrb.helper.typecheck import typechecked
+from zrb.helper.util import to_capitalized_human_readable, to_kebab_case, to_snake_case
+from zrb.task.task import Task
+
+from ._common import get_app_frontend_routes_dir, replace_marker
+
+
+@typechecked
+async def inject_detail_page(
+    task: Task,
+    project_dir: str,
+    app_name: str,
+    module_name: str,
+    entity_name: str,
+    column_name: str,
+):
+    kebab_module_name = to_kebab_case(module_name)
+    kebab_entity_name = to_kebab_case(entity_name)
+    snake_column_name = to_snake_case(column_name)
+    kebab_column_name = to_kebab_case(column_name)
+    column_caption = to_capitalized_human_readable(column_name)
+    file_path = os.path.join(
+        get_app_frontend_routes_dir(project_dir, app_name),
+        kebab_module_name,
+        kebab_entity_name,
+        "detail",
+        "[id]",
+        "+page.svelte",
+    )
+    task.print_out(f"Read HTML from: {file_path}")
+    html_content = await read_text_file_async(file_path)
+    task.print_out("Add field to detail page")
+    html_content = replace_marker(
+        html_content,
+        marker="<!-- DON'T DELETE: insert new field here-->",
+        code="\n".join(
+            [
+                '<div class="mb-4">',
+                f'    <label class="block text-gray-700 font-bold mb-2" for="{kebab_column_name}">{column_caption}</label>',  # noqa
+                f'    <span id="{kebab_column_name}">{{row.{snake_column_name}}}</span>',
+                "</div>",
+            ]
+        ),
+    )
+    task.print_out(f"Write modified HTML to: {file_path}")
+    await write_text_file_async(file_path, html_content)

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

@@ -0,0 +1,62 @@
+import os
+
+from zrb.helper.file.text import read_text_file_async, write_text_file_async
+from zrb.helper.typecheck import typechecked
+from zrb.helper.util import to_capitalized_human_readable, to_kebab_case, to_snake_case
+from zrb.task.task import Task
+
+from ._common import (
+    get_app_frontend_routes_dir,
+    get_default_js_value,
+    get_html_input,
+    replace_marker,
+)
+
+
+@typechecked
+async def inject_insert_page(
+    task: Task,
+    project_dir: str,
+    app_name: str,
+    module_name: str,
+    entity_name: str,
+    column_name: str,
+    column_type: str,
+):
+    kebab_module_name = to_kebab_case(module_name)
+    kebab_entity_name = to_kebab_case(entity_name)
+    snake_column_name = to_snake_case(column_name)
+    kebab_column_name = to_kebab_case(column_name)
+    column_caption = to_capitalized_human_readable(column_name)
+    file_path = os.path.join(
+        get_app_frontend_routes_dir(project_dir, app_name),
+        kebab_module_name,
+        kebab_entity_name,
+        "new",
+        "+page.svelte",
+    )
+    task.print_out(f"Read HTML from: {file_path}")
+    html_content = await read_text_file_async(file_path)
+    task.print_out("Add default value to insert page")
+    default_value = get_default_js_value(column_type)
+    html_content = replace_marker(
+        html_content,
+        marker="// DON'T DELETE: set field default value here",
+        code=f"row.{snake_column_name} = {default_value}",
+    )
+    task.print_out("Add field to insert page")
+    html_input = get_html_input(column_type, column_name, column_caption)
+    html_content = replace_marker(
+        html_content,
+        marker="<!-- DON'T DELETE: insert new field here-->",
+        code="\n".join(
+            [
+                '<div class="mb-4">',
+                f'    <label class="block text-gray-700 font-bold mb-2" for="{kebab_column_name}">{column_caption}</label>',  # noqa
+                f"    {html_input}",
+                "</div>",
+            ]
+        ),
+    )
+    task.print_out(f"Write modified HTML to: {file_path}")
+    await write_text_file_async(file_path, html_content)