
Analyzing Omnistudio Dependencies
Map OmniStudio OmniScripts, IPs, FlexCards, and Data Mappers by parsing embedded JSON configs before refactors or deployments.
Overview
analyzing-omnistudio-dependencies is an agent skill for the Build phase that explains how OmniStudio components reference each other via JSON-embedded dependency patterns.
Install
npx skills add https://github.com/forcedotcom/sf-skills --skill analyzing-omnistudio-dependenciesWhat is this skill?
- Models OmniStudio as a directed graph across OmniScript, Integration Procedure, FlexCard, and Data Mapper
- Dependencies live in JSON fields (PropertySetConfig, Definition, Input/Output object names)—not simple lookups
- OmniScript edges: IP Action, DataRaptor, nested OmniScript, Remote Apex, LWC, HTTP Action
- Integration Procedure edges: Data Mapper, Apex, HTTP, nested IP, uncommon OmniScript Action
- FlexCard edges: IP data sources, Apex sources, child FlexCard references
- 6 OmniScript outbound dependency element types listed (IP, DataRaptor, OmniScript, Apex, LWC, HTTP)
Adoption & trust: 565 installs on skills.sh; 513 GitHub stars; 3/3 security scanners passed (skills.sh audits).
What problem does it solve?
You cannot see what breaks when you change an OmniScript or IP because OmniStudio dependencies are buried in JSON configs, not tidy lookup fields.
Who is it for?
Builders maintaining large OmniStudio estates who need a consistent parsing mental model before deploy or consolidation.
Skip if: Greenfield Salesforce apps with no OmniStudio, or teams only needing generic Apex/LWC dependency analysis outside OmniStudio JSON.
When should I use this skill?
Tasks require understanding OmniStudio component reference patterns embedded in JSON configuration before changes or documentation.
What do I get? / Deliverables
You understand the directed dependency graph across OmniScripts, IPs, FlexCards, and Data Mappers so impact analysis and refactors are intentional.
- Dependency direction map for targeted components
- List of implicit JSON-backed references to validate in org metadata
Recommended Skills
Journey fit
Salesforce OmniStudio integration graphs are untangled during Build when composing customer-facing flows and backend orchestration. Integrations subphase fits dependency extraction across IPs, Data Mappers, Apex, HTTP, and LWC references—not generic frontend styling.
How it compares
OmniStudio-specific dependency ontology—not a generic Salesforce metadata browser or MCP data export tool.
Common Questions / FAQ
Who is analyzing-omnistudio-dependencies for?
Solo Salesforce implementers and small teams working on OmniStudio who need graph-aware impact analysis before editing flows or cards.
When should I use analyzing-omnistudio-dependencies?
During Build integrations work when auditing OmniScript/IP/FlexCard references prior to refactoring, documenting, or planning a release.
Is analyzing-omnistudio-dependencies safe to install?
Review the Security Audits panel on this Prism page; treat Force.com ecosystem skills like any third-party procedure pack and avoid pasting production secrets into chats.
SKILL.md
READMESKILL.md - Analyzing Omnistudio Dependencies
# Credits & Acknowledgments This skill draws on established patterns and platform knowledge from the broader OmniStudio ecosystem. --- <!-- Parent: analyzing-omnistudio-dependencies/SKILL.md --> # OmniStudio Dependency Patterns ## Overview OmniStudio components form a directed graph where each component type can reference others. Dependencies are not stored in lookup fields — they are embedded in JSON configuration fields (`PropertySetConfig`, `Definition`, `InputObjectName`/`OutputObjectName`). Extracting dependencies requires parsing these JSON structures. --- ## Dependency Direction Summary ``` OmniScript ──→ Integration Procedure (via IP Action element) OmniScript ──→ Data Mapper (via DataRaptor Action element) OmniScript ──→ OmniScript (via embedded OmniScript element) OmniScript ──→ Apex Class (via Remote Action element) OmniScript ──→ LWC (via Custom Lightning Web Component element) OmniScript ──→ HTTP Endpoint (via HTTP Action element) Integration Procedure ──→ Data Mapper (via DataRaptor Action element) Integration Procedure ──→ Apex Class (via Remote Action element) Integration Procedure ──→ HTTP Endpoint (via HTTP Action element) Integration Procedure ──→ Integration Procedure (via nested IP Action element) Integration Procedure ──→ OmniScript (via OmniScript Action element — uncommon) FlexCard ──→ Integration Procedure (via data source configuration) FlexCard ──→ Apex Class (via Apex data source) FlexCard ──→ FlexCard (via child card reference) FlexCard ──→ OmniScript (via action configuration — launches OS) Data Mapper ──→ Salesforce Object (via InputObjectName — read) Data Mapper ──→ Salesforce Object (via OutputObjectName — write) ``` --- ## OmniScript Dependencies ### Element Types and Their Dependency Targets OmniScript elements are stored as `OmniProcessElement` records (Core) or `Element__c` records (Vlocity). Each element has a `PropertySetConfig` / `PropertySet__c` JSON field containing the configuration. #### DataRaptor Transform Action Calls a Data Mapper to extract, transform, or load data. **PropertySetConfig structure**: ```json { "Type": "DataRaptor Transform Action", "PropertySet": { "bundle": "AccountExtract", "bundleName": "AccountExtract", "dataRaptorType": "Extract" } } ``` **Extraction rule**: `PropertySet.bundle` or `PropertySet.bundleName` → resolves to an `OmniDataTransform` record by `Name`. #### DataRaptor Turbo Action High-performance variant of DataRaptor Transform Action. Same JSON structure, same extraction rule. **PropertySetConfig structure**: ```json { "Type": "DataRaptor Turbo Action", "PropertySet": { "bundle": "AccountTurboExtract", "bundleName": "AccountTurboExtract" } } ``` #### Integration Procedure Action Calls an Integration Procedure. **PropertySetConfig structure**: ```json { "Type": "Integration Procedure Action", "PropertySet": { "integrationProcedureKey": "TypeName_SubTypeName", "ipMethod": "TypeName", "ipType": "SubTypeName", "integrationProcedureVersion": 1 } } ``` **Extraction rule**: `PropertySet.integrationProcedureKey` → resolves to an `OmniProcess` record where `Type_SubType` matches and `TypeCategory = 'IntegrationProcedure'`. #### OmniScript Action (Embedded OmniScript) Embeds or launches another OmniScript. **PropertySetConfig structure**: ```json { "Type": "OmniScript", "PropertySet": { "Type": "ChildScriptType", "Sub Type": "ChildScriptSubType", "Language": "English" } } ``` **Extraction rule**: `PropertySet.Type` + `PropertySet["Sub Type"]` + `PropertySet.Language` → resolves to an `OmniProcess` where `TypeCategory = 'OmniScript'` and fields match. #### Remote Action Calls an Apex class method. **PropertySetConfig structure**: ```json { "Type": "Remote Action", "PropertySet": { "remoteClass": "MyApexClassName", "remoteMethod": "myMethodName", "remoteTimeout": 30000 } } ``` **Extraction rule**: `PropertySet.remoteClass` → Apex class na