@salesforce/source-tracking 2.1.2 → 2.2.2

package/lib/shared/populateTypesAndNames.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.populateTypesAndNames = 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 core_1 = require("@salesforce/core");
+const ts_types_1 = require("@salesforce/ts-types");
+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.PopulateTypesAndNames');
+/**
+ * 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
+ */
+const populateTypesAndNames = ({ elements, projectPath, forceIgnore, excludeUnresolvable = false, resolveDeleted = false, }) => {
+    if (elements.length === 0) {
+        return [];
+    }
+    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, !!forceIgnore);
+    const sourceComponents = filenames
+        .flatMap((filename) => {
+        try {
+            return resolver.getComponentsFromPath(filename);
+        }
+        catch (e) {
+            logger.warn(`unable to resolve ${filename}`);
+            return undefined;
+        }
+    })
+        .filter(guards_1.sourceComponentGuard);
+    logger.debug(` matching SourceComponents have ${sourceComponents.length} items from local`);
+    // make it simpler to find things later
+    const elementMap = new Map();
+    elements.map((element) => {
+        element.filenames?.map((filename) => {
+            elementMap.set((0, functions_1.ensureRelative)(filename, projectPath), element);
+        });
+    });
+    // iterates the local components and sets their filenames
+    sourceComponents.map((matchingComponent) => {
+        if (matchingComponent?.fullName && matchingComponent?.type.name) {
+            const filenamesFromMatchingComponent = [matchingComponent.xml, ...matchingComponent.walkContent()];
+            const ignored = filenamesFromMatchingComponent
+                .filter(ts_types_1.isString)
+                .filter((f) => !(0, functions_1.isLwcLocalOnlyTest)(f))
+                .some((f) => forceIgnore?.denies(f));
+            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,
+                    });
+                }
+            });
+        }
+    });
+    return excludeUnresolvable
+        ? Array.from(new Set(elementMap.values())).filter((changeResult) => changeResult.name && changeResult.type)
+        : Array.from(new Set(elementMap.values()));
+};
+exports.populateTypesAndNames = populateTypesAndNames;
+//# sourceMappingURL=populateTypesAndNames.js.map

package/lib/shared/remoteSourceTrackingService.d.ts

@@ -128,11 +128,6 @@ export declare class RemoteSourceTrackingService extends ConfigFile<RemoteSource
      * @param pollingTimeout maximum amount of time in seconds to poll for SourceMembers
      */
     pollForSourceTracking(expectedMembers: RemoteSyncInput[]): Promise<void>;
-    /**
-     * Filter out known source tracking issues
-     * This prevents the polling from waiting on things that may never return
-     */
-    private calculateExpectedSourceMembers;
     private calculateTimeout;
     private querySourceMembersFrom;
     private querySourceMembersTo;

package/lib/shared/remoteSourceTrackingService.js

@@ -7,23 +7,22 @@
  */
 /* eslint-disable no-underscore-dangle */
 /* eslint-disable @typescript-eslint/member-ordering */
-var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.remoteChangeElementToChangeResult = exports.RemoteSourceTrackingService = void 0;
 const path = require("path");
 const fs = require("fs");
 const ts_retry_promise_1 = require("ts-retry-promise");
 const core_1 = require("@salesforce/core");
-const source_deploy_retrieve_1 = require("@salesforce/source-deploy-retrieve");
 const kit_1 = require("@salesforce/kit");
 const metadataKeys_1 = require("./metadataKeys");
 const functions_1 = require("./functions");
+const expectedSourceMembers_1 = require("./expectedSourceMembers");
 /*
  * after some results have returned, how many times should we poll for missing sourcemembers
  * even when there is a longer timeout remaining (because the deployment is very large)
  */
 const POLLING_DELAY_MS = 1000;
-const CONSECUTIVE_EMPTY_POLLING_RESULT_LIMIT = ((_a = kit_1.env.getNumber('SFDX_SOURCE_MEMBER_POLLING_TIMEOUT')) !== null && _a !== void 0 ? _a : 120) / kit_1.Duration.milliseconds(POLLING_DELAY_MS).seconds;
+const CONSECUTIVE_EMPTY_POLLING_RESULT_LIMIT = (kit_1.env.getNumber('SFDX_SOURCE_MEMBER_POLLING_TIMEOUT') ?? 120) / kit_1.Duration.milliseconds(POLLING_DELAY_MS).seconds;
 /**
  * This service handles source tracking of metadata between a local project and an org.
  * Source tracking state is persisted to .sfdx/orgs/<orgId>/maxRevision.json.
@@ -264,11 +263,10 @@ class RemoteSourceTrackingService extends core_1.ConfigFile {
         }
         let serverMaxRevisionCounter = this.getServerMaxRevision();
         sourceMembers.forEach((change) => {
-            var _a;
             // try accessing the sourceMembers object at the index of the change's name
             // if it exists, we'll update the fields - if it doesn't, we'll create and insert it
             const key = (0, functions_1.getMetadataKey)(change.MemberType, change.MemberName);
-            const sourceMember = (_a = this.getSourceMember(key)) !== null && _a !== void 0 ? _a : {
+            const sourceMember = this.getSourceMember(key) ?? {
                 serverRevisionCounter: change.RevisionCounter,
                 lastRetrievedFromServer: null,
                 memberType: change.MemberType,
@@ -282,8 +280,8 @@ class RemoteSourceTrackingService extends core_1.ConfigFile {
                 sourceMember.serverRevisionCounter = change.RevisionCounter;
                 sourceMember.isNameObsolete = change.IsNameObsolete;
             }
-            // We are not yet tracking it so we'll insert a new record
             else if (!quiet) {
+                // We are not yet tracking it so we'll insert a new record
                 this.logger.debug(`Inserting ${key} with RevisionCounter: ${change.RevisionCounter}${sync ? ' and syncing' : ''}`);
             }
             // If we are syncing changes then we need to update the lastRetrievedFromServer field to
@@ -349,7 +347,7 @@ class RemoteSourceTrackingService extends core_1.ConfigFile {
             this.logger.warn('Not polling for SourceMembers since SFDX_DISABLE_SOURCE_MEMBER_POLLING = true.');
             return;
         }
-        const outstandingSourceMembers = this.calculateExpectedSourceMembers(expectedMembers);
+        const outstandingSourceMembers = (0, expectedSourceMembers_1.calculateExpectedSourceMembers)(expectedMembers);
         if (expectedMembers.length === 0 || outstandingSourceMembers.size === 0) {
             // Don't bother polling if we're not matching SourceMembers
             return;
@@ -431,78 +429,8 @@ class RemoteSourceTrackingService extends core_1.ConfigFile {
             });
         }
     }
-    /**
-     * Filter out known source tracking issues
-     * This prevents the polling from waiting on things that may never return
-     */
-    // eslint-disable-next-line class-methods-use-this
-    calculateExpectedSourceMembers(expectedMembers) {
-        const outstandingSourceMembers = new Map();
-        expectedMembers
-            .filter(
-        // eslint-disable-next-line complexity
-        (fileResponse) => {
-            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
-            // 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
-                ![
-                    'CustomObject',
-                    'EmailFolder',
-                    'EmailTemplateFolder',
-                    'StandardValueSet',
-                    'Portal',
-                    'StandardValueSetTranslation',
-                    'SharingRules',
-                    'SharingCriteriaRule',
-                    'GlobalValueSetTranslation',
-                    'AssignmentRules',
-                ].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
-                !((fileResponse.type === 'Layout' ||
-                    fileResponse.type === 'BusinessProcess' ||
-                    fileResponse.type === 'Profile' ||
-                    fileResponse.type === 'HomePageComponent' ||
-                    fileResponse.type === 'HomePageLayout') &&
-                    ((_d = fileResponse.filePath) === null || _d === void 0 ? void 0 : _d.includes('%'))) &&
-                // namespaced labels and CMDT don't resolve correctly
-                !(['CustomLabels', 'CustomMetadata'].includes(fileResponse.type) && ((_e = fileResponse.filePath) === null || _e === void 0 ? void 0 : _e.includes('__'))) &&
-                // don't wait on workflow children
-                !fileResponse.type.startsWith('Workflow') &&
-                // aura xml aren't tracked as SourceMembers
-                !((_f = fileResponse.filePath) === null || _f === void 0 ? void 0 : _f.endsWith('.cmp-meta.xml')) &&
-                !((_g = fileResponse.filePath) === null || _g === void 0 ? void 0 : _g.endsWith('.tokens-meta.xml')) &&
-                !((_h = fileResponse.filePath) === null || _h === void 0 ? void 0 : _h.endsWith('.evt-meta.xml')) &&
-                !((_j = fileResponse.filePath) === null || _j === void 0 ? void 0 : _j.endsWith('.app-meta.xml')) &&
-                !((_k = fileResponse.filePath) === null || _k === void 0 ? void 0 : _k.endsWith('.intf-meta.xml'));
-        })
-            .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;
-    }
     calculateTimeout(memberCount) {
-        var _a;
-        const overriddenTimeout = (_a = kit_1.env.getNumber('SFDX_SOURCE_MEMBER_POLLING_TIMEOUT', 0)) !== null && _a !== void 0 ? _a : 0;
+        const overriddenTimeout = kit_1.env.getNumber('SFDX_SOURCE_MEMBER_POLLING_TIMEOUT', 0) ?? 0;
         if (overriddenTimeout > 0) {
             this.logger.debug(`Overriding SourceMember polling timeout to ${overriddenTimeout}`);
             return kit_1.Duration.seconds(overriddenTimeout);

package/lib/shared/types.d.ts

@@ -1,4 +1,5 @@
 import { FileResponse, SourceComponent } from '@salesforce/source-deploy-retrieve';
+import { SfError } from '@salesforce/core';
 export interface ChangeOptions {
     origin: 'local' | 'remote';
     state: 'add' | 'delete' | 'modify' | 'nondelete';
@@ -40,9 +41,16 @@ export declare type SourceMember = {
     RevisionCounter: number;
     ignored?: boolean;
 };
-export interface ConflictError {
-    message: string;
-    name: 'conflict';
-    conflicts: ChangeResult[];
+export interface ConflictResponse {
+    state: 'Conflict';
+    fullName: string;
+    type: string;
+    filePath: string;
+}
+export interface SourceConflictError extends SfError {
+    name: 'SourceConflictError';
+    data: ConflictResponse[];
+}
+export declare class SourceConflictError extends SfError implements SourceConflictError {
 }
 export declare type ChangeOptionType = ChangeResult | SourceComponent | string;

package/lib/shared/types.js

@@ -6,4 +6,9 @@
  * 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.SourceConflictError = void 0;
+const core_1 = require("@salesforce/core");
+class SourceConflictError extends core_1.SfError {
+}
+exports.SourceConflictError = SourceConflictError;
 //# sourceMappingURL=types.js.map

package/lib/sourceTracking.d.ts

@@ -1,11 +1,28 @@
 import { Org, SfProject } from '@salesforce/core';
 import { AsyncCreatable } from '@salesforce/kit';
-import { ComponentSet, SourceComponent, FileResponse } from '@salesforce/source-deploy-retrieve';
-import { RemoteSyncInput, StatusOutputRow, ChangeOptions, ChangeResult, ChangeOptionType, LocalUpdateOptions } from './shared/types';
+import { ComponentSet, SourceComponent, FileResponse, DeployResult, RetrieveResult } from '@salesforce/source-deploy-retrieve';
+import { RemoteSyncInput, StatusOutputRow, ChangeOptions, ChangeResult, LocalUpdateOptions } from './shared/types';
 export interface SourceTrackingOptions {
     org: Org;
     project: SfProject;
+    /** listen for the SDR scoped<Pre|Post><Deploy|Retrieve> events
+     * `pre` events will check for conflicts and throw if there are any (use ignoreConflicts: true to disable)
+     * `post` events will update tracking files with the results of the deploy/retrieve
+     */
+    subscribeSDREvents?: boolean;
+    /** don't check for conflicts when responding to SDR events.
+     * This property has no effect unless you also set subscribeSDREvents to true.
+     */
+    ignoreConflicts?: boolean;
+    /** SourceTracking is caching local file statuses.
+     * If you're using STL as part of a long running process (ex: vscode extensions), set this to false
+     */
+    ignoreLocalCache?: boolean;
 }
+declare type RemoteChangesResults = {
+    componentSetFromNonDeletes: ComponentSet;
+    fileResponsesFromDelete: FileResponse[];
+};
 /**
  * Manages source tracking files (remote and local)
  *
@@ -18,16 +35,21 @@ export declare class SourceTracking extends AsyncCreatable {
     private projectPath;
     private packagesDirs;
     private logger;
-    private registry;
     private localRepo;
     private remoteSourceTrackingService;
     private forceIgnore;
     private hasSfdxTrackingFiles;
+    private ignoreConflicts;
+    private subscribeSDREvents;
+    private ignoreLocalCache;
+    private orgId;
     constructor(options: SourceTrackingOptions);
     init(): Promise<void>;
     /**
      *
-     * @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[]
      */
     localChangesAsComponentSet(byPackageDir?: boolean): Promise<ComponentSet[]>;
@@ -50,7 +72,48 @@ export declare class SourceTracking extends AsyncCreatable {
      * @returns local and remote changed metadata
      *
      */
-    getChanges<T extends ChangeOptionType>(options?: ChangeOptions): Promise<T[]>;
+    getChanges(options: ChangeOptions & {
+        format: 'string';
+    }): Promise<string[]>;
+    getChanges(options: ChangeOptions & {
+        format: 'SourceComponent';
+    }): Promise<SourceComponent[]>;
+    getChanges(options: ChangeOptions & {
+        format: 'ChangeResult';
+    }): Promise<ChangeResult[]>;
+    /**
+     * @deprecated omit the type parameter <string>.
+     */
+    getChanges<T extends string>(options: ChangeOptions & {
+        format: 'string';
+    }): Promise<T[]>;
+    /**
+     * @deprecated omit the type parameter <SourceComponent>.
+     */
+    getChanges<T extends SourceComponent>(options: ChangeOptions & {
+        format: 'SourceComponent';
+    }): Promise<T[]>;
+    /**
+     * @deprecated omit the type parameter <ChangeResult>.
+     */
+    getChanges<T extends ChangeResult>(options: ChangeOptions & {
+        format: 'ChangeResult';
+    }): Promise<T[]>;
+    getChanges(options: ChangeOptions & {
+        format: 'ChangeResultWithPaths';
+    }): Promise<Array<ChangeResult & {
+        filename: string[];
+    }>>;
+    /**
+     *
+     * Convenience method to reduce duplicated steps required to do a fka pull
+     * It's full of side effects: retrieving remote deletes, deleting those files locall, and then updating tracking files
+     * Most bizarrely, it then returns a ComponentSet of the remote nonDeletes and the FileResponses from the delete
+     *
+     * @returns the ComponentSet for what you would retrieve now that the deletes are done, and optionally, a FileResponses array for the deleted files
+     */
+    maybeApplyRemoteDeletesToLocal(returnDeleteFileResponses: true): Promise<RemoteChangesResults>;
+    maybeApplyRemoteDeletesToLocal(returnDeleteFileResponses?: false): Promise<ComponentSet>;
     /**
      *
      * returns immediately if there are no changesToDelete
@@ -69,9 +132,10 @@ export declare class SourceTracking extends AsyncCreatable {
      * Optionall skip polling for the SourceMembers to exist on the server and be updated in local files
      */
     updateRemoteTracking(fileResponses: RemoteSyncInput[], skipPolling?: boolean): Promise<void>;
+    reReadLocalTrackingCache(): Promise<void>;
     /**
      * 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
      */
     ensureLocalTracking(): Promise<void>;
@@ -103,22 +167,28 @@ export declare class SourceTracking extends AsyncCreatable {
      */
     getConflicts(): Promise<ChangeResult[]>;
     /**
-     * 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[]
      */
-    private populateTypesAndNames;
-    private getLocalStatusRows;
-    private registrySupportsType;
+    updateTrackingFromDeploy(deployResult: DeployResult): Promise<void>;
     /**
-     * uses SDR to translate remote metadata records into local file paths
+     * handles both remote and local tracking
+     *
+     * @param result FileResponse[]
      */
-    private populateFilePaths;
-    private ensureRelative;
+    updateTrackingFromRetrieve(retrieveResult: RetrieveResult): Promise<void>;
+    /**
+     * 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: boolean): void;
+    private maybeSubscribeLifecycleEvents;
+    private getLocalStatusRows;
     private getLocalChangesAsFilenames;
     private localChangesToOutputRow;
     private remoteChangesToOutputRows;
 }
+export {};