@salesforce/source-tracking 2.1.0 → 2.2.0

package/lib/sourceTracking.js

@@ -9,17 +9,20 @@ exports.SourceTracking = void 0;
  */
 const fs = require("fs");
 const path_1 = require("path");
-const os_1 = require("os");
 const core_1 = require("@salesforce/core");
 const kit_1 = require("@salesforce/kit");
 const ts_types_1 = require("@salesforce/ts-types");
 const source_deploy_retrieve_1 = require("@salesforce/source-deploy-retrieve");
 const remoteSourceTrackingService_1 = require("./shared/remoteSourceTrackingService");
 const localShadowRepo_1 = require("./shared/localShadowRepo");
+const conflicts_1 = require("./shared/conflicts");
 const guards_1 = require("./shared/guards");
 const functions_1 = require("./shared/functions");
 const metadataKeys_1 = require("./shared/metadataKeys");
 const compatibility_1 = require("./compatibility");
+const populateFilePaths_1 = require("./shared/populateFilePaths");
+const populateTypesAndNames_1 = require("./shared/populateTypesAndNames");
+const localComponentSetArray_1 = require("./shared/localComponentSetArray");
 /**
  * Manages source tracking files (remote and local)
  *
@@ -28,95 +31,48 @@ const compatibility_1 = require("./compatibility");
  */
 class SourceTracking extends kit_1.AsyncCreatable {
     constructor(options) {
+        var _a, _b, _c;
         super(options);
-        this.registry = new source_deploy_retrieve_1.RegistryAccess();
         this.org = options.org;
+        this.orgId = this.org.getOrgId();
         this.projectPath = options.project.getPath();
         this.packagesDirs = options.project.getPackageDirectories();
         this.logger = core_1.Logger.childFromRoot('SourceTracking');
         this.project = options.project;
-        this.hasSfdxTrackingFiles = (0, compatibility_1.hasSfdxTrackingFiles)(this.org.getOrgId(), this.projectPath);
+        this.ignoreConflicts = (_a = options.ignoreConflicts) !== null && _a !== void 0 ? _a : false;
+        this.ignoreLocalCache = (_b = options.ignoreLocalCache) !== null && _b !== void 0 ? _b : false;
+        this.subscribeSDREvents = (_c = options.subscribeSDREvents) !== null && _c !== void 0 ? _c : false;
+        this.hasSfdxTrackingFiles = (0, compatibility_1.hasSfdxTrackingFiles)(this.orgId, this.projectPath);
     }
     // eslint-disable-next-line class-methods-use-this
     async init() {
-        // reserved for future use
+        await this.maybeSubscribeLifecycleEvents();
     }
     /**
      *
-     * @param byPackageDir if true, returns one ComponentSet for each packageDir with changes
+     * @param byPackageDir if true, returns a ComponentSet for each packageDir that has any changes
+     * * if false, returns an array containing one ComponentSet with all changes
+     * * if not specified, this method will follow what sfdx-project.json says
      * @returns ComponentSet[]
      */
-    async localChangesAsComponentSet(byPackageDir = false) {
-        var _a;
-        const [projectConfig] = await Promise.all([this.project.resolveProjectConfig(), this.ensureLocalTracking()]);
-        (_a = this.forceIgnore) !== null && _a !== void 0 ? _a : (this.forceIgnore = source_deploy_retrieve_1.ForceIgnore.findAndCreate(this.project.getDefaultPackage().name));
-        const sourceApiVersion = (0, ts_types_1.getString)(projectConfig, 'sourceApiVersion');
-        // optimistic resolution...some files may not be possible to resolve
-        const resolverForNonDeletes = new source_deploy_retrieve_1.MetadataResolver();
-        // we need virtual components for the deletes.
-        // TODO: could we use the same for the non-deletes?
-        const [allNonDeletes, allDeletes] = (await Promise.all([this.localRepo.getNonDeleteFilenames(), this.localRepo.getDeleteFilenames()]))
-            // remove the forceIgnored items early
-            .map((group) => group.filter((item) => this.forceIgnore.accepts(item)));
+    async localChangesAsComponentSet(byPackageDir) {
+        const [projectConfig] = await Promise.all([
+            this.project.resolveProjectConfig(),
+            this.ensureLocalTracking(),
+        ]);
+        const sourceApiVersion = projectConfig.sourceApiVersion;
+        const [nonDeletes, deletes] = await Promise.all([
+            this.localRepo.getNonDeleteFilenames(),
+            this.localRepo.getDeleteFilenames(),
+        ]);
         // it'll be easier to filter filenames and work with smaller component sets than to filter SourceComponents
-        const groupings = (byPackageDir
-            ? this.packagesDirs.map((pkgDir) => ({
-                path: pkgDir.name,
-                nonDeletes: allNonDeletes.filter((f) => (0, functions_1.pathIsInFolder)(f, pkgDir.name)),
-                deletes: allDeletes.filter((f) => (0, functions_1.pathIsInFolder)(f, pkgDir.name)),
-            }))
-            : [
-                {
-                    nonDeletes: allNonDeletes,
-                    deletes: allDeletes,
-                    path: this.packagesDirs.map((dir) => dir.name).join(';'),
-                },
-            ]).filter((group) => group.deletes.length || group.nonDeletes.length);
+        const groupings = (0, localComponentSetArray_1.getGroupedFiles)({
+            packageDirs: this.packagesDirs,
+            nonDeletes,
+            deletes,
+        }, byPackageDir !== null && byPackageDir !== void 0 ? byPackageDir : Boolean(projectConfig.pushPackageDirectoriesSequentially)); // if the users specified true or false for the param, that overrides the project config
         this.logger.debug(`will build array of ${groupings.length} componentSet(s)`);
-        return groupings
-            .map((grouping) => {
-            this.logger.debug(`building componentSet for ${grouping.path} (deletes: ${grouping.deletes.length} nonDeletes: ${grouping.nonDeletes.length})`);
-            const componentSet = new source_deploy_retrieve_1.ComponentSet();
-            if (sourceApiVersion) {
-                componentSet.sourceApiVersion = sourceApiVersion;
-            }
-            const resolverForDeletes = new source_deploy_retrieve_1.MetadataResolver(undefined, source_deploy_retrieve_1.VirtualTreeContainer.fromFilePaths(grouping.deletes));
-            grouping.deletes
-                .flatMap((filename) => resolverForDeletes.getComponentsFromPath(filename))
-                .filter(guards_1.sourceComponentGuard)
-                .map((component) => {
-                // if the component is a file in a bundle type AND there are files from the bundle that are not deleted, set the bundle for deploy, not for delete
-                if ((0, functions_1.isBundle)(component) && component.content && fs.existsSync(component.content)) {
-                    // all bundle types have a directory name
-                    try {
-                        resolverForNonDeletes
-                            .getComponentsFromPath((0, path_1.resolve)(component.content))
-                            .filter(guards_1.sourceComponentGuard)
-                            .map((nonDeletedComponent) => componentSet.add(nonDeletedComponent));
-                    }
-                    catch (e) {
-                        this.logger.warn(`unable to find component at ${component.content}.  That's ok if it was supposed to be deleted`);
-                    }
-                }
-                else {
-                    componentSet.add(component, source_deploy_retrieve_1.DestructiveChangesType.POST);
-                }
-            });
-            grouping.nonDeletes
-                .flatMap((filename) => {
-                try {
-                    return resolverForNonDeletes.getComponentsFromPath((0, path_1.resolve)(filename));
-                }
-                catch (e) {
-                    this.logger.warn(`unable to resolve ${filename}`);
-                    return undefined;
-                }
-            })
-                .filter(guards_1.sourceComponentGuard)
-                .map((component) => componentSet.add(component));
-            return componentSet;
-        })
-            .filter((componentSet) => componentSet.size > 0);
+        return (0, localComponentSetArray_1.getComponentSets)(groupings, sourceApiVersion);
     }
     async remoteNonDeletesAsComponentSet() {
         const [changeResults, sourceBackedComponents] = await Promise.all([
@@ -176,12 +132,6 @@ class SourceTracking extends kit_1.AsyncCreatable {
         }
         return results;
     }
-    /**
-     * Get metadata changes made locally and in the org.
-     *
-     * @returns local and remote changed metadata
-     *
-     */
     async getChanges(options) {
         if ((options === null || options === void 0 ? void 0 : options.origin) === 'local') {
             await this.ensureLocalTracking();
@@ -218,13 +168,13 @@ class SourceTracking extends kit_1.AsyncCreatable {
             this.logger.debug('remoteChanges', remoteChanges);
             const filteredChanges = remoteChanges
                 .filter(remoteFilterByState[options.state])
-                // skip any remote types not in the registry.  Will emit node warnings
-                .filter((rce) => this.registrySupportsType(rce.type));
+                // skip any remote types not in the registry.  Will emit warnings
+                .filter((rce) => (0, metadataKeys_1.registrySupportsType)(rce.type));
             if (options.format === 'ChangeResult') {
                 return filteredChanges.map((change) => (0, remoteSourceTrackingService_1.remoteChangeElementToChangeResult)(change));
             }
             if (options.format === 'ChangeResultWithPaths') {
-                return this.populateFilePaths(filteredChanges.map((change) => (0, remoteSourceTrackingService_1.remoteChangeElementToChangeResult)(change)));
+                return (0, populateFilePaths_1.populateFilePaths)(filteredChanges.map((change) => (0, remoteSourceTrackingService_1.remoteChangeElementToChangeResult)(change)), this.project.getPackageDirectories().map((pkgDir) => pkgDir.path));
             }
             // turn it into a componentSet to resolve filenames
             const remoteChangesAsComponentSet = new source_deploy_retrieve_1.ComponentSet(filteredChanges.map((element) => ({
@@ -247,6 +197,19 @@ class SourceTracking extends kit_1.AsyncCreatable {
         }
         throw new Error(`unsupported options: ${JSON.stringify(options)}`);
     }
+    /**
+     *
+     * Convenience method to reduce duplicated steps required to do a fka pull
+     * It's full of side effects: retrieving remote deletes, deleting those files locall, and then updating tracking files
+     * Most bizarrely, it then returns a ComponentSet of the remote nonDeletes.
+     *
+     * @returns the ComponentSet for what you would retrieve now that the deletes are done
+     */
+    async maybeApplyRemoteDeletesToLocal() {
+        const changesToDelete = await this.getChanges({ origin: 'remote', state: 'delete', format: 'SourceComponent' });
+        await this.deleteFilesAndUpdateTracking(changesToDelete);
+        return this.remoteNonDeletesAsComponentSet();
+    }
     /**
      *
      * returns immediately if there are no changesToDelete
@@ -294,8 +257,8 @@ class SourceTracking extends kit_1.AsyncCreatable {
         await this.ensureLocalTracking();
         // relative paths make smaller trees AND isogit wants them relative
         const relativeOptions = {
-            files: ((_a = options.files) !== null && _a !== void 0 ? _a : []).map((file) => this.ensureRelative(file)),
-            deletedFiles: ((_b = options.deletedFiles) !== null && _b !== void 0 ? _b : []).map((file) => this.ensureRelative(file)),
+            files: ((_a = options.files) !== null && _a !== void 0 ? _a : []).map((file) => (0, functions_1.ensureRelative)(file, this.projectPath)),
+            deletedFiles: ((_b = options.deletedFiles) !== null && _b !== void 0 ? _b : []).map((file) => (0, functions_1.ensureRelative)(file, this.projectPath)),
         };
         // plot twist: if you delete a member of a bundle (ex: lwc/foo/foo.css) and push, it'll not be in the fileResponses (deployedFiles) or deletedFiles
         // what got deleted?  Any local changes NOT in the fileResponses but part of a successfully deployed bundle
@@ -329,17 +292,23 @@ class SourceTracking extends kit_1.AsyncCreatable {
         }
         await this.remoteSourceTrackingService.syncSpecifiedElements(fileResponses);
     }
+    async reReadLocalTrackingCache() {
+        await this.localRepo.getStatus(true);
+    }
     /**
      * If the local tracking shadowRepo doesn't exist, it will be created.
-     * Does nothing if it already exists.
+     * Does nothing if it already exists, unless you've instantiate SourceTracking to not cache local status, in which case it'll re-read your files
      * Useful before parallel operations
      */
     async ensureLocalTracking() {
         if (this.localRepo) {
+            if (this.ignoreLocalCache) {
+                await this.localRepo.getStatus(true);
+            }
             return;
         }
         this.localRepo = await localShadowRepo_1.ShadowRepo.getInstance({
-            orgId: this.org.getOrgId(),
+            orgId: this.orgId,
             projectPath: (0, path_1.normalize)(this.projectPath),
             packageDirs: this.packagesDirs,
             hasSfdxTrackingFiles: this.hasSfdxTrackingFiles,
@@ -395,7 +364,7 @@ class SourceTracking extends kit_1.AsyncCreatable {
      * Deletes the remote tracking files
      */
     async clearRemoteTracking() {
-        return remoteSourceTrackingService_1.RemoteSourceTrackingService.delete(this.org.getOrgId(), this.hasSfdxTrackingFiles);
+        return remoteSourceTrackingService_1.RemoteSourceTrackingService.delete(this.orgId, this.hasSfdxTrackingFiles);
     }
     /**
      * Sets the files to max revision so that no changes appear
@@ -409,6 +378,7 @@ class SourceTracking extends kit_1.AsyncCreatable {
      * Compares local and remote changes to detect conflicts
      */
     async getConflicts() {
+        var _a;
         // we're going to need have both initialized
         await Promise.all([this.ensureRemoteTracking(), this.ensureLocalTracking()]);
         // Strategy: check local changes first (since it'll be faster) to avoid callout
@@ -430,201 +400,128 @@ class SourceTracking extends kit_1.AsyncCreatable {
         if (remoteChanges.length === 0) {
             return [];
         }
-        // index the remoteChanges by filename
-        const fileNameIndex = new Map();
-        const metadataKeyIndex = new Map();
-        remoteChanges.map((change) => {
-            var _a;
-            if (change.name && change.type) {
-                metadataKeyIndex.set((0, functions_1.getMetadataKey)(change.name, change.type), change);
-            }
-            (_a = change.filenames) === null || _a === void 0 ? void 0 : _a.map((filename) => {
-                fileNameIndex.set(filename, change);
-            });
-        });
-        const conflicts = new Set();
-        this.populateTypesAndNames({ elements: localChanges, excludeUnresolvable: true }).map((change) => {
-            var _a;
-            const metadataKey = (0, functions_1.getMetadataKey)(change.name, change.type);
-            // option 1: name and type match
-            if (metadataKeyIndex.has(metadataKey)) {
-                conflicts.add({ ...metadataKeyIndex.get(metadataKey) });
-            }
-            else {
-                // option 2: some of the filenames match
-                (_a = change.filenames) === null || _a === void 0 ? void 0 : _a.map((filename) => {
-                    if (fileNameIndex.has(filename)) {
-                        conflicts.add({ ...fileNameIndex.get(filename) });
-                    }
-                });
-            }
+        (_a = this.forceIgnore) !== null && _a !== void 0 ? _a : (this.forceIgnore = source_deploy_retrieve_1.ForceIgnore.findAndCreate(this.project.getDefaultPackage().path));
+        return (0, conflicts_1.getDedupedConflictsFromChanges)({
+            localChanges,
+            remoteChanges,
+            projectPath: this.projectPath,
+            forceIgnore: this.forceIgnore,
         });
-        // deeply de-dupe
-        return Array.from(conflicts);
     }
     /**
-     * uses SDR to translate remote metadata records into local file paths (which only typically have the filename).
+     * handles both remote and local tracking
      *
-     * @input elements: ChangeResult[]
-     * @input excludeUnresolvable: boolean Filter out components where you can't get the name and type (that is, it's probably not a valid source component)
-     * @input resolveDeleted: constructs a virtualTree instead of the actual filesystem--useful when the files no longer exist
-     * @input useFsForceIgnore: (default behavior) use forceIgnore from the filesystem.  If false, uses the base forceIgnore from SDR
+     * @param result FileResponse[]
      */
-    populateTypesAndNames({ elements, excludeUnresolvable = false, resolveDeleted = false, useFsForceIgnore = true, }) {
-        if (elements.length === 0) {
-            return [];
+    async updateTrackingFromDeploy(deployResult) {
+        const successes = deployResult
+            .getFileResponses()
+            .filter((fileResponse) => fileResponse.state !== source_deploy_retrieve_1.ComponentStatus.Failed && fileResponse.filePath);
+        if (!successes.length) {
+            return;
         }
-        this.logger.debug(`populateTypesAndNames for ${elements.length} change elements`);
-        const filenames = elements.flatMap((element) => element.filenames).filter(ts_types_1.isString);
-        // component set generated from the filenames on all local changes
-        const resolver = new source_deploy_retrieve_1.MetadataResolver(undefined, resolveDeleted ? source_deploy_retrieve_1.VirtualTreeContainer.fromFilePaths(filenames) : undefined, useFsForceIgnore);
-        const sourceComponents = filenames
-            .flatMap((filename) => {
-            try {
-                return resolver.getComponentsFromPath(filename);
-            }
-            catch (e) {
-                this.logger.warn(`unable to resolve ${filename}`);
-                return undefined;
-            }
-        })
-            .filter(guards_1.sourceComponentGuard);
-        this.logger.debug(` matching SourceComponents have ${sourceComponents.length} items from local`);
-        // make it simpler to find things later
-        const elementMap = new Map();
-        elements.map((element) => {
-            var _a;
-            (_a = element.filenames) === null || _a === void 0 ? void 0 : _a.map((filename) => {
-                elementMap.set(this.ensureRelative(filename), element);
-            });
-        });
-        // iterates the local components and sets their filenames
-        sourceComponents.map((matchingComponent) => {
-            var _a;
-            if ((matchingComponent === null || matchingComponent === void 0 ? void 0 : matchingComponent.fullName) && (matchingComponent === null || matchingComponent === void 0 ? void 0 : matchingComponent.type.name)) {
-                const filenamesFromMatchingComponent = [matchingComponent.xml, ...matchingComponent.walkContent()];
-                // Set the ignored status at the component level so it can apply to all its files, some of which may not match the ignoreFile (ex: ApexClass)
-                (_a = this.forceIgnore) !== null && _a !== void 0 ? _a : (this.forceIgnore = source_deploy_retrieve_1.ForceIgnore.findAndCreate(this.project.getDefaultPackage().path));
-                const ignored = filenamesFromMatchingComponent
-                    .filter(ts_types_1.isString)
-                    .filter((filename) => !filename.includes('__tests__'))
-                    .some((filename) => this.forceIgnore.denies(filename));
-                filenamesFromMatchingComponent.map((filename) => {
-                    if (filename && elementMap.has(filename)) {
-                        // add the type/name from the componentSet onto the element
-                        elementMap.set(filename, {
-                            origin: 'remote',
-                            ...elementMap.get(filename),
-                            type: matchingComponent.type.name,
-                            name: matchingComponent.fullName,
-                            ignored,
-                        });
+        await Promise.all([
+            this.updateLocalTracking({
+                // assertions allowed because filtered above
+                files: successes
+                    .filter((fileResponse) => fileResponse.state !== source_deploy_retrieve_1.ComponentStatus.Deleted)
+                    .map((fileResponse) => fileResponse.filePath),
+                deletedFiles: successes
+                    .filter((fileResponse) => fileResponse.state === source_deploy_retrieve_1.ComponentStatus.Deleted)
+                    .map((fileResponse) => fileResponse.filePath),
+            }),
+            this.updateRemoteTracking(successes.map(({ state, fullName, type, filePath }) => ({ state, fullName, type, filePath }))),
+        ]);
+    }
+    /**
+     * handles both remote and local tracking
+     *
+     * @param result FileResponse[]
+     */
+    async updateTrackingFromRetrieve(retrieveResult) {
+        const successes = retrieveResult
+            .getFileResponses()
+            .filter((fileResponse) => fileResponse.state !== source_deploy_retrieve_1.ComponentStatus.Failed);
+        if (!successes.length) {
+            return;
+        }
+        await Promise.all([
+            this.updateLocalTracking({
+                // assertion allowed because it's filtering out undefined
+                files: successes.map((fileResponse) => fileResponse.filePath).filter(Boolean),
+            }),
+            this.updateRemoteTracking(successes.map(({ state, fullName, type, filePath }) => ({ state, fullName, type, filePath })), true // retrieves don't need to poll for SourceMembers
+            ),
+        ]);
+    }
+    /**
+     * If you've already got an instance of STL, but need to change the conflicts setting
+     * normally you set this on instantiation
+     *
+     * @param value true/false
+     */
+    setIgnoreConflicts(value) {
+        this.ignoreConflicts = value;
+    }
+    async maybeSubscribeLifecycleEvents() {
+        if (this.subscribeSDREvents && (await this.org.tracksSource())) {
+            const lifecycle = core_1.Lifecycle.getInstance();
+            // the only thing STL uses pre events for is to check conflicts.  So if you don't care about conflicts, don't listen!
+            if (!this.ignoreConflicts) {
+                this.logger.debug('subscribing to predeploy/retrieve events');
+                // subscribe to SDR `pre` events to handle conflicts before deploy/retrieve
+                lifecycle.on('scopedPreDeploy', async (e) => {
+                    this.logger.debug('received scopedPreDeploy event');
+                    if (e.orgId === this.orgId) {
+                        (0, conflicts_1.throwIfConflicts)((0, conflicts_1.findConflictsInComponentSet)(e.componentSet, await this.getConflicts()));
+                    }
+                });
+                lifecycle.on('scopedPreRetrieve', async (e) => {
+                    this.logger.debug('received scopedPreRetrieve event');
+                    if (e.orgId === this.orgId) {
+                        (0, conflicts_1.throwIfConflicts)((0, conflicts_1.findConflictsInComponentSet)(e.componentSet, await this.getConflicts()));
                     }
                 });
             }
-        });
-        return excludeUnresolvable
-            ? Array.from(new Set(elementMap.values())).filter((changeResult) => changeResult.name && changeResult.type)
-            : Array.from(new Set(elementMap.values()));
+            // subscribe to SDR post-deploy event
+            this.logger.debug('subscribing to postdeploy/retrieve events');
+            // yes, the post hooks really have different payloads!
+            lifecycle.on('scopedPostDeploy', async (e) => {
+                this.logger.debug('received scopedPostDeploy event');
+                if (e.orgId === this.orgId) {
+                    await this.updateTrackingFromDeploy(e.deployResult);
+                }
+            });
+            lifecycle.on('scopedPostRetrieve', async (e) => {
+                this.logger.debug('received scopedPostRetrieve event');
+                if (e.orgId === this.orgId) {
+                    await this.updateTrackingFromRetrieve(e.retrieveResult);
+                }
+            });
+        }
     }
     async getLocalStatusRows() {
         await this.ensureLocalTracking();
         let results = [];
-        const localDeletes = this.populateTypesAndNames({
+        const localDeletes = (0, populateTypesAndNames_1.populateTypesAndNames)({
             elements: await this.getChanges({ origin: 'local', state: 'delete', format: 'ChangeResult' }),
             excludeUnresolvable: true,
             resolveDeleted: true,
-            useFsForceIgnore: false,
+            projectPath: this.projectPath,
         });
-        const localAdds = this.populateTypesAndNames({
+        const localAdds = (0, populateTypesAndNames_1.populateTypesAndNames)({
             elements: await this.getChanges({ origin: 'local', state: 'add', format: 'ChangeResult' }),
             excludeUnresolvable: true,
-            useFsForceIgnore: false,
+            projectPath: this.projectPath,
         });
-        const localModifies = this.populateTypesAndNames({
+        const localModifies = (0, populateTypesAndNames_1.populateTypesAndNames)({
             elements: await this.getChanges({ origin: 'local', state: 'modify', format: 'ChangeResult' }),
             excludeUnresolvable: true,
-            useFsForceIgnore: false,
+            projectPath: this.projectPath,
         });
         results = results.concat(localAdds.flatMap((item) => this.localChangesToOutputRow(item, 'add')), localModifies.flatMap((item) => this.localChangesToOutputRow(item, 'modify')), localDeletes.flatMap((item) => this.localChangesToOutputRow(item, 'delete')));
         return results;
     }
-    registrySupportsType(type) {
-        try {
-            if (metadataKeys_1.mappingsForSourceMemberTypesToMetadataType.has(type)) {
-                return true;
-            }
-            // this must use getTypeByName because findType doesn't support addressable child types (ex: customField!)
-            this.registry.getTypeByName(type);
-            return true;
-        }
-        catch (e) {
-            process.emitWarning(`Unable to find type ${type} in registry`);
-            return false;
-        }
-    }
-    /**
-     * uses SDR to translate remote metadata records into local file paths
-     */
-    populateFilePaths(elements) {
-        if (elements.length === 0) {
-            return [];
-        }
-        this.logger.debug('populateFilePaths for change elements', elements);
-        // component set generated from an array of MetadataMember from all the remote changes
-        // but exclude the ones that aren't in the registry
-        const remoteChangesAsMetadataMember = elements
-            .map((element) => {
-            if (typeof element.type === 'string' && typeof element.name === 'string') {
-                return {
-                    type: element.type,
-                    fullName: element.name,
-                };
-            }
-        })
-            .filter(guards_1.metadataMemberGuard);
-        const remoteChangesAsComponentSet = new source_deploy_retrieve_1.ComponentSet(remoteChangesAsMetadataMember);
-        this.logger.debug(` the generated component set has ${remoteChangesAsComponentSet.size.toString()} items`);
-        if (remoteChangesAsComponentSet.size < elements.length) {
-            // there *could* be something missing
-            // some types (ex: LWC) show up as multiple files in the remote changes, but only one in the component set
-            // iterate the elements to see which ones didn't make it into the component set
-            const missingComponents = elements.filter((element) => !remoteChangesAsComponentSet.has({ type: element === null || element === void 0 ? void 0 : element.type, fullName: element === null || element === void 0 ? void 0 : element.name }));
-            // Throw if anything was actually missing
-            if (missingComponents.length > 0) {
-                throw new Error(`unable to generate complete component set for ${elements
-                    .map((element) => `${element.name} (${element.type})`)
-                    .join(os_1.EOL)}`);
-            }
-        }
-        const matchingLocalSourceComponentsSet = source_deploy_retrieve_1.ComponentSet.fromSource({
-            fsPaths: this.packagesDirs.map((dir) => dir.path),
-            include: remoteChangesAsComponentSet,
-        });
-        this.logger.debug(` local source-backed component set has ${matchingLocalSourceComponentsSet.size.toString()} items from remote`);
-        // make it simpler to find things later
-        const elementMap = new Map();
-        elements.map((element) => {
-            elementMap.set((0, functions_1.getKeyFromObject)(element), element);
-        });
-        // iterates the local components and sets their filenames
-        for (const matchingComponent of matchingLocalSourceComponentsSet.getSourceComponents().toArray()) {
-            if (matchingComponent.fullName && matchingComponent.type.name) {
-                this.logger.debug(`${matchingComponent.fullName}|${matchingComponent.type.name} matches ${matchingComponent.xml} and maybe ${matchingComponent.walkContent().toString()}`);
-                const key = (0, functions_1.getMetadataKey)(matchingComponent.type.name, matchingComponent.fullName);
-                elementMap.set(key, {
-                    ...elementMap.get(key),
-                    modified: true,
-                    origin: 'remote',
-                    filenames: [matchingComponent.xml, ...matchingComponent.walkContent()].filter((filename) => filename),
-                });
-            }
-        }
-        return Array.from(elementMap.values());
-    }
-    ensureRelative(filePath) {
-        return (0, path_1.isAbsolute)(filePath) ? (0, path_1.relative)(this.projectPath, filePath) : filePath;
-    }
     async getLocalChangesAsFilenames(state) {
         if (state === 'modify') {
             return this.localRepo.getModifyFilenames();
@@ -641,22 +538,21 @@ class SourceTracking extends kit_1.AsyncCreatable {
         throw new Error(`unable to get local changes for state ${state}`);
     }
     localChangesToOutputRow(input, localType) {
-        var _a, _b, _c;
+        var _a;
         this.logger.debug('converting ChangeResult to a row', input);
-        const baseObject = {
-            type: (_a = input.type) !== null && _a !== void 0 ? _a : '',
-            origin: 'local',
-            state: localType,
-            fullName: (_b = input.name) !== null && _b !== void 0 ? _b : '',
-            // ignored property will be set in populateTypesAndNames
-            ignored: (_c = input.ignored) !== null && _c !== void 0 ? _c : false,
-        };
+        (_a = this.forceIgnore) !== null && _a !== void 0 ? _a : (this.forceIgnore = source_deploy_retrieve_1.ForceIgnore.findAndCreate(this.project.getDefaultPackage().path));
         if (input.filenames) {
-            return input.filenames.map((filename) => ({
-                ...baseObject,
-                filePath: filename,
-                origin: 'local',
-            }));
+            return input.filenames.map((filename) => {
+                var _a, _b;
+                return ({
+                    type: (_a = input.type) !== null && _a !== void 0 ? _a : '',
+                    state: localType,
+                    fullName: (_b = input.name) !== null && _b !== void 0 ? _b : '',
+                    filePath: filename,
+                    origin: 'local',
+                    ignored: this.forceIgnore.denies(filename),
+                });
+            });
         }
         throw new Error('no filenames found for local ChangeResult');
     }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@salesforce/source-tracking",
   "description": "API for tracking local and remote Salesforce metadata changes",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "author": "Salesforce",
   "license": "BSD-3-Clause",
   "main": "lib/index.js",
@@ -43,9 +43,9 @@
     "/oclif.manifest.json"
   ],
   "dependencies": {
-    "@salesforce/core": "^3.21.2",
-    "@salesforce/kit": "^1.5.17",
-    "@salesforce/source-deploy-retrieve": "^6.0.4",
+    "@salesforce/core": "^3.22.1",
+    "@salesforce/kit": "^1.5.42",
+    "@salesforce/source-deploy-retrieve": "^6.1.0",
     "graceful-fs": "^4.2.9",
     "isomorphic-git": "1.17.0",
     "ts-retry-promise": "^0.6.0"
@@ -63,9 +63,9 @@
     "cz-conventional-changelog": "^3.3.0",
     "eslint": "^7.32.0",
     "eslint-config-prettier": "^8.3.0",
-    "eslint-config-salesforce": "^0.1.6",
+    "eslint-config-salesforce": "^1.0.1",
     "eslint-config-salesforce-license": "^0.1.6",
-    "eslint-config-salesforce-typescript": "^0.2.7",
+    "eslint-config-salesforce-typescript": "^1.0.0",
     "eslint-plugin-header": "^3.1.1",
     "eslint-plugin-import": "2.25.4",
     "eslint-plugin-jsdoc": "^37.0.1",
@@ -80,7 +80,7 @@
     "sinon": "^10.0.0",
     "ts-node": "^10.1.0",
     "ts-prune": "^0.10.0",
-    "typescript": "^4.4.4"
+    "typescript": "^4.7.4"
   },
   "config": {
     "commitizen": {