Skip to content

v0.18.0

Choose a tag to compare

@github-actions github-actions released this 10 Nov 22:19
821b806

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.