@salesforce/source-tracking 2.1.2 → 2.2.2

package/lib/sourceTracking.js

@@ -9,17 +9,22 @@ 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");
+// this is not exported by SDR (see the comments in SDR regarding its limitations)
+const filePathGenerator_1 = require("@salesforce/source-deploy-retrieve/lib/src/utils/filePathGenerator");
 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)
  *
@@ -29,94 +34,46 @@ const compatibility_1 = require("./compatibility");
 class SourceTracking extends kit_1.AsyncCreatable {
     constructor(options) {
         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 = options.ignoreConflicts ?? false;
+        this.ignoreLocalCache = options.ignoreLocalCache ?? false;
+        this.subscribeSDREvents = options.subscribeSDREvents ?? 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 ?? 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,14 +133,8 @@ 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') {
+        if (options?.origin === 'local') {
             await this.ensureLocalTracking();
             const filenames = await this.getLocalChangesAsFilenames(options.state);
             if (options.format === 'string') {
@@ -212,24 +163,24 @@ class SourceTracking extends kit_1.AsyncCreatable {
                     .filter(guards_1.sourceComponentGuard);
             }
         }
-        if ((options === null || options === void 0 ? void 0 : options.origin) === 'remote') {
+        if (options?.origin === 'remote') {
             await this.ensureRemoteTracking();
             const remoteChanges = await this.remoteSourceTrackingService.retrieveUpdates();
             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) => ({
-                type: element === null || element === void 0 ? void 0 : element.type,
-                fullName: element === null || element === void 0 ? void 0 : element.name,
+                type: element?.type,
+                fullName: element?.name,
             })));
             const matchingLocalSourceComponentsSet = source_deploy_retrieve_1.ComponentSet.fromSource({
                 fsPaths: this.packagesDirs.map((dir) => (0, path_1.resolve)(dir.fullPath)),
@@ -247,6 +198,13 @@ class SourceTracking extends kit_1.AsyncCreatable {
         }
         throw new Error(`unsupported options: ${JSON.stringify(options)}`);
     }
+    async maybeApplyRemoteDeletesToLocal(returnDeleteFileResponses) {
+        const changesToDelete = await this.getChanges({ origin: 'remote', state: 'delete', format: 'SourceComponent' });
+        const fileResponsesFromDelete = await this.deleteFilesAndUpdateTracking(changesToDelete);
+        return returnDeleteFileResponses
+            ? { componentSetFromNonDeletes: await this.remoteNonDeletesAsComponentSet(), fileResponsesFromDelete }
+            : this.remoteNonDeletesAsComponentSet();
+    }
     /**
      *
      * returns immediately if there are no changesToDelete
@@ -274,15 +232,12 @@ class SourceTracking extends kit_1.AsyncCreatable {
             })), true // skip polling because it's a pull
             ),
         ]);
-        return filenames.map((filename) => {
-            var _a, _b;
-            return ({
-                state: 'Deleted',
-                filename,
-                type: (_a = sourceComponentByFileName.get(filename)) === null || _a === void 0 ? void 0 : _a.type.name,
-                fullName: (_b = sourceComponentByFileName.get(filename)) === null || _b === void 0 ? void 0 : _b.fullName,
-            });
-        });
+        return filenames.map((filename) => ({
+            state: 'Deleted',
+            filename,
+            type: sourceComponentByFileName.get(filename)?.type.name,
+            fullName: sourceComponentByFileName.get(filename)?.fullName,
+        }));
     }
     /**
      * Update tracking for the options passed.
@@ -290,12 +245,11 @@ class SourceTracking extends kit_1.AsyncCreatable {
      * @param options the files to update
      */
     async updateLocalTracking(options) {
-        var _a, _b;
         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: (options.files ?? []).map((file) => (0, functions_1.ensureRelative)(file, this.projectPath)),
+            deletedFiles: (options.deletedFiles ?? []).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 +283,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 +355,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
@@ -430,201 +390,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) });
-                    }
-                });
-            }
+        this.forceIgnore ?? (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,39 +528,34 @@ class SourceTracking extends kit_1.AsyncCreatable {
         throw new Error(`unable to get local changes for state ${state}`);
     }
     localChangesToOutputRow(input, localType) {
-        var _a, _b, _c;
         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,
-        };
+        this.forceIgnore ?? (this.forceIgnore = source_deploy_retrieve_1.ForceIgnore.findAndCreate(this.project.getDefaultPackage().path));
         if (input.filenames) {
             return input.filenames.map((filename) => ({
-                ...baseObject,
+                type: input.type ?? '',
+                state: localType,
+                fullName: input.name ?? '',
                 filePath: filename,
                 origin: 'local',
+                ignored: this.forceIgnore.denies(filename),
             }));
         }
         throw new Error('no filenames found for local ChangeResult');
     }
-    // this will eventually have async call to figure out the target file locations for remote changes
+    // reserve the right to do something more sophisticated in the future
+    // via async for figuring out hypothetical filenames (ex: getting default packageDir)
     // eslint-disable-next-line @typescript-eslint/require-await
     async remoteChangesToOutputRows(input) {
-        var _a, _b, _c, _d;
         this.logger.debug('converting ChangeResult to a row', input);
-        (_a = this.forceIgnore) !== null && _a !== void 0 ? _a : (this.forceIgnore = source_deploy_retrieve_1.ForceIgnore.findAndCreate(this.project.getDefaultPackage().path));
+        this.forceIgnore ?? (this.forceIgnore = source_deploy_retrieve_1.ForceIgnore.findAndCreate(this.project.getDefaultPackage().path));
         const baseObject = {
-            type: (_b = input.type) !== null && _b !== void 0 ? _b : '',
+            type: input.type ?? '',
             origin: input.origin,
             state: stateFromChangeResult(input),
-            fullName: (_c = input.name) !== null && _c !== void 0 ? _c : '',
+            fullName: input.name ?? '',
         };
         // it's easy to check ignores if the filePaths exist locally
-        if ((_d = input.filenames) === null || _d === void 0 ? void 0 : _d.length) {
+        if (input.filenames?.length) {
             return input.filenames.map((filename) => ({
                 ...baseObject,
                 filePath: filename,
@@ -681,7 +563,18 @@ class SourceTracking extends kit_1.AsyncCreatable {
             }));
         }
         // when the file doesn't exist locally, there are no filePaths
-        // So we can't say whether it's ignored or not
+        // SDR can generate the hypothetical place it *would* go and check that
+        if (input.name && input.type) {
+            return [
+                {
+                    ...baseObject,
+                    ignored: (0, filePathGenerator_1.filePathsFromMetadataComponent)({
+                        fullName: input.name,
+                        type: new source_deploy_retrieve_1.RegistryAccess().getTypeByName(input.type),
+                    }).some((hypotheticalFilePath) => this.forceIgnore.denies(hypotheticalFilePath)),
+                },
+            ];
+        }
         return [baseObject];
     }
 }