@salesforce/metadata-plugins 1.0.0

package/dist/plugins/schema/SchemaParser.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Copyright (c) 2025, Salesforce, Inc.
+ * All rights reserved.
+ * Licensed under the BSD 3-Clause license.
+ * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+ **/
+/**
+ * Schema Parser
+ *
+ * Parses Salesforce SFDX decomposed source format (.object-meta.xml and .field-meta.xml)
+ * into a SchemaERDData structure for interactive ERD visualization.
+ *
+ * Unlike the ObjectParser which parses a single object at a time, the SchemaParser
+ * discovers and parses ALL objects in the project to build a complete ERD graph
+ * with resolved cross-object relationships.
+ *
+ * Supports:
+ * - Decomposed source format (separate .field-meta.xml files in fields/ subdirectory)
+ * - Inline fields in .object-meta.xml (flat format)
+ * - Standard objects (Account, Asset, etc.) and custom objects (*__c)
+ * - Lookup and MasterDetail relationship resolution
+ * - Full transitive BFS traversal of related objects
+ * - Platform limit validation (max 2 Master-Detail per object)
+ *
+ * @author Schema Team
+ */
+import { IMetadataParser, SalesforceXMLParser, ValidationResult, IPlatformContext, VersionInfo } from '@salesforce/metadata-core-sdk';
+import { SchemaERDData } from './types/SchemaERDData.js';
+export declare class SchemaParser implements IMetadataParser<SchemaERDData> {
+    private platformContext?;
+    private telemetry?;
+    readonly xmlParser: SalesforceXMLParser;
+    setPlatformContext(context: IPlatformContext): void;
+    /**
+     * Parse all objects in the project starting from the given file path.
+     * Discovers all sibling objects, parses their fields, resolves relationships,
+     * and returns a complete SchemaERDData structure.
+     */
+    parse(filePath: string, _versionInfo: VersionInfo): Promise<SchemaERDData>;
+    /**
+     * Validate parsed SchemaERDData against Salesforce platform limits.
+     */
+    validate?(data: SchemaERDData): ValidationResult;
+    /**
+     * Get all file paths that this visualization depends on.
+     * Used by the framework to trigger re-renders when any of these files change.
+     */
+    getVizDependentFilePaths(filePath: string): Promise<string[]>;
+    /**
+     * Walk up from the given file path to find the "objects" directory.
+     */
+    private findObjectsRoot;
+    /**
+     * Extract the object API name from the clicked file path.
+     * e.g. ".../objects/Video__c/Video__c.object-meta.xml" → "Video__c"
+     * e.g. ".../objects/Video__c/fields/Status__c.field-meta.xml" → "Video__c"
+     */
+    private getTriggerObjectName;
+    /**
+     * Find all objects transitively related to the trigger object via BFS.
+     * Walks the full relationship graph: if A→B→C, triggering from A
+     * includes B and C (and anything reachable from them).
+     */
+    private findRelatedObjects;
+    /**
+     * Discover all object directories under the objects root.
+     * Uses the platform fileSystem API.
+     */
+    private discoverObjects;
+    /**
+     * Parse a single object and its fields into an ObjectNode + RelationshipEdge[].
+     */
+    private parseObject;
+    /**
+     * Parse a single field XML element into a SchemaField and optional RelationshipEdge.
+     */
+    private parseFieldXml;
+    private categorizeParseError;
+}
+//# sourceMappingURL=SchemaParser.d.ts.map

package/dist/plugins/schema/SchemaParser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SchemaParser.d.ts","sourceRoot":"","sources":["../../../src/plugins/schema/SchemaParser.ts"],"names":[],"mappings":"AAAA;;;;;IAKI;AAEJ;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EACL,eAAe,EACf,mBAAmB,EACnB,gBAAgB,EAChB,gBAAgB,EAGhB,WAAW,EAGZ,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAE,aAAa,EAA6C,MAAM,0BAA0B,CAAC;AASpG,qBAAa,YAAa,YAAW,eAAe,CAAC,aAAa,CAAC;IACjE,OAAO,CAAC,eAAe,CAAC,CAAmB;IAC3C,OAAO,CAAC,SAAS,CAAC,CAAa;IAE/B,QAAQ,CAAC,SAAS,sBAA6B;IAE/C,kBAAkB,CAAC,OAAO,EAAE,gBAAgB,GAAG,IAAI;IAKnD;;;;OAIG;IACG,KAAK,CAAC,QAAQ,EAAE,MAAM,EAAE,YAAY,EAAE,WAAW,GAAG,OAAO,CAAC,aAAa,CAAC;IA2HhF;;OAEG;IACH,QAAQ,CAAC,CAAC,IAAI,EAAE,aAAa,GAAG,gBAAgB;IAyBhD;;;OAGG;IACG,wBAAwB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAmDnE;;OAEG;IACH,OAAO,CAAC,eAAe;IAqBvB;;;;OAIG;IACH,OAAO,CAAC,oBAAoB;IAa5B;;;;OAIG;IACH,OAAO,CAAC,kBAAkB;IAuC1B;;;OAGG;YACW,eAAe;IA6D7B;;OAEG;YACW,WAAW;IAqGzB;;OAEG;IACH,OAAO,CAAC,aAAa;IAqDrB,OAAO,CAAC,oBAAoB;CAiB7B"}

package/dist/plugins/schema/SchemaParser.js

@@ -0,0 +1,474 @@
+/**
+ * Copyright (c) 2025, Salesforce, Inc.
+ * All rights reserved.
+ * Licensed under the BSD 3-Clause license.
+ * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+ **/
+/**
+ * Schema Parser
+ *
+ * Parses Salesforce SFDX decomposed source format (.object-meta.xml and .field-meta.xml)
+ * into a SchemaERDData structure for interactive ERD visualization.
+ *
+ * Unlike the ObjectParser which parses a single object at a time, the SchemaParser
+ * discovers and parses ALL objects in the project to build a complete ERD graph
+ * with resolved cross-object relationships.
+ *
+ * Supports:
+ * - Decomposed source format (separate .field-meta.xml files in fields/ subdirectory)
+ * - Inline fields in .object-meta.xml (flat format)
+ * - Standard objects (Account, Asset, etc.) and custom objects (*__c)
+ * - Lookup and MasterDetail relationship resolution
+ * - Full transitive BFS traversal of related objects
+ * - Platform limit validation (max 2 Master-Detail per object)
+ *
+ * @author Schema Team
+ */
+import { SalesforceXMLParser, ErrorBuilder, ErrorCategory, } from '@salesforce/metadata-core-sdk';
+export class SchemaParser {
+    constructor() {
+        this.xmlParser = new SalesforceXMLParser();
+    }
+    setPlatformContext(context) {
+        this.platformContext = context;
+        this.telemetry = context.telemetry.createChild({ component: 'SchemaParser' });
+    }
+    /**
+     * Parse all objects in the project starting from the given file path.
+     * Discovers all sibling objects, parses their fields, resolves relationships,
+     * and returns a complete SchemaERDData structure.
+     */
+    async parse(filePath, _versionInfo) {
+        if (!this.platformContext) {
+            throw ErrorBuilder.create()
+                .category(ErrorCategory.Configuration)
+                .message('SchemaParser not initialized with platform context')
+                .build();
+        }
+        return this.telemetry.withSpan('schema.parse', async (span) => {
+            const logger = this.platformContext.logger.createChild('SchemaParser');
+            const triggerFileName = this.platformContext.fileSystem.basename(filePath);
+            logger.info(`Parsing schema from trigger file: ${filePath}`);
+            span.setAttribute('triggerFile', triggerFileName);
+            try {
+                const triggerFilePath = filePath;
+                const objectsRoot = this.findObjectsRoot(triggerFilePath);
+                if (!objectsRoot) {
+                    throw ErrorBuilder.create()
+                        .category(ErrorCategory.Dependency)
+                        .message(`Cannot determine objects root from path: ${triggerFileName}`)
+                        .context({ filePath })
+                        .build();
+                }
+                logger.info(`Objects root: ${objectsRoot}`);
+                const discovered = await this.discoverObjects(objectsRoot, logger);
+                logger.info(`Discovered ${discovered.length} objects`);
+                this.telemetry.sendEvent('schema.discovery_complete', {
+                    pluginId: 'schema',
+                }, {
+                    discoveredObjectCount: discovered.length,
+                    fieldOnlyObjectCount: discovered.filter((d) => !d.objectMetaPath).length,
+                });
+                const allObjects = [];
+                const allRelationships = [];
+                let parseFailures = 0;
+                for (const disc of discovered) {
+                    try {
+                        const { objectNode, rels } = await this.parseObject(disc, logger);
+                        allObjects.push(objectNode);
+                        allRelationships.push(...rels);
+                    }
+                    catch (error) {
+                        parseFailures++;
+                        logger.error(`Failed to parse ${disc.objectName}:`, error);
+                        this.telemetry.sendException('schema.object_parse_error', error, {
+                            pluginId: 'schema',
+                            objectName: disc.objectName,
+                            hasObjectMeta: String(!!disc.objectMetaPath),
+                        });
+                    }
+                }
+                const triggerObjectName = this.getTriggerObjectName(triggerFilePath);
+                logger.info(`Trigger object: ${triggerObjectName}`);
+                span.setAttribute('triggerObject', triggerObjectName);
+                const relatedNames = this.findRelatedObjects(triggerObjectName, allObjects, allRelationships, logger);
+                const objects = allObjects.filter((o) => relatedNames.has(o.apiName));
+                const objectNames = new Set(objects.map((o) => o.apiName));
+                const validRelationships = allRelationships.filter((r) => objectNames.has(r.sourceObject) && objectNames.has(r.targetObject));
+                logger.info(`Filtered to ${objects.length} related objects (from ${allObjects.length} total), ${validRelationships.length} relationships`);
+                span.setAttribute('totalObjectsDiscovered', allObjects.length);
+                span.setAttribute('objectsRendered', objects.length);
+                span.setAttribute('relationshipsRendered', validRelationships.length);
+                span.setAttribute('parseFailures', parseFailures);
+                return {
+                    objects,
+                    relationships: validRelationships,
+                    metadata: {
+                        objectCount: objects.length,
+                        relationshipCount: validRelationships.length,
+                        objectsRoot,
+                        parsedAt: new Date().toISOString(),
+                    },
+                };
+            }
+            catch (error) {
+                logger.error('Schema parsing failed:', error);
+                if (typeof error === 'object' &&
+                    error !== null &&
+                    'category' in error &&
+                    Object.values(ErrorCategory).includes(error.category)) {
+                    throw error;
+                }
+                const pluginError = ErrorBuilder.fromError(this.categorizeParseError(error), error, {
+                    filePath,
+                    objectName: triggerFileName,
+                }).build();
+                throw pluginError;
+            }
+        }, { pluginId: 'schema' });
+    }
+    /**
+     * Validate parsed SchemaERDData against Salesforce platform limits.
+     */
+    validate(data) {
+        const errors = [];
+        const warnings = [];
+        for (const obj of data.objects) {
+            const mdCount = data.relationships.filter((r) => r.sourceObject === obj.apiName && r.type === 'MasterDetail').length;
+            if (mdCount > 2) {
+                errors.push(`${obj.apiName}: Exceeds max 2 Master-Detail relationships (has ${mdCount})`);
+            }
+            if (obj.fields.length === 0 && obj.type === 'custom') {
+                warnings.push(`${obj.apiName}: Custom object has no custom fields`);
+            }
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+            warnings,
+        };
+    }
+    /**
+     * Get all file paths that this visualization depends on.
+     * Used by the framework to trigger re-renders when any of these files change.
+     */
+    async getVizDependentFilePaths(filePath) {
+        if (!this.platformContext) {
+            return [filePath];
+        }
+        const objectsRoot = this.findObjectsRoot(filePath);
+        if (!objectsRoot) {
+            return [filePath];
+        }
+        const pfs = this.platformContext.fileSystem;
+        const paths = [];
+        try {
+            const dirResult = await pfs.readDirectory(objectsRoot);
+            if (!dirResult.success || !dirResult.data) {
+                return [filePath];
+            }
+            for (const entry of dirResult.data) {
+                if (entry.isFile) {
+                    continue;
+                }
+                const objDir = pfs.join(objectsRoot, entry.name);
+                const objectMetaFile = pfs.join(objDir, `${entry.name}.object-meta.xml`);
+                if (await pfs.exists(objectMetaFile)) {
+                    paths.push(objectMetaFile);
+                }
+                const fieldsDir = pfs.join(objDir, 'fields');
+                if (await pfs.exists(fieldsDir)) {
+                    const fieldDirResult = await pfs.readDirectory(fieldsDir);
+                    if (fieldDirResult.success && fieldDirResult.data) {
+                        for (const fe of fieldDirResult.data) {
+                            if (fe.isFile && fe.name.endsWith('.field-meta.xml')) {
+                                paths.push(pfs.join(fieldsDir, fe.name));
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        catch {
+            return [filePath];
+        }
+        return paths;
+    }
+    // ─── Private Helpers ───────────────────────────────────────────────
+    /**
+     * Walk up from the given file path to find the "objects" directory.
+     */
+    findObjectsRoot(filePath) {
+        const sep = this.platformContext?.fileSystem.separator ?? '/';
+        let dir = filePath;
+        if (dir.includes('.')) {
+            const lastSep = dir.lastIndexOf(sep);
+            if (lastSep >= 0) {
+                dir = dir.substring(0, lastSep);
+            }
+        }
+        for (let i = 0; i < 6; i++) {
+            const lastSep = dir.lastIndexOf(sep);
+            const base = lastSep >= 0 ? dir.substring(lastSep + 1) : dir;
+            if (base === 'objects') {
+                return dir;
+            }
+            dir = lastSep >= 0 ? dir.substring(0, lastSep) : dir;
+        }
+        return null;
+    }
+    /**
+     * Extract the object API name from the clicked file path.
+     * e.g. ".../objects/Video__c/Video__c.object-meta.xml" → "Video__c"
+     * e.g. ".../objects/Video__c/fields/Status__c.field-meta.xml" → "Video__c"
+     */
+    getTriggerObjectName(filePath) {
+        const sep = this.platformContext?.fileSystem.separator ?? '/';
+        const parts = filePath.split(sep);
+        const objectsIdx = parts.lastIndexOf('objects');
+        if (objectsIdx >= 0 && objectsIdx + 1 < parts.length) {
+            return parts[objectsIdx + 1];
+        }
+        const lastSep = filePath.lastIndexOf(sep);
+        const dir = lastSep >= 0 ? filePath.substring(0, lastSep) : filePath;
+        const dirLastSep = dir.lastIndexOf(sep);
+        return dirLastSep >= 0 ? dir.substring(dirLastSep + 1) : dir;
+    }
+    /**
+     * Find all objects transitively related to the trigger object via BFS.
+     * Walks the full relationship graph: if A→B→C, triggering from A
+     * includes B and C (and anything reachable from them).
+     */
+    findRelatedObjects(triggerName, _allObjects, allRelationships, logger) {
+        const adjacency = new Map();
+        for (const rel of allRelationships) {
+            if (!adjacency.has(rel.sourceObject)) {
+                adjacency.set(rel.sourceObject, new Set());
+            }
+            if (!adjacency.has(rel.targetObject)) {
+                adjacency.set(rel.targetObject, new Set());
+            }
+            adjacency.get(rel.sourceObject).add(rel.targetObject);
+            adjacency.get(rel.targetObject).add(rel.sourceObject);
+        }
+        const visited = new Set();
+        const queue = [triggerName];
+        visited.add(triggerName);
+        while (queue.length > 0) {
+            const current = queue.shift();
+            const neighbors = adjacency.get(current);
+            if (neighbors) {
+                for (const neighbor of neighbors) {
+                    if (!visited.has(neighbor)) {
+                        visited.add(neighbor);
+                        queue.push(neighbor);
+                    }
+                }
+            }
+        }
+        logger.info(`Related objects for ${triggerName} (full BFS): ${Array.from(visited).join(', ')}`);
+        return visited;
+    }
+    /**
+     * Discover all object directories under the objects root.
+     * Uses the platform fileSystem API.
+     */
+    async discoverObjects(objectsRoot, logger) {
+        if (!this.platformContext) {
+            throw ErrorBuilder.create()
+                .category(ErrorCategory.Configuration)
+                .message('SchemaParser not initialized with platform context')
+                .build();
+        }
+        const discovered = [];
+        // Find all .object-meta.xml files
+        const objectFilesResult = await this.platformContext.fileSystem.findFiles('**/*.object-meta.xml');
+        if (!objectFilesResult.success || !objectFilesResult.data) {
+            logger.error('Error finding object files:', objectFilesResult.error);
+            return [];
+        }
+        // Filter to only files under our objectsRoot
+        const objectFiles = objectFilesResult.data.filter((fp) => fp.startsWith(objectsRoot));
+        // Find all .field-meta.xml files
+        const fieldFilesResult = await this.platformContext.fileSystem.findFiles('**/*.field-meta.xml');
+        const allFieldFiles = fieldFilesResult.success && fieldFilesResult.data
+            ? fieldFilesResult.data.filter((fp) => fp.startsWith(objectsRoot))
+            : [];
+        const pfs = this.platformContext.fileSystem;
+        const discoveredNames = new Set();
+        for (const objectMetaPath of objectFiles) {
+            const objectDir = pfs.dirname(objectMetaPath);
+            const objectName = pfs.basename(objectDir);
+            const fieldsDir = pfs.join(objectDir, 'fields');
+            const fieldMetaPaths = allFieldFiles.filter((fp) => fp.startsWith(fieldsDir + pfs.separator));
+            discovered.push({ objectName, objectMetaPath, fieldMetaPaths });
+            discoveredNames.add(objectName);
+        }
+        // Standard objects (Account, Contact, etc.) often have only a fields/
+        // subdirectory with no .object-meta.xml in SFDX source. Discover those
+        // by finding field files whose parent object wasn't already discovered.
+        for (const fieldPath of allFieldFiles) {
+            const fieldsDir = pfs.dirname(fieldPath);
+            const objectDir = pfs.dirname(fieldsDir);
+            const objectName = pfs.basename(objectDir);
+            if (discoveredNames.has(objectName) || pfs.basename(fieldsDir) !== 'fields') {
+                continue;
+            }
+            const fieldMetaPaths = allFieldFiles.filter((fp) => fp.startsWith(fieldsDir + pfs.separator));
+            discovered.push({ objectName, fieldMetaPaths });
+            discoveredNames.add(objectName);
+            logger.info(`Discovered field-only object (no .object-meta.xml): ${objectName}`);
+        }
+        return discovered;
+    }
+    /**
+     * Parse a single object and its fields into an ObjectNode + RelationshipEdge[].
+     */
+    async parseObject(disc, logger) {
+        if (!this.platformContext) {
+            throw ErrorBuilder.create()
+                .category(ErrorCategory.Configuration)
+                .message('SchemaParser not initialized with platform context')
+                .build();
+        }
+        const { objectName, objectMetaPath, fieldMetaPaths } = disc;
+        const isCustom = objectName.endsWith('__c');
+        logger.info(`Parsing: ${objectName} (${isCustom ? 'custom' : 'standard'})`);
+        let customObject = {};
+        let nameFieldType = 'Text';
+        if (objectMetaPath) {
+            const readResult = await this.platformContext.fileSystem.readFile(objectMetaPath);
+            if (!readResult.success || !readResult.data) {
+                const msg = readResult.error?.message ?? 'Unknown error';
+                throw ErrorBuilder.create()
+                    .category(ErrorCategory.Dependency)
+                    .message(`Failed to read file: ${msg}`)
+                    .context({ filePath: objectMetaPath, objectName })
+                    .build();
+            }
+            const parsed = this.xmlParser.parse(readResult.data);
+            customObject = parsed.CustomObject || {};
+            if (customObject.nameField?.type === 'AutoNumber') {
+                nameFieldType = 'AutoNumber';
+            }
+        }
+        const fields = [];
+        const rels = [];
+        let inlineFields = customObject.fields;
+        if (inlineFields) {
+            if (!Array.isArray(inlineFields)) {
+                inlineFields = [inlineFields];
+            }
+            for (const f of inlineFields) {
+                const { field, rel } = this.parseFieldXml(f, objectName);
+                fields.push(field);
+                if (rel) {
+                    rels.push(rel);
+                }
+            }
+        }
+        // Parse decomposed .field-meta.xml files
+        for (const fieldPath of fieldMetaPaths) {
+            try {
+                const fieldReadResult = await this.platformContext.fileSystem.readFile(fieldPath);
+                if (!fieldReadResult.success || !fieldReadResult.data) {
+                    logger.warn(`Failed to read field file: ${fieldPath}`);
+                    continue;
+                }
+                const fieldParsed = this.xmlParser.parse(fieldReadResult.data);
+                const fieldXml = fieldParsed.CustomField;
+                if (!fieldXml) {
+                    logger.warn(`No CustomField root in ${fieldPath}`);
+                    continue;
+                }
+                if (!fieldXml.fullName) {
+                    fieldXml.fullName = this.platformContext.fileSystem
+                        .basename(fieldPath)
+                        .replace('.field-meta.xml', '');
+                }
+                const { field, rel } = this.parseFieldXml(fieldXml, objectName);
+                fields.push(field);
+                if (rel) {
+                    rels.push(rel);
+                }
+            }
+            catch (error) {
+                logger.error(`Error parsing field ${fieldPath}:`, error);
+                this.telemetry?.sendException('schema.field_parse_error', error, {
+                    pluginId: 'schema',
+                    objectName,
+                    fieldFile: this.platformContext.fileSystem.basename(fieldPath),
+                });
+            }
+        }
+        const objectNode = {
+            apiName: objectName,
+            label: customObject.label || objectName,
+            type: isCustom ? 'custom' : 'standard',
+            nameFieldType,
+            fields,
+        };
+        return { objectNode, rels };
+    }
+    /**
+     * Parse a single field XML element into a SchemaField and optional RelationshipEdge.
+     */
+    parseFieldXml(fieldXml, objectName) {
+        const apiName = fieldXml.fullName || '';
+        const rawType = fieldXml.type || 'Text';
+        const isRelationship = rawType === 'Lookup' || rawType === 'MasterDetail';
+        const referenceTo = fieldXml.referenceTo;
+        // Build display type string
+        let dataType = rawType;
+        if (rawType === 'Text' && fieldXml.length) {
+            dataType = `Text(${fieldXml.length})`;
+        }
+        else if (rawType === 'Html' && fieldXml.length) {
+            dataType = `Html(${fieldXml.length})`;
+        }
+        else if (rawType === 'Number') {
+            const p = fieldXml.precision || '';
+            const s = fieldXml.scale || '';
+            if (p || s) {
+                dataType = `Number(${p},${s})`;
+            }
+        }
+        const field = {
+            apiName,
+            label: fieldXml.label || apiName,
+            dataType,
+            isRelationship,
+            referenceTo: isRelationship ? referenceTo : undefined,
+            relationshipType: isRelationship ? rawType : undefined,
+            description: fieldXml.description,
+            helpText: fieldXml.inlineHelpText,
+            required: fieldXml.required === 'true' || fieldXml.required === true || rawType === 'MasterDetail',
+            length: fieldXml.length ? parseInt(fieldXml.length, 10) : undefined,
+        };
+        let rel = null;
+        if (isRelationship && referenceTo) {
+            rel = {
+                sourceObject: objectName,
+                targetObject: referenceTo,
+                fieldApiName: apiName,
+                type: rawType,
+            };
+        }
+        return { field, rel };
+    }
+    categorizeParseError(error) {
+        if (error instanceof Error) {
+            const message = error.message.toLowerCase();
+            if (message.includes('xml') || message.includes('parse')) {
+                return ErrorCategory.Parsing;
+            }
+            if (message.includes('not found') || message.includes('enoent')) {
+                return ErrorCategory.Dependency;
+            }
+            if (message.includes('permission') || message.includes('eacces')) {
+                return ErrorCategory.Permission;
+            }
+        }
+        return ErrorCategory.Runtime;
+    }
+}

package/dist/plugins/schema/SchemaVisualizer.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Copyright (c) 2025, Salesforce, Inc.
+ * All rights reserved.
+ * Licensed under the BSD 3-Clause license.
+ * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+ **/
+/**
+ * Schema Visualizer Plugin
+ *
+ * Handles .object-meta.xml and .field-meta.xml files and displays an interactive
+ * ERD (Entity Relationship Diagram) using React Flow.
+ *
+ * This plugin discovers ALL objects in the project, parses their fields and
+ * relationships, and renders a full ERD graph with:
+ * - Color-coded object cards (blue=standard, purple=custom)
+ * - Crow's foot notation for relationships
+ * - Solid lines for Master-Detail, dashed for Lookup
+ * - "NEW" badges for custom objects/fields
+ * - Auto-layout with dagre, zoom/pan, minimap
+ *
+ * @author Schema Team
+ */
+import { IVisualizationPlugin, MetadataPluginInfo, IMetadataParser, IPlatformContext } from '@salesforce/metadata-core-sdk';
+import { SchemaERDData } from './types/SchemaERDData.js';
+/**
+ * SchemaVisualizer implementation for Salesforce object metadata ERD
+ */
+export declare class SchemaVisualizer implements IVisualizationPlugin<SchemaERDData> {
+    private readonly pluginMetadata;
+    readonly parser: IMetadataParser<SchemaERDData>;
+    private logger?;
+    constructor();
+    /**
+     * Get plugin metadata information.
+     * Framework calls this during plugin registration.
+     */
+    getMetadataPluginInfo(): MetadataPluginInfo;
+    canHandle(filePath: string): boolean;
+    initialize(context: IPlatformContext): Promise<void>;
+    dispose?(): void;
+}
+//# sourceMappingURL=SchemaVisualizer.d.ts.map

package/dist/plugins/schema/SchemaVisualizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SchemaVisualizer.d.ts","sourceRoot":"","sources":["../../../src/plugins/schema/SchemaVisualizer.ts"],"names":[],"mappings":"AAAA;;;;;IAKI;AAEJ;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EACL,oBAAoB,EACpB,kBAAkB,EAClB,eAAe,EACf,gBAAgB,EAEjB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAGzD;;GAEG;AACH,qBAAa,gBAAiB,YAAW,oBAAoB,CAAC,aAAa,CAAC;IAC1E,OAAO,CAAC,QAAQ,CAAC,cAAc,CAO7B;IAEF,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAC,aAAa,CAAC,CAAC;IAEhD,OAAO,CAAC,MAAM,CAAC,CAAU;;IAMzB;;;OAGG;IACH,qBAAqB,IAAI,kBAAkB;IAI3C,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAS9B,UAAU,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC;IAO1D,OAAO,CAAC,IAAI,IAAI;CAGjB"}

package/dist/plugins/schema/SchemaVisualizer.js

@@ -0,0 +1,46 @@
+/**
+ * Copyright (c) 2025, Salesforce, Inc.
+ * All rights reserved.
+ * Licensed under the BSD 3-Clause license.
+ * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+ **/
+import { SchemaParser } from './SchemaParser.js';
+/**
+ * SchemaVisualizer implementation for Salesforce object metadata ERD
+ */
+export class SchemaVisualizer {
+    constructor() {
+        this.pluginMetadata = {
+            id: 'schema',
+            name: 'Salesforce Schema (Data Model) Visualizer',
+            description: 'Interactive ERD visualization of Salesforce objects, fields, and relationships',
+            author: 'Schema Team',
+            filePatterns: ['.object-meta.xml', '.field-meta.xml'],
+            priority: 10,
+        };
+        this.parser = new SchemaParser();
+    }
+    /**
+     * Get plugin metadata information.
+     * Framework calls this during plugin registration.
+     */
+    getMetadataPluginInfo() {
+        return this.pluginMetadata;
+    }
+    canHandle(filePath) {
+        return this.getMetadataPluginInfo().filePatterns.some((pattern) => {
+            if (pattern.startsWith('*')) {
+                return filePath.endsWith(pattern.slice(1));
+            }
+            return filePath === pattern || filePath.endsWith(pattern);
+        });
+    }
+    async initialize(context) {
+        this.logger = context.logger.createChild(this.getMetadataPluginInfo().id);
+        this.logger.info('Schema visualizer initialized');
+        this.parser.setPlatformContext(context);
+    }
+    dispose() {
+        this.logger?.info(`Disposing ${this.getMetadataPluginInfo().name}`);
+    }
+}