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.18.0. 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 · Binding badge · Class · Source) that filters, sorts and scrolls independently, and a resizable, toggleable editor side panel that stays in view. The panel edits every field with dropdowns/checkboxes, shows inline validation, has Open ↗ buttons to jump to a referenced IDO, and a read-only inherited PropertyClass section.
  • Overview — edit identity / ext-class / revision fields.
  • Tables — fully editable grid (alias, table, type, join) with add/delete rows.
  • 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 an editable parameter grid (seq, name, DB type/length/scale, in/out/message) and add/delete for methods and parameters.
• 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), defaulting to the ones with no data-rule reference (22 of 41 in a real corpus); the title-bar toggle shows all declarations. Each row's tooltip 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 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 Explorer — activity-bar tree of all collections grouped by module, with a fuzzy Go to Collection… quick-pick. _IDS variants are flagged.
• 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: 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)
• 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. 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.