ToDo Row Org

Metadata Intelligence for Salesforce: an org visualizer for dependency analysis, impact analysis, and relationship mapping, right inside VS Code.

Version 0.1.2 (pre-release). Every feature described below ships in this build today; nothing here is a preview of something still being written. The parts with the least real-world mileage are the ones that touch large orgs and unusual project shapes - see Known Limitations for the specifics, not a blanket disclaimer.

Marked as a pre-release on the Marketplace - install it via "Switch to Pre-Release Version" if it doesn't show up as the default install.

If you've looked at a Salesforce "visualizer" before and closed the tab after thirty seconds, this is the thirty seconds meant to change that:

One Card, Every Tab One object card is the entry point to its whole metadata context.

Quick Load App One click - a whole Salesforce app's metadata, on the canvas.

Jump to Source Not just a reference - the exact line, one click away.

Reverse Related Objects See who points at this object, not just what it points to.

Object Explorer Find, jump, and expand - without leaving the list.

Five things, a few seconds each, no login screen in sight - click any of them to open the full recording. Everything below is the reference for what's behind them - and the Feature gallery section has the rest of the tour.

Contents

• Interaction Badges
• Why this exists
• The canvas
• Object nodes
• VR Blueprint
• Flow Blueprint
• Quick Load and Quick Load App
• Org Bridge
• Object Explorer
• Feature gallery
• Install
• Quick start
• Commands
• Requirements
• Known limitations
• Pro tier
• Issues and contributing
• Privacy
• License and author

New here? USER_GUIDE.md walks the whole first session - install, connect an org, load metadata, read a node - with a GIF at each stage that actually needs one. This README is the reference; the guide is the walkthrough.

Interaction Badges

The one part of this tool with no equivalent in Schema Builder or any Tooling-API visualizer.

A generic schema viewer draws a line between two objects and leaves you to work out what it means. ToDo Row Org replaces the guess with a label.

Next to every reference the dependency index finds - a SOQL query inside an Apex class, a @wire in an LWC, a field touch inside a trigger, a Flow element - it drops a small, color-coded badge naming the exact operation, with a tooltip on hover. Not "this Flow touches Account." Something closer to what you'd actually tell a teammate: this Flow reads Account, filters by Status, and updates a custom field. Twenty-eight badges cover eight categories:

The Detection Confidence row is worth pausing on. Not every reference can be resolved with equal certainty from source alone. Rather than presenting every match with the same confidence, the index marks a reference Dynamic or Unresolved when it can't be tied down as cleanly as a direct, static match - so you can see at a glance which ones are worth a second look, instead of a flat list with no sense of which references are certain.

This is free in the beta and stays free. It's the product's visual signature - the reason a screenshot of this tool doesn't look like anything else in the Salesforce tooling space.

Why this exists

Every Salesforce org that survives past its first year grows a second, invisible structure on top of the one in Setup. Somebody on the team just knows that Status__c on Opportunity is read by two Flows, written by a trigger from three years ago, and gated by a validation rule nobody wants to touch because nobody remembers why it's there. That knowledge doesn't live in a file - it lives in one person's head, until they change teams and it's gone.

Salesforce Setup ships Schema Builder, and a handful of third-party "metadata visualizer" tools exist that do roughly the same job: call the Tooling API, draw objects as boxes, draw lines for relationships. They work. They also live in a browser tab, separate from wherever you actually write code, and they can tell you THAT two things are connected - not how.

ToDo Row Org is built around two decisions that follow directly from that gap:

1. It reads your local SFDX source, not a live API response. On first open it scans force-app/main/default and builds a project-wide dependency index from literal source-file references, not from an API guess at what "should" be related. That's why canvas browsing, object exploration, and dependency lookups all work fully offline. A live org connection is required only for the handful of operations that literally touch a live org - Org Bridge, Quick Load, Retrieve, the VR active-toggle, jump-to-org links.
2. It adds a layer Schema Builder has no equivalent for. The Interaction Badges above turn "are these connected" into "how" - visible at a glance instead of reconstructed from a Flow Builder trace.

Neither point is a knock on Schema Builder - it does what a Setup-hosted tool can do. ToDo Row Org just starts from a different vantage point: your editor, your files, your dependency graph.

That's the category this tool actually sits in: Metadata Intelligence for Salesforce, not a data tool and not a deploy tool. Concretely, that means turning a project's own source into a metadata map, with dependency analysis and impact paths you can trace before you touch a field, instead of finding out what broke after you ship.

Reading local source instead of a live API isn't only about working offline - it's the whole architecture. ToDo Row doesn't run a backend for Salesforce metadata, doesn't send that metadata anywhere, and doesn't hold your Salesforce credentials: authentication stays with your existing Salesforce CLI session, under the access you already have. It adds a visual and analytical layer over metadata you're already authorized to see, rather than a separate platform asking to be trusted with a copy of your org. See Privacy below for the specifics.

The canvas

The canvas is the org's metadata map: every object you've loaded, drawn as a node, with dependency graphs connecting the ones that actually reference each other.

• Infinite pan/zoom canvas with grid and axes overlays, both togglable.
• Viewport commands: Fit to content, Center origin, Reset zoom.
• Drag objects to position them; layout persists to .vscode/tdrorg-layout.json in your workspace, across sessions.
• Connections between related objects (Lookup / Master-Detail) draw as smooth curves with interactive endpoints. Click an endpoint to pull a related-but-not-yet-shown object onto the canvas next to its source, instead of hunting for it separately.
• Self-referencing relationships - an object that looks up to itself - draw as a side loop rather than overlapping the node.
• Auto-Arrange (drawer menu -> Layout) lays out every visible object in one pass: objects that relate to each other, however indirectly, cluster together with their own flow-direction layout; objects with no relationship to anything currently on screen are pulled out into a separate grid below the clusters instead of being packed into the same graph with no visual reason why. A single flat layout reads as "random" once more than a few objects are on screen - this reads as arranged.
• Mix Object Colors (drawer menu -> Layout) reshuffles the colors already assigned to your objects across the canvas - the same set of colors, redistributed, not new ones. Manual, one click, nothing recolors itself on its own.
• Undo/Redo (Ctrl+Z / Ctrl+Y, or the two buttons in the top bar) steps back through visual changes - hide, isolate, auto-arrange, mix colors, drag, reset layout - so an accidental click is never a dead end. Session-only: it starts empty each time you reopen the canvas.
• A top-bar toggle injects the standard Owner, CreatedBy, and LastModifiedBy fields onto every node, for the times you want them visible without permanently counting them among an object's own fields. A free-text search box in the same top bar hands off to Object Explorer (below) with your query pre-filled.

Object nodes

Every object lands on the canvas as its own object blueprint: fields, tabs, and every relationship, in one place.

• Each node has a header band colored per object, a per-field lock state, and inline Lookup/Master-Detail connector icons.
• Bottom tabs per node - Fields, SOQL, LWC, Apex Classes, Triggers, Flows, Validation Rules - are populated from the project-wide dependency index built by scanning the actual SFDX source. Not a live API guess: if a class shows up under an object, it's because the index found the literal reference in your codebase.
• The Validation Rules tab is a card list: formula preview, a detail dialog, a per-rule Active toggle that deploys the change via the Salesforce CLI, a "Jump to org" action that opens the rule directly in Salesforce Setup, and a Schema icon that opens VR Blueprint.
• The Flows tab is the same kind of card list, one per Flow that touches the object - each card has its own Schema icon that opens Flow Blueprint.
• The header's Reverse Relationships icon opens a popup listing objects that reference into the current one - the direction a connector line alone doesn't show, since a line only appears once the referencing object is already on the canvas. This is the object's impact path in the other direction: not "what does this depend on" but "what depends on this, and breaks if I change it." From there, Load Related from Org… queries the connected org's live schema for child relationships your local source scan can't see on its own (managed-package objects, anything outside scan scope), filtered down to genuine custom relationships - plain __c/__mdt/__e/__x objects, not Salesforce's own internal change-tracking and system objects - so the list stays signal, not noise.
• Each node's "⋮" menu (or right-click on the node body) has Show/Hide/Arrange Related Objects, Isolate Object (hides every other object on the canvas, regardless of whether it's related - for when you just want to look at one thing), and Hide this object.

VR Blueprint

A validation rule's formula, parsed into an actual syntax tree - not just re-flowed onto a nicer canvas.

• Click the Schema icon on any Validation Rule card to open a modal flowchart of that rule's formula.
• The formula text is parsed into an abstract syntax tree first, and the tree is what gets laid out as a graph: Event to Conditions to Junctions to Actions.
• AND/OR junctions are explicit nodes in that graph, not implied by indentation or bracket-nesting. True/False paths are color-coded so you can trace exactly which branch fires without doing the boolean algebra by eye.
• Smooth cubic Bezier edges, automatic top-to-bottom layout, cursor-anchored zoom with Ctrl+scroll.
• View-only in this beta. The editable version - drag a condition onto the canvas, save it back to the org - is a Pro-tier feature (see below).

Flow Blueprint

A Flow's own element graph, rendered directly - not reverse-engineered from raw XML.

• Click the Schema icon on any Flow card (on an object's Flows tab) to open a modal flowchart of that Flow's elements and connectors.
• Salesforce's Flow metadata is already graph-shaped - elements plus connector references - so this is a direct rendering of that structure, not a reconstruction. Every Decision and Wait branch, loop, fault path, and scheduled path draws as its own labeled connector, color-coded by kind, instead of a flat list of steps.
• Click any element for details in the inspector: condition summaries on a Decision branch, the object a record operation targets, which Flow a subflow calls, what a Wait element is actually waiting for - plus a "Jump to org" action.
• An element type this beta doesn't model in depth (Salesforce keeps adding new ones) still renders as a plain, correctly-connected block instead of breaking the diagram.
• Read-only, same boundary as VR Blueprint - for understanding a Flow at a glance, not editing it. Flow Builder remains the place to build one.

Quick Load and Quick Load App

• Quick Load: a tabbed dialog covering six metadata types - Custom Object, Standard Object, Lightning Web Component, Apex Class, Trigger, Flow. Each tab has its own search, sort, and multi-select. "Load Selected" pulls only the checked items; "Load All" fetches everything of that type.
• Quick Load App: pick one or more Salesforce CustomApplications, and it loads everything that App (or the objects it owns) declares - the App's own XML, every CustomObject referenced in its tabs (with fields and validation rules), every CustomTab, and every Apex Trigger bound to those objects. One click, the App's whole footprint on the canvas. A "Show all on canvas" toggle follows.
• The resolution from an App's declared tabs to CustomObjects is heuristic, not a guaranteed metadata read - see Known Limitations.

Org Bridge

• Connect via Browser, with separate flows for Production and Sandbox. Login happens in your default browser; the Salesforce CLI manages the session token - this extension never sees or stores your credentials directly.
• Locked Org Mode: once a project is bound to one org, it stays bound for the life of that project session. Switching to a different org requires an explicit Disconnect. This exists to close one specific failure mode: a dialog silently pointing at the wrong org, and a deploy or pull happening against it instead of the org you actually meant.
• Auto-detects an org only if this specific project folder has its own local Salesforce CLI config pointing at one (.sf/config.json's target-org) - never from your CLI's global default, which has no relationship to any particular project. Every other project starts in manual selection mode, by design: picking the wrong org for a project is exactly what Locked Org Mode (below) exists to prevent, and a silent guess at project-creation time would defeat that.
• Detects a stale or expired authentication and offers an in-dialog way to remove that org entry.

Object Explorer

A searchable list of every object the extension has scanned: a multi-letter filter, a "locked fields only" filter, per-object show/hide, and a "Go to" action that centers the canvas viewport on that object.

Feature gallery

Everything above covers the highlights with room to explain them. This is the rest of the tour - the smaller, faster interactions that don't need a paragraph each, one glance per row. Each panel shows a still frame; click it to open the full recording at full size and quality.

Interaction Badges A line says two things are connected. This says how.	VR Blueprint A validation rule's formula, as an actual flowchart.	Flow Blueprint A Flow's own logic, rendered directly - not reverse-engineered from XML.
Auto-Arrange Turn a messy map into a clear layout, in one click.	Get Over Here Pull any object onto the canvas, instantly.	Jump to the Org, Too Same idea, other direction - straight into Setup.
Status and Type, at a Glance Active or not, and what kind - before you open a single rule.	Jump from SOQL to source Open the exact query in one click.	Jump from Trigger to source Open the exact trigger in one click.
Jump from LWC to source Open the exact component in one click.	Open related object by connector Follow a relationship directly from the canvas.	Load related object by connector Pull a missing object into the map from the org.
Load and extend the schema Add a missing object and watch the map grow around it.	Jump between objects by connector Navigate relationships without losing context.	Show all related objects Expand the full relationship view in one click.
Hide related objects Collapse the map and reduce noise.	Load Related from Org Discover and load relationships straight from Salesforce.	Jump to Org: Object Open the object directly in Salesforce Setup.
Jump to Org: Flow Open the exact Flow in Salesforce Setup.	Filter fields by letter Focus on A-Z groups instantly, right on the node.	Show locked fields only Hide the noise, focus on the fields that matter.
Quick Load metadata Load objects, Flows, LWC, and more from one dialog.	Jump to object from Explorer Find the object, then land right on it.	Apex and Flow process types Understand purpose before opening the file.
Field types, at a glance Every field type gets its own icon and color - intuitively easy to scan.

One smaller item - a combined formula-and-schema view for validation rules - isn't recorded yet; it'll land in this gallery without any other doc changes once it is.

Install

From the VS Code Extensions panel: Ctrl/Cmd+Shift+X, search "ToDo Row Org", Install.

Or from a terminal:

code --install-extension ToDoRow.todo-row-org

Quick start

1. Open a folder containing an SFDX project - a sfdx-project.json file at the root. The extension auto-detects it and scans force-app/main/default.
2. Open the workspace: click the ToDo Row Org icon in the VS Code Activity Bar (the left-hand icon strip) to open the Quick Actions panel, then choose "Open Workspace." Or run "ToDo Row Org: Open Workspace" from the Command Palette (Ctrl/Cmd+Shift+P).
3. Connect an org: click the org indicator in the canvas's top bar, or "Connect Org..." from Quick Actions, then choose Production or Sandbox under "Connect via Browser."
4. Run "Quick Load App" from the drawer menu. It's the fastest path to a populated canvas.

For the same four steps with a GIF at each one, see USER_GUIDE.md.

Commands

All commands below are reachable from both the Command Palette (prefixed "ToDo Row Org:") and the Activity Bar's Quick Actions panel. They're the entry points for a cold start - the canvas itself carries many more commands through its own drawer menu and per-node header icons.

Requirements

• VS Code 1.106 or newer.
• Salesforce CLI (sf, v2.x) installed and on PATH. Every org-facing operation shells out to it.
• An SFDX project - a sfdx-project.json file at the workspace root.
• A connected Salesforce org for the online features: Org Bridge, Quick Load, Retrieve, the VR active-toggle, jump-to-org links.
• Canvas browsing, object exploration, and the dependency index all work fully offline. Only the operations that literally touch a live org need one.

Known limitations

Stated plainly, not as a hedge:

• LWC schema-import scanning is best-effort. Renamed components or dynamic imports may be missed.
• Quick Load App resolves a CustomApplication's declared tabs to CustomObjects heuristically. Renamed Visualforce or Lightning Component tabs come through as CustomTab metadata, but the underlying page or component itself is not pulled.
• Trigger discovery via the Salesforce Tooling API is a single round-trip, no chunking. Comfortable for roughly 10-30 objects per App; would need chunking to scale past roughly 200.
• VR Blueprint and Flow Blueprint are both view-only in this beta. Editable/interactive versions are a Pro-tier feature (see below).
• Flow Blueprint models the common Flow element types in depth (Start, Screen, Decision, Assignment, Loop, record operations, Subflow, Action, Wait, Custom Error); anything rarer renders as a plain connected block rather than being misrepresented.
• Setup Guide (a 34-item Salesforce admin checklist) is implemented but disabled in this build - its dialog has a known layering bug (opens behind the canvas). Re-enabling it, fixed, is planned for the next release; it is not a Pro-tier feature, just not ready yet.
• Anything currently in flight beyond this list is tracked on the issue tracker: https://github.com/ShamansIT/todo-row-org-issues/issues

Pro tier

Not included in this build - hidden from the beta menu. Everything above this line works today, for free.

• Pre-Flight Validation: a Docker-based static-analysis gate, via the Salesforce Code Analyzer (sf scanner), that runs before a deploy.
• Auto-Validation Manager: an always-on / off / custom-routed pipeline that validates and deploys automatically as files change, with an operations log and automatic backups.
• Quick Load App's full multi-type cascade - adding ApexClass, Flow, LWC, and PermissionSet to what the free cascade already pulls.
• VR Blueprint Edit Mode: a drag-and-drop palette to build or modify a validation rule's logic visually, a Save-back-to-org action, a local Test Rule evaluator, and a linter-style Validation Log.
• Flow Test Mode: supply sample input values directly in Flow Blueprint and see which Decision/Wait branch actually fires, highlighted on the diagram - no org round-trip, evaluated locally against the parsed Flow structure.
• Retrieve Metadata: a dialog wrapping the Salesforce CLI's metadata retrieve command, with nine category filters plus live search, so pulling a specific slice of metadata doesn't require memorizing CLI flags. (Global Refresh from Org.)
• Global Validate Project, Detect Org Drift, Generate Documentation, Export Blueprint, and a Diagnostics section.
• Rename Field: double-click a field to rename its Label and/or API Name. Runs an impact analysis first, blocks unsafe renames (system fields, managed-package fields), backs up before deploying, and rolls back automatically if the Salesforce SOAP renameMetadata call succeeds on the org side but the local file sync fails.

Issues and contributing

File bugs, scanning gaps, and feature requests at the issue tracker: https://github.com/ShamansIT/todo-row-org-issues/issues. This is early beta - feedback from real SFDX projects is the most useful input right now, more than any particular format for reporting it.

Privacy

ToDo Row adds visibility, not a new security boundary. It has no telemetry and no backend of its own - there is no ToDo Row server that your metadata, source code, or usage data is sent to, because none exists. If you never connect an org, ToDo Row never makes a network call at all. If you do, the only network communication is between your machine and Salesforce itself, through the Salesforce CLI, using your own Salesforce session - the CLI manages that session; ToDo Row never sees or stores your credentials directly. Full detail: PRIVACY.md.

License and author

Proprietary. ToDo Row is source-closed software - installing and using the extension is subject to the ToDo Row Software License Agreement. See LICENSE for the full text, and THIRD-PARTY-NOTICES.md for the open-source components bundled with it.

Author: Serhii Spitsyn (https://www.linkedin.com/in/serhii-spitsyn/) Issues: https://github.com/ShamansIT/todo-row-org-issues/issues