ApiLogicServer 15.0.12__py3-none-any.whl → 15.0.19__py3-none-any.whl

api_logic_server_cli/api_logic_server.py

@@ -12,9 +12,10 @@ ApiLogicServer CLI: given a database url, create [and run] customizable ApiLogic
 Called from api_logic_server_cli.py, by instantiating the ProjectRun object.
 '''
 
-__version__ = "15.00.12"  # last public release: 15.00.10 (15.00.00)
+__version__ = "15.00.19"  # last public release: 15.00.19 (15.00.12)
 recent_changes = \
     f'\n\nRecent Changes:\n' +\
+    "\t06/17/2024 - 15.00.19: Tech Preview: als genai-app \n"\
     "\t06/10/2024 - 15.00.12: MCP Security, win fixes for readme, graphics quotes \n"\
     "\t06/08/2024 - 15.00.10: MCP, optional shortening of stacktrace lines, bugfix[92] \n"\
     "\t05/16/2024 - 14.05.00: safrs 3.1.7, running mcp preview \n"\

api_logic_server_cli/api_logic_server_info.yaml

@@ -1,3 +1,3 @@
-last_created_date: June 09, 2025 15:38:58
+last_created_date: June 17, 2025 12:36:00
 last_created_project_name: ../../../servers/basic_demo
-last_created_version: 15.00.10
+last_created_version: 15.00.18

api_logic_server_cli/cli.py

@@ -751,7 +751,7 @@ def genai_logic(ctx, using, genai_version: str, retries: int, suggest: click.BOO
 @click.pass_context
 def genai_graphics(ctx, using, genai_version: str, replace_with: str):
     """
-        Adds (or suggests) logic to current project.
+        Adds graphics to current project.
     """
     global command
     project_dir = resolve_blank_project_name('')
@@ -779,6 +779,49 @@ def genai_graphics(ctx, using, genai_version: str, replace_with: str):
     log.info("")
 
 
+
+
+@main.command("genai-app", cls=HideDunderCommand)
+@click.option('--app-name', 'app_name',
+              default='react_admin',
+              help="Name of generated app in ui/")
+@click.option('--schema',
+              default='admin.yaml',
+              help="Model file in ui/admin/")
+@click.option('--genai-version', 'genai_version',
+              default='gpt-4o',
+              help="Eg, gpt-3.5-turbo, gpt-4o")
+@click.pass_context
+def genai_admin_app(ctx, app_name: str, schema: str, genai_version: str):
+    """
+        Adds a customizable react app to project
+    """
+    global command
+    project_dir = resolve_blank_project_name('')
+    project_name = Path(project_dir).name
+    project = PR.ProjectRun(command="add_security", 
+              project_name=project_name, 
+              db_url="",
+              execute=False
+              )
+    project.project_directory, project.api_name, project.merge_into_prototype = \
+        create_utils.get_project_directory_and_api_name(project)
+    project.project_directory_actual = os.path.abspath(os.getcwd())  # make path absolute, not relative (no /../)
+    project.project_directory_path = Path(project.project_directory_actual)
+    models_py_path = project.project_directory_path.joinpath('database/models.py')
+    project.abs_db_url, project.nw_db_status, project.model_file_name = \
+        create_utils.get_abs_db_url("0. Using Sample DB", project, is_auth=True)
+
+    if not models_py_path.exists():
+        log.info(f'... Error - does not appear to be a project: {str(project.project_directory_path)}')
+        log.info(f'... Typical usage - cd into project, use --project_name=. \n')
+        exit (1)
+    from api_logic_server_cli.genai.genai_admin_app import GenAIAdminApp
+    genai_admin = GenAIAdminApp(project=project, app_name=app_name, schema=schema, genai_version=genai_version)
+    pass
+    log.info("")
+
+
 @main.command("genai-create", cls=HideDunderCommand) 
 @click.option('--project-name', 'project_name',
               default=f'{last_created_project_name}',

api_logic_server_cli/create_from_model/api_logic_server_utils.py

@@ -374,7 +374,21 @@ def get_ontimize_apps(project_dir_path):
                         result.append(name)    
     log.debug(f"Found {len(result)} Ontimize app(s)")          
     return result
+# genai_core/fs_utils.py
 
+
+def ensure_dir(path):
+    os.makedirs(path, exist_ok=True)
+
+def write_file(path, content):
+    ensure_dir(os.path.dirname(path))
+    with open(path, 'w', encoding='utf-8') as f:
+        f.write(content)
+
+def read_file(path):
+    with open(path, 'r', encoding='utf-8') as f:
+        return f.read()
+    
 def does_file_contain(search_for: str, in_file: str) -> bool:
     """ returns True if <search_for> is <in_file> """
     with open(Path(in_file), 'r+') as fp:

api_logic_server_cli/genai/genai_admin_app copy.py

@@ -0,0 +1,150 @@
+import shutil
+from typing import Dict, List
+from api_logic_server_cli.cli_args_project import Project
+import logging
+from pathlib import Path
+import importlib
+from api_logic_server_cli.genai.genai_utils import call_chatgpt
+import requests
+import os, time
+import datetime
+import create_from_model.api_logic_server_utils as utils
+import time
+from openai import OpenAI
+from api_logic_server_cli.genai.genai_svcs import WGResult
+from api_logic_server_cli.genai.genai_svcs import Rule
+import api_logic_server_cli.genai.genai_svcs as genai_svcs
+import json
+from typing import List, Dict
+from pydantic import BaseModel
+from dotmap import DotMap
+from natsort import natsorted
+import glob
+import create_from_model.api_logic_server_utils as create_utils
+from jinja2 import Environment, FileSystemLoader
+import os
+import json
+from pathlib import Path
+from openai import OpenAI
+
+
+K_data_model_prompt = "Use SQLAlchemy to create"
+
+log = logging.getLogger(__name__)
+
+class GenAIAdminApp:
+    """ 6/13/2025
+    Creates ui/admin_app_react.zip, a source version of ui/admin/admin.yaml.
+
+    Users without JS/HTML background can use Nat Lang to customize ("Vibe for dummies").
+
+    Called by CLI for existing projects.  
+    
+    * The constructor project arg provides project.project_directory_path, to provide meta data to ChatGPT:
+        * docs/db.dbml describes the schema
+        * docs/mcp_learning/mcp_discovery.json describes the JSON:API
+        * docs/training/admin_app.md describes the app functionality and architecture
+
+    * Basic steps
+        * Step 1 – Parse Schema
+        * Step 2 – Generate <each_resource.js> (per schema)
+        * Step 3 – Generate `App.js`
+        * Step 4 – Custom dataProvider.js
+            * provide alternative for React Admin's default data provider for REST APIs,
+            * believe that is: 'ra-data-simple-rest'
+
+    Testing:
+    * BLT to create manager
+    * Use basic_demo
+    
+    """
+
+
+    def __init__(self, project: Project, genai_version: OpenAI):
+        self.project = project        
+        self.schema_path = project.project_directory_path / "docs/db.dbml"
+        self.discovery_path = project.project_directory_path / "docs/mcp_learning/mcp_discovery.json"
+        self.genai_version = genai_version
+
+        self.manager_path = genai_svcs.get_manager_path()
+
+        self.start_time = time.time()
+        self.prompt = self.compose_prompt()
+        self.response = self.get_response(self.prompt)
+        self.content = self.response.choices[0].message.content
+        self.write_output(self.content)
+        return self.content
+
+
+
+    def compose_prompt(self) -> str:
+
+        def load_prompt_parts(self):
+            """
+            Step 2: load context, functionality, and architecture prompt sections
+            """
+            context = (self.project_path / "docs/prompts/context.md").read_text()
+            functionality = (self.project_path / "docs/prompts/functionality.md").read_text()
+            architecture = (self.project_path / "docs/prompts/architecture.md").read_text()
+            return context, functionality, architecture
+
+        def load_schema(self) -> str:
+            return self.schema_path.read_text()
+
+        def load_discovery(self) -> str:
+            return json.dumps(json.loads(self.discovery_path.read_text()), indent=4)
+
+        """
+        Step 3: compose the prompt by combining static prompt parts with schema and discovery
+        """
+        context, functionality, architecture = self.load_prompt_parts()
+        schema = self.load_schema()
+        discovery = self.load_discovery()
+
+        prompt = f"""
+{context}
+
+The JSON:API backend is described by:
+docs/db.dbml describes the schema:
+
+```dbml
+{schema}
+```
+
+docs/mcp_learning/mcp_discovery.json describes the JSON:API:
+
+```json
+{discovery}
+```
+
+{functionality}
+
+{architecture}
+"""
+        return prompt
+
+
+    def get_response(self):
+        """
+        Step 4: issue the prompt to the LLM to get generated source code
+        """
+        response = self.client.chat.completions.create(
+            model="gpt-4o",
+            messages=[
+                {"role": "system", "content": "You are a senior React Admin developer."},
+                {"role": "user", "content": self.prompt}
+            ],
+            temperature=0.3
+        )
+        return response
+
+
+    def write_output(self, output: str, output_file: str = "admin_app_generated.txt"):
+        """
+        Step 5: write generated source code to output file for inspection or extraction
+        """
+        output_path = self.project_path / output_file
+        output_path.write_text(output)
+        print(f"Output written to {output_path}")
+
+

api_logic_server_cli/genai/genai_admin_app.py

@@ -0,0 +1,155 @@
+import shutil
+from typing import Dict, List
+from api_logic_server_cli.cli_args_project import Project
+import logging
+from pathlib import Path
+import importlib
+from api_logic_server_cli.genai.genai_utils import call_chatgpt
+import requests
+import os, time
+import datetime
+import create_from_model.api_logic_server_utils as utils
+import time
+from openai import OpenAI
+from api_logic_server_cli.genai.genai_svcs import WGResult
+from api_logic_server_cli.genai.genai_svcs import Rule
+import api_logic_server_cli.genai.genai_svcs as genai_svcs
+import json
+from typing import List, Dict
+from pydantic import BaseModel
+from dotmap import DotMap
+from natsort import natsorted
+import glob
+import create_from_model.api_logic_server_utils as create_utils
+from jinja2 import Environment, FileSystemLoader
+import os
+import json
+from pathlib import Path
+from openai import OpenAI
+import yaml
+import api_logic_server_cli.genai.genai_svcs as genai_svcs
+
+log = logging.getLogger(__name__)
+
+
+class JSResponseFormat(BaseModel):  # must match system/genai/prompt_inserts/response_format.prompt
+    code : str # generated javascript code (only)
+
+
+class GenAIAdminApp:
+
+    def __init__(self, project: Project, app_name: str, schema: str, genai_version: OpenAI):  #  TODO: type??
+        self.start_time = time.time()
+        
+        self.api_version = genai_version
+        self.project_root = project.project_directory_path
+        self.dbml_path = self.project_root / "docs/db.dbml"
+        self.admin_yaml_path = self.project_root / f"ui/admin/{schema}"
+        self.discovery_path = self.project_root / "docs/mcp_learning/mcp_discovery.json"
+
+        self.ui_project_path = self.project_root / f"ui/{app_name}"
+        self.ui_src_path = self.ui_project_path / "src"
+
+        self.app_templates_path = genai_svcs.get_manager_path(use_env=True).joinpath('system/genai/app_templates')
+        self.react_admin_template_path = self.app_templates_path / 'react-admin-template'
+        self.prompts_path = self.app_templates_path / "app_learning"
+        self.admin_app_learning = utils.read_file(self.prompts_path / "Admin-App-Learning-Prompt.md")
+        self.image_url = self.prompts_path / 'Order-Page.png'  # did not seem to help, made it 2x slower
+
+        # self.schema = utils.read_file(self.dbml_path)
+        self.schema_yaml = utils.read_file(self.admin_yaml_path)
+        self.schema = yaml.safe_load(self.schema_yaml)
+
+
+        self.resources = {}
+        ''' dict keyed by resource_name (todo: relns?) '''
+        self.resource_names = []
+        ''' array of resource names '''
+
+        shutil.copytree(self.react_admin_template_path, self.ui_project_path, dirs_exist_ok=True)
+
+        # self.parse_resources()
+        self.a_generate_resource_files()
+        self.b_generate_app_js()
+        # comes from copytree, above -- self.c_generate_data_provider()
+
+        log.info(f"✅ Completed in [{str(int(time.time() - self.start_time))} secs] \n\n")
+
+        log.info(f"✅ Next Steps:\n")
+        log.info('Start the API Logic Project: F5')
+        log.info('> cd ui/react-admin')
+        log.info('> npm install')
+        log.info('> npm start')
+
+
+    def a_generate_resource_files(self):
+
+        def fix_source(raw_source: str) -> str:
+            ''' remove code occasional begin/end code markers '''
+            source_lines = raw_source.splitlines()
+            result_lines = []
+            found_start_marker = False
+            for each_line in source_lines:
+                if each_line.startswith("```"):
+                    if each_line.startswith("```jsx") or each_line.startswith("```javascript"):
+                        result_lines = []
+                        continue
+                    else:
+                        break
+                result_lines.append(each_line)
+                
+            # return source_lines as a string
+            return "\n".join(result_lines)
+
+
+        for each_resource_name, each_resource in self.schema['resources'].items():
+            # image moves app gen time from 70 -> 130 secs
+            example_image_content_unused = [
+                {
+                    "type": "text",
+                    "text": "Here is a screenshot of the desired admin app layout. Use this as a visual guide to generate a React-Admin app that mimics the layout, structure, and joins."
+                },
+                {
+                    "type": "image_url",
+                    "image_url": {
+                        "url": "https://apilogicserver.github.io/Docs/images/ui-admin/Order-Page-Learning.png"
+                        # "url": f"attachment:/{str(self.image_url)}"
+                    }
+                }
+            ]
+            messages = [
+                {"role": "user", "content": "You are a helpful expert in react and JavaScript"},
+                {"role": "user", "content": self.admin_app_learning},
+                # {"role": "user", "content": example_image_content},
+                {"role": "user", "content": f'Schema:\n{self.schema_yaml}'},
+                {"role": "user", "content": f'Generate the full javascript source code for the `{each_resource_name}.js` React Admin file, formatted as a JSResponseFormat'}]
+            save_response = self.project_root / f"docs/admin_app/{each_resource_name}"
+            output = genai_svcs.call_chatgpt(messages = messages, 
+                                             api_version=self.api_version,
+                                             using=save_response,
+                                             response_as=JSResponseFormat)
+            response_dict = json.loads(output)
+            target_file = self.ui_src_path / f"{each_resource_name}.js"
+            source_code = fix_source(response_dict['code'])
+            utils.write_file(target_file, source_code)
+            log.info(f"\n✅ Wrote: {target_file}")
+
+
+    def b_generate_app_js(self):
+        messages = []
+        messages = [
+            {"role": "user", "content": "You are a helpful expert in react and JavaScript"},
+            {"role": "user", "content": self.admin_app_learning},
+            {"role": "user", "content": f'Schema:\n{self.schema_yaml}'},
+            {"role": "user", "content": f'Generate the complete App.js that wires together the above resources. for the `app.js` React Admin file, formatted as a JSResponseFormat.'}]
+        save_response = self.project_root / f"docs/admin_app/app.js"
+        output = genai_svcs.call_chatgpt(messages = messages, 
+                                            api_version=self.api_version,
+                                            using=save_response,
+                                            response_as=JSResponseFormat)
+        response_dict = json.loads(output)
+        target_file = self.ui_src_path / "App.js"
+        utils.write_file(target_file, response_dict['code'])
+
+        log.info(f"✅ Wrote: {target_file}\n")
+

api_logic_server_cli/genai/genai_svcs.py

@@ -883,7 +883,7 @@ def select_messages(messages: List[Dict], messages_out: List[Dict], message_sele
     return result
 
 
-def call_chatgpt(messages: List[Dict[str, str]], api_version: str, using: str) -> str:
+def call_chatgpt(messages: List[Dict[str, str]], api_version: str, using: str, response_as: dict=WGResult) -> str:
     """call ChatGPT with messages
 
     Args:
@@ -893,6 +893,25 @@ def call_chatgpt(messages: List[Dict[str, str]], api_version: str, using: str) -
     Returns:
         str: response from ChatGPT
     """
+
+    def admin_app_path(request_path: Path, suffix: str) -> Path:
+        '''
+        returns path = remove the last node of the path, and prepend that to _request.json
+        # Example: if request_path is /a/b/c/d/request.json, make it /a/b/c/d_request.json
+        '''
+        parent = request_path.parent
+        last_node = parent.name
+        grandparent = parent.parent
+        request_path = grandparent.joinpath(f"{last_node}_{suffix}.json")
+        request_path.parent.mkdir(parents=True, exist_ok=True)
+        return request_path
+    
+    def string_to_lines(dict_long_string: dict) -> dict:
+        result = dict_long_string
+        if isinstance(result[1]['content'], str):
+            result[1]['content'] = result[1]['content'].split('\n')
+        return result
+
     try:
         start_time = time.time()
         model = api_version
@@ -901,26 +920,46 @@ def call_chatgpt(messages: List[Dict[str, str]], api_version: str, using: str) -
             if model is None or model == "*":   # system default chatgpt model
                 model = "gpt-4o-2024-08-06"     #  33 sec
                 # model = "o3-mini"               # 130 sec
-        with open(Path(using).joinpath('request.json'), "w") as request_file:  # save for debug
-            json.dump(messages, request_file, indent=4)
+        request_path = Path(using).joinpath('request.json')
+        if 'admin_app' in str(request_path):
+            request_path = admin_app_path(request_path, 'request_raw')
+            with open(request_path, "w") as request_file:  # save for debug
+                json.dump(messages, request_file, indent=4)
+            request_path = admin_app_path(request_path, 'request')
+        messages_for_print = messages
+        # make the long string better for viewing - convert to lines.
+        messages_for_print = [msg.copy() if isinstance(msg, dict) else msg for msg in messages]
+        messages_for_print = string_to_lines(messages_for_print)  # Removed to avoid altering messages
+        with open(request_path, "w") as request_file:  # save for debug
+            json.dump(messages_for_print, request_file, indent=4)
         log.info(f'.. saved request: {using}/request.json')
         client = get_ai_client()
+        # response_format = "json_object" if wg_response else {"type": "text"}
         completion = client.beta.chat.completions.parse(
             messages=messages,
-            response_format=WGResult,
+            response_format=response_as,
             # temperature=self.project.genai_temperature,  values .1 and .7 made students / charges fail
             model=model  # for own model, use "ft:gpt-4o-2024-08-06:personal:logicbank:ARY904vS" 
         )
         log.info(f'ChatGPT ({str(int(time.time() - start_time))} secs) - response at: system/genai/temp/chatgpt_original.response')
         
         data = completion.choices[0].message.content
+
         response_dict = json.loads(data)
-        with open(Path(using).joinpath('response.json'), "w") as response_file:  # save for debug
-            json.dump(response_dict, response_file, indent=4)
-        with open(Path(using).joinpath('response.yaml'), "w") as response_file:
-            yaml.dump(response_dict, response_file, default_flow_style=False, default_style='|')
-            #yaml_string = yaml.dump(data, default_flow_style=False, default_style='|')
-            #response_dict['yaml'] = yaml_string
+        request_path = Path(using).joinpath('request.json')
+        if 'admin_app' in str(request_path):
+            request_path = admin_app_path(request_path, 'response')
+            with open(request_path, "w") as request_file:  # save for debug
+                json.dump(data, request_file, indent=4)
+        else:
+            with open(Path(using).joinpath('response.json'), "w") as response_file:  # save for debug
+                json.dump(response_dict, response_file, indent=4)
+            with open(Path(using).joinpath('response.yaml'), "w") as response_file:
+                yaml.dump(response_dict, response_file, default_flow_style=False, default_style='|')
+        request_path = Path(using).joinpath('request.json')
+        request_path = admin_app_path(request_path, 'response_raw')
+        with open(Path(request_path), "w") as response_file:  # save for debug
+            response_file.writelines(data)
         log.debug(f'.. call_chatgpt saved response: {using}/response.json')
         return data # this is a string...
     except Exception as inst:

api_logic_server_cli/logging.yml

@@ -72,6 +72,11 @@ loggers:
         handlers: [console]
         propagate: no
 
+    api_logic_server_cli.genai.genai_admin_app:   
+        level: DEBUG
+        handlers: [console]
+        propagate: no
+
 
     api_logic_server_cli.genai.genai_logic_builder:   
         level: DEBUG

api_logic_server_cli/prototypes/base/config/config.py

@@ -162,24 +162,18 @@ class Config:
     ''' keycloak client id '''
 
     SECURITY_ENABLED = os.getenv("SECURITY_ENABLED",False)
-    SECURITY_PROVIDER = None
+    SECURITY_PROVIDER =  os.getenv('SECURITY_PROVIDER', None)  # type: ignore # type: str
     if os.getenv('SECURITY_ENABLED'):  # e.g. export SECURITY_ENABLED=true
-        security_export = os.getenv('SECURITY_ENABLED')  # type: ignore # type: str
-        security_export = security_export.lower()  # type: ignore
-        if security_export in ["false", "no"]:  # NO SEC
-            SECURITY_ENABLED = False  # to remove env: unset SECURITY_ENABLED
-        else:
-            SECURITY_ENABLED = True
-        app_logger.debug(f'Security .. overridden from env variable: {SECURITY_ENABLED}')
+        security_export = os.getenv('SECURITY_ENABLED','false').lower()  # type: ignore # type: str
+        SECURITY_ENABLED = security_export not in ["false", "no"]  # NO SEC
+        app_logger.debug(f'Security .. overridden from env variable SECURITY_ENABLED: {SECURITY_ENABLED}')
     if SECURITY_ENABLED:
-        from security.authentication_provider.sql.auth_provider import Authentication_Provider
+        from security.authentication_provider.sql.auth_provider import Authentication_Provider as SQL_Authentication_Provider
+        from security.authentication_provider.keycloak.auth_provider import Authentication_Provider as KC_Authentication_Provider
         # typically, authentication_provider is [ keycloak | sql ]
-        SECURITY_PROVIDER = Authentication_Provider
-        app_logger.debug(f'config.py - security enabled')
-    else:
-        app_logger.info(f'config.py - security disabled')
-	
-    app_logger.info(f'SECURITY_PROVIDER={SECURITY_PROVIDER}')
+        SECURITY_PROVIDER = KC_Authentication_Provider if "keycloak" in str(SECURITY_PROVIDER).lower() else SQL_Authentication_Provider
+    
+    app_logger.info(f'config.py - security enabled: {SECURITY_ENABLED} using SECURITY_PROVIDER: {str(SECURITY_PROVIDER)}\n')
 
     # Begin Multi-Database URLs (from ApiLogicServer add-db...)
     auth_db_path = str(project_path.joinpath('database/authentication_db.sqlite'))

api_logic_server_cli/prototypes/base/docs/training/admin_app_1_context.prompt.md

@@ -0,0 +1,3 @@
+
+Generate a full React Admin application using the following instructions.  
+The result must be a runnable React app (`npm start`) that connects to the supplied JSON:API, with fully implemented components (no placeholders or empty files).

api_logic_server_cli/prototypes/base/docs/training/admin_app_2_functionality.prompt.md

@@ -0,0 +1,69 @@
+
+
+## App Features
+
+### Multi-Page
+
+For each resource:
+- Create a **List page** showing 7 user-friendly columns
+- Add **pagination**, **sorting**, and **filtering**
+- Link each row to a **Display (Show) page**
+
+### Multi-Resource
+
+Each **Display Page** should:
+- Show all fields in a **multi-column layout**
+- Include a **tab sheet** (`<TabbedShowLayout>`) for each related resource using `<ReferenceManyField>`
+- Link child rows to their own display page
+
+Example:  
+- Customer Display has tab for OrderList  
+- Each Order in the tab links to Order Display
+
+### Automatic Joins
+
+For foreign keys:
+- Display joined value (e.g., `product.name` instead of `product_id`)
+- Use first string field from parent table containing `name`, `title`, or `description`
+
+Primary key fields:
+- Display at the end of forms/lists
+
+### Lookups (Foreign Keys)
+
+For foreign key fields:
+- Provide auto-complete dropdown (`<ReferenceInput>`)
+- For numeric foreign keys, use the joined string field as lookup text
+
+
+---
+
+## Per-Resource Files (Required)
+
+For each resource (`Customer`, `Order`, `Product`, `Item`):
+- Create a source file under `src/`, e.g., `Customer.js`
+- **Each file must fully implement**:
+  - `CustomerList`
+  - `CustomerShow`
+  - `CustomerCreate`
+  - `CustomerEdit`
+
+Use:
+- `<ReferenceField>` for foreign key displays
+- `<ReferenceInput>` for foreign key input
+- `<ReferenceManyField>` for tabbed child lists
+- `<TabbedShowLayout>` for display pages
+
+Do **not leave any file empty**.
+
+---
+
+## App Wiring
+
+In `App.js`:
+- Import each resource file
+- Register them in `<Admin>` using:
+
+```jsx
+<Resource name="Customer" list={CustomerList} show={CustomerShow} edit={CustomerEdit} create={CustomerCreate} />
+```

api_logic_server_cli/prototypes/base/docs/training/admin_app_3_architecture.prompt.md

@@ -0,0 +1,29 @@
+
+## Architecture
+
+- **Framework**: React 18 + react-admin 4.x
+- **Data Provider**: Custom `dataProvider.js` using `fetchUtils` (no external `ra-jsonapi-client`)
+  - Must support: `getList`, `getOne`, `getMany`, `getManyReference`, `create`, `update`, `delete`
+  - Must support: filters, joins, sorting, pagination
+- **Backend**: JSON:API per `mcp_discovery.json`
+- **CORS**: Ensure API allows `http://localhost:3000`
+  ```py
+  from flask_cors import CORS  
+  CORS(app, origins='*')  # or restrict to localhost:3000
+  ```
+- **Project Setup**:
+  - Use `create-react-app`
+  - Include: `react-admin`, `@mui/material`, `@emotion/react`, `@emotion/styled`, `react-router-dom`
+  - Do not use any deprecated or unmaintained libraries
+  - Include complete and correct `App.js`, `index.js`, `dataProvider.js`, and `index.html`
+
+---
+
+## Run Instructions
+
+```bash
+npm install
+npm start
+```
+
+Then open in browser: `http://localhost:3000`