@salesforce/source-tracking 0.2.2 → 0.4.2

package/lib/shared/types.d.ts

@@ -1,2 +1,48 @@
-import { FileResponse } from '@salesforce/source-deploy-retrieve';
+import { FileResponse, SourceComponent } from '@salesforce/source-deploy-retrieve';
+export interface ChangeOptions {
+    origin: 'local' | 'remote';
+    state: 'add' | 'delete' | 'modify' | 'nondelete';
+    format: 'ChangeResult' | 'SourceComponent' | 'string' | 'ChangeResultWithPaths';
+}
 export declare type RemoteSyncInput = Pick<FileResponse, 'fullName' | 'filePath' | 'type' | 'state'>;
+export declare type StatusOutputRow = Pick<FileResponse, 'fullName' | 'filePath' | 'type'> & {
+    conflict?: boolean;
+    ignored?: boolean;
+} & Pick<ChangeOptions, 'origin' | 'state'>;
+export interface LocalUpdateOptions {
+    files?: string[];
+    deletedFiles?: string[];
+}
+export declare type RemoteChangeElement = {
+    name: string;
+    type: string;
+    deleted?: boolean;
+    modified?: boolean;
+};
+/**
+ * Summary type that supports both local and remote change types
+ */
+export declare type ChangeResult = Partial<RemoteChangeElement> & {
+    origin: 'local' | 'remote';
+    filenames?: string[];
+    ignored?: boolean;
+};
+export declare type MemberRevision = {
+    serverRevisionCounter: number;
+    lastRetrievedFromServer: number | null;
+    memberType: string;
+    isNameObsolete: boolean;
+};
+export declare type SourceMember = {
+    MemberType: string;
+    MemberName: string;
+    IsNameObsolete: boolean;
+    RevisionCounter: number;
+    ignored?: boolean;
+};
+export interface ConflictError {
+    message: string;
+    name: 'conflict';
+    conflicts: ChangeResult[];
+}
+export declare type ChangeOptionType = ChangeResult | SourceComponent | string;

package/lib/sourceTracking.d.ts

@@ -1,36 +1,11 @@
 import { Org, SfdxProject } from '@salesforce/core';
 import { AsyncCreatable } from '@salesforce/kit';
 import { ComponentSet, SourceComponent, FileResponse } from '@salesforce/source-deploy-retrieve';
-import { RemoteChangeElement } from './shared/remoteSourceTrackingService';
-import { RemoteSyncInput } from './shared/types';
-export declare const getKeyFromObject: (element: RemoteChangeElement | ChangeResult) => string;
-export declare const getKeyFromStrings: (metadataType: string, metadataName: string) => string;
-export declare type ChangeOptionType = ChangeResult | SourceComponent | string;
-export interface ChangeOptions {
-    origin: 'local' | 'remote';
-    state: 'add' | 'delete' | 'modify' | 'nondelete';
-    format: 'ChangeResult' | 'SourceComponent' | 'string';
-}
-export interface LocalUpdateOptions {
-    files?: string[];
-    deletedFiles?: string[];
-}
-/**
- * Summary type that supports both local and remote change types
- */
-export declare type ChangeResult = Partial<RemoteChangeElement> & {
-    origin: 'local' | 'remote';
-    filenames?: string[];
-};
-export interface ConflictError {
-    message: string;
-    name: 'conflict';
-    conflicts: ChangeResult[];
-}
+import { RemoteSyncInput, StatusOutputRow, ChangeOptions, ChangeResult, ChangeOptionType, LocalUpdateOptions } from './shared/types';
 export interface SourceTrackingOptions {
     org: Org;
     project: SfdxProject;
-    /** defaults to sfdxProject sourceApiVersion unless provided */
+    /** @deprecated not used defaults to sfdxProject sourceApiVersion unless provided */
     apiVersion?: string;
 }
 /**
@@ -41,19 +16,34 @@ export interface SourceTrackingOptions {
  */
 export declare class SourceTracking extends AsyncCreatable {
     private orgId;
+    private project;
     private projectPath;
     private packagesDirs;
     private username;
     private logger;
     private localRepo;
     private remoteSourceTrackingService;
+    private forceIgnore;
     constructor(options: SourceTrackingOptions);
     init(): Promise<void>;
     localChangesAsComponentSet(): Promise<ComponentSet>;
+    /**
+     * Does most of the work for the force:source:status command.
+     * Outputs need a bit of massage since this aims to provide nice json.
+     *
+     * @param local you want local status
+     * @param remote you want remote status
+     * @returns StatusOutputRow[]
+     */
+    getStatus({ local, remote }: {
+        local: boolean;
+        remote: boolean;
+    }): Promise<StatusOutputRow[]>;
     /**
      * Get metadata changes made locally and in the org.
      *
      * @returns local and remote changed metadata
+     *
      */
     getChanges<T extends ChangeOptionType>(options?: ChangeOptions): Promise<T[]>;
     /**
@@ -103,22 +93,26 @@ export declare class SourceTracking extends AsyncCreatable {
      * Sets the files to max revision so that no changes appear
      */
     resetRemoteTracking(serverRevision?: number): Promise<number>;
+    /**
+     * Compares local and remote changes to detect conflicts
+     */
+    getConflicts(): Promise<ChangeResult[]>;
     /**
      * uses SDR to translate remote metadata records into local file paths (which only typically have the filename).
      *
      * @input elements: ChangeResult[]
      * @input excludeUnresolvables: 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
      */
-    populateTypesAndNames({ elements, excludeUnresolvable, resolveDeleted, }: {
-        elements: ChangeResult[];
-        excludeUnresolvable?: boolean;
-        resolveDeleted?: boolean;
-    }): ChangeResult[];
-    getConflicts(): Promise<ChangeResult[]>;
+    private populateTypesAndNames;
+    private getLocalStatusRows;
     /**
      * uses SDR to translate remote metadata records into local file paths
      */
     private populateFilePaths;
     private ensureRelative;
+    private getLocalChangesAsFilenames;
+    private localChangesToOutputRow;
+    private remoteChangesToOutputRows;
 }
-export declare const stringGuard: (input: string | undefined) => input is string;

package/lib/sourceTracking.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.stringGuard = exports.SourceTracking = exports.getKeyFromStrings = exports.getKeyFromObject = void 0;
+exports.SourceTracking = void 0;
 /*
  * Copyright (c) 2021, salesforce.com, inc.
  * All rights reserved.
@@ -9,21 +9,16 @@ exports.stringGuard = exports.SourceTracking = exports.getKeyFromStrings = expor
  */
 const fs = require("fs");
 const path = 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 filenamesToVirtualTree_1 = require("./shared/filenamesToVirtualTree");
-const getKeyFromObject = (element) => {
-    if (element.type && element.name) {
-        return (0, remoteSourceTrackingService_1.getMetadataKey)(element.type, element.name);
-    }
-    throw new Error(`unable to complete key from ${JSON.stringify(element)}`);
-};
-exports.getKeyFromObject = getKeyFromObject;
-// external users of SDR might need to convert a fileResponse to a key
-exports.getKeyFromStrings = remoteSourceTrackingService_1.getMetadataKey;
+const guards_1 = require("./shared/guards");
+const functions_1 = require("./shared/functions");
 /**
  * Manages source tracking files (remote and local)
  *
@@ -38,13 +33,18 @@ class SourceTracking extends kit_1.AsyncCreatable {
         this.projectPath = options.project.getPath();
         this.packagesDirs = options.project.getPackageDirectories();
         this.logger = core_1.Logger.childFromRoot('SourceTracking');
+        this.project = options.project;
     }
     async init() {
-        // reserved for future use.  If not, can remove asyncCreatable
+        // reserved for future use
     }
     async localChangesAsComponentSet() {
-        await this.ensureLocalTracking();
+        const [projectConfig] = await Promise.all([this.project.resolveProjectConfig(), this.ensureLocalTracking()]);
+        const sourceApiVersion = (0, ts_types_1.getString)(projectConfig, 'sourceApiVersion');
         const componentSet = new source_deploy_retrieve_1.ComponentSet();
+        if (sourceApiVersion) {
+            componentSet.sourceApiVersion = sourceApiVersion;
+        }
         const [nonDeletes, deletes] = await Promise.all([
             this.localRepo.getNonDeleteFilenames(),
             this.localRepo.getDeleteFilenames(),
@@ -68,39 +68,59 @@ class SourceTracking extends kit_1.AsyncCreatable {
                 return undefined;
             }
         })
-            .filter(sourceComponentGuard)
+            .filter(guards_1.sourceComponentGuard)
             .map((component) => componentSet.add(component));
         deletes
             .flatMap((filename) => resolverForDeletes.getComponentsFromPath(filename))
-            .filter(sourceComponentGuard)
-            .map((component) => componentSet.add(component, true));
+            .filter(guards_1.sourceComponentGuard)
+            .map((component) => componentSet.add(component, source_deploy_retrieve_1.DestructiveChangesType.POST));
         return componentSet;
     }
+    /**
+     * Does most of the work for the force:source:status command.
+     * Outputs need a bit of massage since this aims to provide nice json.
+     *
+     * @param local you want local status
+     * @param remote you want remote status
+     * @returns StatusOutputRow[]
+     */
+    async getStatus({ local, remote }) {
+        let results = [];
+        if (local) {
+            results = results.concat(await this.getLocalStatusRows());
+        }
+        if (remote) {
+            await this.ensureRemoteTracking(true);
+            const [remoteDeletes, remoteModifies] = await Promise.all([
+                this.getChanges({ origin: 'remote', state: 'delete', format: 'ChangeResult' }),
+                this.getChanges({ origin: 'remote', state: 'nondelete', format: 'ChangeResultWithPaths' }),
+            ]);
+            results = results.concat((await Promise.all(remoteDeletes.concat(remoteModifies).map((item) => this.remoteChangesToOutputRows(item)))).flat(1));
+        }
+        if (local && remote) {
+            // keys like ApexClass__MyClass.cls
+            const conflictFiles = (await this.getConflicts()).flatMap((conflict) => conflict.filenames).filter(guards_1.stringGuard);
+            results = results.map((row) => ({
+                ...row,
+                conflict: !!row.filePath && conflictFiles.includes(row.filePath),
+            }));
+        }
+        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') {
-            let filenames = [];
             await this.ensureLocalTracking();
-            if (options.state === 'modify') {
-                filenames = await this.localRepo.getModifyFilenames();
-            }
-            if (options.state === 'nondelete') {
-                filenames = await this.localRepo.getNonDeleteFilenames();
-            }
-            if (options.state === 'delete') {
-                filenames = await this.localRepo.getDeleteFilenames();
-            }
-            if (options.state === 'add') {
-                filenames = await this.localRepo.getAddFilenames();
-            }
+            const filenames = await this.getLocalChangesAsFilenames(options.state);
             if (options.format === 'string') {
                 return filenames;
             }
-            if (options.format === 'ChangeResult') {
+            if (options.format === 'ChangeResult' || options.format === 'ChangeResultWithPaths') {
                 return filenames.map((filename) => ({
                     filenames: [filename],
                     origin: 'local',
@@ -120,35 +140,25 @@ class SourceTracking extends kit_1.AsyncCreatable {
                         return undefined;
                     }
                 })
-                    .filter(sourceComponentGuard);
+                    .filter(guards_1.sourceComponentGuard);
             }
         }
-        if (options && options.origin === 'remote') {
+        if ((options === null || options === void 0 ? void 0 : options.origin) === 'remote') {
             await this.ensureRemoteTracking();
             const remoteChanges = await this.remoteSourceTrackingService.retrieveUpdates();
             this.logger.debug('remoteChanges', remoteChanges);
-            let filteredChanges = [];
-            if (options.state === 'add') {
-                filteredChanges = remoteChanges.filter((change) => !change.deleted && !change.modified);
-            }
-            else if (options.state === 'modify') {
-                filteredChanges = remoteChanges.filter((change) => change.modified);
-            }
-            else if (options.state === 'delete') {
-                filteredChanges = remoteChanges.filter((change) => change.deleted);
-            }
-            else if (options.state === 'nondelete') {
-                filteredChanges = remoteChanges.filter((change) => !change.deleted);
-            }
+            const filteredChanges = remoteChanges.filter(remoteFilterByState[options.state]);
             if (options.format === 'ChangeResult') {
-                return filteredChanges.map((change) => ({ ...change, origin: 'remote' }));
+                return filteredChanges.map((change) => (0, remoteSourceTrackingService_1.remoteChangeElementToChangeResult)(change));
+            }
+            if (options.format === 'ChangeResultWithPaths') {
+                return this.populateFilePaths(filteredChanges.map((change) => (0, remoteSourceTrackingService_1.remoteChangeElementToChangeResult)(change)));
             }
             // turn it into a componentSet to resolve filenames
-            const remoteChangesAsComponentLike = filteredChanges.map((element) => ({
+            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,
-            }));
-            const remoteChangesAsComponentSet = new source_deploy_retrieve_1.ComponentSet(remoteChangesAsComponentLike);
+            })));
             const matchingLocalSourceComponentsSet = source_deploy_retrieve_1.ComponentSet.fromSource({
                 fsPaths: this.packagesDirs.map((dir) => dir.path),
                 include: remoteChangesAsComponentSet,
@@ -163,10 +173,7 @@ class SourceTracking extends kit_1.AsyncCreatable {
                 return matchingLocalSourceComponentsSet.getSourceComponents().toArray();
             }
         }
-        // by default return all local and remote changes
-        // eslint-disable-next-line no-console
-        this.logger.debug(options);
-        return [];
+        throw new Error(`unsupported options: ${JSON.stringify(options)}`);
     }
     /**
      *
@@ -240,7 +247,7 @@ class SourceTracking extends kit_1.AsyncCreatable {
         if (this.localRepo) {
             return;
         }
-        this.localRepo = await localShadowRepo_1.ShadowRepo.create({
+        this.localRepo = await localShadowRepo_1.ShadowRepo.getInstance({
             orgId: this.orgId,
             projectPath: this.projectPath,
             packageDirs: this.packagesDirs,
@@ -305,20 +312,79 @@ class SourceTracking extends kit_1.AsyncCreatable {
         const resetMembers = await this.remoteSourceTrackingService.reset(serverRevision);
         return resetMembers.length;
     }
+    /**
+     * Compares local and remote changes to detect conflicts
+     */
+    async getConflicts() {
+        // 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
+        // early return if either local or remote is empty
+        const localChanges = await this.getChanges({
+            state: 'nondelete',
+            origin: 'local',
+            format: 'ChangeResult',
+        });
+        if (localChanges.length === 0) {
+            return [];
+        }
+        const remoteChanges = await this.getChanges({
+            origin: 'remote',
+            state: 'nondelete',
+            // remote adds won't have a filename, so we ask for it to be resolved
+            format: 'ChangeResultWithPaths',
+        });
+        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) });
+                    }
+                });
+            }
+        });
+        // deeply de-dupe
+        return Array.from(conflicts);
+    }
     /**
      * uses SDR to translate remote metadata records into local file paths (which only typically have the filename).
      *
      * @input elements: ChangeResult[]
      * @input excludeUnresolvables: 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
      */
-    populateTypesAndNames({ elements, excludeUnresolvable = false, resolveDeleted = false, }) {
+    populateTypesAndNames({ elements, excludeUnresolvable = false, resolveDeleted = false, useFsForceIgnore = true, }) {
         if (elements.length === 0) {
             return [];
         }
         this.logger.debug(`populateTypesAndNames for ${elements.length} change elements`);
-        const filenames = elements.flatMap((element) => element.filenames).filter(exports.stringGuard);
+        const filenames = elements.flatMap((element) => element.filenames).filter(guards_1.stringGuard);
         // component set generated from the filenames on all local changes
-        const resolver = new source_deploy_retrieve_1.MetadataResolver(undefined, resolveDeleted ? (0, filenamesToVirtualTree_1.filenamesToVirtualTree)(filenames) : undefined);
+        const resolver = new source_deploy_retrieve_1.MetadataResolver(undefined, resolveDeleted ? (0, filenamesToVirtualTree_1.filenamesToVirtualTree)(filenames) : undefined, useFsForceIgnore);
         const sourceComponents = filenames
             .flatMap((filename) => {
             try {
@@ -329,7 +395,7 @@ class SourceTracking extends kit_1.AsyncCreatable {
                 return undefined;
             }
         })
-            .filter(sourceComponentGuard);
+            .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();
@@ -341,15 +407,24 @@ class SourceTracking extends kit_1.AsyncCreatable {
         });
         // 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)
+                this.forceIgnore = (_a = this.forceIgnore) !== null && _a !== void 0 ? _a : source_deploy_retrieve_1.ForceIgnore.findAndCreate(this.project.getDefaultPackage().path);
+                const ignored = filenamesFromMatchingComponent
+                    .filter(guards_1.stringGuard)
+                    .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,
                         });
                     }
                 });
@@ -359,35 +434,27 @@ class SourceTracking extends kit_1.AsyncCreatable {
             ? Array.from(new Set(elementMap.values())).filter((changeResult) => changeResult.name && changeResult.type)
             : Array.from(new Set(elementMap.values()));
     }
-    async getConflicts() {
-        // we're going to need have both initialized
-        await Promise.all([this.ensureRemoteTracking(), this.ensureLocalTracking()]);
-        const localChanges = await this.getChanges({
-            state: 'nondelete',
-            origin: 'local',
-            format: 'ChangeResult',
+    async getLocalStatusRows() {
+        await this.ensureLocalTracking();
+        let results = [];
+        const localDeletes = this.populateTypesAndNames({
+            elements: await this.getChanges({ origin: 'local', state: 'delete', format: 'ChangeResult' }),
+            excludeUnresolvable: true,
+            resolveDeleted: true,
+            useFsForceIgnore: false,
         });
-        // remote adds won't have a filename
-        const remoteChanges = this.populateFilePaths(await this.getChanges({ origin: 'remote', state: 'nondelete', format: 'ChangeResult' }));
-        // index them by filename
-        const fileNameIndex = new Map();
-        remoteChanges.map((change) => {
-            var _a;
-            (_a = change.filenames) === null || _a === void 0 ? void 0 : _a.map((filename) => {
-                fileNameIndex.set(filename, change);
-            });
+        const localAdds = this.populateTypesAndNames({
+            elements: await this.getChanges({ origin: 'local', state: 'add', format: 'ChangeResult' }),
+            excludeUnresolvable: true,
+            useFsForceIgnore: false,
         });
-        const conflicts = new Set();
-        localChanges.map((change) => {
-            var _a;
-            (_a = change.filenames) === null || _a === void 0 ? void 0 : _a.map((filename) => {
-                if (fileNameIndex.has(filename)) {
-                    conflicts.add({ ...fileNameIndex.get(filename) });
-                }
-            });
+        const localModifies = this.populateTypesAndNames({
+            elements: await this.getChanges({ origin: 'local', state: 'modify', format: 'ChangeResult' }),
+            excludeUnresolvable: true,
+            useFsForceIgnore: false,
         });
-        // deeply de-dupe
-        return Array.from(conflicts);
+        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;
     }
     /**
      * uses SDR to translate remote metadata records into local file paths
@@ -405,9 +472,11 @@ class SourceTracking extends kit_1.AsyncCreatable {
         const remoteChangesAsComponentSet = new source_deploy_retrieve_1.ComponentSet(remoteChangesAsComponentLike);
         this.logger.debug(` the generated component set has ${remoteChangesAsComponentSet.size.toString()} items`);
         if (remoteChangesAsComponentSet.size < elements.length) {
+            // iterate the elements to see which ones didn't make it into the component set
             throw new Error(`unable to generate complete component set for ${elements
-                .map((element) => `${element.name}(${element.type})`)
-                .join(',')}`);
+                .filter((element) => !remoteChangesAsComponentSet.has({ type: element === null || element === void 0 ? void 0 : element.type, fullName: element === null || element === void 0 ? void 0 : element.name }))
+                .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),
@@ -417,16 +486,17 @@ class SourceTracking extends kit_1.AsyncCreatable {
         // make it simpler to find things later
         const elementMap = new Map();
         elements.map((element) => {
-            elementMap.set((0, exports.getKeyFromObject)(element), 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, exports.getKeyFromStrings)(matchingComponent.type.name, matchingComponent.fullName);
+                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),
                 });
             }
@@ -436,13 +506,80 @@ class SourceTracking extends kit_1.AsyncCreatable {
     ensureRelative(filePath) {
         return path.isAbsolute(filePath) ? path.relative(this.projectPath, filePath) : filePath;
     }
+    async getLocalChangesAsFilenames(state) {
+        if (state === 'modify') {
+            return this.localRepo.getModifyFilenames();
+        }
+        if (state === 'nondelete') {
+            return this.localRepo.getNonDeleteFilenames();
+        }
+        if (state === 'delete') {
+            return this.localRepo.getDeleteFilenames();
+        }
+        if (state === 'add') {
+            return this.localRepo.getAddFilenames();
+        }
+        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,
+        };
+        if (input.filenames) {
+            return input.filenames.map((filename) => ({
+                ...baseObject,
+                filePath: filename,
+                origin: 'local',
+            }));
+        }
+        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
+    // 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);
+        this.forceIgnore = (_a = this.forceIgnore) !== null && _a !== void 0 ? _a : source_deploy_retrieve_1.ForceIgnore.findAndCreate(this.project.getDefaultPackage().path);
+        const baseObject = {
+            type: (_b = input.type) !== null && _b !== void 0 ? _b : '',
+            origin: input.origin,
+            state: stateFromChangeResult(input),
+            fullName: (_c = input.name) !== null && _c !== void 0 ? _c : '',
+        };
+        // it's easy to check ignores if the filePaths exist locally
+        if ((_d = input.filenames) === null || _d === void 0 ? void 0 : _d.length) {
+            return input.filenames.map((filename) => ({
+                ...baseObject,
+                filePath: filename,
+                ignored: this.forceIgnore.denies(filename),
+            }));
+        }
+        // when the file doesn't exist locally, there are no filePaths
+        // So we can't say whether it's ignored or not
+        return [baseObject];
+    }
 }
 exports.SourceTracking = SourceTracking;
-const stringGuard = (input) => {
-    return typeof input === 'string';
+const remoteFilterByState = {
+    add: (change) => !change.deleted && !change.modified,
+    modify: (change) => change.modified === true,
+    delete: (change) => change.deleted === true,
+    nondelete: (change) => !change.deleted,
 };
-exports.stringGuard = stringGuard;
-const sourceComponentGuard = (input) => {
-    return input instanceof source_deploy_retrieve_1.SourceComponent;
+const stateFromChangeResult = (input) => {
+    if (input.deleted) {
+        return 'delete';
+    }
+    if (input.modified) {
+        return 'modify';
+    }
+    return 'add';
 };
 //# sourceMappingURL=sourceTracking.js.map