@powerhousedao/academy 5.1.0-dev.0 → 5.1.0-dev.10

package/docs/academy/00-EthereumArgentinaHackathon.md

@@ -1,207 +0,0 @@
----
-id: EthereumArgentinaHackathon
-title: Ethereum Argentina Hackathon
----
-
-# Ethereum Argentina Hackathon
-
-**November 19-20, 2024**
-
-Welcome to the Vetra hacker page for the Ethereum Argentina Hackathon! We're excited to support developers building with Powerhouse during this event.
-
-## Overview
-
-Join us for two days of intensive development support as you build decentralized applications using the Vetra framework. Our team will be available online and at the mentor's table to help you navigate the builder platform, answer questions, and guide you through best practices.
-
-## 📅 Event Details
-
-- **Dates**: November 19-20, 2024
-- **Format**: Online & IRL Developer Support
-- **Time Zone**: Argentina Time (ART)
-- **Support Hours at Mentor Table @ la Rural**: Please get in touch [on Discord to schedule](https://discord.gg/pwQJwgaQKd)
-- **Hackathon informations**: [Taiki Hackathon](https://taikai.network/ethargentina/hackathons/tierra-de-buidlers-2025/overview)
-
-## 🚀 Getting Started
-
-<details>
-<summary> Vetra Introduction & Follow Along Demo </summary>
-
-Please Rewatch our Hackathon introduction & follow along tutorial. 
-
-<iframe width="560" height="315" src="https://www.youtube.com/embed/R5MAaGaopJg" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>
-
-Find a complete overview of how to use the Vetra Studio for you project [here](./01-GetStarted/05-VetraStudio.md)
-
-**Quick Start Summary**
-
-- Step 1: Install the powerhouse-CLI: `pnpm install -g ph-cmd`
-- Step 2: Initialize a project & directory `ph init my-project-name`
-- Step 3: CD into you project directory
-- Step 4: Launch Vetra Studio with the `ph vetra`command
-- Step 5: Add the necessary document models & editors for your intended solution in Vetra Studio
-- Step 6: If you're well versed in schema creation or graphql. Just talk with an agent about your imagined solution.
-- Step 7: Start your preferred agent to help you with the initial scaffolding of your schema, operations and reducers. 
-- Step 8: Test your implementation in the "Vetra Preview Drive" with the `ph vetra --watch`command. 
-- Step 9: Run pnpm build and push your project to a remote repository. Follow the package publishing [Tutorial](./02-MasteryTrack/05-Launch/02-PublishYourProject.md)
-
-**Basic tips** 
-- 1️⃣ Write a detailed description of your intented functionality inside the document model specification manifest
-- 2️⃣ Ask your agent to ask for clarifying questions before starting any ideation process. 
-- 3️⃣ For each document model you'll want to create an accompanying editor in vetra studio. 
-- 4️⃣ An 'App' specifcation is an drive that can act as an app because of the specific interface you create for it. 
-
-### Before the Hackathon
-
-1. **Set Up Your Environment**
-   - Install the Powerhouse CLI
-   - Set up your development environment
-   - Review the [Get Started Guide](./01-GetStarted/home.mdx)
-
-2. **Explore the Platform**
-   - Check out the [Demo Package](./01-GetStarted/00-ExploreDemoPackage.mdx)
-   - Familiarize yourself with [Document Models](./02-MasteryTrack/02-DocumentModelCreation/01-WhatIsADocumentModel.md)
-
-3. **Join Our Community**
-   - Discord: [Join our server](#)
-
-
-</details>
-
-:::tip Use your preferred AI agent
-Vetra studio is compatible with Cursor, Claude and Gemini. Find the dedicated markdown files to guide your agent with the correct instruction in your directory. Your agent should also have access to the MCP's available. 
-::: 
-
-
-## **Hackathon Project Ideas**
-
-Powerhouse is perfect for building:
-
-- **Real World Use-cases**: Every document can act as a mini ledger/blockchain. 
-- **Decentralized Applications**: Create apps with built-in version control and collaboration.
-- **Document-Based Systems**: Build structured data applications.
-- **Collaborative Tools**: Enable real-time multi-user editing.
-- **Data Management Platforms**: Create systems with queryable, structured data.
-
-### Coordination & DAO Design
-
-- 🧩 **What if** DAOs weren't chaotic? What documents would you need to make them coordinate like space X and ship like stripe?
-- 🎯 **What if** making decisions as a group felt like playing a co-op strategy game. With a clearly aligned vision, instant dashboards and a way to capture hard won knowledge in expertise into custom software for the Dao?
-
-:::tip IDEA
-The ultimate DAO Template toolkit where vision & mission documents influence guidelines & onboarding for contributors.
-:::
-
----
-
-### GovTech & Public Infrastructure
-
-- 🗳 **What if** local governments had to reach consensus with residents before making a decision? How would that look like?
-- 🚧 **What if** you could submit pothole fixes or transit complaints into a civic DAO, and track the response like GitHub issues?
-- 🧾 **What if** municipal budgets were editable public documents with community feedback loops?
-
-:::tip IDEA
-An Open Source Enterprise Resource Planning-suite for municipalities & governments
-:::
-
----
-
-### Education & Group Work
-
-- 📝 **What if** your group project auto-divided work, tracked contributions, and paid out in real-time?
-- 👾 **What if** "homework" was a multiplayer quest, and grades came from the DAO?
-- 🏫 **What if** we DAO-ified a classroom and let the students vote on rules, roles, and rewards?
-
-:::tip IDEA
-The remote classroom SAAS back-end that fosters connection, gives purpose to bullies and empowers younger generation to dream big again.
-:::
-
----
-
-### 💸 Grants, Crypto, and Incentive Design
-
-- 💰 **What if** grant tooling felt like bounty hunting across a galaxy of projects?
-- 📊 **What if** every grant had a live budget dashboard, contributor feed, and impact score?
-- 🎮 **What if** you could stake on coordination itself, betting that people will work together well?
-
-:::tip IDEA
-The future of grant platforms that dares to imagine grants in new ways. With follow up, tracking and impact visualisations of teams, time, risk & resources invested.
-:::
-
----
-
-### 💸 Lawmaking, Legislation & Legal
-
-- 🧑‍⚖️ **What if** any government or DAO could fork a legal template, customize it, and track changes in a public, composable way?
-- 🎨 **What if** legislation could be transparently co-created by citizens, NGOs, and governments all with aligned incentives?
-- 💻 **What if** legislation, contracts & templates could exist on an open-source market place like software?
-- 🤖 **What if** a network agent could create a legal vehicle by simply inputing  set of requirements and risk preferences (in non legalese)?
-- 🤝 **What if** 2 agents in a network could negotiate terms of an agreement according to predefined functions and risk parameters, without lawyers?
-
-:::tip IDEA
-Build a Decentralized Lawmaking Engine using Reactive Document Models
-:::
-
-
-## 🛠️ Resources
-
-### Documentation
-
-- [Quick Start Guide](./01-GetStarted/home.mdx)
-- [Create a New Project](./01-GetStarted/01-CreateNewPowerhouseProject.md)
-- [Define Document Models](./01-GetStarted/02-DefineToDoListDocumentModel.md)
-- [Build Editors](./01-GetStarted/04-BuildToDoListEditor.md)
-- [API References](./04-APIReferences/00-PowerhouseCLI.md)
-
-### Tutorials
-
-- [To-Do List Example](./01-GetStarted/02-DefineToDoListDocumentModel.md)
-- [Chatroom Use Case](./03-ExampleUsecases/Chatroom/02-CreateNewPowerhouseProject.md)
-
-## 🏆 Judging Criteria
-
-Projects will be evaluated based on:
-
-- **Usefulness & Impact**: How well does it solve a certain job or problem?
-- **Composability/Structure**: How are the different document models and / or drive apps collaborating?
-- **Clarity of the developer or user experience**: Did you unlock the secret sauce of UX & reactive documents?
-- **Alignment with Vetra/Powerhouse principles**: Local-first, auditable, usefull for common good. 
-
-## 📋 Submission Guidelines
-
-### What to Submit
-
-- GitHub repository with your code
-- (Video) presentation (2-3 minutes)
-- README with:
-  - Project description
-  - Setup instructions
-  - Screenshots/demos
-  - Technologies used
-
-The Powerhouse team will add you as a builder on the Vetra platform and host your application and drive. 
-
-
-## Tips for Success
-
-### Development Tips
-
-1. **Start Simple**: Begin with a basic implementation and iterate
-2. **Use Templates**: Leverage existing examples and templates
-3. **Ask Questions**: Don't hesitate to reach out for help
-4. **Test Early**: Test your application frequently during development
-5. **Document**: Keep notes on your decisions and implementations
-
-### Presentation Tips
-
-1. **Show, Don't Tell**: Live demos are more impactful than slides
-2. **Tell a Story**: Explain the problem you're solving
-3. **Highlight Innovation**: Show what makes your solution unique
-4. **Be Concise**: Respect the time limits for presentations
-5. **Prepare Backup**: Have screenshots/video in case of technical issues
-
----
-
-**Good luck, and happy hacking! 🚀**
-
-*Last updated: November 17, 2025*
-

package/docs/academy/01-GetStarted/04-BuildToDoListEditor.md

@@ -1,218 +0,0 @@
-# Build a to-do list editor
-
-In this chapter we will continue with the interface or editor implementation of the **To-do List** document model. This means you will create a simple user interface for the **To-do List** document model which will be used inside the Connect app to create, update and delete your ToDoList items.
-
-## Generate the editor template
-
-Run the command below to generate the editor template for the **To-do List** document model.  
-This command reads the **To-do List** document model definition from the `document-models` folder and generates the editor template in the `editors/to-do-list` folder as `editor.tsx`.
-
-Notice the `--editor` flag which specifies the **To-do List** document model, and the `--document-types` flag defines the document type `powerhouse/todolist`.
-
-```bash
-ph generate --editor ToDoList --document-types powerhouse/todolist
-```
-
-Once complete, navigate to the `editors/to-do-list/editor.tsx` file and open it in your editor.
-
-### Editor implementation options
-
-When building your editor component within the Powerhouse ecosystem, you have several options for styling, allowing you to leverage your preferred methods:
-
-1.  **Default HTML Styling:** Standard HTML tags (`<h1>`, `<p>`, `<button>`, etc.) will render with default styles offered through the boilerplate.
-2.  **Tailwind CSS:** Connect Studio comes with Tailwind CSS integrated. You can directly use Tailwind utility classes for rapid, consistent styling without writing separate CSS files.
-3.  **Custom CSS Files:** You can import traditional CSS files (`.css`) to apply custom styles or integrate existing style libraries.
-
-Connect Studio provides a dynamic local environment, by running `ph connect` to visualize your components instantly as you build them, regardless of the styling method you choose.  
-Manual build steps are typically only needed when publishing packages.
-
-## To-do List editor
-
-Below is the complete code for the To-Do List editor. Paste this code in `editors/to-do-list/editor.tsx`.
-
-<details>
-<summary>Complete ToDoList Editor Example (using Tailwind CSS)</summary>
-
-```typescript
-import { EditorProps } from 'document-model';
-import {
-    ToDoListState,
-    ToDoListAction,
-    ToDoListLocalState,
-    ToDoItem,
-    actions,
-    ToDoListDocument,
-} from '../../document-models/to-do-list/index.js';
-import { useState } from 'react';
-
-// EditorProps is a generic type that provides the document and a dispatch function.
-// The dispatch function is used to send actions to the document's reducer to update the state.
-export type IProps = EditorProps<ToDoListDocument>;
-
-export default function Editor(props: IProps) {
-    // Destructure document and dispatch from props.
-    const { document, dispatch } = props;
-    // Get the global state from the document. This state is shared across all editors of this document.
-    const {
-        state: { global: state },
-    } = document;
-
-    // React's useState hook is used for local component state.
-    // This state is not shared with other components.
-    // `todoItem` stores the text of the new to-do item being added.
-    const [todoItem, setTodoItem] = useState('');
-    // `editingItemId` stores the ID of the item currently being edited.
-    const [editingItemId, setEditingItemId] = useState<string | null>(null);
-    // `editedText` stores the text of the item while it's being edited.
-    const [editedText, setEditedText] = useState('');
-
-    return (
-        <div className="p-4 font-sans max-w-lg mx-auto">
-            <h1 className="text-2xl font-bold mb-4 text-center">To-do List</h1>
-            <div className="w-96 mx-auto">
-                <div className="flex mb-4">
-                    <input
-                        className="border border-gray-300 p-2 rounded-l-md flex-grow"
-                        placeholder="Insert task here..."
-                        value={todoItem}
-                        onChange={e => setTodoItem(e.target.value)}
-                        onKeyDown={e => {
-                            if (e.key === 'Enter') {
-                                // Dispatch an action to add a new to-do item.
-                                // `actions.addTodoItem` is an action creator from our document model.
-                                dispatch(
-                                    actions.addTodoItem({
-                                        id: Math.random().toString(), // In a real app, use a more robust ID generation.
-                                        text: todoItem,
-                                    })
-                                );
-                                setTodoItem('');
-                            }
-                        }}
-                    />
-                    <button
-                        className="bg-blue-500 hover:bg-blue-600 text-white p-2 rounded-r-md"
-                        onClick={() => {
-                            // Also add item on button click.
-                            dispatch(
-                                actions.addTodoItem({
-                                    id: Math.random().toString(),
-                                    text: todoItem,
-                                })
-                            );
-                            setTodoItem('');
-                        }}
-                    >
-                        Add
-                    </button>
-                </div>
-                <ul className="list-none p-0">
-                    {/* Map over the items in the global state to render each to-do item. */}
-                    {state.items.map((item: ToDoItem) => (
-                        <li
-                            key={item.id}
-                            className="flex items-center p-2 relative border-b border-gray-200"
-                        >
-                            <input
-                                type="checkbox"
-                                checked={item.checked}
-                                className="mr-3"
-                                onChange={() => {
-                                    // Dispatch an action to update the checked status of an item.
-                                    dispatch(
-                                        actions.updateTodoItem({
-                                            id: item.id,
-                                            checked: !item.checked,
-                                        })
-                                    );
-                                }}
-                            />
-                            {/* Conditional rendering: show an input field if the item is being edited, otherwise show the text. */}
-                            {editingItemId === item.id ? (
-                                <input
-                                    value={editedText}
-                                    onChange={e =>
-                                        setEditedText(e.target.value)
-                                    }
-                                    onKeyDown={e => {
-                                        if (e.key === 'Enter') {
-                                            // Dispatch an action to update the item's text.
-                                            dispatch(
-                                                actions.updateTodoItem({
-                                                    id: item.id,
-                                                    text: editedText,
-                                                })
-                                            );
-                                            // Exit editing mode.
-                                            setEditingItemId(null);
-                                        }
-                                    }}
-                                    className="flex-grow"
-                                    autoFocus // Automatically focus the input when it appears.
-                                />
-                            ) : (
-                                <div className="flex items-center flex-grow gap-1">
-                                    <span
-                                        onClick={() => {
-                                            // Enter editing mode when the text is clicked.
-                                            setEditingItemId(item.id);
-                                            setEditedText(item.text);
-                                        }}
-                                        className={`cursor-pointer ${
-                                            item.checked
-                                                ? 'line-through text-gray-500'
-                                                : ''
-                                        }`}
-                                    >
-                                        {item.text}
-                                    </span>
-                                    <span
-                                        onClick={() =>
-                                            dispatch(
-                                                actions.deleteTodoItem({
-                                                    id: item.id,
-                                                })
-                                            )
-                                        }
-                                        className="text-gray-400 cursor-pointer opacity-40 transition-all duration-200 text-base font-bold inline-flex items-center pl-1 hover:opacity-100 hover:text-red-500"
-                                    >
-                                        ×
-                                    </span>
-                                </div>
-                            )}
-                        </li>
-                    ))}
-                </ul>
-            </div>
-        </div>
-    );
-}
-```
-
-</details>
-
-Now you can run the Connect app and see the **To-do List** editor in action.
-
-```bash
-ph connect
-```
-
-In Connect, in the bottom right corner you'll find a new Document Model that you can create: **To-do List**.  
-Click on it to create a new To-do List document.
-
-:::info
-The editor will update dynamically, so you can play around with your editor styling while seeing your results appear in Connect Studio.
-:::
-
-Congratulations!
-If you managed to follow this tutorial until this point, you have successfully implemented the **To-do List** document model with its reducer operations and editor.
-
-### Up next: Mastery Track
-
-In the [Mastery Track chapther: Document Model Creation](/academy/MasteryTrack/DocumentModelCreation/WhatIsADocumentModel) we guide you through the theoretics of the previous steps while created a more advanced version of the To-do List.
-
-You will learn:
-
-- The in's & out's of a document model.
-- How to use UI & Scalar components from the Document Engineering system.
-- How to build Custom Drive Apps or Drive Explorers.

package/docs/academy/01-GetStarted/06-ReactorMCP.md

@@ -1,58 +0,0 @@
-# Tool: Reactor MCP
-
-**Reactor-mcp** is a Model Context Protocol (MCP) server for the Powerhouse ecosystem that provides AI agents and tools with structured access to document model operations. 
-It serves as a bridge between AI systems and the Powerhouse document management infrastructure.
-
-## Main Functions of the Reactor-mcp
-
-**Document Operations**:
-- createDocument - Create new documents
-- getDocument - Retrieve documents by ID
-- addActions - Add actions to modify document state
-- deleteDocument - Remove documents
-
-**Drive Operations**:
-- getDrives - List all document drives
-- addDrive - Create new drives
-- getDrive - Retrieve specific drives
-- addRemoteDrive - Connect to remote drives
-
-**Document Model Operations**:
-- getDocumentModels - List available document model types
-- getDocumentModelSchema - Get schema for specific document models
-
-<details>
-<summary>Architecture Context</summary>
-
-Within the broader Powerhouse ecosystem:
-
-- Document Model: Defines structure and operations for document types
-- Document Drive: Manages collections of documents with sync capabilities
-- Reactor-MCP: Provides AI/tool access to document operations
-- Connect/Switchboard: User interfaces and synchronization servers
-
-The reactor-mcp essentially makes the sophisticated document model system accessible to AI agents and external tools through a standardized protocol, enabling programmatic document creation, modification, and management within the Powerhouse ecosystem.
-
-</details>
-
-### Document Model Agent
-
-Alongside the MCP is a **specialized AI agent** for document model creation:
-
-- Purpose: Guide users through creating document models
-- Workflow: Requirements gathering → Design confirmation → Implementation
-- Tools: Comprehensive set of MCP tools for model management
-- Capabilities: 
-    - State schema definition
-    - Operation creation
-    - Module organization
-    - Code generation
-
-:::tip Supports with:
-
-1. **AI-Assisted Document Model Creation**: AI agents can use the MCP tools to help users create and modify document models
-2. **Automated Document Management**: Programmatic creation and management of documents and drives
-3. **Integration with AI Tools**: Claude, GPT, or other AI systems can use this as an MCP server to interact with Powerhouse
-4. **Development Tooling**: CLI and development server for working with document models locally
-:::
-

package/docs/academy/05-Architecture/02-ReferencingMonorepoPackages

@@ -1,65 +0,0 @@
-# Referencing Monorepo Packages
-
-## **Context**
-
-In scenarios where a project is not part of the monorepo but needs to reference monorepo packages (e.g., using `@powerhousedeao/ph-cli`), there's a streamlined approach that avoids duplicating dependencies and maintains consistency with monorepo versions.
-
----
-
-## **Approach**
-
-### **1. Using `link:` in `package.json`**
-
-Instead of manually copying dependencies or trying complex build setups, you can use the `link:` protocol to create a symlink to the monorepo package.
-
-```json
-{
-  "dependencies": {
-    "@powerhousedeao/ph-cli": "link:../monorepo/clis/ph-cli"
-  }
-}
-```
-
-This approach creates a symlink under the node_modules directory, linking directly to the specified monorepo package.
-
-### **2. Running the Linked CLI**
-
-After linking, you can run the CLI tool using pnpm:
-
-```bash
-pnpm install
-pnpm run ../powerhouse/clis/ph-cli
-```
-
-Alternatively, use the command through the linked CLI:
-
-```bash
-ph connect
-```
-
-This will invoke the connect package from the monorepo.
-
-### **3. Building Dependencies**
-
-To ensure all dependencies are correctly built:
-
-```bash
-nx run @powerhousedeao/ph-cli
-```
-
-This command will build all necessary dependencies within the monorepo.
-
-### **4. Key Insights**
-
-- **Symlink Simplicity:** The link: protocol is the least disruptive, as it avoids version conflicts and unnecessary duplication.
-- **Development Workflow:** Changes made to the connect code in the monorepo will be picked up automatically when using the linked CLI, as ph-cli defers calls to the respective packages.
-
-### **5. Troubleshooting**
-
-If dependencies aren't picked up correctly: Ensure the symlink path is accurate relative to the project root.
-
-For isolated package builds: Use nx run to trigger specific package builds when needed.
-
-### **6. Conclusion**
-Using link: is an effective, developer-friendly method to reference monorepo packages in external boilerplate projects. It supports efficient development workflows, reduces redundancy, and ensures consistency across environments.
-

package/docs/academy/05-Architecture/04-MovingBeyondCRUD

@@ -1,61 +0,0 @@
-# Moving Beyond CRUD
-
-Powerhouse uses "single field operations" as granular actions that go beyond traditional CRUD (Create, Read, Update, Delete) operations.   
-In a basic CRUD framework, the focus is on making entire objects or records editable as a whole, often leading to oversimplified data management that can't easily handle complex workflows or state transitions.
-
-## What Are Single Field Operations?
-These are focused, granular updates to individual fields within a document rather than treating the document as a whole. This approach allows for precise control and tracking of changes. For example:
-
-- Setting a Document Number (simple string input)
-- Changing Master Status (an enum dropdown selection)
-
-Each of these operations targets only one field and has a corresponding form that collects and submits the new value.
-
-## Why go beyond CRUD?
-
-### Granular State Tracking:
-Powerhouse's system emphasizes understanding how documents transition from one state to another in fine detail. By breaking down actions into specific field-level operations, it allows for tracking the exact sequence of changes, which is crucial for things like auditing, version control, and complex workflows.
-
-### Operational Focus:
-The system is designed around the idea of operations themselves—not just the data they manipulate. While traditional CRUD frameworks might treat each field as independently updatable without any logic or process attached, Powerhouse assigns specific operations that can enforce business rules and state transitions.
-
-### Customization & Flexibility:
-CRUD frameworks are often too rigid for real-world applications that need more nuanced behaviors. Powerhouse offers both the simplicity of CRUD for standard operations and the ability to go deeper, defining more complex, field-specific operations when needed. This hybrid approach ensures flexibility without sacrificing systematic structure.
-
-### Automation Potential:
-Even though creating these granular operations might seem tedious, the goal is to build a system where standard CRUD operations can eventually be auto-generated, leaving developers to focus only on defining the exceptional, non-standard behaviors.
-
-### Improved Permissions and User Intent:
-By having specific operations tied to individual fields, it becomes easier to manage permissions (e.g., who can change the master status but not the content) and to capture user intent more precisely, which is valuable in complex collaborative environments.
-
-
-## Understanding the Code Example
-
-![Alt text for the image](./images/image.png)
-
-| `SetDocNumberForm.tsx` (StringField) | `SetMasterStatusForm.tsx` (EnumField) |
-|-------------------------------------|---------------------------------------|
-| **Purpose:** To update the document number (a string field).<br /><br />**How it works:**<br />- A form is rendered with a StringField input<br />- The defaultValue comes from the document model (props.defaultValue.docNo)<br />- On submit (or onBlur), the new document number is dispatched via the dispatch function<br />- It uses a generic onSubmit handler that processes the collected input and triggers the document update<br /><br />**Key takeaway:**<br />- This is a simple, single field form that maps a scalar string to a reusable component (StringField)<br />- The form structure is systematic: label, name, placeholder, and onBlur event handler | **Purpose:** To update the master status (an enum field).<br /><br />**How it works:**<br />- A form is rendered with an EnumField dropdown<br />- The dropdown options are enum values like "APPROVED", "DEFERRED", etc.<br />- The default value is pre-filled from props.defaultValue.masterStatus<br />- On change, the form dispatches the updated status<br /><br />**Key takeaway:**<br />- This form uses an EnumField component, showcasing how different scalar types (in this case, enums) map to different input components<br />- Options are provided systematically, meaning they could potentially be auto-generated from the document model |
-
-
-
-## Why Is This Granular Approach Important?    
-1. **Systematic Yet Customizable:**
-Even we are manually building these forms now, the structure is simple and repeatable:
-- Identify the scalar type (string, enum, etc.).
-- Map it to a reusable component.
-- Use a standardized form structure with an onSubmit handler and a dispatch function.
-2. **Auto-Generation Potential:**
-The systematic nature of these forms means they could be automatically generated in the future.
-- For example, if a field is identified as a string, the system could auto-generate a form using a StringField.
-- For enums, it could auto-generate the EnumField with all valid options.
-
-
-## How to implement single field operations
-
-### At the schema definition level
-
-### At the frontend level
-
-
-