2.2.0

MagicAppBuilder Version 2.2.0

Date: March 1st, 2026

What’s New

Import Database Schema from MySQL Workbench Model

MagicAppBuilder 2.2.0 introduces the ability to import database schemas directly from a MySQL Workbench model file. This feature helps streamline migration and accelerates project setup by preserving structural and relational integrity.

What is imported?

1. Table structures – Including columns, data types, primary keys, constraints, and table options.
2. Indexes – All single-column and multi-column indexes are imported, including unique indexes.
3. Foreign keys – All defined relationships between tables are recognized and reconstructed.
4. Table data – Existing records can be imported along with the schema.
5. Diagrams – Visual database diagrams are preserved to maintain layout and design context.

This ensures that logical structure, performance-related definitions, and visual representation are retained during the import process.

Export Database Schema to MySQL Workbench Model

You can now export your database design from MagicAppBuilder into a MySQL Workbench model format. This makes it easier to collaborate with teams that use MySQL Workbench or to continue development in other tools.

What is exported?

1. Table structures – Complete definitions including columns, primary keys, constraints, and table configuration.
2. Indexes – All index definitions (single-column, multi-column, and unique indexes) are exported accurately.
3. Foreign keys – All table relationships are exported with full referential definitions.
4. Table data – Optional export of data along with schema definitions.
5. Diagrams – Database diagrams are generated to reflect the current design layout.

This feature ensures compatibility and smooth interoperability between MagicAppBuilder and MySQL Workbench while preserving performance-related metadata.

Enhanced Foreign Key Support

MagicAppBuilder version 2.2.0 significantly improves foreign key support across multiple workflows.

Foreign keys are now fully supported in:

• Database design creation
• Schema import
• Schema export
• Database query export

This enhancement guarantees relational consistency throughout the entire database lifecycle — from design and migration to deployment.

Enhanced Index Support

MagicAppBuilder 2.2.0 introduces comprehensive improvements to index management across the entire database modeling workflow.

Indexes are now fully supported in:

• Database design creation
• Schema import
• Schema export
• Database query export

This enhancement ensures that index definitions — including single-column, multi-column, and unique indexes — are accurately preserved during import and export operations.

Index indicators are also visually integrated into the Entity Editor, allowing users to quickly identify indexed columns directly within the column list. This improves clarity when designing performance-sensitive schemas.

With these improvements, MagicAppBuilder provides more reliable performance modeling and better consistency between logical design and generated database structures.

What’s Changed

The button layout in the Entity Editor has been redesigned.

Previously, there were too many buttons displayed below the diagram, which required a high screen resolution to view them all properly. In version 2.2.0, several of these buttons have been moved into dropdown menus.

This improvement makes the interface cleaner, more organized, and more accessible on lower-resolution screens.

Fixes

DOM Structure Fix in Update and Detail Pages

In previous versions, there was an incorrect DOM structure in the Update and Detail pages. Although this issue did not directly affect the default appearance, it could cause layout instability if users modified the generated code — potentially resulting in broken or disorganized page structures.

Version 2.2.0 resolves this DOM structure issue, ensuring a cleaner and more stable markup foundation. This improvement makes the modules safer and more reliable for customization and further development.

MagicAppBuilder 2.2.0 represents a significant step forward in database modeling, delivering stronger relational support, improved performance design, and seamless integration with professional database tools.

What's Changed

• Version 2.2.0 by @kamshory in #867
• Add index by @kamshory in #868
• Update CHANGELOG.md by @kamshory in #869
• Update CHANGELOG.md by @kamshory in #870
• Update Context Menu by @kamshory in #871
• add-index by @kamshory in #872
• Add index by @kamshory in #873
• Feature/version 2.2.0 by @kamshory in #874
• Feature/version 2.2.0 by @kamshory in #875
• Fix generate MWB by @kamshory in #876

Full Changelog: 2.1.0...2.2.0

2.1.0

MagicAppBuilder Version 2.1.0

Date: January 15th, 2026

What's New

New Feature: Import Database from Markdown

In line with MagicAppBuilder’s mission to make data import as seamless as possible, version 2.1 introduces support for importing databases from Markdown.

Since Markdown is a text-based format, the import process does not involve selecting a Markdown file directly. Instead, users open their Markdown file, copy the content to the clipboard, and paste it into the editor. MagicAppBuilder will automatically detect and extract all tables from the pasted content.

After import, users are expected to adjust table names and column names to align with MagicAppBuilder’s naming conventions. Importantly, all data from the Markdown document remains intact, even if column names are modified.

New Feature: Add Special Access for Key Module

In the previous version, there was a potential risk of users losing access to key modules, such as modules for adding users, adding modules, managing user permissions, and so on, due to data errors. Version 2.1 ensures that users will not lose access to these modules because they are marked as key modules in the program code.

What's Changed

Updated Primary Key Strategy for String-Based Identifiers

In version 2.1, MagicAppBuilder updates its strategy for generating string-based primary key values, aligning with the latest improvements in MagicObject.

Previously, MagicAppBuilder used a UUID-based approach; however, the generated values were not standard UUIDs. Starting from version 2.1, the default strategy has been replaced with a new standard: TIMEBASED string identifiers.

The TIMEBASED string strategy offers several advantages:

1. It represents the creation time of the record, even though the timestamp is not fully precise.
2. It supports nanosecond-level resolution, significantly reducing the likelihood of key collisions.
3. It is augmented with 2096 bits of random data to further minimize collision risk.
4. The identifier is encoded in hexadecimal format, making it shorter and more human-readable.
5. It has a fixed length of 20 characters, ensuring efficient storage without excessive space usage.
6. The first 17 characters represent the time component, which can be converted back into a timestamp if needed.

This change provides a better balance between uniqueness, performance, readability, and storage efficiency compared to the previous non-standard UUID approach.

Standard UUID Support

In version 2.1, the UUID strategy now generates standard-compliant UUIDs. This means that when users select the UUID strategy, the application will produce UUID values that fully conform to the official UUID specification.

As a result, users upgrading MagicObject from version 3.21 to 3.22 will experience a primary key value transition, since the newly generated UUIDs will differ from those produced by the previous non-standard implementation.

If maintaining the legacy UUID generation behavior is required, it is recommended to continue using MagicObject version 3.21.x. Version 3.22.x should be adopted only for new applications where a clean primary key strategy can be applied from the start.

Bug Fixes

Admin Role Module Sorting

Version 2.1 fixes an issue in the Admin Role management where modules were not sorted by their module groups. In previous versions, modules appeared in an unsorted order, making it difficult for administrators to configure roles efficiently.

In version 2.1, modules are now sorted first by module group order, and then by module order. This ensures a consistent and logical display of modules, significantly improving usability when managing admin roles.

SQL Export Bug Fix (Entity Editor)

Version 2.1 fixes a bug in the Entity Editor where SQL exports incorrectly used entity indexes instead of entity names. This could lead to entity index errors during SQL execution.

In version 2.1, SQL exports now correctly use entity names rather than entity indexes, preventing index-related errors and ensuring more reliable SQL generation.

What's Changed

• Feature/version 2.1.0 by @kamshory in #856
• Update CHANGELOG.md by @kamshory in #857
• Update MagicObject by @kamshory in #858
• Feature/version 2.1.0 by @kamshory in #859
• Feature/version 2.1.0 by @kamshory in #860
• Bug fix export SQL by @kamshory in #861
• Update CHANGELOG.md by @kamshory in #862
• Fix save entity and diagram by @kamshory in #863
• Update README.md by @kamshory in #864
• Update MagicAppBuilder.pdf by @kamshory in #865
• Update Editor by @kamshory in #866

Full Changelog: 2.0.0...2.1.0

2.0.0

MagicAppBuilder Version 2.0.0

Date: December 10th, 2025

MagicAppBuilder 2.0 marks a major evolution of the platform — introducing multi-language GraphQL application generators, cross-database improvements, performance enhancements, and UI refinements.
This release strengthens MagicAppBuilder’s position as a powerful, multi-stack application generator supporting PHP, Java, Kotlin, Node.js, Python, and Go.

New Feature: GraphQL Application Generator for Java (Spring Boot with Maven)

MagicAppBuilder 2.0 introduces the GraphQL Application Generator for Java, powered by the robust Spring Boot framework and the Maven build system.

This feature enables developers to instantly generate fully functional, production-ready Java GraphQL backends directly from their entity schema.

What the Generator Produces

• Full Project Structure — A ready-to-build Maven project (pom.xml) with all required dependencies (Spring Boot, Spring GraphQL, Spring Data JPA).
• JPA Entities — Java POJOs annotated with @Entity and fully mapped to database tables.
• Spring Data Repositories — Auto-generated JpaRepository interfaces for all entities.
• GraphQL Controllers — Methods annotated with @QueryMapping and @MutationMapping.
• Advanced Filtering — SpecificationBuilder for dynamic, type-safe query building with JPA Specifications.
• Ready-to-Use Frontend — Minimal HTML/CSS/JS frontend pre-connected to the backend.

Why Spring Boot with Maven?

• Enterprise-Grade — The global standard for large-scale Java applications.
• Stable Build System — Maven provides predictable, standardized dependency management.
• High Performance — Optimized runtime suitable for high-concurrency workloads.
• Powerful Ecosystem — Rich tooling and integrations across the Java world.
• Strong Type Safety — Compile-time validation reduces runtime errors.

Available only in the Professional Edition.

New Feature: GraphQL Application Generator for Kotlin (Spring Boot with Maven)

MagicAppBuilder 2.0 also adds a complete Kotlin GraphQL Application Generator, offering a modern, concise alternative while maintaining full compatibility with the Spring ecosystem.

The generator uses Spring Boot with Maven, ensuring consistency with the Java version.

What the Generator Produces

• Full Project Structure — A Maven project (pom.xml) with all necessary dependencies.
• Kotlin Data Classes — Clean, idiomatic data classes annotated with @Entity.
• Spring Data Repositories — Auto-generated interfaces based on JpaRepository.
• GraphQL Controllers — Using @QueryMapping and @MutationMapping.
• Advanced Filtering — JPA SpecificationBuilder adapted for Kotlin.
• Ready-to-Use Frontend — HTML/CSS/JS frontend for immediate use.

Why Kotlin?

• Concise & Expressive — Less boilerplate, cleaner code.
• Null Safety — Eliminates whole classes of runtime errors.
• Full Java Interoperability — Works seamlessly with all Spring libraries.
• Modern Language Features — Coroutines, extension functions, smart casts, and more.

Available only in the Professional Edition.

New Feature: GraphQL Application Generator for Node.js

MagicAppBuilder 2.0 expands to the JavaScript ecosystem by introducing the Node.js GraphQL Application Generator.

It creates a full-featured Node.js application suitable for small projects, rapid prototyping, or scalable microservices.

What the Generator Produces

• Project Setup — Pre-configured package.json with Express, Apollo Server, and database drivers.
• GraphQL Schema & Resolvers — Auto-generated typeDefs and resolver handlers.
• Database Integration — Ready-to-use data access utilities.
• Express Server — Apollo Server mounted on Express.
• Web Frontend — Minimal HTML/CSS/JS UI that connects to the backend.

Why Node.js?

• Non-Blocking Architecture — Perfect for real-time and high-throughput apps.
• JavaScript Everywhere — One language for both frontend and backend.
• Massive npm Ecosystem — Thousands of packages for accelerated development.
• High Performance — V8 engine delivers blazing-fast execution.

Available only in the Professional Edition.

New Feature: GraphQL Application Generator for Python

MagicAppBuilder 2.0 includes a Python GraphQL Generator, ideal for developers who prefer Python’s simplicity and powerful ecosystem.

Built using modern, high-performance frameworks:

• FastAPI
• SQLAlchemy 2.0
• Ariadne GraphQL

What the Generator Produces

• Full Directory Structure — Organized into models, resolvers, schema, etc.
• SQLAlchemy Models — ORM models based on your entity schema.
• GraphQL Schema & Resolvers — Auto-generated type_defs and resolvers.
• Advanced Filtering & Pagination — Built into all list queries.
• Web Frontend — Ready-to-use HTML/CSS/JS UI.

Why Python?

• Developer-Friendly — Easy to learn and highly productive.
• Extensive Libraries — Particularly strong for analytics and data science.
• High Performance (Async) — FastAPI provides best-in-class asynchronous capabilities.
• Readable & Maintainable — Clean, simple syntax.

Available only in the Professional Edition.

New Feature: GraphQL Application Generator for Go

MagicAppBuilder 2.0 now supports the Go ecosystem with the Go GraphQL Application Generator.

This generator creates a high-performance, concurrent GraphQL backend using idiomatic Go practices and popular libraries:

What the Generator Produces

• Complete Project Structure — A standard Go project with a go.mod file for dependency management.
• GraphQL Schema & Resolvers — Auto-generated .graphqls schema and corresponding Go resolver stubs.
• Advanced Filtering & Pagination — Built into all list queries.
• Ready-to-Run Server — A pre-configured HTTP server using Chi.
• Web Frontend — A minimal HTML/CSS/JS UI that connects to the backend.

Why Go?

• Exceptional Performance — Compiled to native machine code, offering C-like speed.
• Built-in Concurrency — Goroutines and channels make concurrent programming simple and efficient.
• Statically Typed — Catches errors at compile time, ensuring robust applications.
• Simple & Clean Syntax — Easy to learn and maintain.
• Ideal for Microservices — Lightweight and fast, perfect for building scalable backend services.

Available only in the Professional Edition.

New Feature: GraphQL Application Profiles

MagicAppBuilder 2.0 introduces GraphQL Application Profiles, allowing you to save and reuse complete GraphQL application configurations. This feature is designed to streamline the process of generating multiple applications with different settings or regenerating existing ones after an update.

Each profile is saved with a unique name and stores the following configuration details:

• Programming Language: The selected backend language (PHP, Java, Kotlin, Node.js, Python, or Go).
• Entity Selection: The specific entities included in the application.
• Column Selection: The columns chosen for each entity.
• Filter Configuration: The filters defined for each entity.
• Primary Key Generation Strategy: How primary keys are handled (autogenerated, manual-insert, or manual-all).

With profiles, you can generate multiple distinct applications using different programming languages from the same database schema. If you need to update an application, you can simply select its profile and regenerate it without having to reconfigure everything from scratch.

New Feature: Database Design Selector in Entity Editor

The Entity Editor now includes a feature to select different database designs.

Previously, if a user created a database design for an application and then changed the application's database configuration, the original design would become inaccessible. This often led to the unintentional loss of work.

With this feature:

• Users can now choose from a list of previously created database designs directly within the Entity Editor.
• This ensures that even if the database configuration is updated, old designs remain accessible and are not lost.
• It provides greater flexibility and data safety, allowing developers to manage multiple design versions or switch between different database contexts without losing their work.

This feature is particularly useful for developers who iterate on database schemas or manage multiple environments, as it decouples the entity design from the live database configuration.

New Feature: Default Sort Order for Data Lists

In previous versions, if a user did not specify a sort order when viewing a data list, the ordering was left to the database. Some databases might default to sorting by the primary key in ascending order, while others might sort based on when the data was created rather than any column value. This could lead to inconsistent user experiences across different database systems.

In version 2.0.0, users can now define a default sort order for each entity using the defaultSort property. This allows for multi-level sorting instead of relying on just a single column.

Example:

"defaultSort": [
  {
    "field": "buku_id",
    "direction": "ASC"
  }
]

This configuration is set in the frontend-config.json file, which can be edited by the user. When generated, MagicAppBuilder will default to using the primary key with an ASC direction.

This allows users to define a default data order in the list for each entity with specific columns and directions, ensuring a consistent and predictable...

1.28.0

MagicAppBuilder Version 1.28.0

Date: November 10th, 2025

New Feature: Theme Selector

Applications generated by the GraphQL Generator now feature a theme selector, allowing users to change the interface's appearance according to their preferences. The selected theme is stored in localStorage, ensuring it persists across user visits. To enhance the user experience, theme transitions are designed to be seamless. The new stylesheet is preloaded in the background before being applied, preventing any flash of unstyled content and ensuring a smooth visual change.

Logic Summary

1. JavaScript (graphql.js):

   • Added new options themeConfigUrl and defaultThemeUrl to the constructor.

   • Created a new method initializeTheme() that is called during initialization. This method will:

     • Fetch the list of available themes from available-theme.php.
     • Check the theme stored in localStorage.
     • Validate the stored theme; if invalid, revert to the default theme.
     • Apply the correct theme when the page loads.

   • Created a populateThemeMenu() method to dynamically populate the theme dropdown.

   • Created a changeTheme() method to handle user theme selection, save it to localStorage, and update the stylesheet.

   • Updated the applyTheme() method to add a new <link> element for the new theme. Once the new stylesheet is successfully loaded, the old one is removed to ensure a seamless transition.

2. HTML (index.php):

   • Added id="theme-stylesheet" to the stylesheet <link> tag for easier manipulation by JavaScript. The default href is changed to assets/style.css as a fallback.
   • Added a new icon and dropdown menu structure in the header for theme selection, similar to the language and profile menus.

Manual API Generation in HTML Format

In addition to generating MANUAL.md, the GraphQL Generator now also creates a manual.html file. This file is an enhanced HTML version of the API documentation, offering several significant advantages:

Benefits

1. Improved Readability:
   The HTML file can be opened in any web browser and is visually more appealing and easier to read compared to a raw Markdown file. This makes it ideal for sharing with non-technical teams or for presentations.

2. Easy Navigation:

   • Automatic Table of Contents:
     manual.html automatically generates a clickable table of contents at the top of the document. Users can quickly jump to specific query or mutation sections without scrolling through the entire document.
   • Back-to-Top Button:
     A floating button is added at the bottom-right corner of the page, allowing users to quickly return to the table of contents from anywhere within the document.

3. No Additional Tools Required:
   Users don’t need any special Markdown viewer or editor to read the documentation. A standard web browser is sufficient to view and interact with the API documentation easily.

4. Built-in Browser Search:
   Since it’s a standard HTML page, users can utilize the browser’s built-in search feature (Ctrl+F or Cmd+F) to quickly find keywords, field names, or specific operations.

Overall, the addition of manual.html drastically improves the usability and accessibility of the generated API documentation, making it more user-friendly for both developers and other stakeholders.

Enhancement: Improved Development Experience for GraphQL API

A condition has been added to check if $appAdmin['admin_id'] exists and has a value. This change prevents PHP warnings when a developer bypasses authentication (for instance, by not including the auth.php file) while testing the GraphQL API in a development environment. Consequently, developers no longer need to manually set values for $appAdminCreate and $appAdminEdit during testing, leading to a smoother and more efficient workflow.

Enhancement: Optimized Data Fetching to Prevent Overfetching

The frontend script now intelligently avoids data overfetching to improve performance and reduce payload size.

• Limited Depth for List Views: When fetching lists of data, the GraphQL query depth is now limited to a maximum of two levels. This prevents excessively large and slow responses when dealing with deeply nested relationships.

• Minimal Fields for Reference Data: When populating dropdowns or fetching reference data, if the target entity has a displayField defined, the frontend will only request the primary key and the specified display field. This significantly reduces the payload size for reference lookups, making the UI more responsive.

These optimizations ensure that the application only requests the data it needs, leading to a faster and more efficient user experience.

Enhancement: Improved Input Form Attributes

Key Attributes Added:

• readonly: Applied to primary key fields in the update form to prevent modification.
• required: Added to fields that are marked as mandatory in the entity definition, ensuring users cannot submit the form without filling them.
• autocomplete="off": Added to all input fields to prevent browsers from suggesting previously entered values, which is useful for sensitive data or to avoid incorrect auto-fills.
• min and max: Applied to numeric input fields to enforce range constraints, providing immediate feedback to the user.
• spellcheck="false": Applied to textarea to disable spelliing check.

These enhancements ensure that data entered by users is more likely to be valid before it is even sent to the server, reducing errors and improving the overall robustness of the application.

Enhancement: Right-to-Left (RTL) Language Support

The generated GraphQL application has been tested with right-to-left languages (such as Arabic) to ensure proper display and functionality.

The forms in the generated GraphQL application have been enhanced with additional HTML attributes to improve data validation and user experience. These attributes are dynamically applied based on the entity's schema and validation rules.

New Feature: Live Application Reload

A "Refresh App" feature has been added to the user dropdown menu in the generated GraphQL application. This allows developers to reload application configurations without a full page refresh, which is especially useful during the development phase.

Key Benefits:

• Instant Updates: Reloads frontend-config.json, UI translations (language.php), and entity translations (entity-language.php) on the fly.
• Seamless Workflow: Allows developers to see changes to configurations, menus, and translations immediately without losing their current context or navigating away from the page.
• User Feedback: Displays a success or failure notification to confirm the outcome of the reload operation.

Enhancement: Primary Key Generation Option in GraphQL Application

There are three options for handling the generation of primary key values in applications generated through the GraphQL Generator:

1. autogenerated: The primary key value is automatically generated by the backend system. Users cannot specify it during either insert or update operations.
2. manual-insert: The primary key value is provided by the user during insert operations. Users cannot modify it during update operations.
3. manual-all: The primary key value is provided by the user during insert operations and can also be modified during update operations.

Technical Implementation

To support this functionality, a new flag has been added to the primary key column of each entity in the config/frontend-config.json file.
This flag, called primaryKeyValue, holds one of the three possible values: autogenerated, manual-insert, or manual-all.

This flag serves a dual purpose:

1. Frontend Side: The frontend (graphql.js) uses the primaryKeyValue setting to dynamically control the behavior of the insert and update forms.
   For example, if the value is set to autogenerated, the primary key field will be hidden in both forms.
   If it is set to manual-insert, the field will only appear in the insert form.

2. Backend Side: The GraphQL resolver (graphql.php) on the backend also uses this flag to validate input and store values in the database.
   If the flag is set to autogenerated, the backend automatically generates a unique value and ignores any input provided by the client.
   If it is set to manual-insert or manual-all, the backend validates and uses the value provided by the client according to the defined rules.

Enhancement: Textarea Support in Forms

In version 1.28.0, users can now select <textarea> as a form element. This enhancement increases flexibility, allowing users to choose the most appropriate input element for their needs, especially for fields requiring multi-line text.

Enhancement: Improved Button Appearance

The "Update" and "Deactivate" buttons in data lists have been visually enhanced to better represent their respective actions. The "Update" button now features a more intuitive color for editing, while the "Deactivate" button has been updated to more clearly signify its deactivation function, improving overall UI clarity.

Enhancement: Cross-Tab UI Synchronization

Applications generated by the GraphQL Generator now support synchronization of user interface (UI) settings across all open tabs.

Key Highlights:

• Automatic Synchronization: When users change the theme, dark/light mode, or language, those changes are automatically applied to all other tabs open in the same browser.
• Consistent User Experience: This feature ensures users enjoy a uniform visual experience across all their sessions without needing t...

1.27.0

MagicAppBuilder Version 1.27.0

Date: November 2th, 2025

New Feature: Automatic GraphQL API and App Generation

MagicAppBuilder 1.27.0 introduces the GraphQL Generator, a powerful feature that not only creates a complete GraphQL API but also generates both frontend and backend applications that communicate through GraphQL. With this new system, users can instantly obtain a fully functional web application just by providing their database configuration.

Key Features of GraphQL Generator

• Schema-Based Generation
  Using your existing JSON entity schema, MagicAppBuilder automatically builds a complete GraphQL backend and frontend application that stays perfectly synchronized with your database structure.

• Full CRUD Operations
  Automatically generates:

  • Queries – Retrieve single records by ID or lists with pagination.
  • Mutations – Perform create, update, and delete operations.

• Advanced Query Capabilities
  Generated list queries include:

  • Filtering – Supports operators like EQUALS, CONTAINS, GREATER_THAN, and LESS_THAN.
  • Sorting – Allows sorting by multiple columns in ASC or DESC order.
  • Pagination – Full support for limit and offset for efficient data loading.

• Automatic Relationship Handling
  Automatically detects foreign key relationships (based on the _id naming convention) and generates resolvers to fetch nested related data.

• Soft-Delete Support
  If an entity includes an active column, the delete mutation will automatically perform a soft-delete (sets active to 0). Otherwise, a hard-delete is executed.

• Automatic API Documentation
  Generates a detailed MANUAL.md file with ready-to-use query and mutation examples to simplify integration with frontend teams.

• Ready-to-Use Endpoint
  The generator produces a fully functional graphql.php endpoint that includes database connectivity and request handling logic.

• Instant Frontend Generation
  The frontend is automatically generated to interact with the GraphQL backend. It dynamically reads the GraphQL schema to render data tables, forms, and filters. Mutations such as insert, update, and delete are automatically executed through GraphQL queries.

  This means you can immediately use the generated app after configuring your database—no additional coding required.

Benefits

• Rapid Development – Instantly generate complete backend and frontend applications in minutes.
• Guaranteed Consistency – Keeps the database schema, backend, and frontend perfectly synchronized.
• Production-Ready Code – Generates optimized and clean GraphQL-based source code for immediate deployment.
• Comprehensive Documentation – Simplifies API integration with automatically generated documentation.

What’s Changed?

To make room for the new GraphQL button in the export section, the checkbox caption for Draw Relationship has been shortened to Relationship. The Sort Entity button caption has been changed to Sort, and Sort Entity by Type has been changed to Sort by Type. These adjustments ensure that users with a 1366×768 screen resolution can still access all features without overflow issues.

Object Name Suffix for Reserved Keywords

When generating code, if an entity name conflicts with a reserved system variable (e.g., appConfig, database), MagicAppBuilder now automatically appends the suffix Obj (e.g., appConfigObj). This ensures valid and collision-free generated code.

Enhancement: Updated Z-Index Layer

When a session expires, MagicAppBuilder displays a login prompt. Previously, this element could appear beneath other components, making it inaccessible. In this version, the element’s z-index has been updated so it always appears on top and remains usable.

Bug Fix: Standardized X-Requested-With Header

The X-Requested-With: xmlhttprequest header is used to indicate AJAX requests. Previously, inconsistent casing caused detection issues. This version standardizes the casing for better compatibility.

What's Changed

• Feature/version 1.27.1 by @kamshory in #766
• Generate Full GraphQL Application by @kamshory in #767
• Handle unchecked checkboxes by @kamshory in #768
• Feature/version 1.27.1 by @kamshory in #769
• Feature/version 1.27.1 by @kamshory in #770
• Update docblock by @kamshory in #771
• Feature/version 1.27.1 by @kamshory in #772
• Feature/version 1.27.3 by @kamshory in #773
• Bug fix reserved columns by @kamshory in #774
• Enhance entity display by @kamshory in #775
• Bug fix display field by @kamshory in #776
• Bug fix relation display by @kamshory in #777
• Update graphql.min.js by @kamshory in #778
• Use minified version by @kamshory in #779
• Update graphql.min.js by @kamshory in #780
• Update style by @kamshory in #781

Full Changelog: 1.26.1...1.27.0

1.26.1

MagicAppBuilder Version 1.26.1

Date: October 21, 2025

Enhancement: Time Zone Datalist

To improve user experience and prevent typos, a datalist with time zone suggestions has been added to time zone input fields. This makes it easier for users to select the correct time zone without manual entry.

Dependency Updates

Project dependencies have been updated to their latest compatible versions. This ensures the application benefits from the latest bug fixes, security patches, and performance improvements from its underlying libraries.

Bug Fixes: Save Multiple Values on Insert/Update

Previously, even when a user intended to submit multiple values (e.g., from a multi-select dropdown or tag input), the application would incorrectly force the input into a single scalar value, causing data loss. After this fix, array inputs are handled correctly. The array of values is now properly JSON-encoded before being saved to the database, ensuring all selected data is preserved.

Bug Fixes: Show Multiple Values on Update Form

Previously, when loading an update form, the application would incorrectly read a JSON-encoded array from the database as a single scalar value. This prevented multi-select fields from being correctly pre-populated with all their stored values. After this fix, the application now properly decodes the JSON string from the database before rendering the form. As a result, the update form now accurately reflects the actual stored data, with all previously selected options correctly displayed.

What's Changed

• Feature/version 1.26.1 by @kamshory in #760
• Set application flag on create by @kamshory in #761
• Feature/version 1.26.1 by @kamshory in #762
• Feature/version 1.26.1 by @kamshory in #763
• Update SECURITY.md by @kamshory in #764
• Feature/version 1.26.1 by @kamshory in #765

Full Changelog: 1.26.0...1.26.1

1.26.0

MagicAppBuilder Version 1.26.0

Date: October 19th, 2025

New Feature: Inspect Application

An application is considered valid if it meets all the following conditions:

1. It is registered in the database.
2. It has a configuration file within a workspace.
3. It has source code files in the application directory following the defined structure.
4. It has an application configuration file in the application directory.

Previously, even if conditions 3 and 4 were not met, the application was still considered valid. Version 1.26.0 enforces a new rule that all four conditions above must be fulfilled for an application to be considered valid.

Version 1.26.0 adds two new columns, application_valid and directory_exists, to the application table. These columns store inspection results about the application’s validity. Invalid applications will now be handled differently from valid ones.

New Feature: Rebuild Application

Users can rebuild invalid applications. MagicAppBuilder will recreate the application according to the configuration stored in the workspace. Users can also choose to rebuild application modules and localizations.

New Feature: Recreate Application

Users can now import existing applications. Instead of importing only from a configuration, users can regenerate an application configuration from an existing MagicAppBuilder-created application.
This method is strongly discouraged, as it should only be used if the original application configuration files have been completely lost. MagicAppBuilder will only recreate the directory structure and generate a default.yml file — it cannot restore the lost configuration.

New Feature: Add Entity Filter

An entity filter has been added to the Entity Editor to display only the desired entities on the left side of the editor. This makes it easier for users to select, modify, or delete the desired entities instead of scrolling to find the intended one. This feature is very useful when working on large databases with many entities.

New Feature: Autocomplete Suggestions in Entity Data Editor

To improve data entry accuracy and speed, the Entity Data Editor now includes an autocomplete suggestion feature.

• When adding new data in a column that is a foreign key (e.g., artist_id), the input field will now display a dropdown list of suggestions.
• The suggestions are populated from the related entity (e.g., the artist table).
• This helps users select valid IDs without needing to manually look them up, reducing errors and speeding up data entry.

Enhancement: Applicatin Validation when Scan Workspace

When scanning a workspace, MagicAppBuilder validates applications before importing them. Invalid applications will still be imported but will be marked as invalid.

What's Changed

• Update module-translate.php by @kamshory in #755
• Update Template by @kamshory in #756
• Feature/version 1.26.0 by @kamshory in #757
• Update app.ini by @kamshory in #758
• Add date to changelog by @kamshory in #759

Full Changelog: 1.25.3...1.26.0

1.25.3

MagicAppBuilder Version 1.25.3

Bug Fix: User Language

Fixed a user language issue. Before the fix, MagicAppBuilder would always use the language based on the browser's selection, overwriting the user's preference even if they had already selected a language.

Bug Fix: currentAction

Fixed an issue with the currentAction object. Before the fix, the user ID in the currentAction object was always superuser, even when the logged-in user was not a superuser.

Bug Fix: Export Database

Fixed an issue with the database export query.

What's Changed

• Bug fix user language and current action by @kamshory in #753
• Bug Fix: Export Database by @kamshory in #754

Full Changelog: 1.25.2...1.25.3

1.25.2

MagicAppBuilder Version 1.25.2

Bug fix: Menu URL

Fixed menu URL when the system module is not in the root.

What's Changed

• Fix menu URL by @kamshory in #750
• Fixed menu URL when the system module is not in the root. by @kamshory in #751
• Update app.ini by @kamshory in #752

Full Changelog: 1.25.1...1.25.2

1.25.1

MagicAppBuilder Version 1.25.1

Enhancement: Dump Undefined Localization

MagicAppBuilder version 1.25.1 now only dumps undefined localizations in Development Mode. This prevents the application from creating localization files in a production environment. This enhancement ensures that the application will not make any changes to files within the localization directory in a production environment.

Enhancement: Improved File Manager Styling

The File Manager interface has been improved with better hover effects.
When hovering over a file or directory item, only the specific list item (<li>) is highlighted, without affecting its parent directories.
This provides a clearer and more intuitive navigation experience when browsing and expanding directories.

Enhancement: Writable Directory Check at Root Level

The writable directory check logic has been refined to handle edge cases where root directories (e.g., C:\, D:\, or /) appear non-writable due to system-level restrictions.
Now, the system will only attempt to create a temporary directory using mkdir() if the target location resides directly under a root path.
This is determined by counting the number of segments in the normalized path—only paths with a single segment (after trimming and normalization) are considered root.
This enhancement improves reliability when validating writable paths across different operating systems.

What's Changed

• Feature/version 1.25.1 by @kamshory in #749

Full Changelog: 1.25.0...1.25.1