zrb 0.0.85__py3-none-any.whl → 0.0.87__py3-none-any.whl

zrb/builtin/generator/fastapp_field/helper.py

@@ -0,0 +1,283 @@
+from typeguard import typechecked
+from ....task.task import Task
+from ....helper.codemod.add_property_to_class import add_property_to_class
+from ....helper.codemod.add_key_value_to_dict import add_key_value_to_dict
+from ....helper.file.text import read_text_file_async, write_text_file_async
+import os
+import re
+
+
+@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='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/generator/fastapp_module/add.py

@@ -1,29 +1,24 @@
-from typing import Any, List, Mapping
-from dotenv import dotenv_values
-from ..._group import project_add_group
+from typing import Any
+from .helper import (
+    create_microservice_config, register_module, register_migration,
+    create_app_config, append_all_enabled_env, append_all_disabled_env,
+    append_src_template_env, append_deployment_template_env
+)
+from ..common.helper import validate_existing_project_dir
+from ..common.task_input import (
+    project_dir_input, app_name_input, module_name_input
+)
+from ...group import project_add_group
 from ....task.task import Task
 from ....task.decorator import python_task
 from ....task.resource_maker import ResourceMaker
 from ....runner import runner
-from .._common.input import (
-    project_dir_input, app_name_input,
-    module_name_input
-)
-from .._common.helper import validate_project_dir
 from ....helper import util
-from ....helper.codemod.add_import_module import add_import_module
-from ....helper.codemod.add_function_call import add_function_call
-from ....helper.codemod.append_code_to_function import append_code_to_function
-from ....helper.docker_compose.file import add_services
-from ....helper.file.text import (
-    read_text_file_async, write_text_file_async, append_text_file_async
-)
 
 import asyncio
 import os
-import jsons
 
-current_dir = os.path.dirname(__file__)
+CURRENT_DIR = os.path.dirname(__file__)
 
 ###############################################################################
 # Task Definitions
@@ -37,7 +32,7 @@ current_dir = os.path.dirname(__file__)
 )
 async def validate(*args: Any, **kwargs: Any):
     project_dir = kwargs.get('project_dir')
-    validate_project_dir(project_dir)
+    validate_existing_project_dir(project_dir)
     app_name = kwargs.get('app_name')
     module_name = kwargs.get('module_name')
     snake_module_name = util.to_snake_case(module_name)
@@ -70,7 +65,7 @@ copy_resource = ResourceMaker(
         'zrbAppName': '{{input.app_name}}',
         'zrbModuleName': '{{input.module_name}}',
     },
-    template_path=os.path.join(current_dir, 'template'),
+    template_path=os.path.join(CURRENT_DIR, 'template'),
     destination_path='{{ input.project_dir }}',
     excludes=[
         '*/__pycache__',
@@ -95,335 +90,31 @@ async def add_fastapp_module(*args: Any, **kwargs: Any):
     snake_module_name = util.to_snake_case(module_name)
     upper_snake_module_name = snake_module_name.upper()
     await asyncio.gather(
-        asyncio.create_task(_create_microservice_config(
+        asyncio.create_task(create_microservice_config(
             task, project_dir, kebab_app_name, snake_app_name,
             kebab_module_name, snake_module_name, upper_snake_module_name
         )),
-        asyncio.create_task(_register_module(
+        asyncio.create_task(register_module(
             task, project_dir, kebab_app_name, snake_module_name
         )),
-        asyncio.create_task(_register_migration(
+        asyncio.create_task(register_migration(
             task, project_dir, kebab_app_name, snake_module_name
         )),
-        asyncio.create_task(_create_app_config(
+        asyncio.create_task(create_app_config(
             task, project_dir, kebab_app_name, snake_module_name,
             upper_snake_module_name
         )),
-        asyncio.create_task(_append_all_enabled_env(
+        asyncio.create_task(append_all_enabled_env(
             task, project_dir, kebab_app_name, upper_snake_module_name
         )),
-        asyncio.create_task(_append_all_disabled_env(
+        asyncio.create_task(append_all_disabled_env(
             task, project_dir, kebab_app_name, upper_snake_module_name
         )),
-        asyncio.create_task(_append_src_template_env(
+        asyncio.create_task(append_src_template_env(
             task, project_dir, kebab_app_name, upper_snake_module_name
         )),
-        asyncio.create_task(_append_deployment_template_env(
+        asyncio.create_task(append_deployment_template_env(
             task, project_dir, kebab_app_name, upper_snake_module_name
         )),
     )
     task.print_out('Success')
-
-
-###############################################################################
-# Helper Definitions
-###############################################################################
-
-
-async def _create_microservice_config(
-    task: Task,
-    project_dir: str,
-    kebab_app_name: str,
-    snake_app_name: str,
-    kebab_module_name: str,
-    snake_module_name: str,
-    upper_snake_module_name: str
-):
-    modules = await _create_automation_json_config(
-        task, project_dir, snake_app_name, snake_module_name
-    )
-    return await asyncio.gather(
-        asyncio.create_task(_add_docker_compose_service(
-            task, modules, project_dir, kebab_app_name,
-            snake_app_name, kebab_module_name, snake_module_name,
-            upper_snake_module_name
-        )),
-        asyncio.create_task(_append_compose_env(
-            task, modules, project_dir, kebab_app_name, upper_snake_module_name
-        ))
-    )
-
-
-async def _add_docker_compose_service(
-    task: Task,
-    modules: List[str],
-    project_dir: str,
-    kebab_app_name: str,
-    snake_app_name: str,
-    kebab_module_name: str,
-    snake_module_name: str,
-    upper_snake_module_name: str
-):
-    module_app_port = 8080 + len(modules)
-    module_app_port_str = str(module_app_port)
-    docker_compose_file_path = os.path.join(
-        project_dir, 'src', kebab_app_name, 'docker-compose.yml'
-    )
-    app_container_port_env_name = f'APP_{upper_snake_module_name}_MODULE_PORT'
-    app_container_port_env = '${' + app_container_port_env_name + ':-' + module_app_port_str + '}' # noqa
-    app_host_port_env_name = f'APP_{upper_snake_module_name}_HOST_MODULE_PORT'
-    app_host_port_env = '${' + app_host_port_env_name + ':-' + module_app_port_str + '}' # noqa
-    service_definition = _get_new_docker_compose_service_definition(
-        kebab_app_name, snake_app_name, kebab_module_name, snake_module_name,
-        upper_snake_module_name, app_host_port_env, app_container_port_env
-    )
-    task.print_out(f'Add service at: {docker_compose_file_path}')
-    add_services(
-        file_name=docker_compose_file_path,
-        new_services=service_definition,
-    )
-
-
-def _get_new_docker_compose_service_definition(
-    kebab_app_name: str,
-    snake_app_name: str,
-    kebab_module_name: str,
-    snake_module_name: str,
-    upper_snake_module_name: str,
-    app_host_port_env: str,
-    app_container_port_env: str
-) -> Mapping[str, Any]:
-    return {
-        f'{kebab_app_name}-{kebab_module_name}-service': {
-            'build': {
-                'dockerfile': 'Dockerfile',
-                'context': './src'
-            },
-            'image': '${IMAGE:-' + kebab_app_name + '}',
-            'container_name': '${CONTAINER_PREFIX:-my}-' + f'{kebab_app_name}-{kebab_module_name}-service', # noqa
-            'hostname': f'{kebab_app_name}-{kebab_module_name}-service',
-            'env_file': [
-                'src/template.env',
-                'all-module-disabled.env'
-            ],
-            'environment': {
-                'APP_NAME': '${APP_NAME:-' + kebab_app_name + '}-' + f'{kebab_module_name}-service', # noqa
-                'APP_PORT': app_container_port_env,
-                'APP_ENABLE_EVENT_HANDLER': 'true',
-                'APP_ENABLE_RPC_SERVER': 'true',
-                'APP_ENABLE_API': 'false',
-                'APP_ENABLE_FRONTEND': 'false',
-                f'APP_ENABLE_{upper_snake_module_name}_MODULE': 'true',
-            },
-            'ports': [
-                f'{app_host_port_env}:{app_container_port_env}'
-            ],
-            'restart': 'unless-stopped',
-            'profiles': [
-                'microservices'
-            ],
-            'healthcheck': {
-                'test': [
-                    'CMD-SHELL',
-                    'curl --fail http://localhost:' + app_container_port_env + '/readiness || exit 1' # noqa
-                ],
-                'interval': '5s',
-                'timeout': '3s',
-                'retries': 10
-            },
-            'networks': ['zrb']
-        }
-    }
-
-
-async def _append_compose_env(
-    task: Task,
-    modules: List[str],
-    project_dir: str,
-    kebab_app_name: str,
-    upper_snake_module_name: str
-):
-    compose_template_env_path = os.path.join(
-        project_dir, 'src', kebab_app_name, 'docker-compose.env'
-    )
-    compose_env_map = dotenv_values(compose_template_env_path)
-    host_port = int(compose_env_map.get('APP_GATEWAY_HOST_PORT', '8080'))
-    module_app_port = host_port + len(modules)
-    new_env_str = '\n'.join([
-        f'APP_{upper_snake_module_name}_HOST_MODULE_PORT={module_app_port}',
-        f'APP_{upper_snake_module_name}_MODULE_PORT={module_app_port}',
-    ])
-    task.print_out(f'Add new environment to: {compose_template_env_path}')
-    await append_text_file_async(compose_template_env_path, new_env_str)
-
-
-async def _append_src_template_env(
-    task: Task,
-    project_dir: str,
-    kebab_app_name: str,
-    upper_snake_module_name: str
-):
-    src_template_env_path = os.path.join(
-        project_dir, 'src', kebab_app_name, 'src', 'template.env'
-    )
-    new_env_str = '\n'.join([
-        f'APP_ENABLE_{upper_snake_module_name}_MODULE=true',
-    ])
-    task.print_out(f'Add new environment to: {src_template_env_path}')
-    await append_text_file_async(src_template_env_path, new_env_str)
-
-
-async def _append_deployment_template_env(
-    task: Task,
-    project_dir: str,
-    kebab_app_name: str,
-    upper_snake_module_name: str
-):
-    deployment_template_env_path = os.path.join(
-        project_dir, 'src', kebab_app_name, 'deployment', 'template.env'
-    )
-    new_env_str = '\n'.join([
-        f'REPLICA_{upper_snake_module_name}_SERVICE=1',
-    ])
-    task.print_out(f'Add new environment to: {deployment_template_env_path}')
-    await append_text_file_async(deployment_template_env_path, new_env_str)
-
-
-async def _append_all_enabled_env(
-    task: Task,
-    project_dir: str,
-    kebab_app_name: str,
-    upper_snake_module_name: str
-):
-    all_enabled_env_path = os.path.join(
-        project_dir, 'src', kebab_app_name, 'all-module-enabled.env'
-    )
-    task.print_out(f'Add new environment to: {all_enabled_env_path}')
-    await append_text_file_async(
-        all_enabled_env_path,
-        f'APP_ENABLE_{upper_snake_module_name}_MODULE=true'
-    )
-
-
-async def _append_all_disabled_env(
-    task: Task,
-    project_dir: str,
-    kebab_app_name: str,
-    upper_snake_module_name: str
-):
-    all_disabled_env_path = os.path.join(
-        project_dir, 'src', kebab_app_name, 'all-module-disabled.env'
-    )
-    task.print_out(f'Add new environment to: {all_disabled_env_path}')
-    await append_text_file_async(
-        all_disabled_env_path,
-        f'APP_ENABLE_{upper_snake_module_name}_MODULE=false'
-    )
-
-
-async def _create_app_config(
-    task: Task,
-    project_dir: str,
-    kebab_app_name: str,
-    snake_module_name: str,
-    upper_snake_module_name: str
-):
-    config_file_path = os.path.join(
-        project_dir, 'src', kebab_app_name, 'src', 'config.py'
-    )
-    config_code = '\n'.join([
-        f'app_enable_{snake_module_name}_module = str_to_boolean(os.environ.get(',  # noqa
-        f"    'APP_ENABLE_{upper_snake_module_name}_MODULE', 'true'"
-        '))'
-    ])
-    task.print_out(f'Read config from: {config_file_path}')
-    code = await read_text_file_async(config_file_path)
-    code += '\n' + config_code
-    task.print_out(f'Write config to: {config_file_path}')
-    await write_text_file_async(config_file_path, code)
-
-
-async def _create_automation_json_config(
-    task: Task,
-    project_dir: str,
-    snake_app_name: str,
-    snake_module_name: str,
-):
-    json_modules_file_path = os.path.join(
-        project_dir, '_automate', snake_app_name, 'config', 'modules.json'
-    )
-    task.print_out(f'Read json config from: {json_modules_file_path}')
-    json_str = await read_text_file_async(json_modules_file_path)
-    task.print_out(f'Add "{snake_module_name}" to json config')
-    modules: List[str] = jsons.loads(json_str)
-    modules.append(snake_module_name)
-    json_str = jsons.dumps(modules)
-    task.print_out(f'Write new json config to: {json_modules_file_path}')
-    await write_text_file_async(json_modules_file_path, json_str)
-    return modules
-
-
-async def _register_migration(
-    task: Task,
-    project_dir: str,
-    kebab_app_name: str,
-    snake_module_name: str
-):
-    app_migration_file_path = os.path.join(
-        project_dir, 'src', kebab_app_name, 'src', 'migrate.py'
-    )
-    import_module_path = '.'.join([
-        'module', snake_module_name, 'migrate'
-    ])
-    function_name = f'migrate_{snake_module_name}'
-    task.print_out(f'Read code from: {app_migration_file_path}')
-    code = await read_text_file_async(app_migration_file_path)
-    task.print_out(
-        f'Add import "{function_name}" from "{import_module_path}" to the code'
-    )
-    code = add_import_module(
-        code=code,
-        module_path=import_module_path,
-        resource=function_name
-    )
-    task.print_out(f'Add "{function_name}" call to the code')
-    code = append_code_to_function(
-        code=code,
-        function_name='migrate',
-        new_code=f'await {function_name}()'
-    )
-    task.print_out(f'Write modified code to: {app_migration_file_path}')
-    await write_text_file_async(app_migration_file_path, code)
-
-
-async def _register_module(
-    task: Task,
-    project_dir: str,
-    kebab_app_name: str,
-    snake_module_name: str
-):
-    app_main_file_path = os.path.join(
-        project_dir, 'src', kebab_app_name, 'src', 'main.py'
-    )
-    import_module_path = '.'.join([
-        'module', snake_module_name, 'register_module'
-    ])
-    function_name = f'register_{snake_module_name}'
-    task.print_out(f'Read code from: {app_main_file_path}')
-    code = await read_text_file_async(app_main_file_path)
-    task.print_out(
-        f'Add import "{function_name}" from "{import_module_path}" to the code'
-    )
-    code = add_import_module(
-        code=code,
-        module_path=import_module_path,
-        resource=function_name
-    )
-    task.print_out(f'Add "{function_name}" call to the code')
-    code = add_function_call(
-        code=code,
-        function_name=function_name,
-        parameters=[]
-    )
-    task.print_out(f'Write modified code to: {app_main_file_path}')
-    await write_text_file_async(app_main_file_path, code)