@salesforce/source-tracking 2.1.1 → 2.2.1

package/CHANGELOG.md

@@ -2,6 +2,36 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+### [2.2.1](https://github.com/forcedotcom/source-tracking/compare/v2.2.0...v2.2.1) (2022-07-05)
+
+### Bug Fixes
+
+- bump core ([#180](https://github.com/forcedotcom/source-tracking/issues/180)) ([bf0c1f7](https://github.com/forcedotcom/source-tracking/commit/bf0c1f71f91701dacd2516914ab2abca33b1d00a))
+
+## [2.2.0](https://github.com/forcedotcom/source-tracking/compare/v2.1.2...v2.2.0) (2022-06-29)
+
+### Features
+
+- event subscription and convenience method for push ([0c2135b](https://github.com/forcedotcom/source-tracking/commit/0c2135ba3076d3d7a3efd1e4d3c41a468e349728))
+- local repo cache breaking for get status, and a generic method ([6645b72](https://github.com/forcedotcom/source-tracking/commit/6645b72c4695a15caca8aa6d3dc158a600fd15de))
+- never track utam ([6e71f03](https://github.com/forcedotcom/source-tracking/commit/6e71f031c27c4e690d8538253b751da13da0b6e3))
+- option to use SDR events ([d86f698](https://github.com/forcedotcom/source-tracking/commit/d86f69896185b68af7e489f6026589957e06f29d))
+- top-level cache config of local cache behavior ([236ac28](https://github.com/forcedotcom/source-tracking/commit/236ac28314b45c42eff83b9ab8003d0c39efbbb0))
+- track based on sdr events ([1238a68](https://github.com/forcedotcom/source-tracking/commit/1238a686f1d2c6091154ac6370c3d3d019c3a7a7))
+
+### Bug Fixes
+
+- async lifecycle subscribe ([75031f3](https://github.com/forcedotcom/source-tracking/commit/75031f3bbe753001a42f7abcfec1415bfb62547e))
+- custom field was not polling correctly (logic error on del\_\_c) ([1ff2341](https://github.com/forcedotcom/source-tracking/commit/1ff23419d737cb2a22bcf070f5b2790b9ef0536d))
+- logic on local ignored ([9667a6e](https://github.com/forcedotcom/source-tracking/commit/9667a6e8b442a6df0a42fd42dde4dfc289928f90))
+- use fixed jsforce autoFetch, restore ut ([0b32d21](https://github.com/forcedotcom/source-tracking/commit/0b32d217013a346ef8826d3820566b7d70dba3c1))
+
+### [2.1.2](https://github.com/forcedotcom/source-tracking/compare/v2.1.1...v2.1.2) (2022-06-23)
+
+### Bug Fixes
+
+- bump core for autofetch ([3567c69](https://github.com/forcedotcom/source-tracking/commit/3567c69dd49444ef757b9699bb676a0a1a25561c))
+
 ### [2.1.1](https://github.com/forcedotcom/source-tracking/compare/v2.1.0...v2.1.1) (2022-06-22)
 
 ### Bug Fixes

package/README.md

@@ -2,8 +2,6 @@
 
 JavaScript library for tracking local and remote Salesforce metadata changes.
 
-**_ UNDER DEVELOPMENT _**
-
 You should use the class named SourceTracking.
 
 Start like this:
@@ -14,7 +12,6 @@ import { SourceTracking } from '@salesforce/source-tracking';
 const tracking = await SourceTracking.create({
   org: this.org, // Org from sfdx-core
   project: this.project, // Project from sfdx-core
-  apiVersion: this.flags.apiversion as string, // can be undefined, will figure it out if you don't allow users to override
 });
 ```
 
@@ -87,26 +84,3 @@ await tracking.updateRemoteTracking(
   false
 );
 ```
-
-## TODO
-
-NUT for tracking file compatibility check logic
-pollSourceMembers should better handle aggregated types. ex:
-
-```txt
-DEBUG Could not find 2 SourceMembers (using ebikes): AuraDefinition__pageTemplate_2_7_3/pageTemplate_2_7_3.cmp-meta.xml,[object Object],CustomObject__Account,[object Object]
-```
-
-### Enhancements
-
-- for updating ST after deploy/retrieve, we need a quick way for those commands to ask, "is this an ST org?" OR a graceful "ifSupported" wrapper for those methods.
-- ensureRemoteTracking could have 2 options in an object
-  1. `ensureQueryHasReturned` which will make sure the query has run at least once
-  2. `forceQuery` will re-query even if the query already ran (cache-buster typically)
-
-### Cleanup
-
-- review commented code
-- review public methods for whether they should be public
-- organize any shared types
-- export top-level stuff

package/lib/index.d.ts

@@ -1,4 +1,4 @@
 export * from './sourceTracking';
 export * from './compatibility';
-export { RemoteSyncInput, ChangeOptionType, ChangeOptions, LocalUpdateOptions, ChangeResult, ConflictError, StatusOutputRow, } from './shared/types';
+export { RemoteSyncInput, ChangeOptionType, ChangeOptions, LocalUpdateOptions, ChangeResult, StatusOutputRow, ConflictResponse, SourceConflictError, } from './shared/types';
 export { getKeyFromObject } from './shared/functions';

package/lib/index.js

@@ -20,9 +20,11 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getKeyFromObject = void 0;
+exports.getKeyFromObject = exports.SourceConflictError = void 0;
 __exportStar(require("./sourceTracking"), exports);
 __exportStar(require("./compatibility"), exports);
+var types_1 = require("./shared/types");
+Object.defineProperty(exports, "SourceConflictError", { enumerable: true, get: function () { return types_1.SourceConflictError; } });
 var functions_1 = require("./shared/functions");
 Object.defineProperty(exports, "getKeyFromObject", { enumerable: true, get: function () { return functions_1.getKeyFromObject; } });
 //# sourceMappingURL=index.js.map

package/lib/shared/conflicts.d.ts

@@ -0,0 +1,16 @@
+import { ComponentSet, ForceIgnore } from '@salesforce/source-deploy-retrieve';
+import { ConflictResponse, ChangeResult } from './types';
+export declare const throwIfConflicts: (conflicts: ConflictResponse[]) => void;
+/**
+ *
+ * @param cs ComponentSet to compare
+ * @param conflicts ChangeResult[] representing conflicts from SourceTracking.getConflicts
+ * @returns ConflictResponse[] de-duped and formatted for json or table display
+ */
+export declare const findConflictsInComponentSet: (cs: ComponentSet, conflicts: ChangeResult[]) => ConflictResponse[];
+export declare const getDedupedConflictsFromChanges: ({ localChanges, remoteChanges, projectPath, forceIgnore, }: {
+    localChanges: ChangeResult[];
+    remoteChanges: ChangeResult[];
+    projectPath: string;
+    forceIgnore: ForceIgnore;
+}) => ChangeResult[];

package/lib/shared/conflicts.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDedupedConflictsFromChanges = exports.findConflictsInComponentSet = exports.throwIfConflicts = void 0;
+/*
+ * Copyright (c) 2020, salesforce.com, inc.
+ * All rights reserved.
+ * Licensed under the BSD 3-Clause license.
+ * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+ */
+const path_1 = require("path");
+const types_1 = require("./types");
+const functions_1 = require("./functions");
+const populateTypesAndNames_1 = require("./populateTypesAndNames");
+const throwIfConflicts = (conflicts) => {
+    if (conflicts.length > 0) {
+        const conflictError = new types_1.SourceConflictError(`${conflicts.length} conflicts detected`, 'SourceConflictError');
+        conflictError.setData(conflicts);
+        throw conflictError;
+    }
+};
+exports.throwIfConflicts = throwIfConflicts;
+/**
+ *
+ * @param cs ComponentSet to compare
+ * @param conflicts ChangeResult[] representing conflicts from SourceTracking.getConflicts
+ * @returns ConflictResponse[] de-duped and formatted for json or table display
+ */
+const findConflictsInComponentSet = (cs, conflicts) => {
+    // map do dedupe by name-type-filename
+    const conflictMap = new Map();
+    conflicts
+        .filter((cr) => cr.name && cr.type && cs.has({ fullName: cr.name, type: cr.type }))
+        .forEach((cr) => {
+        var _a;
+        (_a = cr.filenames) === null || _a === void 0 ? void 0 : _a.forEach((f) => {
+            conflictMap.set(`${cr.name}#${cr.type}#${f}`, {
+                state: 'Conflict',
+                // the following 2 type assertions are valid because of previous filter statement
+                // they can be removed once TS is smarter about filtering
+                fullName: cr.name,
+                type: cr.type,
+                filePath: (0, path_1.resolve)(f),
+            });
+        });
+    });
+    const reformattedConflicts = Array.from(conflictMap.values());
+    return reformattedConflicts;
+};
+exports.findConflictsInComponentSet = findConflictsInComponentSet;
+const getDedupedConflictsFromChanges = ({ localChanges = [], remoteChanges = [], projectPath, forceIgnore, }) => {
+    // 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();
+    (0, populateTypesAndNames_1.populateTypesAndNames)({ elements: localChanges, excludeUnresolvable: true, projectPath, forceIgnore }).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);
+};
+exports.getDedupedConflictsFromChanges = getDedupedConflictsFromChanges;
+//# sourceMappingURL=conflicts.js.map

package/lib/shared/expectedSourceMembers.d.ts

@@ -0,0 +1,2 @@
+import { RemoteSyncInput } from './types';
+export declare const calculateExpectedSourceMembers: (expectedMembers: RemoteSyncInput[]) => Map<string, RemoteSyncInput>;

package/lib/shared/expectedSourceMembers.js

@@ -0,0 +1,76 @@
+"use strict";
+/*
+ * Copyright (c) 2020, salesforce.com, inc.
+ * All rights reserved.
+ * Licensed under the BSD 3-Clause license.
+ * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateExpectedSourceMembers = void 0;
+const source_deploy_retrieve_1 = require("@salesforce/source-deploy-retrieve");
+const metadataKeys_1 = require("./metadataKeys");
+const typesToNoPollFor = [
+    'CustomObject',
+    'EmailFolder',
+    'EmailTemplateFolder',
+    'StandardValueSet',
+    'Portal',
+    'StandardValueSetTranslation',
+    'SharingRules',
+    'SharingCriteriaRule',
+    'GlobalValueSetTranslation',
+    'AssignmentRules',
+    'InstalledPackage',
+];
+const typesNotToPollForIfNamespace = ['CustomLabels', 'CustomMetadata', 'DuplicateRule', 'WebLink'];
+const isEncodedTypeWithPercentSign = (type, filePath) => ['Layout', 'Profile', 'HomePageComponent', 'HomePageLayout', 'MilestoneType'].includes(type) &&
+    Boolean(filePath === null || filePath === void 0 ? void 0 : filePath.includes('%'));
+// aura xml aren't tracked as SourceMembers
+const isSpecialAuraXml = (filePath) => Boolean(filePath &&
+    (filePath.endsWith('.cmp-meta.xml') ||
+        filePath.endsWith('.tokens-meta.xml') ||
+        filePath.endsWith('.evt-meta.xml') ||
+        filePath.endsWith('.app-meta.xml') ||
+        filePath.endsWith('.intf-meta.xml')));
+const calculateExpectedSourceMembers = (expectedMembers) => {
+    const outstandingSourceMembers = new Map();
+    expectedMembers
+        .filter((fileResponse) => {
+        var _a, _b, _c, _d;
+        // unchanged files will never be in the sourceMembers.  Not really sure why SDR returns them.
+        return fileResponse.state !== source_deploy_retrieve_1.ComponentStatus.Unchanged &&
+            // if a listView is the only change inside an object, the object won't have a sourceMember change.  We won't wait for those to be found
+            // we don't know which email folder type might be there, so don't require either
+            // Portal doesn't support source tracking, according to the coverage report
+            !typesToNoPollFor.includes(fileResponse.type) &&
+            // don't wait for standard fields on standard objects
+            !(fileResponse.type === 'CustomField' && !((_a = fileResponse.filePath) === null || _a === void 0 ? void 0 : _a.includes('__c'))) &&
+            // deleted fields
+            !(fileResponse.type === 'CustomField' && ((_b = fileResponse.filePath) === null || _b === void 0 ? void 0 : _b.includes('_del__c'))) &&
+            // built-in report type ReportType__screen_flows_prebuilt_crt
+            !(fileResponse.type === 'ReportType' && ((_c = fileResponse.filePath) === null || _c === void 0 ? void 0 : _c.includes('screen_flows_prebuilt_crt'))) &&
+            // they're settings to mdapi, and FooSettings in sourceMembers
+            !fileResponse.type.includes('Settings') &&
+            // mdapi encodes these, sourceMembers don't have encoding
+            !isEncodedTypeWithPercentSign(fileResponse.type, fileResponse.filePath) &&
+            !(typesNotToPollForIfNamespace.includes(fileResponse.type) && ((_d = fileResponse.filePath) === null || _d === void 0 ? void 0 : _d.includes('__'))) &&
+            // don't wait on workflow children
+            !fileResponse.type.startsWith('Workflow') &&
+            !isSpecialAuraXml(fileResponse.filePath);
+    })
+        .map((member) => {
+        (0, metadataKeys_1.getMetadataKeyFromFileResponse)(member)
+            // remove some individual members known to not work with tracking even when their type does
+            .filter((key) => 
+        // CustomObject could have been re-added by the key generator from one of its fields
+        !key.startsWith('CustomObject') &&
+            key !== 'Profile__Standard' &&
+            key !== 'CustomTab__standard-home' &&
+            key !== 'AssignmentRules__Case' &&
+            key !== 'ListView__CollaborationGroup.All_ChatterGroups')
+            .map((key) => outstandingSourceMembers.set(key, member));
+    });
+    return outstandingSourceMembers;
+};
+exports.calculateExpectedSourceMembers = calculateExpectedSourceMembers;
+//# sourceMappingURL=expectedSourceMembers.js.map

package/lib/shared/functions.d.ts

@@ -3,9 +3,11 @@ import { RemoteChangeElement, ChangeResult } from './types';
 export declare const getMetadataKey: (metadataType: string, metadataName: string) => string;
 export declare const getKeyFromObject: (element: RemoteChangeElement | ChangeResult) => string;
 export declare const isBundle: (cmp: SourceComponent) => boolean;
+export declare const isLwcLocalOnlyTest: (filePath: string) => boolean;
 /**
  * Verify that a filepath starts exactly with a complete parent path
  * ex: '/foo/bar-extra/baz'.startsWith('foo/bar') would be true, but this function understands that they are not in the same folder
  */
 export declare const pathIsInFolder: (filePath: string, folder: string) => boolean;
 export declare const chunkArray: <T>(arr: T[], size: number) => T[][];
+export declare const ensureRelative: (filePath: string, projectPath: string) => string;

package/lib/shared/functions.js

@@ -6,7 +6,7 @@
  * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.chunkArray = exports.pathIsInFolder = exports.isBundle = exports.getKeyFromObject = exports.getMetadataKey = void 0;
+exports.ensureRelative = exports.chunkArray = exports.pathIsInFolder = exports.isLwcLocalOnlyTest = exports.isBundle = exports.getKeyFromObject = exports.getMetadataKey = void 0;
 const path_1 = require("path");
 const ts_types_1 = require("@salesforce/ts-types");
 const getMetadataKey = (metadataType, metadataName) => {
@@ -22,6 +22,8 @@ const getKeyFromObject = (element) => {
 exports.getKeyFromObject = getKeyFromObject;
 const isBundle = (cmp) => { var _a; return ((_a = cmp.type.strategies) === null || _a === void 0 ? void 0 : _a.adapter) === 'bundle'; };
 exports.isBundle = isBundle;
+const isLwcLocalOnlyTest = (filePath) => filePath.includes('__utam__') || filePath.includes('__tests__');
+exports.isLwcLocalOnlyTest = isLwcLocalOnlyTest;
 /**
  * Verify that a filepath starts exactly with a complete parent path
  * ex: '/foo/bar-extra/baz'.startsWith('foo/bar') would be true, but this function understands that they are not in the same folder
@@ -40,4 +42,6 @@ const nonEmptyStringFilter = (value) => {
 // adapted for TS from https://github.com/30-seconds/30-seconds-of-code/blob/master/snippets/chunk.md
 const chunkArray = (arr, size) => Array.from({ length: Math.ceil(arr.length / size) }, (v, i) => arr.slice(i * size, i * size + size));
 exports.chunkArray = chunkArray;
+const ensureRelative = (filePath, projectPath) => (0, path_1.isAbsolute)(filePath) ? (0, path_1.relative)(projectPath, filePath) : filePath;
+exports.ensureRelative = ensureRelative;
 //# sourceMappingURL=functions.js.map

package/lib/shared/localComponentSetArray.d.ts

@@ -0,0 +1,15 @@
+import { NamedPackageDir } from '@salesforce/core';
+import { ComponentSet } from '@salesforce/source-deploy-retrieve';
+interface GroupedFileInput {
+    packageDirs: NamedPackageDir[];
+    nonDeletes: string[];
+    deletes: string[];
+}
+interface GroupedFile {
+    path: string;
+    nonDeletes: string[];
+    deletes: string[];
+}
+export declare const getGroupedFiles: (input: GroupedFileInput, byPackageDir?: boolean) => GroupedFile[];
+export declare const getComponentSets: (groupings: GroupedFile[], sourceApiVersion?: string) => ComponentSet[];
+export {};

package/lib/shared/localComponentSetArray.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getComponentSets = exports.getGroupedFiles = void 0;
+/*
+ * Copyright (c) 2020, salesforce.com, inc.
+ * All rights reserved.
+ * Licensed under the BSD 3-Clause license.
+ * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+ */
+const fs = require("fs");
+const path_1 = require("path");
+const core_1 = require("@salesforce/core");
+const source_deploy_retrieve_1 = require("@salesforce/source-deploy-retrieve");
+const guards_1 = require("./guards");
+const functions_1 = require("./functions");
+const getGroupedFiles = (input, byPackageDir = false) => {
+    return (byPackageDir ? getSequential(input) : getNonSequential(input)).filter((group) => group.deletes.length || group.nonDeletes.length);
+};
+exports.getGroupedFiles = getGroupedFiles;
+const getSequential = ({ packageDirs, nonDeletes, deletes }) => packageDirs.map((pkgDir) => ({
+    path: pkgDir.name,
+    nonDeletes: nonDeletes.filter((f) => (0, functions_1.pathIsInFolder)(f, pkgDir.name)),
+    deletes: deletes.filter((f) => (0, functions_1.pathIsInFolder)(f, pkgDir.name)),
+}));
+const getNonSequential = ({ packageDirs, nonDeletes: nonDeletes, deletes: deletes, }) => [
+    {
+        nonDeletes,
+        deletes,
+        path: packageDirs.map((dir) => dir.name).join(';'),
+    },
+];
+const getComponentSets = (groupings, sourceApiVersion) => {
+    const logger = core_1.Logger.childFromRoot('localComponentSetArray');
+    // optimistic resolution...some files may not be possible to resolve
+    const resolverForNonDeletes = new source_deploy_retrieve_1.MetadataResolver();
+    return groupings
+        .map((grouping) => {
+        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;
+        }
+        // we need virtual components for the deletes.
+        // TODO: could we use the same for the non-deletes?
+        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) {
+                    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) {
+                logger.warn(`unable to resolve ${filename}`);
+                return undefined;
+            }
+        })
+            .filter(guards_1.sourceComponentGuard)
+            .map((component) => componentSet.add(component));
+        return componentSet;
+    })
+        .filter((componentSet) => componentSet.size > 0);
+};
+exports.getComponentSets = getComponentSets;
+//# sourceMappingURL=localComponentSetArray.js.map

package/lib/shared/localShadowRepo.js

@@ -97,7 +97,7 @@ class ShadowRepo {
                 // no hidden files
                 !f.includes(`${path.sep}.`) &&
                     // no lwc tests
-                    !f.includes('__tests__') &&
+                    !(0, functions_1.isLwcLocalOnlyTest)(f) &&
                     // no gitignore files
                     !f.endsWith('.gitignore') &&
                     // isogit uses `startsWith` for filepaths so it's possible to get a false positive

package/lib/shared/metadataKeys.d.ts

@@ -1,3 +1,4 @@
 import { RemoteSyncInput } from './types';
 export declare const getMetadataKeyFromFileResponse: (fileResponse: RemoteSyncInput) => string[];
 export declare const mappingsForSourceMemberTypesToMetadataType: Map<string, string>;
+export declare const registrySupportsType: (type: string) => boolean;

package/lib/shared/metadataKeys.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mappingsForSourceMemberTypesToMetadataType = exports.getMetadataKeyFromFileResponse = void 0;
+exports.registrySupportsType = exports.mappingsForSourceMemberTypesToMetadataType = exports.getMetadataKeyFromFileResponse = void 0;
 /*
  * Copyright (c) 2020, salesforce.com, inc.
  * All rights reserved.
@@ -9,6 +9,7 @@ exports.mappingsForSourceMemberTypesToMetadataType = exports.getMetadataKeyFromF
  */
 const path_1 = require("path");
 const source_deploy_retrieve_1 = require("@salesforce/source-deploy-retrieve");
+const core_1 = require("@salesforce/core");
 const functions_1 = require("./functions");
 // See UT for examples of the complexity this must handle
 // keys always use forward slashes, even on Windows
@@ -69,4 +70,19 @@ exports.mappingsForSourceMemberTypesToMetadataType = new Map([
     ['AuraDefinition', 'AuraDefinitionBundle'],
     ['LightningComponentResource', 'LightningComponentBundle'],
 ]);
+const registrySupportsType = (type) => {
+    try {
+        if (exports.mappingsForSourceMemberTypesToMetadataType.has(type)) {
+            return true;
+        }
+        // this must use getTypeByName because findType doesn't support addressable child types (ex: customField!)
+        registry.getTypeByName(type);
+        return true;
+    }
+    catch (e) {
+        void core_1.Lifecycle.getInstance().emitWarning(`Unable to find type ${type} in registry`);
+        return false;
+    }
+};
+exports.registrySupportsType = registrySupportsType;
 //# sourceMappingURL=metadataKeys.js.map

package/lib/shared/populateFilePaths.d.ts

@@ -0,0 +1,9 @@
+import { ChangeResult } from './types';
+/**
+ * Will build a component set, crawling your local directory, to get paths for remote changes
+ *
+ * @param elements ChangeResults that may or may not have filepaths in their filenames parameters
+ * @param packageDirPaths Array of paths from PackageDirectories
+ * @returns
+ */
+export declare const populateFilePaths: (elements: ChangeResult[], packageDirPaths: string[]) => ChangeResult[];

package/lib/shared/populateFilePaths.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.populateFilePaths = void 0;
+/*
+ * Copyright (c) 2020, salesforce.com, inc.
+ * All rights reserved.
+ * Licensed under the BSD 3-Clause license.
+ * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+ */
+const os_1 = require("os");
+const core_1 = require("@salesforce/core");
+const source_deploy_retrieve_1 = require("@salesforce/source-deploy-retrieve");
+const guards_1 = require("./guards");
+const functions_1 = require("./functions");
+const logger = core_1.Logger.childFromRoot('SourceTracking.PopulateFilePaths');
+/**
+ * Will build a component set, crawling your local directory, to get paths for remote changes
+ *
+ * @param elements ChangeResults that may or may not have filepaths in their filenames parameters
+ * @param packageDirPaths Array of paths from PackageDirectories
+ * @returns
+ */
+const populateFilePaths = (elements, packageDirPaths) => {
+    if (elements.length === 0) {
+        return [];
+    }
+    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);
+    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: packageDirPaths,
+        include: remoteChangesAsComponentSet,
+    });
+    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((e) => [(0, functions_1.getKeyFromObject)(e), e]));
+    // iterates the local components and sets their filenames
+    for (const matchingComponent of matchingLocalSourceComponentsSet.getSourceComponents().toArray()) {
+        if (matchingComponent.fullName && matchingComponent.type.name) {
+            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());
+};
+exports.populateFilePaths = populateFilePaths;
+//# sourceMappingURL=populateFilePaths.js.map

package/lib/shared/populateTypesAndNames.d.ts

@@ -0,0 +1,18 @@
+import { ForceIgnore } from '@salesforce/source-deploy-retrieve';
+import { ChangeResult } from './types';
+/**
+ * uses SDR to translate remote metadata records into local file paths (which only typically have the filename).
+ *
+ * @input elements: ChangeResult[]
+ * @input projectPath
+ * @input forceIgnore: ForceIgnore.  If provided, result will indicate whether the file is ignored
+ * @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
+ */
+export declare const populateTypesAndNames: ({ elements, projectPath, forceIgnore, excludeUnresolvable, resolveDeleted, }: {
+    elements: ChangeResult[];
+    projectPath: string;
+    forceIgnore?: ForceIgnore | undefined;
+    excludeUnresolvable?: boolean | undefined;
+    resolveDeleted?: boolean | undefined;
+}) => ChangeResult[];