@salesforce/source-tracking 7.1.25 → 7.2.1

package/lib/shared/{remoteSourceTrackingService.js → remote/remoteSourceTrackingService.js}

@@ -9,7 +9,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.querySourceMembersTo = exports.calculateTimeout = exports.remoteChangeElementToChangeResult = exports.RemoteSourceTrackingService = void 0;
+exports.remoteChangeElementToChangeResult = exports.RemoteSourceTrackingService = void 0;
 const node_path_1 = __importDefault(require("node:path"));
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_os_1 = require("node:os");
@@ -17,10 +17,11 @@ const ts_retry_promise_1 = require("ts-retry-promise");
 const core_1 = require("@salesforce/core");
 const kit_1 = require("@salesforce/kit");
 const ts_types_1 = require("@salesforce/ts-types");
-const metadataKeys_1 = require("./metadataKeys");
-const functions_1 = require("./functions");
+const metadataKeys_1 = require("../metadataKeys");
+const functions_1 = require("../functions");
 const expectedSourceMembers_1 = require("./expectedSourceMembers");
-const FILENAME = 'maxRevision.json';
+const fileOperations_1 = require("./fileOperations");
+const orgQueries_1 = require("./orgQueries");
 /*
  * 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)
@@ -31,37 +32,37 @@ const CONSECUTIVE_EMPTY_POLLING_RESULT_LIMIT = (core_1.envVars.getNumber('SF_SOU
  * 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.
  * This JSON file keeps track of `SourceMember` objects and the `serverMaxRevisionCounter`,
- * which is the highest `serverRevisionCounter` value of all the tracked elements.
+ * which is the highest `RevisionCounter` value of all the tracked elements.
  *
- * Each SourceMember object has 4 fields:
- * * serverRevisionCounter: the current RevisionCounter on the server for this object
- * * lastRetrievedFromServer: the RevisionCounter last retrieved from the server for this object
- * * memberType: the metadata name of the SourceMember
- * * isNameObsolete: `true` if this object has been deleted in the org
- *
- * ex.
+ * See @MemberRevision for the structure of the `MemberRevision` object.  It's SourceMember (the tooling sobject) with the additional lastRetrievedFromServer field
  ```
  {
+    fileVersion: 1,
     serverMaxRevisionCounter: 3,
     sourceMembers: {
-      ApexClass__MyClass: {
-        serverRevisionCounter: 3,
+      ApexClass###MyClass: {
+        RevisionCounter: 3,
+        MemberType: ApexClass,
+        ...,
         lastRetrievedFromServer: 2,
-        memberType: ApexClass,
-        isNameObsolete: false
       },
-      CustomObject__Student__c: {
-        serverRevisionCounter: 1,
+      CustomObject###Student__c: {
+        RevisionCounter: 1,
+        MemberType: CustomObject,
+        ...,
         lastRetrievedFromServer: 1,
-        memberType: CustomObject,
-        isNameObsolete: false
       }
     }
   }
   ```
- * In this example, `ApexClass__MyClass` has been changed in the org because the `serverRevisionCounter` is different
+ * In this example, `ApexClass###MyClass` has been changed in the org because the `serverRevisionCounter` is different
  * from the `lastRetrievedFromServer`. When a pull is performed, all of the pulled members will have their counters set
  * to the corresponding `RevisionCounter` from the `SourceMember` of the org.
+ *
+ * Tracking files are written to the older format described in `MemberRevisionLegacy`
+ * if the environment variable CURRENT_FILE_VERSION_ENV is not set to 1
+ *
+ * The "in memorgy" storage is in MemberRevision format.
  */
 class RemoteSourceTrackingService {
     /** map of constructed, init'ed instances; key is orgId.  It's like a singleton at the org level */
@@ -74,13 +75,14 @@ class RemoteSourceTrackingService {
     // A short term cache (within the same process) of query results based on a revision.
     // Useful for source:pull, which makes 3 of the same queries; during status, building manifests, after pull success.
     queryCache = new Map();
+    userQueryCache = new Map();
     /**
      * Initializes the service with existing remote source tracking data, or sets
      * the state to begin source tracking of metadata changes in the org.
      */
     constructor(options) {
         this.org = options.org;
-        this.filePath = node_path_1.default.join(options.projectPath, '.sf', 'orgs', this.org.getOrgId(), FILENAME);
+        this.filePath = node_path_1.default.join(options.projectPath, '.sf', 'orgs', this.org.getOrgId(), fileOperations_1.FILENAME);
     }
     /**
      * Get the singleton instance for a given user.
@@ -104,7 +106,7 @@ class RemoteSourceTrackingService {
      * @returns the path of the deleted source tracking file
      */
     static async delete(orgId) {
-        const fileToDelete = getFilePath(orgId);
+        const fileToDelete = (0, fileOperations_1.getFilePath)(orgId);
         // the file might not exist, in which case we don't need to delete it
         if (node_fs_1.default.existsSync(fileToDelete)) {
             await node_fs_1.default.promises.unlink(fileToDelete);
@@ -112,7 +114,7 @@ class RemoteSourceTrackingService {
         return node_path_1.default.isAbsolute(fileToDelete) ? fileToDelete : node_path_1.default.join(process.cwd(), fileToDelete);
     }
     /**
-     * pass in a set of metadata keys (type__name like 'ApexClass__MyClass').\
+     * pass in a series of SDR FilResponses .\
      * it sets their last retrieved revision to the current revision counter from the server.
      */
     async syncSpecifiedElements(elements) {
@@ -130,11 +132,18 @@ class RemoteSourceTrackingService {
                 this.logger.warn(`found no matching revision for ${metadataKey}`);
             }
             else if (doesNotMatchServer(revision)) {
-                quietLogger(`Syncing ${metadataKey} revision from ${revision.lastRetrievedFromServer ?? 'null'} to ${revision.serverRevisionCounter}`);
-                this.setMemberRevision(metadataKey, { ...revision, lastRetrievedFromServer: revision.serverRevisionCounter });
+                quietLogger(`Syncing ${metadataKey} revision from ${revision.lastRetrievedFromServer ?? 'null'} to ${revision.RevisionCounter}`);
+                this.setMemberRevision(metadataKey, {
+                    ...revision,
+                    lastRetrievedFromServer: revision.RevisionCounter,
+                });
             }
         });
-        await this.write();
+        await (0, fileOperations_1.writeTrackingFile)({
+            filePath: this.filePath,
+            maxCounter: this.serverMaxRevisionCounter,
+            members: this.sourceMembers,
+        });
     }
     /**
      * Resets source tracking state by first clearing all tracked data, then
@@ -152,8 +161,14 @@ class RemoteSourceTrackingService {
         this.serverMaxRevisionCounter = 0;
         this.sourceMembers = new Map();
         const members = toRevision !== undefined && toRevision !== null
-            ? await (0, exports.querySourceMembersTo)(this.org.getConnection(), toRevision)
-            : await this.querySourceMembersFrom({ fromRevision: 0 });
+            ? await (0, orgQueries_1.querySourceMembersTo)(this.org.getConnection(), toRevision)
+            : await (0, orgQueries_1.querySourceMembersFrom)({
+                fromRevision: 0,
+                logger: this.logger,
+                userQueryCache: this.userQueryCache,
+                queryCache: this.queryCache,
+                conn: this.org.getConnection(),
+            });
         await this.trackSourceMembers(members, true);
         return members.map((member) => (0, functions_1.getMetadataKey)(member.MemberType, member.MemberName));
     }
@@ -166,17 +181,21 @@ class RemoteSourceTrackingService {
     // to sync the retrieved SourceMembers; meaning it will update the lastRetrievedFromServer
     // field to the SourceMember's RevisionCounter, and update the serverMaxRevisionCounter
     // to the highest RevisionCounter.
-    async retrieveUpdates({ sync = false, cache = true } = {}) {
+    async retrieveUpdates() {
         // Always track new SourceMember data, or update tracking when we sync.
-        const queriedSourceMembers = await this.querySourceMembersFrom({ useCache: cache });
-        if (queriedSourceMembers.length || sync) {
-            await this.trackSourceMembers(queriedSourceMembers, sync);
-        }
+        const queriedSourceMembers = await (0, orgQueries_1.querySourceMembersFrom)({
+            fromRevision: this.serverMaxRevisionCounter,
+            logger: this.logger,
+            userQueryCache: this.userQueryCache,
+            queryCache: this.queryCache,
+            conn: this.org.getConnection(),
+        });
+        await this.trackSourceMembers(queriedSourceMembers);
         // Look for any changed that haven't been synced.  I.e, the lastRetrievedFromServer
         // does not match the serverRevisionCounter.
-        const returnElements = Array.from(this.sourceMembers.entries())
-            .filter(revisionDoesNotMatch)
-            .map(revisionToRemoteChangeElement);
+        const returnElements = Array.from(this.sourceMembers.values())
+            .filter(doesNotMatchServer)
+            .map(fileOperations_1.revisionToRemoteChangeElement);
         this.logger.debug(returnElements.length
             ? `Found ${returnElements.length} elements not synced with org`
             : 'Remote source tracking is up to date');
@@ -192,8 +211,7 @@ class RemoteSourceTrackingService {
      */
     async pollForSourceTracking(expectedMembers) {
         if (core_1.envVars.getBoolean('SF_DISABLE_SOURCE_MEMBER_POLLING')) {
-            this.logger.warn('Not polling for SourceMembers since SF_DISABLE_SOURCE_MEMBER_POLLING = true.');
-            return;
+            return this.logger.warn('Not polling for SourceMembers since SF_DISABLE_SOURCE_MEMBER_POLLING = true.');
         }
         if (expectedMembers.length === 0) {
             return;
@@ -202,7 +220,7 @@ class RemoteSourceTrackingService {
         const originalOutstandingSize = outstandingSourceMembers.size;
         // this will be the absolute timeout from the start of the poll.  We can also exit early if it doesn't look like more results are coming in
         let highestRevisionSoFar = this.serverMaxRevisionCounter;
-        const pollingTimeout = (0, exports.calculateTimeout)(this.logger)(outstandingSourceMembers.size);
+        const pollingTimeout = (0, orgQueries_1.calculateTimeout)(this.logger)(outstandingSourceMembers.size);
         let pollAttempts = 0;
         let consecutiveEmptyResults = 0;
         let someResultsReturned = false;
@@ -213,10 +231,10 @@ class RemoteSourceTrackingService {
             pollAttempts += 1; // not used to stop polling, but for debug logging
             // get sourceMembers added since our most recent max
             // use the "new highest" revision from the last poll that returned results
-            const queriedMembers = await this.querySourceMembersFrom({
+            const queriedMembers = await (0, orgQueries_1.querySourceMembersFrom)({
+                conn: this.org.getConnection(),
                 fromRevision: highestRevisionSoFar,
-                quiet: pollAttempts !== 1,
-                useCache: false,
+                logger: pollAttempts > 1 ? undefined : this.logger,
             });
             if (queriedMembers.length) {
                 queriedMembers.map((member) => {
@@ -299,7 +317,7 @@ ${formatSourceMemberWarnings(outstandingSourceMembers)}`),
         }
     }
     /**
-     * Adds the given SourceMembers to the list of tracked MemberRevisions,  optionally updating
+     * Adds the given SourceMembers to the list of tracked MemberRevisions, optionally updating
      * the lastRetrievedFromServer field (sync), and persists the changes to maxRevision.json.
      */
     async trackSourceMembers(sourceMembers, sync = false) {
@@ -315,31 +333,20 @@ ${formatSourceMemberWarnings(outstandingSourceMembers)}`),
             // 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 = this.getSourceMember(key) ?? {
-                serverRevisionCounter: change.RevisionCounter,
-                lastRetrievedFromServer: null,
-                memberType: change.MemberType,
-                isNameObsolete: change.IsNameObsolete,
-            };
-            if (sourceMember.lastRetrievedFromServer) {
-                // We are already tracking this element so we'll update it
-                quietLogger(`Updating ${key} to RevisionCounter: ${change.RevisionCounter}${sync ? ' and syncing' : ''}`);
-                sourceMember.serverRevisionCounter = change.RevisionCounter;
-                sourceMember.isNameObsolete = change.IsNameObsolete;
-            }
-            else {
-                // We are not yet tracking it so we'll insert a new record
-                quietLogger(`Inserting ${key} with RevisionCounter: ${change.RevisionCounter}${sync ? ' and syncing' : ''}`);
-            }
-            // If we are syncing changes then we need to update the lastRetrievedFromServer field to
-            // match the RevisionCounter from the SourceMember.
-            if (sync) {
-                sourceMember.lastRetrievedFromServer = change.RevisionCounter;
-            }
-            // Update the state with the latest SourceMember data
-            this.setMemberRevision(key, sourceMember);
+            const sourceMemberFromTracking = this.getSourceMember(key);
+            quietLogger(`${sourceMemberFromTracking ? `Updating ${key} to` : `Inserting ${key} with`} RevisionCounter: ${change.RevisionCounter}${sync ? ' and syncing' : ''}`);
+            this.setMemberRevision(key, {
+                ...change,
+                // If we are syncing changes then we need to update the lastRetrievedFromServer field to
+                // match the RevisionCounter from the SourceMember.
+                lastRetrievedFromServer: sync ? change.RevisionCounter : sourceMemberFromTracking?.lastRetrievedFromServer,
+            });
+        });
+        await (0, fileOperations_1.writeTrackingFile)({
+            filePath: this.filePath,
+            maxCounter: this.serverMaxRevisionCounter,
+            members: this.sourceMembers,
         });
-        await this.write();
     }
     /** reads the tracking file and inits the logger and contents */
     async init() {
@@ -351,7 +358,7 @@ ${formatSourceMemberWarnings(outstandingSourceMembers)}`),
         this.logger = core_1.Logger.getRawRootLogger().child({ name: this.constructor.name });
         if (node_fs_1.default.existsSync(this.filePath)) {
             // read the file contents and turn it into the map
-            const rawContents = await readFileContents(this.filePath);
+            const rawContents = await (0, fileOperations_1.readFileContents)(this.filePath);
             if (rawContents.serverMaxRevisionCounter && rawContents.sourceMembers) {
                 this.serverMaxRevisionCounter = rawContents.serverMaxRevisionCounter;
                 this.sourceMembers = new Map(Object.entries(rawContents.sourceMembers ?? {}));
@@ -359,7 +366,11 @@ ${formatSourceMemberWarnings(outstandingSourceMembers)}`),
         }
         else {
             // we need to init the file
-            await this.write();
+            await (0, fileOperations_1.writeTrackingFile)({
+                filePath: this.filePath,
+                maxCounter: this.serverMaxRevisionCounter,
+                members: this.sourceMembers,
+            });
         }
         return this;
     }
@@ -373,31 +384,7 @@ ${formatSourceMemberWarnings(outstandingSourceMembers)}`),
         const matchingKey = sourceMembers.get(key)
             ? key
             : getDecodedKeyIfSourceMembersHas({ sourceMembers, key, logger: this.logger });
-        this.sourceMembers.set(matchingKey, sourceMember);
-    }
-    async querySourceMembersFrom({ fromRevision, quiet = false, useCache = true, } = {}) {
-        const rev = fromRevision ?? this.serverMaxRevisionCounter;
-        if (useCache) {
-            // Check cache first and return if found.
-            const cachedQueryResult = this.queryCache.get(rev);
-            if (cachedQueryResult) {
-                this.logger.debug(`Using cache for SourceMember query for revision ${rev}`);
-                return cachedQueryResult;
-            }
-        }
-        // because `serverMaxRevisionCounter` is always updated, we need to select > to catch the most recent change
-        const query = `SELECT MemberType, MemberName, IsNameObsolete, RevisionCounter FROM SourceMember WHERE RevisionCounter > ${rev}`;
-        this.logger[quiet ? 'silent' : 'debug'](`Query: ${query}`);
-        const queryResult = await queryFn(this.org.getConnection(), query);
-        this.queryCache.set(rev, queryResult);
-        return queryResult;
-    }
-    async write() {
-        const lockResult = await (0, core_1.lockInit)(this.filePath);
-        await lockResult.writeAndUnlock(JSON.stringify({
-            serverMaxRevisionCounter: this.serverMaxRevisionCounter,
-            sourceMembers: Object.fromEntries(this.sourceMembers),
-        }, null, 4));
+        this.sourceMembers.set(matchingKey, { ...sourceMember, MemberName: decodeURIComponent(sourceMember.MemberName) });
     }
 }
 exports.RemoteSourceTrackingService = RemoteSourceTrackingService;
@@ -418,11 +405,6 @@ const remoteChangeElementToChangeResult = (rce) => ({
     origin: 'remote', // we know they're remote
 });
 exports.remoteChangeElementToChangeResult = remoteChangeElementToChangeResult;
-const revisionToRemoteChangeElement = ([memberKey, memberRevision]) => ({
-    type: memberRevision.memberType,
-    name: memberKey.replace(`${memberRevision.memberType}__`, ''),
-    deleted: memberRevision.isNameObsolete,
-});
 /**
  *
  * iterate SourceMember keys and compare their decoded value with the decoded key.
@@ -444,47 +426,9 @@ const getDecodedKeyIfSourceMembersHas = ({ key, sourceMembers, logger, }) => {
     }
     return key;
 };
-const getFilePath = (orgId) => node_path_1.default.join('.sf', 'orgs', orgId, FILENAME);
-const readFileContents = async (filePath) => {
-    try {
-        const contents = await node_fs_1.default.promises.readFile(filePath, 'utf8');
-        return (0, kit_1.parseJsonMap)(contents, filePath);
-    }
-    catch (e) {
-        core_1.Logger.childFromRoot('remoteSourceTrackingService:readFileContents').debug(`Error reading or parsing file file at ${filePath}.  Will treat as an empty file.`, e);
-        return {};
-    }
-};
-const calculateTimeout = (logger) => (memberCount) => {
-    const overriddenTimeout = core_1.envVars.getNumber('SF_SOURCE_MEMBER_POLLING_TIMEOUT', 0);
-    if (overriddenTimeout > 0) {
-        logger.debug(`Overriding SourceMember polling timeout to ${overriddenTimeout}`);
-        return kit_1.Duration.seconds(overriddenTimeout);
-    }
-    // Calculate a polling timeout for SourceMembers based on the number of
-    // member names being polled plus a buffer of 5 seconds.  This will
-    // wait 50s for each 1000 components, plus 5s.
-    const pollingTimeout = Math.ceil(memberCount * 0.05) + 5;
-    logger.debug(`Computed SourceMember polling timeout of ${pollingTimeout}s`);
-    return kit_1.Duration.seconds(pollingTimeout);
-};
-exports.calculateTimeout = calculateTimeout;
-/** exported only for spy/mock  */
-const querySourceMembersTo = async (conn, toRevision) => {
-    const query = `SELECT MemberType, MemberName, IsNameObsolete, RevisionCounter FROM SourceMember WHERE RevisionCounter <= ${toRevision}`;
-    return queryFn(conn, query);
-};
-exports.querySourceMembersTo = querySourceMembersTo;
-const queryFn = async (conn, query) => {
-    try {
-        return (await conn.tooling.query(query, { autoFetch: true, maxFetch: 50_000 })).records.map(sourceMemberCorrections);
-    }
-    catch (error) {
-        throw core_1.SfError.wrap(error);
-    }
-};
 /** organize by type and format for warning output */
 const formatSourceMemberWarnings = (outstandingSourceMembers) => {
+    // TODO: use Map.groupBy when we node22 is minimum
     // ex: CustomObject : [Foo__c, Bar__c]
     const mapByType = Array.from(outstandingSourceMembers.values()).reduce((acc, value) => {
         acc.set(value.type, [...(acc.get(value.type) ?? []), value.fullName]);
@@ -494,13 +438,5 @@ const formatSourceMemberWarnings = (outstandingSourceMembers) => {
         .map(([type, names]) => `  - ${type}: ${names.join(', ')}`)
         .join(node_os_1.EOL);
 };
-const revisionDoesNotMatch = ([, member]) => doesNotMatchServer(member);
-const doesNotMatchServer = (member) => member.serverRevisionCounter !== member.lastRetrievedFromServer;
-/** A series of workarounds for server-side bugs.  Each bug should be filed against a team, with a WI, so we know when these are fixed and can be removed */
-const sourceMemberCorrections = (sourceMember) => {
-    if (sourceMember.MemberType === 'QuickActionDefinition') {
-        return { ...sourceMember, MemberType: 'QuickAction' }; // W-15837125
-    }
-    return sourceMember;
-};
+const doesNotMatchServer = (member) => member.RevisionCounter !== member.lastRetrievedFromServer;
 //# sourceMappingURL=remoteSourceTrackingService.js.map

package/lib/shared/remote/types.d.ts

@@ -0,0 +1,39 @@
+/** represents the contents of the config file stored in 'maxRevision.json' */
+export type ContentsV1 = {
+    fileVersion: 1;
+    serverMaxRevisionCounter: number;
+    sourceMembers: Record<string, MemberRevision>;
+};
+export type ContentsV0 = {
+    fileVersion?: 0;
+    serverMaxRevisionCounter: number;
+    sourceMembers: Record<string, MemberRevisionLegacy>;
+};
+export type SourceMember = {
+    MemberType: string;
+    MemberName: string;
+    /** The change is a delete */
+    IsNameObsolete: boolean;
+    /** The change is an add (newly created metadata) */
+    IsNewMember: boolean;
+    RevisionCounter: number;
+    /** The recordId of the metadata */
+    MemberIdOrName: string;
+    /** userID of the person who made change */
+    ChangedBy: string;
+};
+export type MemberRevision = SourceMember & {
+    /** the last revision retrieved.  Used for detecting changes*/
+    lastRetrievedFromServer?: number;
+};
+/**
+ * @deprecated replaced by the new MemberRevision
+ * used for reading and writing the legacy tracking file format
+ */
+export type MemberRevisionLegacy = {
+    memberType: string;
+    serverRevisionCounter: number;
+    lastRetrievedFromServer: number | null;
+    isNameObsolete: boolean;
+};
+export declare const SOURCE_MEMBER_FIELDS: ("MemberType" | "MemberName" | "IsNameObsolete" | "IsNewMember" | "RevisionCounter" | "MemberIdOrName" | "ChangedBy")[];

package/lib/shared/remote/types.js

@@ -0,0 +1,19 @@
+"use strict";
+/*
+ * Copyright (c) 2023, 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.SOURCE_MEMBER_FIELDS = void 0;
+exports.SOURCE_MEMBER_FIELDS = [
+    'MemberIdOrName',
+    'MemberType',
+    'MemberName',
+    'IsNameObsolete',
+    'RevisionCounter',
+    'IsNewMember',
+    'ChangedBy',
+];
+//# sourceMappingURL=types.js.map

package/lib/shared/types.d.ts

@@ -19,6 +19,10 @@ export type RemoteChangeElement = {
     type: string;
     deleted?: boolean;
     modified?: boolean;
+    changedBy: string;
+    revisionCounter: number;
+    /** the ID of the metadata that was changed.  Each metadata type has a different 3-char prefix */
+    memberIdOrName: string;
 };
 /**
  * Summary type that supports both local and remote change types
@@ -28,19 +32,6 @@ export type ChangeResult = Partial<RemoteChangeElement> & {
     filenames?: string[];
     ignored?: boolean;
 };
-export type MemberRevision = {
-    serverRevisionCounter: number;
-    lastRetrievedFromServer: number | null;
-    memberType: string;
-    isNameObsolete: boolean;
-};
-export type SourceMember = {
-    MemberType: string;
-    MemberName: string;
-    IsNameObsolete: boolean;
-    RevisionCounter: number;
-    ignored?: boolean;
-};
 export type ConflictResponse = {
     state: 'Conflict';
     fullName: string;

package/lib/sourceTracking.js

@@ -19,7 +19,7 @@ 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 performance_1 = require("@oclif/core/performance");
-const remoteSourceTrackingService_1 = require("./shared/remoteSourceTrackingService");
+const remoteSourceTrackingService_1 = require("./shared/remote/remoteSourceTrackingService");
 const localShadowRepo_1 = require("./shared/local/localShadowRepo");
 const conflicts_1 = require("./shared/conflicts");
 const guards_1 = require("./shared/guards");