Main Entities

1. Entity

Entity is the core model of the system, serving as the foundation for creating various types of models. It allows users to define components, organize metadata, and generate the necessary backend and frontend structures for models such as pages, views, and forms. The drag-and-drop interface and flexibility make it a versatile tool for general-purpose model creation.

---

2. Builders

Builders are specialized entities created using the Entity model, designed to generate specific types of models. While Entity offers general-purpose functionality, Builders focus on tailoring metadata and functionality to meet the requirements of particular model types. This eliminates unnecessary metadata and ensures optimized structures for each case.

Types of Builders

• Page Builder
  Focused on creating desktop or web pages, the Page Builder provides all the tools needed to design complete web pages such as homepages, blogs, or landing pages. It ensures only the essential metadata for a page is included, offering a streamlined and efficient page-building experience.

• View Builder
  The View Builder creates models designed specifically for rendering data. Its main function is to connect to a model and visually display its metadata. It also allows users to customize the layout and presentation of the view, offering flexibility for unique display needs.

• Form Builder
  The Form Builder is specialized in creating forms. Its primary purpose is to facilitate data collection and submission to a controller. Examples include login forms, password recovery forms, or specific forms for handling segments of a model.

• Controller Builder
  The Controller Builder focuses on generating the structure of server-side controllers. It is ideal for creating controllers such as LoginController that manage specific actions like login, registration, or password reset. Controllers built this way enable the creation of routes and actions without requiring a full model, providing an efficient solution for specific backend tasks.

---

By providing these specialized Builders, Loopar ensures a highly efficient and streamlined development process, where each model type is perfectly adapted to its intended purpose.

App

The App entity serves as the main organizer of the system. It features a structured arrangement of folders and files represented by Modules, Module Types, and Entities.

This representation transforms into an independent program within the system, encapsulating all its modules and models within its structure. Moreover, it can be installed or uninstalled in an initialized environment.

When an app is created, a module with the same name as the app is also generated. Subsequently, any created entities, whether database models or web pages, are associated with the app through the selection of its corresponding module.

The system provides an interface at desk/App Manager/view that allows managing apps within the system. This includes installing or uninstalling them or retrieving them from a repository.

Folder Structure of App

/apps
	/loopar-webpage
		/modules
			/pages
				/loopar-concepts
					/client
						loopar-concepts-view.jsx
					loopar-concepts.js
					loopar-concepts-controller.js
					loopar-concepts.json

apps/

The main branch of the directory is /apps, which serves as the root directory for all applications in the system.

App Name/

Each app resides within its own directory, named after the app, such as /loopar-webpage. This encapsulates all the app's components and modules.

Modules/

Within the app directory, the /modules folder organizes the app into broader functional categories, such as core, sales, or client. These modules represent a higher-level organization that groups related entities and functionality.

Models Within Modules

Each module contains subdirectories that house individual models. For example, within a /pages directory, you might find models like loopar-concepts.

Model Files/

Each model has its own directory, which includes the following key files:

• Client/ Contains frontend files, such as loopar-concepts-view.jsx, for rendering the model’s user interface.

• Model.js Manages the model's data and provides the logic for data handling and processing.

• model-controller.js Defines the permitted or customized actions for the model, such as specific API endpoints or logic for user interactions.

• model.json
  Contains the metadata for the model, including its schema, attributes, and configuration settings.

This hierarchical structure ensures that each app is modular, with clearly defined modules that group related functionality, and that each model within those modules is well-organized and self-contained