Merge branch 'dev' into auto-merge/rel-10-6/4712

common.props

@@ -1,8 +1,8 @@
 <Project>
   <PropertyGroup>
     <LangVersion>latest</LangVersion>
-    <Version>10.6.0-rc.2</Version>
-    <LeptonXVersion>5.6.0-rc.2</LeptonXVersion>
+    <Version>10.7.0-preview</Version>
+    <LeptonXVersion>5.7.0-preview</LeptonXVersion>
     <NoWarn>$(NoWarn);CS1591;CS0436</NoWarn>
     <PackageIconUrl>https://abp.io/assets/abp_nupkg.png</PackageIconUrl>
     <PackageProjectUrl>https://abp.io/</PackageProjectUrl>

docs/en/Community-Articles/2026-07-07-building-a-vendor-onboarding-workflow-with-abp-low-code/post.md

@@ -0,0 +1,394 @@
+# Building a Vendor Onboarding Workflow with ABP Low-Code
+
+Vendor onboarding usually starts with a few familiar steps.
+
+A company sends its details, someone checks the documents, another person reviews the score, and the team either approves the vendor or asks for more information. After a while, the process turns into a mix of spreadsheets, uploaded files, status notes, and "who is waiting on this one?" messages.
+
+In this article, we'll build that workflow with the [Low-Code System](https://abp.io/docs/latest/low-code/index). We'll model the data in the [Low-Code Designer](https://abp.io/docs/latest/low-code/designer), let the [React runtime](https://abp.io/docs/latest/low-code/react-runtime) render the page, and then add one [custom endpoint](https://abp.io/docs/latest/low-code/custom-endpoints) for a summary that does not belong to normal CRUD.
+
+The example is an internal operations page where a team receives vendor applications, reviews compliance documents, tracks deadlines, and follows rejected or priority vendors from one place.
+
+That is a good place to try ABP Low-Code, because the first version of the workflow is mostly data, screens, validation rules, and a few process-specific actions. You do not need to hand-write a React page only to list vendor applications, upload a compliance document, or show a rejection reason when the status is rejected.
+
+We will start from an already running ABP React + EF Core application with Low-Code enabled, so the article can stay focused on the Admin Console, the Designer, and the runtime flow.
+
+## What We Are Building
+
+The workflow has one main record: `VendorApplication`.
+
+A reviewer should be able to:
+
+- Create a vendor application with company and contact details.
+- Track whether the vendor is `Submitted`, `InReview`, `Approved`, or `Rejected`.
+- Set the requested date and approval deadline.
+- Mark priority vendors.
+- Assign a category such as `Software`, `Services`, or `Hardware`.
+- Upload a logo and a compliance document.
+- Fill in a rejection reason only when the application is rejected.
+- Filter the generated grid by status, requested date, priority, and category.
+- Call a summary endpoint that returns counts for dashboard-like use.
+
+We'll also touch two extra pieces around that main record. `VendorReviewTemplate` comes from C# so you can see how code-defined metadata appears in the Designer. Later, a `VendorEscalation` model is added while the Designer is switched to `Runtime JSON`. You could build the whole workflow with one entry point, but using these three entry points makes the hybrid model visible without turning the article into three separate implementations.
+
+## A Quick Note on How Low-Code Fits Together
+
+The Low-Code Designer is where you describe the model and the UI metadata. In this article we use four areas:
+
+- `Data` for enums and entities.
+- `Pages` for the generated grid route.
+- `Forms` for the create/edit form layout.
+- `Actions` for the custom HTTP endpoint.
+
+The Designer stores metadata. The React runtime reads that metadata and renders the page at runtime. That is the important mental model: when we add a field to the entity, the field can become a grid column, a filter, a validation rule, or a form input depending on how we configure the metadata around it.
+
+There is also one database detail to keep in mind. Metadata that comes from C# code or from `Dev JSON` is source-controlled application metadata. When it introduces or changes a persisted entity, run the normal EF Core migration and database update flow before using the generated runtime page. In the validated demo for this article I used SQLite, so the migration updated the local SQLite database. `Runtime JSON` is different: it is authored at runtime, so I do not run a C# migration in that section.
+
+## Add a Code-Defined Review Template
+
+Let's start with one model that does not come from the Designer.
+
+In this workflow, vendor reviewers can use review templates. The template itself is not the center of the workflow, so I kept it focused on the review rules:
+
+```csharp
+[DynamicEnum]
+public enum VendorReviewTemplateType
+{
+    Standard = 0,
+    Security = 1,
+    Finance = 2
+}
+
+[DynamicEntity(DefaultDisplayPropertyName = nameof(Name))]
+[DynamicEntityUI(DisplayName = "Vendor Review Templates")]
+public class VendorReviewTemplate : DynamicEntityBase
+{
+    [Required]
+    [StringLength(128)]
+    [DynamicPropertyUnique]
+    public string Name { get; set; }
+
+    public VendorReviewTemplateType TemplateType { get; set; }
+    public int MinimumComplianceScore { get; set; }
+    public bool RequiresDocumentReview { get; set; }
+    public string? Notes { get; set; }
+}
+```
+
+Then include the entity in your EF Core DbContext. This is the part that makes the migration create a real backing table for the code-defined model:
+
+```csharp
+public DbSet<VendorReviewTemplate> VendorReviewTemplates { get; set; }
+
+builder.Entity<VendorReviewTemplate>(b =>
+{
+    b.ToTable(
+        VendorOnboardingLowCodeConsts.DbTablePrefix + "VendorReviewTemplates",
+        VendorOnboardingLowCodeConsts.DbSchema
+    );
+    b.ConfigureByConvention();
+    b.Property(x => x.Name).IsRequired().HasMaxLength(128);
+    b.Property(x => x.Notes).HasMaxLength(512);
+    b.HasIndex(x => x.Name).IsUnique();
+});
+```
+
+Because this model is defined in C#, treat it like the rest of your application schema changes: add the entity, add the DbSet/mapping, create/apply the EF Core migration, and then start the application.
+
+After the app starts, open **Admin Console > Low-Code Designer > Data**. The model is visible there, but it is read-only because it was defined in code.
+
+![Code-defined VendorReviewTemplate shown as read-only in the Low-Code Designer](assets/screenshots/designer-code-layer.png)
+
+Open the **Properties** tab and you can see the fields that came from the C# class. They are available to the Low-Code System, but the Designer marks them as code-owned.
+
+![The Properties tab for the code-defined VendorReviewTemplate entity](assets/screenshots/designer-review-template-properties.png)
+
+That is useful in real projects. Some metadata can be shipped with the application, while the rest of the workflow can still be designed through the Admin Console.
+
+## Create the Vendor Enums
+
+Now move to the part we actually build in the Designer.
+
+The animation below shows the Designer path in one pass. The next sections slow it down and explain the enum, entity, page, and form steps.
+
+![Creating the Designer metadata for the vendor onboarding workflow](assets/gifs/designer-hybrid-flow.gif)
+
+Open `Data > Enums` and create the status enum:
+
+```text
+VendorApplicationStatus
+Submitted
+InReview
+Approved
+Rejected
+```
+
+Before saving, the enum modal should contain the name and the four values:
+
+![The VendorApplicationStatus enum creation modal before saving](assets/screenshots/designer-enum-status-modal.png)
+
+Then create the category enum:
+
+```text
+VendorCategory
+Software
+Services
+Hardware
+```
+
+The order of the status values matters for the custom endpoint later, because the script checks the enum values by their numeric indexes. In this example `Submitted` is `0`, `Approved` is `2`, and `Rejected` is `3`.
+
+After saving, the enum detail page shows the numeric values that the runtime and scripts will use:
+
+![The saved VendorApplicationStatus enum values in the Designer](assets/screenshots/designer-enum-status-saved.png)
+
+## Create the VendorApplication Entity
+
+Go to `Data > Entities` and create `VendorApplication`.
+
+This is the model that drives the rest of the article. Add these fields:
+
+| Field | Type | Configuration |
+| --- | --- | --- |
+| `CompanyName` | `String` | Required and unique |
+| `ContactEmail` | `String` | Required, email validation |
+| `Status` | `Enum` | `VendorApplicationStatus` |
+| `RequestedOn` | `Date` | Application date |
+| `ApprovalDeadline` | `Date` | Review deadline |
+| `IsPriority` | `Boolean` | Priority flag |
+| `Category` | `Enum` | `VendorCategory` |
+| `ComplianceScore` | `Int` | Review score |
+| `Logo` | `Image` | Logo upload |
+| `ComplianceDocument` | `File` | Document upload |
+| `RejectionReason` | `String` | Optional |
+
+![VendorApplication entity definition in the Designer](assets/screenshots/designer-devjson-entity.png)
+
+The **Properties** tab is where the entity becomes more than a name. The table shows the field types, enum bindings, and source layer. Scroll down and the upload-related fields are visible with their `Image` and `File` types:
+
+![The VendorApplication properties table in the Designer](assets/screenshots/designer-vendor-application-properties.png)
+
+There is no React code yet, but we already have a lot of behavior described: required fields, uniqueness, email validation, enum fields, upload fields, and the data shape that the runtime will use.
+
+The `Image` and `File` types are worth calling out. They are not plain strings with a path. In the generated form they become upload controls, which is exactly what we need for vendor logos and compliance documents.
+
+Since `VendorApplication` is authored in the `Dev JSON` layer, it also belongs to the source-controlled model. After saving the entity metadata, create/apply the EF Core migration before you open the generated page in the runtime. This is the step that creates the backing table for the low-code entity in the database.
+
+## Generate a Grid Page
+
+The reviewers need a page where they can work with applications, so go to `Pages` and create a `dataGrid` page named `vendor-onboarding`.
+
+Bind it to `VendorApplication`.
+
+Before saving the page, the modal connects the route name, title, icon, and entity:
+
+![The vendor-onboarding data grid page modal before saving](assets/screenshots/designer-page-create-before-save.png)
+
+After the page is created, set `RequestedOn` as the default sort field, keep it descending, adjust the icon if you want, and assign `vendor-application-form` as the create/edit form:
+
+![The vendor-onboarding data grid page bound to VendorApplication](assets/screenshots/designer-devjson-page.png)
+
+For the review workflow, keep the configured columns focused on the fields reviewers use most:
+
+- Company name
+- Status
+- Requested date
+- Priority
+- Category
+
+Then configure the filters you want reviewers to use most often. In this workflow, the important filters are company, status, requested date, priority, and category. Depending on the runtime defaults, the generated grid may still expose additional fields such as contact email; the workflow is still driven by the focused page metadata above.
+
+Once the page is saved, the React runtime can resolve the route from the page metadata. The grid is generated from the entity and page configuration rather than from a hand-written React component.
+
+## Build the Create/Edit Form
+
+A grid is not enough. We also need a form that feels like the workflow.
+
+Go to `Forms` and create `vendor-application-form` for `VendorApplication`. Split the fields into three tabs:
+
+![The vendor-application-form creation modal before saving](assets/screenshots/designer-form-create-modal.png)
+
+- **Company**: `CompanyName`, `ContactEmail`, `Category`, `IsPriority`
+- **Review**: `Status`, `RequestedOn`, `ApprovalDeadline`, `ComplianceScore`, `RejectionReason`
+- **Documents**: `Logo`, `ComplianceDocument`
+
+Now add the conditional behavior for `RejectionReason`. In this demo I used two complementary rules: one rule shows the field when `Status = Rejected`, and the other hides it for non-rejected statuses.
+
+![The vendor-application-form with tabs and a conditional rule](assets/screenshots/designer-devjson-form.png)
+
+This is one of the places where Low-Code becomes more than "generate a CRUD page". The runtime does more than render a static form; it evaluates the rule while the user edits the record.
+
+## Apply the Migration Before Opening the Runtime
+
+Before opening the generated page, apply the database migration for the `Dev JSON` changes. We used `Dev JSON` for `VendorApplication`, so the Designer wrote source-controlled descriptor files under `_Dynamic`. The entity shape is now part of the application model, and the database needs the matching backing table before the React runtime can save records.
+
+That is why `Dev JSON` is a good fit during development: the metadata files and the EF Core migration can be reviewed, committed, and reproduced in another environment. If the same entity had been created in the `Runtime JSON` layer, you would not create a C# migration for that runtime edit; the metadata change would be stored in the database instead. In practice, use `Dev JSON` for development-time, source-controlled changes, and use `Runtime JSON` when you want production-time changes to be managed from the Admin Console and persisted in the database.
+
+## Try It in the React Runtime
+
+Open the generated `vendor-onboarding` page in the React runtime and create a vendor application.
+
+On the `Documents` tab, the `Logo` and `ComplianceDocument` fields are rendered as upload fields:
+
+![The generated Documents tab rendering image and file upload fields](assets/screenshots/runtime-form-documents.png)
+
+Now edit a record and change the status to `Rejected`. The `RejectionReason` field becomes available on the `Review` tab:
+
+![The Review tab showing the conditional RejectionReason field](assets/screenshots/runtime-review-rejected.png)
+
+After saving a few records, use the generated filters to narrow the list to rejected vendors. Depending on the runtime configuration, the filter panel can expose more fields than the small set you configured for the workflow; here we only use the `Status = Rejected` filter:
+
+![The generated grid filtered by Status = Rejected](assets/screenshots/runtime-grid-filtered.png)
+
+The short animation below gives a quick pass through the same runtime states: upload fields, the conditional rejection reason, and the filtered grid.
+
+![Generated upload fields, conditional review field, and grid filters in the React runtime](assets/gifs/runtime-workflow.gif)
+
+At this point we have a working page, form, validation, uploads, and filters. The important part is that all of it came from the metadata we configured in the Designer.
+
+## Add a Custom Summary Endpoint
+
+Generated CRUD is enough for day-to-day record editing, but teams often need one operation that is specific to their process.
+
+For vendor onboarding, a summary endpoint is a good example:
+
+```text
+GET /api/custom/vendor-onboarding/summary
+```
+
+In the Designer, open `Actions` and create a custom HTTP action with that route. The script can use the [Scripting API](https://abp.io/docs/latest/low-code/scripting-api) to query the same `VendorApplication` data that the generated grid uses.
+
+![The custom HTTP action configured under Actions in the Designer](assets/screenshots/designer-devjson-endpoint.png)
+
+Here is the script used in the demo:
+
+```js
+var entityName = 'Acme.VendorOnboardingLowCode.Procurement.VendorApplication';
+var vendorQuery = await db.query(entityName);
+var totalVendors = await db.count(entityName);
+var submittedVendors = await vendorQuery.where(x => x.Status === 0).count();
+var approvedVendors = await vendorQuery.where(x => x.Status === 2).count();
+var today = query.today || new Date().toISOString().slice(0, 10);
+var overdueReviews = await vendorQuery
+  .where(x => x.ApprovalDeadline != null && x.ApprovalDeadline < today && x.Status !== 2)
+  .count();
+
+return ok({
+  totalVendors: totalVendors,
+  submittedVendors: submittedVendors,
+  approvedVendors: approvedVendors,
+  overdueReviews: overdueReviews,
+  evaluatedOn: today
+});
+```
+
+Use the entity name shown in your Designer. In the screenshots, it is `Acme.VendorOnboardingLowCode.Procurement.VendorApplication`.
+
+When the endpoint runs, it returns the current counts from the low-code records:
+
+![The JSON response of the custom summary endpoint](assets/screenshots/custom-endpoint-summary.png)
+
+That is the bridge I like here. The page and form stay metadata-driven, but the process-specific summary is a short script exposed as a custom endpoint.
+
+## Add One Runtime Model
+
+Now switch the Designer layer to `Runtime JSON` and add one more entity: `VendorEscalation`.
+
+This model represents the items that need extra attention. It could have been created in the same place as `VendorApplication`; I am adding it here only to show that runtime-authored metadata participates in the same Low-Code System.
+
+Unlike the code and `Dev JSON` examples above, this runtime-authored model is not part of the source-controlled migration flow in this walkthrough.
+
+The create modal is the same Designer experience, but the selected layer is now `Runtime JSON`:
+
+![The VendorEscalation entity creation modal in the Runtime JSON layer](assets/screenshots/designer-vendor-escalation-save-modal.png)
+
+![The VendorEscalation entity authored in the Runtime JSON layer](assets/screenshots/designer-runtime-entity.png)
+
+Create a data grid page for it and open it in the React runtime:
+
+![The runtime-generated Vendor Escalations page](assets/screenshots/runtime-vendor-escalations.png)
+
+From the user's point of view, it behaves like the first generated page. From the metadata point of view, we have now seen code-defined metadata, Designer-authored metadata, and runtime-authored metadata in the same application.
+
+## Read the Same Data from ABP Code
+
+The last bridge is application code.
+
+Sometimes the generated page is not the only consumer. You may want a typed application service, a scheduled job, or another API to read the same low-code records. The code below shows the idea by returning a backlog summary:
+
+```csharp
+private readonly IRepository<DynamicEntity, Guid> _vendorApplicationRepository;
+private readonly IAsyncQueryableExecuter _queryableExecuter;
+
+public async Task<VendorBacklogDto> GetBacklogAsync()
+{
+    var entityDescriptor = DynamicModelManager.Instance.Find(
+        "Acme.VendorOnboardingLowCode.Procurement.VendorApplication"
+    );
+
+    if (entityDescriptor == null)
+    {
+        throw new UserFriendlyException("VendorApplication model was not found.");
+    }
+
+    var query = await _vendorApplicationRepository
+        .SetEntityName(entityDescriptor.Name)
+        .GetQueryableAsync();
+    var today = DateOnly.FromDateTime(Clock.Now);
+    var priorityQuery = query.Where(vendor =>
+        vendor.Data["IsPriority"] != null &&
+        (bool?)vendor.Data["IsPriority"] == true);
+
+    var nextPriorityVendor = await _queryableExecuter.FirstOrDefaultAsync(
+        priorityQuery.OrderByDescending(vendor =>
+            (DateOnly?)vendor.Data["RequestedOn"]));
+
+    return new VendorBacklogDto
+    {
+        TotalVendors = checked((int)await _queryableExecuter.LongCountAsync(query)),
+        PriorityVendors = checked((int)await _queryableExecuter.LongCountAsync(priorityQuery)),
+        RejectedVendors = checked((int)await _queryableExecuter.LongCountAsync(
+            query.Where(vendor =>
+                vendor.Data["Status"] != null &&
+                (int?)vendor.Data["Status"] == 3))),
+        OverdueReviews = checked((int)await _queryableExecuter.LongCountAsync(
+            query.Where(vendor =>
+                vendor.Data["ApprovalDeadline"] != null &&
+                (DateOnly?)vendor.Data["ApprovalDeadline"] < today &&
+                vendor.Data["Status"] != null &&
+                (int?)vendor.Data["Status"] != 2))),
+        NextPriorityVendor = nextPriorityVendor?.GetData<string>("CompanyName")
+    };
+}
+```
+
+![The typed backlog summary returned by the application service](assets/screenshots/code-backlog-summary.png)
+
+The important detail is that the aggregate operations stay on `IQueryable`; the code does not load every vendor into memory just to count them. This is not a replacement for the generated page. It is the other direction: use the generated page for the admin experience, then read the same records from normal ABP code when another part of the application needs them.
+
+## Going Further
+
+The workflow we built is intentionally focused, but the same shape can grow in a few directions:
+
+- Add permissions around the generated pages and custom endpoint.
+- Add more form rules for review-specific fields.
+- Add an approval notification after a vendor is accepted.
+- Add a scheduled job that checks overdue applications.
+- Build a dashboard widget on top of the summary endpoint.
+
+The main pattern stays the same: model the data in the Low-Code Designer, let the React runtime render the operational page, and add code or scripting only for the parts that are specific to your business process.
+
+## Conclusion
+
+ABP Low-Code is useful when the first version of a business workflow is mostly metadata: entities, fields, filters, forms, validation, uploads, and a few custom actions.
+
+In this vendor onboarding example, the `VendorApplication` model gave us a generated grid and form, the runtime handled upload fields and conditional UI, and a custom endpoint added the summary that CRUD would not provide by itself. We also saw that low-code metadata can come from the Designer, from runtime JSON, or from C# code when you need that bridge.
+
+That is the part worth remembering: you can start with a working admin experience quickly, then extend the workflow where the generated behavior stops being enough.
+
+### Further Reading
+
+- [Low-Code System Overview](https://abp.io/docs/latest/low-code/index)
+- [Low-Code Designer](https://abp.io/docs/latest/low-code/designer)
+- [React Runtime](https://abp.io/docs/latest/low-code/react-runtime)
+- [Custom Endpoints](https://abp.io/docs/latest/low-code/custom-endpoints)
+- [Scripting API](https://abp.io/docs/latest/low-code/scripting-api)

docs/en/Community-Articles/2026-07-07-building-a-vendor-onboarding-workflow-with-abp-low-code/summary.md

@@ -0,0 +1 @@
+Build a vendor onboarding workflow with ABP Low-Code: model vendor applications in the Designer, let the React runtime render the grid and form, then add a custom endpoint and a typed ABP code bridge for process-level counts.

docs/en/Community-Articles/2026-07-07-introducing-abp-low-code/post.md

@@ -0,0 +1,225 @@
+# Introducing ABP Low-Code: Build Real ABP Apps in Minutes
+
+**Create runtime-managed pages, generated React screens, code-first C# entities, and Script API extensions without leaving the ABP application model.**
+
+![ABP Low-Code runtime loop — grids, forms, calendars, and pipelines inside one ABP app](assets/gifs/eventflow-hero-loop.gif)
+
+> **Want to try the same path?** Start from ABP Studio, enable the Low-Code runtime and designer, define pages in the Admin Console, and see them resolve inside the running ABP app.
+
+---
+
+## ABP Low-Code at a glance
+
+| Runtime authoring | Generated screens | ABP-native extensibility | One application model |
+| :---: | :---: | :---: | :---: |
+| Define and update pages in the Admin Console | Grid, Form, Calendar, Kanban, Gallery, Dashboard | Code-first entities, Script API actions, and C# query paths | Runtime metadata, generated UI, and application code stay together |
+
+---
+
+## Built into the ABP Platform
+
+Low-code is most useful when speed does not create a separate stack to maintain later.
+
+That is where many low-code products start to strain. They move quickly at the beginning, then force a second implementation track when the app needs permissions, auditability, custom logic, or tighter integration with existing application code.
+
+ABP Low-Code takes a different path. It runs **inside the ABP Platform**, so runtime-managed pages are part of an application foundation that already includes identity, permissions, audit logging, APIs, and code-level extensibility.
+
+---
+
+## Edit at runtime. See it in the app.
+
+In the Low-Code Designer, you update a runtime-managed page. A few seconds later, the same application surface is visible in the live app. No rebuild loop. No parallel front-end implementation. No "we will wire it later" gap between authoring and runtime.
+
+ABP Low-Code shortens the cycle from model change to running screen while keeping the output grounded in the same ABP application.
+
+![ABP Low-Code designer workspace for a runtime page](assets/screenshots/admin-console-lowcode.png)
+
+> **What this shows:** authoring and runtime are connected. Pages are defined in the designer and resolved in the running application.
+
+---
+
+## CRUD is table stakes
+
+If low-code only saves you from drawing a table and a form, it is not enough. Business applications need richer operational surfaces.
+
+In the generated app, the `Events` screen ships with search, actions, filters, and form-driven editing. The form structure already understands tabs, relations, validation, and business-shaped input instead of leaving you with a blank shell to finish by hand.
+
+![Generated event grid and generated event form](assets/gifs/eventflow-grid-form-flow.gif)
+
+The point is not just generated CRUD. It is generated CRUD that already looks like the operational screens teams maintain in real applications.
+
+---
+
+## One model, multiple operational screens
+
+Business users do not think in one view. Operators want a calendar for scheduling, a kanban board for workflow, a grid for bulk operations, a gallery when media matters, and a dashboard when they need the state of the business at a glance.
+
+ABP Low-Code keeps those surfaces attached to the same underlying model. The same `Session` model can appear as a **calendar** for planning and a **kanban pipeline** for operational flow. The same generated app can also include a **speaker gallery** and an **overview dashboard** for metrics.
+
+![The same runtime model shown as calendar and kanban views](assets/gifs/eventflow-calendar-kanban-flow.gif)
+
+![Overview dashboard in the live runtime app](assets/screenshots/overview-dashboard.png)
+
+This is where ABP Low-Code starts to feel less like a form generator and more like a runtime application layer: one model, many working screens, no second implementation track for each view type.
+
+---
+
+## When low-code needs code
+
+The real differentiator is not that ABP Low-Code can go fast. It is that **speed does not require isolation from the application foundation**.
+
+When generated CRUD is not enough, you extend the same app instead of throwing the low-code layer away.
+
+ABP Low-Code exposes a server-side **Script API** inside the same application model. That scripting surface can back:
+
+- **Custom endpoints** when the UI needs an API-shaped response.
+- **Interceptors** when create or update commands need validation or mutation.
+- **Event handlers** when logic should react to runtime events.
+- **Background jobs** when work should continue asynchronously.
+- **Background workers** when operational logic should run on a schedule.
+
+In this article, the visible proof happens to be `GET /api/custom/eventflow/highlights`. The GIF shows an endpoint because it is the easiest proof surface to read. But the broader point is that endpoints are only one consumer of the same low-code scripting layer.
+
+That hybrid model matters in both directions:
+
+- **Code-first ABP entities can be surfaced in low-code flows and runtime pages.**
+- **Low-code-managed data and screens stay reachable from Script API actions, application services, repository queries, and custom endpoints.**
+- **Teams do not lose architectural control just because they gained a faster authoring layer.**
+
+![Endpoint result and runtime dashboard reading the same numbers](assets/gifs/eventflow-custom-endpoint-flow.gif)
+
+The actual capability is the shared ABP application model behind it: script when runtime logic is enough, C# when typed application services and repository queries are the better fit.
+
+This is the difference between "low-code as a shortcut" and "low-code as part of your application platform."
+
+---
+
+## From code-first entity to generated page
+
+The first direction is code-first to low-code. A **code-first** `SponsorActivation` entity checked into the ASP.NET Core project can still become a working runtime page without forking into a separate low-code-only model.
+
+The code-first entity carries the same metadata that ABP Low-Code uses to generate the page:
+
+```csharp
+[DynamicEntity(DefaultDisplayPropertyName = nameof(CompanyName))]
+[DynamicEntityUI("Sponsor Activations")]
+[DynamicEntityAttachments("application/pdf", "image/*", MaxFileCount = 4)]
+public class SponsorActivation : DynamicEntityBase
+{
+    [Required]
+    [DynamicPropertyUI(DisplayName = "Sponsor")]
+    public string CompanyName { get; private set; }
+
+    [Required]
+    [EmailAddress]
+    [DynamicPropertyUI(DisplayName = "Contact Email")]
+    public string ContactEmail { get; private set; }
+
+    public SponsorActivationStatus Status { get; set; }
+
+    [DynamicForeignKey("EventFlow.Events.Event", "Title")]
+    public Guid? EventId { get; set; }
+
+    [DynamicForeignKey("Volo.Abp.Identity.IdentityUser", nameof(IdentityUser.UserName), ForeignAccess.View)]
+    public Guid? OwnerUserId { get; set; }
+
+    [DynamicPropertyType(EntityPropertyType.Money)]
+    public decimal ActivationBudget { get; set; }
+
+    [DynamicPropertyImageOptions("image/png", "image/jpeg")]
+    public string? BrandLogo { get; set; }
+
+    [DynamicPropertyFileOptions("application/pdf", ".pptx", ".docx")]
+    public string? ActivationBrief { get; set; }
+}
+```
+
+That class lives as normal C# source, gets migrated like the rest of the application, and is seeded with real records so the runtime page does not open as an empty shell.
+
+Inside the designer, selecting the `SponsorActivation` entity auto-generates the page identity, binds the grid to the entity, and lands on a real runtime route at `/dynamic/sponsor-activation`. The generated surface includes sponsor, email, event lookup, owner lookup, budget, image, and file fields directly from the C# model.
+
+![ABP Low-Code selecting the SponsorActivation C# entity, generating the page, and opening the resulting runtime surface](assets/gifs/eventflow-page-builder.gif)
+
+![Generated SponsorActivation form showing lookups, budget, image, and file fields coming directly from the C# entity](assets/screenshots/sponsor-activation-form.png)
+
+That is the distinction that matters: code-first ABP entities can move through low-code without becoming throwaway artifacts, and low-code-generated surfaces remain part of the same application story.
+
+---
+
+## Low-code data stays reachable from C#
+
+The bridge also works in the other direction. A normal ABP application service can query a low-code model through `IRepository<DynamicEntity, Guid>`, apply real filters, and combine that result with code-first aggregates.
+
+The service behind the endpoint in the previous section looks like this:
+
+```csharp
+public async Task<EventFlowLowCodeProofDto> GetHybridSummaryAsync()
+{
+    var liveSessionQuery = (await _dynamicEntityRepository
+            .SetEntityName("EventFlow.Events.Session")
+            .GetQueryableAsync())
+        .Where("int(it[\"Status\"]) == @0", 2);
+
+    var publicSessionQuery = liveSessionQuery
+        .Where("bool(it[\"IsPublic\"]) == @0", true);
+
+    var sponsorQuery = (await _sponsorActivationRepository.GetQueryableAsync())
+        .Where(activation =>
+            activation.Status == SponsorActivationStatus.Approved ||
+            activation.Status == SponsorActivationStatus.Live);
+
+    var liveSessionCount = await AsyncExecuter.CountAsync(liveSessionQuery);
+    var publicSessionCount = await AsyncExecuter.CountAsync(publicSessionQuery);
+    var activeSponsorActivationCount = await AsyncExecuter.CountAsync(sponsorQuery);
+
+    return new EventFlowLowCodeProofDto
+    {
+        LiveSessionCount = liveSessionCount,
+        PublicSessionCount = publicSessionCount,
+        ActiveSponsorActivationCount = activeSponsorActivationCount
+    };
+}
+```
+
+Here, low-code-managed `Session` rows are filtered from C# with real `Where(...)` clauses, then combined with the typed `SponsorActivation` repository. The endpoint and dashboard are just one presentation surface for that shared ABP query path.
+
+That is the ABP difference: low-code data stays reachable from code, and code-first entities stay reachable from low-code.
+
+---
+
+## Why ABP Low-Code matters
+
+The value is not novelty. It is a faster way to build real business applications without separating speed from the application foundation.
+
+- **Speed without replatforming.** Runtime-managed screens reduce delivery time without moving the team onto a separate application stack.
+- **Governance without friction.** Permissions, identity, auditability, and ABP platform foundations stay part of the story from day one.
+- **Extensibility without rewrite pressure.** When custom behavior shows up, the same application can be extended instead of replacing the low-code output.
+
+That is the core ABP Low-Code promise: faster delivery, still inside the application model you can extend.
+
+---
+
+## Try it yourself
+
+The public starting point for ABP Low-Code is **ABP Studio**.
+
+![ABP Studio new solution wizard with the Low-Code runtime and designer option enabled](assets/screenshots/abp-studio-lowcode-system.png)
+
+1. Open **ABP Studio** and create a new solution.
+2. In the solution wizard, enable **Include Low-Code runtime and designer**.
+3. Complete the wizard, then run the generated backend and React UI from the solution.
+4. Sign in with the administrator account created for that solution.
+5. Open **Admin Console** to define runtime-managed entities, forms, pages, permissions, endpoints, and script actions.
+6. Switch to the application side to see those changes resolve live in the running app.
+
+---
+
+## Further reading
+
+- [ABP Low-Code Designer Documentation](https://abp.io/docs/latest/low-code/designer)
+- [ABP Low-Code Configuration & Fluent API](https://abp.io/docs/latest/low-code/fluent-api)
+- [ABP Low-Code Scripting API](https://abp.io/docs/latest/low-code/scripting-api)
+- [ABP Low-Code Script Actions](https://abp.io/docs/latest/low-code/script-actions)
+- [ABP Low-Code Interceptors](https://abp.io/docs/latest/low-code/interceptors)
+- [ABP Studio Documentation](https://abp.io/docs/latest/studio)
+- [Get Started with ABP: Creating a Layered Web Application](https://abp.io/docs/latest/get-started/layered-web-application)

docs/en/Community-Articles/2026-07-07-introducing-abp-low-code/summary.md

@@ -0,0 +1 @@
+Discover how ABP Low-Code blends runtime page building with code-first entities, C# queries, and extensible application logic.

docs/en/framework/api-development/auto-controllers.md

@@ -62,6 +62,8 @@ ABP uses a naming convention while determining the HTTP method for a service met
 
 If you need to customize HTTP method for a particular method, then you can use one of the standard ASP.NET Core attributes ([HttpPost], [HttpGet], [HttpPut]... etc.). This requires to add [Microsoft.AspNetCore.Mvc.Core](https://www.nuget.org/packages/Microsoft.AspNetCore.Mvc.Core) nuget package to your project that contains the service.
 
+The naming convention doesn't map the HTTP QUERY method (a safe method that carries its parameters in the request body, useful when a GET request would have too many query string parameters). If you want to expose an action as a QUERY endpoint, use the `[AcceptVerbs("QUERY")]` attribute explicitly. Such an action is treated as a safe method, so it is not audited and doesn't start a transactional unit of work by default, just like a GET request. However, unlike a GET request, a QUERY request still requires the anti-forgery token because it carries a request body. This is consistent with ASP.NET Core, which doesn't treat QUERY as an anti-forgery exempt method.
+
 ### Route
 
 Route is calculated based on some conventions:

docs/en/framework/architecture/domain-driven-design/unit-of-work.md

@@ -38,10 +38,10 @@ All of these are automatically handled by the ABP.
 
 While the section above explains the UOW as it is database transaction, actually a UOW doesn't have to be transactional. By default;
 
-* **HTTP GET** requests don't start a transactional UOW. They still starts a UOW, but **doesn't create a database transaction**.
+* **HTTP GET** and **HTTP QUERY** requests don't start a transactional UOW. They still start a UOW, but **don't create a database transaction**.
 * All other HTTP request types start a UOW with a database transaction, if database level transactions are supported by the underlying database provider.
 
-This is because an HTTP GET request doesn't (and shouldn't) make any change in the database. You can change this behavior using the options explained below.
+This is because they are safe HTTP methods that don't (and shouldn't) make any change in the database. You can change this behavior using the options explained below.
 
 ## Default Options
 

docs/en/framework/infrastructure/audit-logging.md

@@ -48,7 +48,7 @@ Here, a list of the options you can configure:
 * `IsEnabledForAnonymousUsers` (default: `true`): If you want to write audit logs only for the authenticated users, set this to `false`. If you save audit logs for anonymous users, you will see `null` for `UserId` values for these users.
 * `AlwaysLogOnException` (default: `true`): If you set to true, it always saves the audit log on an exception/error case without checking other options (except `IsEnabled`, which completely disables the audit logging).
 * `IsEnabledForIntegrationService` (default: `false`): Audit Logging is disabled for [integration services](../api-development/integration-services.md) by default. Set this property as `true` to enable it.
-* `IsEnabledForGetRequests` (default: `false`): HTTP GET requests should not make any change in the database normally and audit log system doesn't save audit log objects for GET request. Set this to `true` to enable it also for the GET requests.
+* `IsEnabledForGetRequests` (default: `false`): Safe HTTP methods (GET, HEAD and QUERY) should not make any change in the database normally and the audit log system doesn't save audit log objects for these requests. Set this to `true` to enable it also for the safe requests.
 * `DisableLogActionInfo` (default: `false`):If you set to true, Will no longer log `AuditLogActionInfo`.
 * `ApplicationName`: If multiple applications are saving audit logs into a single database, set this property to your application name, so you can distinguish the logs of different applications. If you don't set, it will set from the `IApplicationInfoAccessor.ApplicationName` value, which is the entry assembly name by default.
 * `IgnoredTypes`: A list of `Type`s to be ignored for audit logging. If this is an entity type, changes for this type of entities will not be saved. This list is also used while serializing the action parameters.

docs/en/suite/create-solution.md

@@ -23,8 +23,8 @@
 
 ## Create a new solution
 
-From ABP Suite v8.3, **create a new solution** option has been removed. Instead, it's suggessted to use [ABP Studio](../studio/index.md) or [ABP CLI](../cli/index.md) to create a new solution. After, creating an ABP Solution, then you can generate CRUD pages via ABP Suite as always.
+From ABP Suite v8.3, **create a new solution** option has been removed. Instead, it's suggested to use [ABP Studio](../studio/index.md) or [ABP CLI](../cli/index.md) to create a new solution. After creating an ABP solution, you can generate CRUD pages via ABP Suite as usual.
 
-> **Note:** ABP Suite does not generate React UI pages. If you create a modern React solution, use Suite where applicable for backend and application-layer generation, and develop the React UI in the source-owned [React UI](../framework/ui/react/index.md) application. ABP license holders can use [ABP Studio AI Agent](https://abp.io/studio/ai-agent) with predefined AI credits to generate React pages more easily.
+> **Note:** For modern React UI solutions, ABP Suite generates the backend, the application layer and the React CRUD UI. Develop any React UI that generation does not cover in the source-owned [React UI](../framework/ui/react/index.md) application. ABP license holders can also use the [ABP Studio AI Agent](https://abp.io/studio/ai-agent) with predefined AI credits for React pages.
 
 > ABP Studio has a shortcut for running [ABP Suite](./index.md) to allow using it without starting it externally and using it on a browser, which means you can create, manage, deploy your applications in a single desktop application and also generate CRUD pages via Suite as a pre-integrated application to ABP Studio. 

docs/en/suite/creating-many-to-many-relationship.md

@@ -75,6 +75,6 @@ Click the **Navigations** tab. Then click the **Add navigation collection** butt
 
 The below image is the final page created by ABP Suite. The **new book** dialog has a **Categories** tab which lists all categories of the book and allows add/remove categories.
 
-> **Note:** ABP Suite does not generate React UI for this page. The generated UI applies to Suite-supported UI stacks such as MVC, Blazor and Angular. ABP license holders can use [ABP Studio AI Agent](https://abp.io/studio/ai-agent) with predefined AI credits to generate React pages more easily.
+> **Note:** For modern React UI solutions, ABP Suite generates the navigation collection as an inline multi-select on the entity's create/edit dialog — add or remove connected records, pre-selected when editing an existing record, and available as a list filter — alongside the MVC, Blazor and Angular UI stacks.
 
 ![navigation-collection-books-page](../images/navigation-collection-books-page.8.1.png)

docs/en/suite/creating-master-detail-relationship.md

@@ -39,7 +39,7 @@ You need to specify the **Entity type** as _Master_ (default). Then, provide the
 
 Create a child entity, specify the **Entity type** as _Child_, and associate it with a master entity. In the figure above, you can see an example of, a child entity **OrderLine** with the associated master entity **Order**. When you specify the **Entity type** as _Child_, then the UI and tests will not be generated for the child entity and instead, all of the orchestration of the entity will be delegated to its master entity.
 
-> **Note:** ABP Suite does not generate React UI for master-detail pages. The generated UI applies to Suite-supported UI stacks such as MVC, Blazor and Angular. ABP license holders can use [ABP Studio AI Agent](https://abp.io/studio/ai-agent) with predefined AI credits to generate React pages more easily.
+> **Note:** For modern React UI solutions, ABP Suite generates the master-detail UI: once the master record exists, each child entity renders as a sub-grid on its own tab inside the master edit dialog, with its own add/edit/delete dialog. This is generated in addition to the MVC, Blazor and Angular UI stacks.
 
 Application services will be generated for the child entity, so it's possible for you to consume its endpoints and create-update-list or delete the child entity specifically. Suite also respects your multi-tenancy selection and sets the child entity as a multi-tenant entity, if the master entity has multi-tenancy enabled.
 

docs/en/suite/customizing-the-generated-code.md

@@ -58,7 +58,7 @@ You can see the example below, which demonstrates defining a new method in the `
 
 For the UI side, ABP Suite provides convenient comment placeholders within pages for MVC, Blazor, and Angular UIs. These comment sections serve as hook points where you can add your custom code. By placing your custom logic with these hook points, you can enhance the UI to your needs without the fear of losing your changes during the next CRUD page generation.
 
-> **Note:** ABP Suite does not generate React UI pages or React customization hook points. React UI is part of ABP's modern template system and is customized directly in the source-owned [React UI](../framework/ui/react/index.md) application. ABP license holders can use [ABP Studio AI Agent](https://abp.io/studio/ai-agent) with predefined AI credits to generate React pages and customize them more easily.
+> **Note:** These comment-based hook points are available for the MVC, Blazor and Angular UIs. ABP Suite also generates React CRUD pages for modern React UI solutions, but the React pages do not provide the same in-page custom-code hook points yet, so re-generating an entity overwrites its React page. Keep customizations to the React UI in the source-owned [React UI](../framework/ui/react/index.md) application, outside the generated pages. ABP license holders can also use the [ABP Studio AI Agent](https://abp.io/studio/ai-agent) with predefined AI credits to evolve the React UI.
 
 ### Customizations on MVC UI
 

docs/en/suite/editing-templates.md

@@ -11,12 +11,12 @@ ABP Suite uses templates to generate the code files. You can see the template fi
 
 ![Suite template list](../images/suite-templates-8.1.png)
 
-The are 2 template filters:
+There are 2 template filters:
 
 1. **UI**:  You can switch between `Angular`, `MVC` and `Blazor` templates.
 2. **Database provider:** You can switch between `EF Core` and `MongoDb` templates.
 
-> **Note:** ABP Suite does not include React UI templates or generate React client-side code. React UI belongs to the modern template system and should be developed in the source-owned [React UI](../framework/ui/react/index.md) application. ABP license holders can use [ABP Studio AI Agent](https://abp.io/studio/ai-agent) with predefined AI credits to generate React pages more easily.
+> **Note:** This template editor lists the `Angular`, `MVC` and `Blazor` templates. ABP Suite generates React CRUD pages for modern React UI solutions from built-in templates, but those React templates are not editable through this template editor.
 
 These filters are automatically selected based on your ABP solution. The selected solution is shown on the top right of the page. In the current screenshot it is "Acme.BookStore". 
 

docs/en/suite/generating-crud-page.md

@@ -110,7 +110,7 @@ To create a new entity, make sure the *-New entity-* is selected in the **Entity
 
 * **Create user interface:** Creates pages, modals, components, `JavaScript`, `CSS` files and adds the new page to the main menu. If you don't have a requirement to manage the entity via user interface, you can uncheck this option.
 
-  > **Note:** This option does not generate React UI pages. ABP Suite's UI generation targets Suite-supported UI stacks such as MVC, Blazor and Angular. For React-based solutions, build the UI in the source-owned [React UI](../framework/ui/react/index.md) application. ABP license holders can use [ABP Studio AI Agent](https://abp.io/studio/ai-agent) with predefined AI credits to generate React pages more easily.
+  > **Note:** For modern React UI solutions, this option also generates and registers React CRUD pages, alongside the MVC, Blazor and Angular UI stacks. React generation is template-based and does not use AI.
 
   > **Blazor UI library:** For Blazor solutions, the generated UI matches the underlying Blazor component library. Solutions that reference `Volo.Abp.MudBlazorUI` produce pages built around `MudDataGrid`, `MudDialog`, `MudForm` and the rest of the [MudBlazor](https://mudblazor.com) controls; Blazorise-based solutions keep emitting the original `DataGrid` / `Modal` / `Validations` markup. ABP Suite picks the variant automatically by scanning the Blazor project `.csproj` and shows the resolved value in the solution info tooltip — no extra switch is required. See the [Blazor UI library](index.md#blazor-ui-library) section for details.
 

docs/en/suite/index.md

@@ -21,7 +21,7 @@
 
 ABP Suite is a complementary tool to the ABP Platform. ABP Suite allows you to build web pages in a matter of minutes. 
 
-> **Important:** ABP Suite does not generate React UI pages or client-side React code. Its CRUD UI generation is designed for the established Suite-supported UI stacks, such as MVC, Blazor and Angular. The new [React UI](../framework/ui/react/index.md) belongs to ABP's modern template system and is designed for an AI-first, AI-oriented development flow with a modern frontend stack such as React, TypeScript, Vite, TanStack Router, TanStack Query, shadcn/ui, Zod and React Hook Form. In React UI solutions, ABP Suite can still be useful for the backend and application layers where applicable, but the React UI side is expected to be developed in the source-owned React application. ABP license holders can use [ABP Studio AI Agent](https://abp.io/studio/ai-agent) with predefined AI credits to generate React pages and evolve the UI more easily.
+> **Note:** ABP Suite also generates React CRUD pages for modern React UI solutions, in addition to the MVC, Blazor and Angular UI stacks. The generator is template-based and does not use AI. It covers the standard CRUD scenarios — navigation-property lookups, many-to-many navigation collections, master-detail child grids, file upload, enums, filtering, Excel export and bulk delete — and registers each page in the React app's route configuration and menu.
 
 It's a .NET Core Global tool that can be installed from the command line. If you are using [ABP Studio](../studio/index.md), you don't even need to install it because it should already be installed, when you first installed the [ABP Studio](../studio/index.md).
 

framework/src/Volo.Abp.AspNetCore.Mvc/Volo/Abp/AspNetCore/Mvc/Uow/AbpUowActionFilter.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Net.Http;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Mvc.Abstractions;
@@ -7,6 +6,7 @@ using Microsoft.AspNetCore.Mvc.Filters;
 using Microsoft.Extensions.Options;
 using Volo.Abp.AspNetCore.Filters;
 using Volo.Abp.DependencyInjection;
+using Volo.Abp.Http;
 using Volo.Abp.Threading;
 using Volo.Abp.Uow;
 
@@ -81,7 +81,8 @@ public class AbpUowActionFilter : IAsyncActionFilter, IAbpFilter, ITransientDepe
         {
             var abpUnitOfWorkDefaultOptions = context.GetRequiredService<IOptions<AbpUnitOfWorkDefaultOptions>>().Value;
             options.IsTransactional = abpUnitOfWorkDefaultOptions.CalculateIsTransactional(
-                autoValue: !string.Equals(context.HttpContext.Request.Method, HttpMethod.Get.Method, StringComparison.OrdinalIgnoreCase)
+                autoValue: !(HttpMethodHelper.IsGet(context.HttpContext.Request.Method)
+                             || HttpMethodHelper.IsQuery(context.HttpContext.Request.Method))
             );
         }
 

framework/src/Volo.Abp.AspNetCore.Mvc/Volo/Abp/AspNetCore/Mvc/Uow/AbpUowPageFilter.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Net.Http;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Mvc.Abstractions;
@@ -7,6 +6,7 @@ using Microsoft.AspNetCore.Mvc.Filters;
 using Microsoft.Extensions.Options;
 using Volo.Abp.AspNetCore.Filters;
 using Volo.Abp.DependencyInjection;
+using Volo.Abp.Http;
 using Volo.Abp.Threading;
 using Volo.Abp.Uow;
 
@@ -86,7 +86,8 @@ public class AbpUowPageFilter : IAsyncPageFilter, IAbpFilter, ITransientDependen
         {
             var abpUnitOfWorkDefaultOptions = context.GetRequiredService<IOptions<AbpUnitOfWorkDefaultOptions>>().Value;
             options.IsTransactional = abpUnitOfWorkDefaultOptions.CalculateIsTransactional(
-                autoValue: !string.Equals(context.HttpContext.Request.Method, HttpMethod.Get.Method, StringComparison.OrdinalIgnoreCase)
+                autoValue: !(HttpMethodHelper.IsGet(context.HttpContext.Request.Method)
+                             || HttpMethodHelper.IsQuery(context.HttpContext.Request.Method))
             );
         }
 

framework/src/Volo.Abp.AspNetCore/Volo/Abp/AspNetCore/Auditing/AbpAuditingMiddleware.cs

@@ -7,6 +7,7 @@ using Microsoft.Extensions.Options;
 using Volo.Abp.AspNetCore.Middleware;
 using Volo.Abp.Auditing;
 using Volo.Abp.DependencyInjection;
+using Volo.Abp.Http;
 using Volo.Abp.Uow;
 using Volo.Abp.Users;
 
@@ -135,8 +136,9 @@ public class AbpAuditingMiddleware : AbpMiddlewareBase, ITransientDependency
         }
 
         if (!AuditingOptions.IsEnabledForGetRequests &&
-            (string.Equals(httpContext.Request.Method, HttpMethods.Get, StringComparison.OrdinalIgnoreCase) ||
-             string.Equals(httpContext.Request.Method, HttpMethods.Head, StringComparison.OrdinalIgnoreCase)))
+            (HttpMethodHelper.IsGet(httpContext.Request.Method) ||
+             HttpMethodHelper.IsHead(httpContext.Request.Method) ||
+             HttpMethodHelper.IsQuery(httpContext.Request.Method)))
         {
             return false;
         }

framework/src/Volo.Abp.AspNetCore/Volo/Abp/AspNetCore/Uow/AspNetCoreUnitOfWorkTransactionBehaviourProvider.cs

@@ -1,8 +1,8 @@
 using System;
-using System.Net.Http;
 using Microsoft.AspNetCore.Http;
 using Microsoft.Extensions.Options;
 using Volo.Abp.DependencyInjection;
+using Volo.Abp.Http;
 using Volo.Abp.Uow;
 
 namespace Volo.Abp.AspNetCore.Uow;
@@ -37,10 +37,8 @@ public class AspNetCoreUnitOfWorkTransactionBehaviourProvider : IUnitOfWorkTrans
                 }
             }
 
-            return !string.Equals(
-                httpContext.Request.Method,
-                HttpMethod.Get.Method, StringComparison.OrdinalIgnoreCase
-            );
+            var method = httpContext.Request.Method;
+            return !(HttpMethodHelper.IsGet(method) || HttpMethodHelper.IsQuery(method));
         }
     }
 

framework/src/Volo.Abp.Auditing/Volo/Abp/Auditing/AbpAuditingOptions.cs

@@ -62,6 +62,7 @@ public class AbpAuditingOptions
     //TODO: Move this to asp.net core layer or convert it to a more dynamic strategy?
     /// <summary>
     /// Default: false.
+    /// When false, safe methods (GET, HEAD and QUERY) are excluded from audit logging.
     /// </summary>
     public bool IsEnabledForGetRequests { get; set; }
 

framework/src/Volo.Abp.Auditing/Volo/Abp/Auditing/AuditingInterceptor.cs

@@ -193,6 +193,7 @@ public class AuditingInterceptor : AbpInterceptor, ITransientDependency
         if (!options.IsEnabledForGetRequests &&
             (string.Equals(auditLogInfo.HttpMethod, "Get", StringComparison.OrdinalIgnoreCase) ||
              string.Equals(auditLogInfo.HttpMethod, "Head", StringComparison.OrdinalIgnoreCase) ||
+             string.Equals(auditLogInfo.HttpMethod, "Query", StringComparison.OrdinalIgnoreCase) ||
              invocation.Method.Name.StartsWith("Get", StringComparison.OrdinalIgnoreCase)))
         {
             return false;

framework/src/Volo.Abp.Http/Volo/Abp/Http/HttpMethodHelper.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Net.Http;
@@ -8,15 +8,25 @@ namespace Volo.Abp.Http;
 
 public static class HttpMethodHelper
 {
-    public const string DefaultHttpVerb = "POST";
+    public const string Get = "GET";
+    public const string Post = "POST";
+    public const string Put = "PUT";
+    public const string Delete = "DELETE";
+    public const string Patch = "PATCH";
+    public const string Head = "HEAD";
+    public const string Options = "OPTIONS";
+    public const string Trace = "TRACE";
+    public const string Query = "QUERY";
+
+    public const string DefaultHttpVerb = Post;
 
     public static Dictionary<string, string[]> ConventionalPrefixes { get; set; } = new Dictionary<string, string[]>
         {
-            {"GET", new[] {"GetList", "GetAll", "Get"}},
-            {"PUT", new[] {"Put", "Update"}},
-            {"DELETE", new[] {"Delete", "Remove"}},
-            {"POST", new[] {"Create", "Add", "Insert", "Post"}},
-            {"PATCH", new[] {"Patch"}}
+            {Get, new[] {"GetList", "GetAll", "Get"}},
+            {Put, new[] {"Put", "Update"}},
+            {Delete, new[] {"Delete", "Remove"}},
+            {Post, new[] {"Create", "Add", "Insert", "Post"}},
+            {Patch, new[] {"Patch"}}
         };
 
     public static string GetConventionalVerbForMethodName(string methodName)
@@ -50,24 +60,44 @@ public static class HttpMethodHelper
     {
         switch (httpMethod?.ToUpperInvariant())
         {
-            case "GET":
+            case Get:
                 return HttpMethod.Get;
-            case "POST":
+            case Post:
                 return HttpMethod.Post;
-            case "PUT":
+            case Put:
                 return HttpMethod.Put;
-            case "DELETE":
+            case Delete:
                 return HttpMethod.Delete;
-            case "OPTIONS":
+            case Options:
                 return HttpMethod.Options;
-            case "TRACE":
+            case Trace:
                 return HttpMethod.Trace;
-            case "HEAD":
+            case Head:
                 return HttpMethod.Head;
-            case "PATCH":
-                return new HttpMethod("PATCH");
+            case Patch:
+                return new HttpMethod(Patch);
+            case Query:
+                return new HttpMethod(Query);
             default:
                 throw new AbpException("Unknown HTTP METHOD: " + httpMethod);
         }
     }
+
+    public static bool IsGet(string? httpMethod) => string.Equals(httpMethod, Get, StringComparison.OrdinalIgnoreCase);
+
+    public static bool IsPost(string? httpMethod) => string.Equals(httpMethod, Post, StringComparison.OrdinalIgnoreCase);
+
+    public static bool IsPut(string? httpMethod) => string.Equals(httpMethod, Put, StringComparison.OrdinalIgnoreCase);
+
+    public static bool IsDelete(string? httpMethod) => string.Equals(httpMethod, Delete, StringComparison.OrdinalIgnoreCase);
+
+    public static bool IsPatch(string? httpMethod) => string.Equals(httpMethod, Patch, StringComparison.OrdinalIgnoreCase);
+
+    public static bool IsHead(string? httpMethod) => string.Equals(httpMethod, Head, StringComparison.OrdinalIgnoreCase);
+
+    public static bool IsOptions(string? httpMethod) => string.Equals(httpMethod, Options, StringComparison.OrdinalIgnoreCase);
+
+    public static bool IsTrace(string? httpMethod) => string.Equals(httpMethod, Trace, StringComparison.OrdinalIgnoreCase);
+
+    public static bool IsQuery(string? httpMethod) => string.Equals(httpMethod, Query, StringComparison.OrdinalIgnoreCase);
 }

framework/test/Volo.Abp.AspNetCore.Mvc.Tests/Volo/Abp/AspNetCore/Mvc/Auditing/AuditTestController_Tests.cs

@@ -58,6 +58,20 @@ public class AuditTestController_Tests : AspNetCoreMvcTestBase
         await _auditingStore.Received().DidNotReceive().SaveAsync(Arg.Any<AuditLogInfo>());
     }
 
+    [Fact]
+    public async Task Should_Disable_AuditLog_For_Query_Requests()
+    {
+        _options.IsEnabledForGetRequests = false;
+
+        using (var requestMessage = new HttpRequestMessage(new HttpMethod("QUERY"), "api/audit-test/audit-success"))
+        {
+            var response = await Client.SendAsync(requestMessage);
+            response.StatusCode.ShouldBe(System.Net.HttpStatusCode.OK);
+        }
+
+        await _auditingStore.Received().DidNotReceive().SaveAsync(Arg.Any<AuditLogInfo>());
+    }
+
     [Fact]
     public async Task Should_Trigger_Middleware_And_AuditLog_Success_For_GetRequests()
     {

framework/test/Volo.Abp.AspNetCore.Mvc.Tests/Volo/Abp/AspNetCore/Mvc/Uow/UnitOfWorkMiddleware_Tests.cs

@@ -1,4 +1,5 @@
-using System.Threading.Tasks;
+using System.Net.Http;
+using System.Threading.Tasks;
 using Shouldly;
 using Xunit;
 
@@ -18,4 +19,12 @@ public class UnitOfWorkMiddleware_Tests : AspNetCoreMvcTestBase
         var result = await Client.PostAsync("/api/unitofwork-test/ActionRequiresUowPost", null);
         result.IsSuccessStatusCode.ShouldBeTrue();
     }
+
+    [Fact]
+    public async Task Query_Actions_Should_Not_Be_Transactional()
+    {
+        using var requestMessage = new HttpRequestMessage(new HttpMethod("QUERY"), "/api/unitofwork-test/ActionRequiresUowQuery");
+        var result = await Client.SendAsync(requestMessage);
+        result.IsSuccessStatusCode.ShouldBeTrue();
+    }
 }

framework/test/Volo.Abp.AspNetCore.Mvc.Tests/Volo/Abp/AspNetCore/Mvc/Uow/UnitOfWorkPageFilter_Tests.cs

@@ -1,4 +1,5 @@
-using System.Threading.Tasks;
+using System.Net.Http;
+using System.Threading.Tasks;
 using Shouldly;
 using Xunit;
 
@@ -18,4 +19,12 @@ public class UnitOfWorkPageFilter_Tests : AspNetCoreMvcTestBase
         var result = await Client.PostAsync("/Uow/UnitOfWorkTestPage?handler=RequiresUow", null);
         result.IsSuccessStatusCode.ShouldBeTrue();
     }
+
+    [Fact]
+    public async Task Query_Actions_Should_Not_Be_Transactional()
+    {
+        using var requestMessage = new HttpRequestMessage(new HttpMethod("QUERY"), "/Uow/UnitOfWorkTestPage?handler=RequiresUow");
+        var result = await Client.SendAsync(requestMessage);
+        result.IsSuccessStatusCode.ShouldBeTrue();
+    }
 }

framework/test/Volo.Abp.AspNetCore.Mvc.Tests/Volo/Abp/AspNetCore/Mvc/Uow/UnitOfWorkTestController.cs

@@ -34,6 +34,16 @@ public class UnitOfWorkTestController : AbpController
         return Content("OK");
     }
 
+    [AcceptVerbs("QUERY")]
+    [Route("ActionRequiresUowQuery")]
+    public ActionResult ActionRequiresUowQuery()
+    {
+        CurrentUnitOfWork.ShouldNotBeNull();
+        CurrentUnitOfWork.Options.IsTransactional.ShouldBeFalse();
+
+        return Content("OK");
+    }
+
     [HttpGet]
     [Route("HandledException")]
     [UnitOfWork(isTransactional: true)]

framework/test/Volo.Abp.AspNetCore.Mvc.Tests/Volo/Abp/AspNetCore/Mvc/Uow/UnitOfWorkTestPage.cshtml.cs

@@ -31,6 +31,14 @@ public class UnitOfWorkTestPage : AbpPageModel
         return Content("OK");
     }
 
+    public IActionResult OnQueryRequiresUow()
+    {
+        CurrentUnitOfWork.ShouldNotBeNull();
+        CurrentUnitOfWork.Options.IsTransactional.ShouldBeFalse();
+
+        return Content("OK");
+    }
+
     [UnitOfWork(isTransactional: true)]
     public ObjectResult OnGetHandledException()
     {

framework/test/Volo.Abp.AspNetCore.Tests/Volo/Abp/AspNetCore/Uow/AspNetCoreUnitOfWorkTransactionBehaviourProvider_Tests.cs

@@ -0,0 +1,32 @@
+using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.Options;
+using Shouldly;
+using Xunit;
+
+namespace Volo.Abp.AspNetCore.Uow;
+
+public class AspNetCoreUnitOfWorkTransactionBehaviourProvider_Tests
+{
+    private static AspNetCoreUnitOfWorkTransactionBehaviourProvider CreateProvider(string method)
+    {
+        var httpContext = new DefaultHttpContext();
+        httpContext.Request.Method = method;
+
+        return new AspNetCoreUnitOfWorkTransactionBehaviourProvider(
+            new HttpContextAccessor { HttpContext = httpContext },
+            Microsoft.Extensions.Options.Options.Create(new AspNetCoreUnitOfWorkTransactionBehaviourProviderOptions()));
+    }
+
+    [Theory]
+    [InlineData("GET", false)]
+    [InlineData("QUERY", false)]
+    [InlineData("query", false)]
+    [InlineData("HEAD", true)]
+    [InlineData("POST", true)]
+    [InlineData("PUT", true)]
+    [InlineData("DELETE", true)]
+    public void IsTransactional_Should_Treat_Get_And_Query_As_Non_Transactional(string method, bool expected)
+    {
+        CreateProvider(method).IsTransactional.ShouldBe(expected);
+    }
+}

framework/test/Volo.Abp.Auditing.Tests/Volo/Abp/Auditing/AuditingInterceptor_HttpMethod_Tests.cs

@@ -0,0 +1,64 @@
+using System;
+using System.Threading.Tasks;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection.Extensions;
+using NSubstitute;
+using Xunit;
+
+namespace Volo.Abp.Auditing;
+
+public class AuditingInterceptor_HttpMethod_Tests : AbpAuditingTestBase
+{
+    protected IAuditingStore AuditingStore;
+
+    private string? _httpMethod;
+
+    protected override void AfterAddApplication(IServiceCollection services)
+    {
+        AuditingStore = Substitute.For<IAuditingStore>();
+        services.Replace(ServiceDescriptor.Singleton(AuditingStore));
+
+        services.Configure<AbpAuditingOptions>(options =>
+        {
+            options.IsEnabledForGetRequests = false;
+            options.Contributors.Add(new TestHttpMethodAuditContributor(() => _httpMethod));
+        });
+    }
+
+    [Fact]
+    public async Task Should_Not_Write_AuditLog_For_Query_Http_Method_Without_Explicit_Scope()
+    {
+        _httpMethod = "QUERY";
+
+        var auditedObject = GetRequiredService<Auditing_Tests.MyAuditedObject1>();
+        await auditedObject.DoItAsync(new Auditing_Tests.InputObject { Value1 = "x", Value2 = 1 });
+
+        await AuditingStore.DidNotReceive().SaveAsync(Arg.Any<AuditLogInfo>());
+    }
+
+    [Fact]
+    public async Task Should_Write_AuditLog_For_Post_Http_Method_Without_Explicit_Scope()
+    {
+        _httpMethod = "POST";
+
+        var auditedObject = GetRequiredService<Auditing_Tests.MyAuditedObject1>();
+        await auditedObject.DoItAsync(new Auditing_Tests.InputObject { Value1 = "x", Value2 = 1 });
+
+        await AuditingStore.Received().SaveAsync(Arg.Any<AuditLogInfo>());
+    }
+
+    public class TestHttpMethodAuditContributor : AuditLogContributor
+    {
+        private readonly Func<string?> _httpMethodFactory;
+
+        public TestHttpMethodAuditContributor(Func<string?> httpMethodFactory)
+        {
+            _httpMethodFactory = httpMethodFactory;
+        }
+
+        public override void PreContribute(AuditLogContributionContext context)
+        {
+            context.AuditInfo.HttpMethod = _httpMethodFactory();
+        }
+    }
+}

framework/test/Volo.Abp.Http.Client.Tests/Volo/Abp/Http/DynamicProxying/IRegularTestController.cs

@@ -43,6 +43,8 @@ public interface IRegularTestController
 
     Task<Car> PostObjectWithQueryAsync(Car bodyValue);
 
+    Task<Car> QueryObjectWithBodyAsync(Car bodyValue);
+
     Task<Car> GetObjectWithUrlAsync(Car bodyValue);
 
     Task<Car> GetObjectandIdAsync(int id, Car bodyValue);

framework/test/Volo.Abp.Http.Client.Tests/Volo/Abp/Http/DynamicProxying/RegularTestController.cs

@@ -150,6 +150,13 @@ public class RegularTestController : AbpController, IRegularTestController
         return Task.FromResult(bodyValue);
     }
 
+    [AcceptVerbs("QUERY")]
+    [Route("query-object-with-body")]
+    public Task<Car> QueryObjectWithBodyAsync([FromBody] Car bodyValue)
+    {
+        return Task.FromResult(bodyValue);
+    }
+
     [HttpGet]
     [Route("post-object-with-url/bodyValue")]
     public Task<Car> GetObjectWithUrlAsync(Car bodyValue)

framework/test/Volo.Abp.Http.Client.Tests/Volo/Abp/Http/DynamicProxying/RegularTestControllerClientProxy_Tests.cs

@@ -97,6 +97,14 @@ public class RegularTestControllerClientProxy_Tests : AbpHttpClientTestBase
         result.Model.ShouldBe("Ford");
     }
 
+    [Fact]
+    public async Task QueryObjectWithBodyAsync()
+    {
+        var result = await _controller.QueryObjectWithBodyAsync(new Car { Year = 1976, Model = "Ford", FirstReleaseDate = new DateTime(1976, 02, 22, 15, 0, 6, 22) });
+        result.Year.ShouldBe(1976);
+        result.Model.ShouldBe("Ford");
+    }
+
     [Fact]
     public async Task PostObjectWithQueryAsync_With_Different_Culture()
     {

framework/test/Volo.Abp.Http.Tests/Volo/Abp/Http/HttpMethodHelper_Tests.cs

@@ -0,0 +1,105 @@
+using System;
+using System.Collections.Generic;
+using Shouldly;
+using Xunit;
+
+namespace Volo.Abp.Http;
+
+public class HttpMethodHelper_Tests
+{
+    private static readonly Dictionary<string, Func<string?, bool>> Predicates = new()
+    {
+        [HttpMethodHelper.Get] = HttpMethodHelper.IsGet,
+        [HttpMethodHelper.Post] = HttpMethodHelper.IsPost,
+        [HttpMethodHelper.Put] = HttpMethodHelper.IsPut,
+        [HttpMethodHelper.Delete] = HttpMethodHelper.IsDelete,
+        [HttpMethodHelper.Patch] = HttpMethodHelper.IsPatch,
+        [HttpMethodHelper.Head] = HttpMethodHelper.IsHead,
+        [HttpMethodHelper.Options] = HttpMethodHelper.IsOptions,
+        [HttpMethodHelper.Trace] = HttpMethodHelper.IsTrace,
+        [HttpMethodHelper.Query] = HttpMethodHelper.IsQuery
+    };
+
+    [Theory]
+    [InlineData(HttpMethodHelper.Get)]
+    [InlineData(HttpMethodHelper.Post)]
+    [InlineData(HttpMethodHelper.Put)]
+    [InlineData(HttpMethodHelper.Delete)]
+    [InlineData(HttpMethodHelper.Patch)]
+    [InlineData(HttpMethodHelper.Head)]
+    [InlineData(HttpMethodHelper.Options)]
+    [InlineData(HttpMethodHelper.Trace)]
+    [InlineData(HttpMethodHelper.Query)]
+    public void Is_Predicates_Should_Match_Only_Their_Own_Verb_Ignoring_Case(string verb)
+    {
+        foreach (var (name, predicate) in Predicates)
+        {
+            var shouldMatch = name == verb;
+            predicate(verb).ShouldBe(shouldMatch);
+            predicate(verb.ToLowerInvariant()).ShouldBe(shouldMatch);
+        }
+    }
+
+    [Fact]
+    public void Is_Predicates_Should_Return_False_For_Null()
+    {
+        foreach (var predicate in Predicates.Values)
+        {
+            predicate(null).ShouldBeFalse();
+        }
+    }
+
+    [Theory]
+    [InlineData("QUERY", true)]
+    [InlineData("query", true)]
+    [InlineData("Query", true)]
+    [InlineData("GET", false)]
+    [InlineData("POST", false)]
+    [InlineData("", false)]
+    [InlineData(null, false)]
+    public void IsQuery_Should_Match_Query_Method_Ignoring_Case(string? httpMethod, bool expected)
+    {
+        HttpMethodHelper.IsQuery(httpMethod).ShouldBe(expected);
+    }
+
+    [Fact]
+    public void ConvertToHttpMethod_Should_Support_Query()
+    {
+        HttpMethodHelper.ConvertToHttpMethod("QUERY").Method.ShouldBe("QUERY");
+        HttpMethodHelper.ConvertToHttpMethod("query").Method.ShouldBe("QUERY");
+    }
+
+    [Theory]
+    [InlineData("GET")]
+    [InlineData("POST")]
+    [InlineData("PUT")]
+    [InlineData("DELETE")]
+    [InlineData("PATCH")]
+    [InlineData("QUERY")]
+    public void ConvertToHttpMethod_Should_Not_Throw_For_Known_Methods(string httpMethod)
+    {
+        Should.NotThrow(() => HttpMethodHelper.ConvertToHttpMethod(httpMethod));
+    }
+
+    [Fact]
+    public void ConvertToHttpMethod_Should_Throw_For_Unknown_Method()
+    {
+        Should.Throw<AbpException>(() => HttpMethodHelper.ConvertToHttpMethod("UNKNOWN"));
+    }
+
+    [Theory]
+    [InlineData("GetFooAsync", "GET")]
+    [InlineData("GetListAsync", "GET")]
+    [InlineData("CreateFooAsync", "POST")]
+    [InlineData("UpdateFooAsync", "PUT")]
+    [InlineData("DeleteFooAsync", "DELETE")]
+    [InlineData("PatchFooAsync", "PATCH")]
+    [InlineData("DoSomethingAsync", "POST")]
+    // QUERY is intentionally NOT a naming convention: an action must opt in explicitly
+    // with [AcceptVerbs("QUERY")]. A method named Query* still maps to the default verb.
+    [InlineData("QueryFooAsync", "POST")]
+    public void GetConventionalVerbForMethodName_Should_Not_Map_Query_By_Name(string methodName, string expectedVerb)
+    {
+        HttpMethodHelper.GetConventionalVerbForMethodName(methodName).ShouldBe(expectedVerb);
+    }
+}

modules/cms-kit/angular/package.json

@@ -15,7 +15,7 @@
     },
     "private": true,
     "dependencies": {
-        "@abp/ng.account": "~10.5.0",
+        "@abp/ng.account": "~10.6.0-rc.1",
         "@abp/ng.identity": "~10.6.0-rc.1",
         "@abp/ng.setting-management": "~10.6.0-rc.1",
         "@abp/ng.tenant-management": "~10.6.0-rc.1",

modules/docs/src/Volo.Docs.Admin.HttpApi.Client/Volo.Docs.Admin.HttpApi.Client.csproj

@@ -13,6 +13,7 @@
   <ItemGroup>
     <ProjectReference Include="..\Volo.Docs.Admin.Application.Contracts\Volo.Docs.Admin.Application.Contracts.csproj" />
     <ProjectReference Include="..\..\..\..\framework\src\Volo.Abp.Http.Client\Volo.Abp.Http.Client.csproj" />
+    <ProjectReference Include="..\Volo.Docs.Common.HttpApi.Client\Volo.Docs.Common.HttpApi.Client.csproj" />
 
   </ItemGroup>
 

modules/docs/src/Volo.Docs.Admin.HttpApi.Client/Volo/Docs/Admin/DocsAdminHttpApiClientModule.cs

@@ -6,6 +6,7 @@ using Volo.Abp.VirtualFileSystem;
 namespace Volo.Docs.Admin
 {
     [DependsOn(
+        typeof(DocsCommonHttpApiClientModule),
         typeof(DocsAdminApplicationContractsModule),
         typeof(AbpHttpClientModule))]
     public class DocsAdminHttpApiClientModule : AbpModule

modules/docs/src/Volo.Docs.HttpApi.Client/Volo.Docs.HttpApi.Client.csproj

@@ -13,6 +13,7 @@
   <ItemGroup>
     <ProjectReference Include="..\Volo.Docs.Application.Contracts\Volo.Docs.Application.Contracts.csproj" />
     <ProjectReference Include="..\..\..\..\framework\src\Volo.Abp.Http.Client\Volo.Abp.Http.Client.csproj" />
+    <ProjectReference Include="..\Volo.Docs.Common.HttpApi.Client\Volo.Docs.Common.HttpApi.Client.csproj" />
   </ItemGroup>
 
 </Project>

modules/docs/src/Volo.Docs.HttpApi.Client/Volo/Docs/DocsHttpApiClientModule.cs

@@ -6,6 +6,7 @@ using Volo.Abp.VirtualFileSystem;
 namespace Volo.Docs
 {
     [DependsOn(
+        typeof(DocsCommonHttpApiClientModule),
         typeof(DocsApplicationContractsModule),
         typeof(AbpHttpClientModule)
     )]

npm/ng-packs/packages/components/extensible/src/lib/components/extensible-form/extensible-form-prop.component.html

@@ -162,11 +162,7 @@
       @if (prop().displayTextResolver) {
         {{ prop().displayTextResolver(data()) | abpLocalization }}
       } @else {
-        @if (prop().isExtra) {
-          {{ '::' + prop().displayName | abpLocalization }}
-        } @else {
-          {{ prop().displayName | abpLocalization }}
-        }
+        {{ prop().displayName | abpLocalization }}
       }
       {{ asterisk() }}
       @if (prop().tooltip) {

npm/ng-packs/packages/components/extensible/src/lib/components/extensible-table/extensible-table.component.html

@@ -136,7 +136,7 @@
         *abpVisible="prop.columnVisible(getInjected)"
         [width]="columnWidths()[i] || 200"
         [canAutoResize]="!columnWidths()[i]"
-        [name]="(prop.isExtra ? '::' + prop.displayName : prop.displayName) | abpLocalization"
+        [name]="prop.displayName | abpLocalization"
         [prop]="prop.name"
         [sortable]="prop.sortable"
       >

npm/ng-packs/packages/core/src/lib/utils/localization-utils.ts

@@ -13,11 +13,17 @@ export function createLocalizer(localization: ApplicationLocalizationConfigurati
   return (resourceName: string, key: string, defaultValue: string | null) => {
     if (resourceName === '_') return key;
 
-    const resource = localization?.values?.[resourceName];
+    const resource = localization?.resources?.[resourceName];
 
-    if (!resource) return defaultValue;
+    if (!resource) {
+      const fallbackResource = localization?.values?.[resourceName];
 
-    return resource[key] || defaultValue;
+      if (!fallbackResource) return defaultValue;
+
+      return fallbackResource[key] || defaultValue;
+    }
+
+    return resource.texts?.[key] || defaultValue;
   };
 }