Mongoose IDO Metadata Editor

A VS Code / Kiro IDE extension for editing Mongoose IDO Collection metadata (ObjectStudioExport XML) through a friendly, visual UI instead of hand-editing deeply nested XML.

Version 1.122.2. See CHANGELOG.md for release notes and DESIGN.md for the design and roadmap.

Features (v1)

• Visual custom editor for any **/Collections/**/*.xml IDO file, with tabs:
  • Properties — the primary working view: a sticky Identity bar (name, module, ext-class, revision, inline-editable description), a read-only property grid (# · Name · Set / Where · Binding badge · Class · Source) that filters, sorts and scrolls independently, with the Property Grid opening in document order by default and supporting drag reordering, and a resizable, toggleable editor side panel that stays in view. The panel edits every field with dropdowns/checkboxes, shows inline validation, has Editor, Data Rules, and Bound Components sub-tabs, Open ↗ buttons to jump to a referenced IDO, and a read-only inherited PropertyClass section. Bound Components queries the installed SyteLine IDS Form Designer for direct IDS/IV2 bindings of the selected property and can reveal the exact control in its custom editor. Completed lookups are cached briefly in memory with bounded LRU storage; repeated requests are deduplicated, empty results are cached, and Refresh forces a rescan without starting a background query for every Property.
  • Overview — edit identity / ext-class / revision fields.
  • Tables — relationship-aware master–detail view with Primary/Secondary and IDO Alias badges, database table/view identity, Property usage counts and links, collapsible/filterable Usage, editable Join fields, inline validation, and add/edit/delete operations.
  • Properties — master–detail with binding badges, key markers, drag-to-reorder (auto-renumbers Sequence), add/delete, and a binding-aware detail form (BOUND/DERIVED/UNBOUND/SUBCOLLECTION fields + PropertyAttributes) with enum dropdowns.
  • Methods — editable method cards (name, type, transactional, stored proc, description) with a parameter grid (name, DB type/length/scale, in/out/message) and add/delete for methods and parameters. Parameter and Result Set Column Sequence values are calculated from row order: each grid displays in sequence order and offers Move up / Move down controls that reorder the XML nodes and recalculate 1…N. SP + Result Set and C# + Result Set methods also expose a Result Set Columns grid for the <ResultSetProperties> output contract; during a Dev Hub CLM refresh, its Match column lists deterministic/inferred/ambiguous candidate Properties for explicit selection, and the selected candidate is copied into the searchable Reference Property picker. Candidate selection updates locally without rebuilding or jumping the Methods editor; the persistent grid still preserves free-text output names. Duplicate Method is available on the selected method and deep-copies its full XML subtree, including parameters and result-set columns.
  • Data Rules — edit rule actions, activation conditions and filter conditions, with Set / Where filtering in the Property Editor side panel to focus on rules that set properties or filter rows, and Duplicate Rule for a complete deep copy that preserves unknown XML fields and nested content. When an IDO is saved, its direct DataRule nodes are ordered by RuleName without reordering other metadata or rule internals.
  • Feature Status — an IDO-level right-side panel collects Feature IDs from Data Rule activation conditions in an IDS Form Designer-style collapsible tree, with summary cards, grouped status cards, expandable details, text/status filters, AppFeatures details, and direct rule-reference navigation. Live AppFeatures status querying through the MG REST Client runs automatically once when the panel is opened, if the client is available; opening without the client remains static and does not prompt. Check Feature Status is always available as the explicit force-refresh action and follows the active MG REST Client connection profile, reusing its stored token without opening the IDO Editor connection form, matching IDS Form Designer behavior. Live results distinguish Force GA, GA Active/Inactive, Pre-Release Active/Inactive, and Hidden Active/Inactive; ActivatedBy is only considered for active GA features. Force GA remains an advisory warning based on current AppFeatures data, not an authoritative audit, and the editor never removes conditions or DataRules automatically.
  • Cached Settings — inspect and edit IDO cached-setting declarations, with Duplicate Cached Setting to deep-copy the selected declaration and all of its XML children while assigning a unique name.
• Data tab (read-only live preview) — when the MG REST Client extension (jeking.mg-rest-client) is installed, a Data tab runs a LoadCollection against the server and shows the rows in a grid. Columns are seeded from the IDO's own properties (keys first; subcollections excluded) via a searchable column picker (All / None / Reset, key markers); a SQL-WHERE server filter, a Top-N cap, an in-results Find box, click-to-sort headers (numeric-aware), Copy (TSV, copies the rows shown) and an Open in MG REST Client hand-off (opens the same query in the full REST client) round it out. Read-only, and hidden when the MG REST Client isn't installed.
• IDO Outline — a second sidebar tree showing the structure of the active IDO (Tables, Properties grouped by binding, Methods → parameters, Data Rules, Cached Settings). Clicking a node navigates the visual editor to that item and focuses it.
• Cached-setting aware data rules — authoring a Cached Setting activation condition now resolves the chosen IDO's <CachedSetting> declarations on demand: the Setting IDO field lists only the IDOs that actually declare cached settings (9 of ~5,700 in a real corpus), the Setting field becomes a picker of the real setting names, Value offers the backing property's coded values, a hint shows the scope/source (Site/User · property/method), and a name that isn't declared there is flagged inline. Both fields stay free-text so a not-yet-indexed name can still be typed. The condition's comparison also offers the full six operators (=, ≠, ≥, >, ≤, <).
• IDO Cached Settings panel — an activity-bar tree of every <CachedSetting> declaration and whether any data rule reads it (IDO → setting), showing all declarations by default; the title-bar filter toggle narrows to the ones with no data-rule reference (22 of 41 in a real corpus). Each IDO node has an inline cloud-upload icon (and a right-click Import to SyteLine…) that imports that declaring IDO's XML. Each setting that a data rule reads is expandable — its reading references are grouped by reading IDO, with the individual rules (part · kind) listed beneath each; clicking an IDO group or a rule opens that IDO on the Data Rules tab. Each setting row's tooltip also lists the reading rule parts and the scope/source. Detection covers all three reference kinds: action (ValueType=1/ActionType=10), activation condition (SourceType=4) and filter condition (ValueType=2). IDO metadata only — an empty reference list means "no data-rule reference found", not that the setting is unused: a form script or C# extension class may still read it.
• Labeled enums — "magic number" fields (MethodType, Binding, OperationType, ActionType, comparison operators, …) render as dropdowns with human labels.
• Validation — semantic + intra-file reference checks surfaced as diagnostics (Problems panel) and a live footer summary: required fields, invalid enum codes, duplicate names, BOUND/DERIVED/SUBCOLLECTION requirements, ColumnTableAlias must match a real table alias, duplicate sequences, and more. A Fix all button in the Problems panel applies safe default fixes for eligible errors (e.g. setting IsReadOnly on a property targeted by a "Set Property Enabled" data-rule action). IDO: Validate All scans every indexed collection at once (batched, schema-aware), lists every flagged file in the Problems panel, and offers a themed report (IDOs sorted by error/warning count). After a scan the IDO Explorer filter can narrow the tree to IDOs with errors / warnings / clean, and flagged rows show a ⛔ N · ⚠ M badge.
• IDO Explorer — activity-bar tree of all collections grouped by module, with a fuzzy Go to Collection… quick-pick. _IDS variants are flagged. Its filter (title-bar search) combines a name substring with a validation status (all / has errors / has warnings / clean; a status pick runs IDO: Validate All first if nothing has been scanned yet).
• Base ⇄ _IDS compare — open a diff between a collection and its _IDS sibling.
• PropertyClass editor — **/PropertyClasses/**/*.xml files open in a dedicated visual master–detail editor (list of PropertyClass definitions + a detail form covering the full PropertyAttributes set from PropertyClass.xsd), with clean round-trip and validation. A dedicated IDO Property Classes activity-bar panel (grouped by module) and the IDO: Go to PropertyClass… quick-pick help you find and open them.
• Clean round-trip — writes are format-conformant (BOM, CRLF, 3-space indent, self-closing empties) and schema-faithful. 98% of the real corpus round-trips byte-for-byte; the rest are irregularly-indented files that get normalized by design.
• Always available: one-click Open as XML to drop to the raw text editor.

Configuration

Schema-aware validation (verify tables & columns)

Point mgIdo.schemaCatalog at a JSON file mapping each table to its columns; validation then checks that every <Table Name> exists and every BOUND property's BoundToColumn is a real column of its table (surfaced as warnings in the Problems panel). Generate the catalog from INFORMATION_SCHEMA, e.g. with sqlcmd + a small transform:

sqlcmd -S localhost -E -d <YourDb> -h -1 -W -s "," -Q \
  "SELECT TABLE_NAME + ',' + COLUMN_NAME FROM INFORMATION_SCHEMA.COLUMNS" \
  | awk -F, 'NF==2{printf "%s\t%s\n",$1,$2}' \
  | node -e "const m={};require('readline').createInterface({input:process.stdin}).on('line',l=>{const [t,c]=l.split('\t');if(t&&c){(m[t]=m[t]||[]).push(c);}}).on('close',()=>process.stdout.write(JSON.stringify(m)))" \
  > schema-catalog.json

Commands

• IDO: Open in Visual Editor / IDO: Open as XML
• IDO: Validate / IDO: Validate All — validate the active file, or scan every indexed collection (Problems panel + a themed report; then filter the explorer to flagged IDOs)
• IDO: Go to Collection…
• IDO: Compare base ⇄ _IDS variant — native side-by-side XML diff
• IDO: Compare base ⇄ _IDS (structured) — a readable HTML report (themed tables) of what differs (added / removed / changed properties, tables, methods, data rules), ignoring the revision stamp
• IDO: Analyze Cached Setting Impact… — cross-file report of every data rule (action/condition) that reads a chosen cached setting, so you can see what breaks before renaming/removing it
• IDO: Analyze Data Rules (test plan) — writes <IDO>.datarules.md: a test-plan analysis that classifies every rule by REST-testability, renders trigger logic trees, lists environment dependencies, and derives test scenarios (for automated MG API test generation)
• IDO: Apply Authoring Spec… — pick an idoAuthoringSpec:1 JSON file and apply it to the active IDO (add/update properties + add data rules); strictly validated, shows a summary and confirms before writing (same engine as the ido_apply_spec MCP tool)
• IDO: Import to SyteLine (for testing) — deploys the current IDO XML via AppMetadataTransport.exe (or, when mgIdo.mgRest.enabled is on, over the Mongoose REST API via IdoCollections.ImportFromXmlString)
• IDO: Import to SyteLine (AppMetadataTransport) — always uses AppMetadataTransport.exe, even when mgIdo.mgRest.enabled is on — a fallback that doesn't require toggling the setting off (also offered as a button if a REST import fails)
• IDO: Export from SyteLine (MG REST) — with mgIdo.mgRest.enabled on, exports the IDO's XML from the server via IdoCollections.GenerateXml and offers to diff it against the workspace file (format/semantic fidelity check). Every REST call is verified (HTTP + ReturnValue/infobar) with visible errors.
• IDO: Test in MG REST Client — opens a pre-selected quick test form (Load/Update/Invoke/…) using the REST client's active profile, or Generate Data Rule Tests (calls mgRestClient.generateDataRuleTests to build a test collection from this IDO's data rules); shown only when the jeking.mg-rest-client extension is installed
• SyteLine Dev Hub integration (shown only when the SyteLine Dev Hub extension is installed): IDO: Open C# Entry Point (title-bar → jump to the IDO's C# entry-point code), IDO: Forms Using This IDO (title-bar → every form that consumes the IDO), IDO: Trace Dependencies in Dev Hub (title-bar → down-trace the IDO's C# entry point), and IDO: Trace GetService Roots (right-click a method in the IDO Outline → trace that method's services)
• SyteLine IDS Form Designer integration (shown only when the jeking.sl-ids-form-designer extension is installed): IDO: Forms Using This IDO Method… (title-bar → pick one of the open IDO's methods and list the workspace forms that call it — declarative event calls and form-script Invoke — then pick a form to open it). The same lookup is also a per-method button in the Methods editor (scoped to that method, no picker). The selected Property Editor also has a Bound Components tab that calls slIds.findComponentsBoundToPropertyData for the exact IDO/property; each result can call slIds.selectLayoutNode to activate the IDS/IV2 custom editor and reveal the bound control. This part is available only when the Form Designer exposes both commands.
• IDO: Enable XSD Validation (Red Hat XML) — binds the bundled official Mongoose IDODefinition.xsd to **/Collections/**/*.xml so the Red Hat XML extension validates IDO files against the schema
• IDO: Rebuild Index

For other extensions (programmatic)

mgIdo.openIdoByName(name: string): Promise<boolean> — resolve an IDO by name via the workspace index and open it in the visual editor; returns true if found. Hidden from the Command Palette. Example:

const ext = vscode.extensions.getExtension('jeking.mg-ido-pro-editor');
await ext.activate();
const ok = await vscode.commands.executeCommand('mgIdo.openIdoByName', 'SLItems');

Read-only metadata API (used by MG REST Client to source IDO metadata from the workspace files instead of live Mongoose REST queries — faster and works offline). Each returns undefined when the IDO isn't found in the workspace, so the caller can fall back to REST. Activate the extension first.

MCP server (for AI agents)

The extension ships a dependency-free MCP server (dist/mcp/server.js, stdio JSON-RPC) that exposes the IDO engine to MCP-capable agents (e.g. Kiro). Register it with IDO: Register MCP Server with Kiro (writes .kiro/settings/mcp.json, seeding MG_IDO_ROOTS from your metadata-root settings); remove it with IDO: Unregister MCP Server from Kiro. After an extension upgrade, an existing registration is refreshed automatically on activation (the launcher + entry are regenerated so the newest server ships without re-running the command); this never creates a registration you didn't opt into and can be turned off with mgIdo.mcpAutoReregister. Tools:

Read tools are auto-approved; the write tools default to a dry-run and only touch disk with apply:true.

Architecture

src/
  model/        XML tree (parse/serialize), typed projection, enums, sequence, edits
  validation/   semantic + reference validation
  editor/       CustomTextEditorProvider (hosts the webview, applies edits)
  explorer/     workspace index + collections tree + active-IDO outline tree
  webview/      UI (framework-free TS) + host/webview message protocol
  extension.ts  activation: editor, explorer, commands, diagnostics
media/          webview.css + activity-bar icon
test/           node:test suites (core + corpus round-trip)

The open TextDocument is the single source of truth. Webview edits post typed messages; the host applies them to the XML tree, re-serializes canonically, and replaces the document via a WorkspaceEdit — so text view, undo/redo, and external edits all stay in sync.

Development

npm install
npm run build        # bundle extension + webview (esbuild)
npm run watch        # rebuild on change
npm run typecheck    # tsc --noEmit
npm test             # compile + run node:test suites

Run the extension: open this folder in VS Code / Kiro and press F5 (Extension Development Host), then open any IDO collection XML.

Tests

• test/roundtrip.test.ts — runs against the real corpus (set MG_CORPUS to override the path, MG_SAMPLE to change the file count). Hard gates: semantic equality (no data loss) and idempotency (no formatting drift); plus a byte-exact rate metric.
• test/core.test.ts — enum catalog, model projection, sequence renumbering, edit ops, and validation.
• test/edits.test.ts — full CRUD edit operations (add/edit/delete for properties, tables, methods, parameters) with serialization-stability checks.
• test/webview.test.ts — jsdom smoke test that runs the real bundled webview, asserts the Canvas renders, and that inline edits / row-expand / add emit the correct messages.

Status / Roadmap

This is the MVP. Planned next: cross-file reference go-to-definition, the guided DataRule builder, canvas relationship lines + drag-drop binding conversions, _IDS sync, and editors for the sibling constructs (PropertyClass, Form/ComponentClass/Validator). See DESIGN.md.