You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
This commit was created on GitHub.com and signed with GitHub’s verified signature.
Added
Plugins (plugin API 1, docs): a plugin declares in plugin.json what it contributes — commands (bca <plugin> <command>),
tasks for bca run (placed with before/after, outputs included in verify,
stage, artifacts, and pull requests), health rules for bca check, MCP
tools, hooks (run:before, task:after, run:after, check:after), and
extension points for other plugins. Code runs only when a contribution is
used, through activate(context) with the project, its config section, a
log, and services (architecture model, docs renderer). Plugins come built in
(plugins/), from npm (bc-atlas-plugin-* dependencies, no configuration),
from "plugins" in .bca.json, or from BCA_PLUGINS.
bca plugins list|show|doctor|new: see what a project's plugins
contribute, check every declared contribution, and start a plugin from a
working template.
Built-in plugin sync (formerly the separate bc-atlas-sync repository,
imported with its history into plugins/sync): Business Central process
recordings (clicks, writes, AL call stacks as fact snapshots) synced into
documents, BC Atlas UI tests, the architecture layer, and a process index — bca sync plan|run|status|describe, the sync task (before docs), the sync-outdated health rule, the bc_atlas_sync_status MCP tool, and the
extension points sync.sources and sync.formats. Includes the BC Atlas
Sync AL extension, its tests, and the Playwright run.
Visibility view (bca export --view visibility): what is public,
internal, or local, in three levels and three colors. Every app, object,
procedure, event, and table field is a data point with its level: public
(other apps can use it), internal (this app), local (this object). A
relation is as wide as the border it crosses. Where the uses found need
less, a dashed border says what the data point can be: a procedure nobody
calls from outside its object can be local, a codeunit no other app uses
can be Access = Internal. One box per object by default, --expand-procedures for every member inside its object, --focus for a
part, --format json for the data points and uses. Also in bca export --view report --views ...,visibility and in the MCP tools.
In VS Code and the offline app the visibility view opens as a canvas:
graphs in graphs. An app holds its objects, an object its members, and a
procedure the data points it uses and that use it, which open again,
without an end; local sits at the core of every circle, public at the rim.
Click a circle to go into it, search by name, show only some levels, and
switch to the diagram of boxes. See Architecture diagrams.
Dashboard, the page where VS Code and the offline app now open: every
content in every form. Pick what to look at (a diagram view, the
components of the architecture, the objects, the apps, the health
findings) and how (2D graph, 3D graph, table, and for diagram views their
diagram), independently. A diagram view can be a 3D graph, the
architecture a table, the objects a graph. The filter and the tools are
the same for all: filter by name, type, group, and kind of relation, show
only a node and its neighbors, hide nodes, size them by a number, put them
where you want them, sort the table, save a PNG or CSV. New view from
this keeps what you see under a name in My views. See The Dashboard.
One list instead of tabs. The pages (Overview, Health, Architecture,
Dependencies, Diagrams, Objects, Docs) are no longer tabs: one list on the
left holds everything by topic, the contents of the Dashboard next to the
page of the same topic, with a filter above it. Every page works as
before. In VS Code the panel has this list too, so the BC Atlas side bar
is a set of shortcuts and no longer the only way to a page.
Every page says what it is read from: Sources below the list (AL files
and objects, apps, symbol packages, AL compiler, settings), and for a
content of the Dashboard what that content reads.
Battle test: simulate the use in your company.bca simulate lets
agents with the roles, permission sets, and task groups of your company
perform the process tests of the app (the AL UI tests with [SCENARIO])
step by step. For every step it follows the code behind it and checks what
the agent needs: Execute on the page and on every codeunit, page, or report
the code calls or runs, the table-data rights for what it reads and writes,
and the codeunits of event subscribers. One run is an automatic test (exit
code 1 when a role is blocked, or can do what it must not), a process test
(does each use case run end to end across roles?), and the data the
documentation is written from: who can do what, an explanation of every
permission a step needs, the permissions a role holds but no task needs,
and a fit-gap analysis of your requirements against the app (fit, gap in
permissions, nobody assigned, not proven by a process test, not in the
app). Describe the company under simulation in .bca.json (roles, agents, taskGroups, requirements, mustNot for segregation of
duties) or in a file (--company); without it, every combination of [PERMISSIONS] in the tests is a role. Text, Markdown, or JSON, in English
or German. Also a task of bca run (simulate, report in docs/simulation), a page of Docs in VS Code and the offline app, and
the MCP tool bc_atlas_simulate. See Battle test
and the new purchasing example (examples/purchasing-app, report).
The model keeps which rights a permission grants only indirectly
(indirectRights: tabledata "X" = Ri reads directly and inserts
indirectly).
Changed
bca setup (and bca update, which runs setup apply --from-config) keeps
the tasks it does not ask about in their triggers: plugin tasks, simulate, handbook, and diagrams were dropped before.
A group in a diagram is at least as wide as its name.
Docs and Handbook are one page in VS Code and the offline app. The
list shows the system handbook first, then the user guides and test cases
from UI tests. Sources beside each page says what it is read from. The
page is there without UI tests too. Old #/handbook/... links open the
same page in Docs.
Every handbook page starts with Based on:, the parts of the AL code it
reads. The overview ends with a Sources table: AL files and objects,
apps, symbol packages with versions, the AL compiler, the architecture, and .bca.json.
Fixed
An object's properties are its own. The properties of a group, repeater,
grid, cue group, action group, view, request page, rendering layout, field
group, or modify(...) inside it no longer count as the object's, so the
caption of a page is the page's Caption, not that of its last captioned
group (the same for ApplicationArea, Editable, ToolTip, Visible,
and SourceTableTemporary of a request page). An XMLport element no
longer lists the properties of its attributes.
Objects, table fields, page fields, and procedures whose header is split
by #if (#if X / table 50100 "A" / #else / table 50101 "A" / #endif / { ... }) are in the model. They were missing: a table declared
this way did not exist, nor did its fields. Each is there once, with the
header of the first branch (#if): ID, name, type, source expression,
access modifier, parameters, return type, and attributes. Its conditionalSymbols names the condition of that branch. The body is shared,
so its properties, fields, and code count as usual. What the other branches
refer to still becomes a relation with the condition of its branch: the
interfaces of an implements list, the record types of parameters, and a
base object that differs by branch.
A relation found in the shared body after #endif of a procedure with a
split header no longer carries the condition of the last branch (else).
A wildcard permission (tabledata * = RIMD, codeunit * = X) is a
wildcard, not a reference to a missing object named *: no unresolved-reference diagnostic, and it no longer counts as unresolved
in bca check. In the model its edge has wildcard: { type } instead of unresolved: { name: "*", type }. Diagrams draw it to a node of its own
(table *) instead of "External / unresolved", the handbook lists it as table * and knows that tabledata * covers every table, and the
dependency explorer and the knowledge graph no longer show an external
object *. A quoted "*" stays the name of an object.
The permission set of the warehouse example lacked Execute on the codeunit
that subscribes to OnRequestProcessed. The battle test found it: with WAREHOUSE PROCESS alone, the Process action would have failed.
bca run --tasks and the MCP tool bc_atlas_run accept the handbook
task, as .bca.json triggers already did.
The header of a procedure or trigger is its declaration line only: local procedure Plain(var R: Record Customer): Boolean. It included the var section (... : Boolean var L: Integer), and a comment or #pragma
between the declaration and its variables or begin.
A procedure or trigger whose body is split by #if (procedure A() / #if X / var ... begin ... end; / #else / begin end; / #endif, or
branches that open the body and share its end) has a body: hasBody is true, so it has a complexity and counts as code. It read as a declaration
without a body, with the whole body in its header. Its statements are one
condition with a path per branch, followed by what all branches share, so a
contract check sees it as conditional. Without the AL compiler the branches
are not evaluated: the calls, variables, and complexity of all of them count.