@salesforce/plugin-data 0.6.10 → 0.6.11

package/lib/api/data/tree/exportApi.js

@@ -7,12 +7,9 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExportApi = void 0;
-/* eslint-disable  @typescript-eslint/no-explicit-any */
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
 const path = require("path");
 const core_1 = require("@salesforce/core");
-const ts_types_1 = require("@salesforce/ts-types");
-const executors_1 = require("./executors");
+const dataSoqlQueryTypes_1 = require("../../../dataSoqlQueryTypes");
 core_1.Messages.importMessagesDirectory(__dirname);
 const messages = core_1.Messages.loadMessages('@salesforce/plugin-data', 'exportApi');
 const DATA_PLAN_FILENAME_PART = '-plan.json';
@@ -25,8 +22,8 @@ class ExportApi {
         this.org = org;
         this.ux = ux;
         this.objectTypeRegistry = {}; // registry for object type data plan descriptor
-        this.referenceRegistry = {}; // registry of object type-specific id-to-ref mappings
-        this.typeRefIndexes = {}; // registry for object type-specific ref counters
+        this.refFromIdByType = new Map(); // refFromIdByType.get('account').get(someAccountId) => AccountRef1
+        this.typeRefIndexes = new Map(); // registry for object type-specific ref counters
         this.logger = core_1.Logger.childFromRoot(this.constructor.name);
     }
     /**
@@ -47,7 +44,7 @@ class ExportApi {
             queryResults = await this.org.getConnection().query(query);
         }
         catch (err) {
-            if (err.name === 'MALFORMED_QUERY') {
+            if (err instanceof Error && err.name === 'MALFORMED_QUERY') {
                 const errMsg = messages.getMessage('soqlMalformed');
                 const errMsgAction = messages.getMessage('soqlMalformedAction');
                 throw new core_1.SfdxError(errMsg, 'MalformedQuery', [errMsgAction]);
@@ -56,17 +53,14 @@ class ExportApi {
                 throw err;
             }
         }
-        const sobjectTree = (await this.processQueryResults(queryResults));
+        const sobjectTree = await this.processQueryResults(queryResults);
         if (!((_a = sobjectTree.records) === null || _a === void 0 ? void 0 : _a.length)) {
             return sobjectTree;
         }
         if (plan) {
             return this.generateDataPlan(sobjectTree);
         }
-        else {
-            const fileName = `${Object.keys(this.objectTypeRegistry).join('-')}.json`;
-            return this.writeDataFileSync(fileName, sobjectTree);
-        }
+        return this.writeDataFileSync(`${Object.keys(this.objectTypeRegistry).join('-')}.json`, sobjectTree);
     }
     //   P R I V A T E   M E T H O D S
     /**
@@ -98,52 +92,47 @@ class ExportApi {
             core_1.fs.mkdirpSync(outputDir);
         }
         catch (err) {
-            // It is ok if the directory already exist
-            const error = err;
-            if (error.name !== 'EEXIST') {
+            // It is ok if the directory already exists
+            if (err instanceof Error && err.name !== 'EEXIST') {
                 throw err;
             }
         }
     }
     // Process query results generating SObject Tree format
     async processQueryResults(recordList) {
+        var _a;
         await this.recordObjectTypes(recordList);
-        const { plan, query } = this.config;
-        const processedRecordList = (await this.processRecordList(recordList));
+        const processedRecordList = await this.queryResultsToTree(recordList);
         // log record count; warn if > 200 and !options.plan
-        const recordCount = (0, ts_types_1.getNumber)(processedRecordList, 'records.length', 0);
-        this.logger.debug(messages.getMessage('dataExportRecordCount', [recordCount, query]));
-        if (recordCount > 200 && !plan) {
-            this.ux.warn(messages.getMessage('dataExportRecordCountWarning', [recordCount, query]));
+        const recordCount = (_a = processedRecordList.records.length) !== null && _a !== void 0 ? _a : 0;
+        this.logger.debug(messages.getMessage('dataExportRecordCount', [recordCount, this.config.query]));
+        if (recordCount > 200 && !this.config.plan) {
+            this.ux.warn(messages.getMessage('dataExportRecordCountWarning', [recordCount, this.config.query]));
         }
         return this.finalApplyRefs(processedRecordList.records);
     }
-    // Register object types and type hierarchy for plan generation
+    /**
+     * Register object types and type hierarchy for plan generation
+     **/
     async recordObjectTypes(recordList) {
         const records = recordList.records;
         if (!records.length) {
             // TODO: should be on the command
             this.ux.log('Query returned no results');
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
             return recordList;
         }
         // top level object type
-        const topLevelType = (0, ts_types_1.getString)(records[0], 'attributes.type');
+        const topLevelType = records[0].attributes.type;
         this.objectTypeRegistry[topLevelType] = {
             order: 0,
             type: topLevelType,
             saveRefs: true,
             resolveRefs: false, // pre-save, don't resolve relationship references to parent ids (from previous save)
         };
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-call
         records.forEach((record) => {
-            Object.keys(record).map((key) => {
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-                const value = record[key];
-                if (value && (0, ts_types_1.getNumber)(value, 'records.length')) {
-                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-                    const firstRec = value.records[0];
-                    const type = (0, ts_types_1.getString)(firstRec, 'attributes.type');
+            Object.entries(record).map(([key, value]) => {
+                if ((0, dataSoqlQueryTypes_1.hasNestedRecords)(value)) {
+                    const type = value.records[0].attributes.type;
                     // found a related object, add to map
                     if (type && !this.objectTypeRegistry[type]) {
                         this.objectTypeRegistry[type] = {
@@ -159,22 +148,18 @@ class ExportApi {
         });
         // pre-load object metadata
         const promises = Object.keys(this.objectTypeRegistry).map((key) => this.loadMetadata(key));
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
         return Promise.all(promises).then(() => recordList);
     }
-    async processRecordList(recordList, parentRef) {
+    async queryResultsToTree(recordList, parentRef) {
         // holds transformed sobject tree
         const sobjectTree = { records: [] };
-        // visit each record in the list
-        const processRecordsFn = (record) => () => this.processRecords(parentRef, record, sobjectTree);
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-assignment
-        const recordFns = recordList.records.map((record) => processRecordsFn(record));
-        // TODO: do we really need sequentialExecute?  Can't we just use Promise.all()?
-        await (0, executors_1.sequentialExecute)(recordFns);
+        for (const record of recordList.records) {
+            await this.processRecords(record, sobjectTree, parentRef);
+        }
         this.logger.debug(JSON.stringify(sobjectTree, null, 4));
         return sobjectTree;
     }
-    async processRecords(parentRef, record, sobjectTree) {
+    async processRecords(record, sobjectTree, parentRef) {
         // incremented every time we visit another record
         const objRefId = this.incrementTypeRefIndex(record.attributes.type);
         // add the attributes for this record, setting the type and reference
@@ -189,191 +174,134 @@ class ExportApi {
         // handle each record attribute
         await this.processRecordAttributes(record, treeRecord, objRefId);
         if (parentRef && this.config.plan) {
-            const parentFieldName = (0, ts_types_1.getString)(parentRef, 'fieldName', '');
+            const parentFieldName = parentRef.fieldName;
             if (!treeRecord[parentFieldName]) {
                 treeRecord[parentFieldName] = parentRef.id;
             }
         }
         // add record to tree
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-call
         sobjectTree.records.push(treeRecord);
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
         return sobjectTree;
     }
     // Generate object type reference (<ObjectType>Ref<Counter>)
     incrementTypeRefIndex(type) {
-        if (!this.typeRefIndexes[type]) {
-            this.typeRefIndexes[type] = 0;
-        }
-        return `${type}Ref${++this.typeRefIndexes[type]}`;
+        var _a;
+        this.typeRefIndexes.set(type, 1 + ((_a = this.typeRefIndexes.get(type)) !== null && _a !== void 0 ? _a : 0));
+        return `${type}Ref${this.typeRefIndexes.get(type)}`;
     }
     async processRecordAttributes(record, treeRecord, objRefId) {
         const promises = Object.keys(record).map((key) => this.processRecordAttribute(record, key, treeRecord, objRefId));
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-        return Promise.all(promises).then(() => treeRecord);
+        await Promise.all(promises);
+        return treeRecord;
     }
     async processRecordAttribute(record, key, treeRecord, objRefId) {
-        return Promise.resolve().then(() => {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        var _a;
+        // skip attributes and id.  Data import does not accept records with IDs.
+        if (key === 'attributes' || key === 'Id') {
+            // If this is an attributes section then we need to add an object reference
+            this.saveRecordRef(record, objRefId);
+            return;
+        }
+        const metadata = await this.loadMetadata(record.attributes.type);
+        if (this.isQueryResult(metadata, key)) {
             const field = record[key];
-            // skip attributes and id.  Data import does not accept records with IDs.
-            if (key === 'attributes' || key === 'Id') {
-                // If this is an attributes section then we need to add an object reference
-                this.saveRecordRef(record, objRefId);
+            // handle child records
+            if (!field) {
+                // The parent has no child records, so return an empty records array
+                treeRecord[key] = { records: [] };
+                return;
             }
-            else {
-                return this.loadMetadata(record.attributes.type)
-                    .then((metadata) => {
-                    if (this.isQueryResult(metadata, key)) {
-                        if (!field) {
-                            // The parent has no child records, so return an empty records array
-                            return { records: [] };
-                        }
-                        // handle child records
-                        return this.loadMetadata(field.records[0].attributes.type).then((childMetadata) => this.processRecordList(field, {
-                            id: `@${objRefId}`,
-                            fieldName: this.getRelationshipFieldName(childMetadata, record.attributes.type),
-                        }));
-                    }
-                    else {
-                        // see if this is a relationship field
-                        if (this.isRelationshipWithMetadata(metadata, key)) {
-                            // related to which field?
-                            const relTo = this.getRelatedToWithMetadata(metadata, key);
-                            if (this.config.plan) {
-                                // find reference in record result
-                                if (this.objectTypeRegistry[relTo]) {
-                                    // add ref to replace the value
-                                    const id = record[key];
-                                    const relatedObject = this.referenceRegistry[relTo];
-                                    if (relatedObject) {
-                                        const ref = relatedObject[id];
-                                        // If ref is not found, then leave intact because we may not have processed
-                                        // this parent fully. We'll go back through the sObject tree
-                                        // later and replace the id with a reference.
-                                        return ref ? `@${ref}` : id;
-                                    }
-                                    else {
-                                        // again, this will just be the id for now and replaced with a ref later.
-                                        return id;
-                                    }
-                                }
-                                else {
-                                    // TODO: what to do if ref not found?
-                                    const recordId = record['Id'];
-                                    this.logger.error(`Reference ${relTo} not found for ${key}.  Skipping record ${recordId}.`);
-                                }
-                            }
-                        }
-                        else {
-                            // not a relationship field, simple key/value insertion
-                            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-                            return record[key];
-                        }
-                    }
-                    return null;
-                })
-                    .then((processedAttribute) => {
-                    if (processedAttribute !== null) {
-                        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-                        treeRecord[key] = processedAttribute;
-                    }
-                    return Promise.resolve(null);
-                })
-                    .catch((e) => {
-                    throw e;
+            if ((0, dataSoqlQueryTypes_1.hasNestedRecords)(field)) {
+                const childMetadata = await this.loadMetadata(field.records[0].attributes.type);
+                treeRecord[key] = await this.queryResultsToTree(field, {
+                    id: `@${objRefId}`,
+                    fieldName: this.getRelationshipFieldName(childMetadata, record.attributes.type),
                 });
+                return;
             }
-            return Promise.resolve(null);
-        });
+        }
+        if (this.config.plan && this.isRelationshipWithMetadata(metadata, key)) {
+            const relTo = this.getRelatedToWithMetadata(metadata, key);
+            // find reference in record result
+            if (this.objectTypeRegistry[relTo]) {
+                // add ref to replace the value
+                const id = record[key];
+                const ref = (_a = this.refFromIdByType.get(relTo)) === null || _a === void 0 ? void 0 : _a.get(id);
+                // If ref is not found, then leave intact because we may not have processed
+                // this parent fully. We'll go back through the sObject tree
+                // later and replace the id with a reference.
+                treeRecord[key] = ref && ref !== id ? `@${ref}` : id;
+                return;
+            }
+            // TODO: what to do if ref not found?
+            const recordId = record['Id'];
+            this.logger.error(`Reference ${relTo} not found for ${key}.  Skipping record ${recordId}.`);
+            return;
+        }
+        // not a relationship field, simple key/value
+        if (!this.isRelationshipWithMetadata(metadata, key)) {
+            treeRecord[key] = record[key];
+        }
     }
     // Get sObject description and cache for given object type
     async loadMetadata(objectName) {
-        if (!describe[objectName]) {
-            const sObject = this.org.getConnection().sobject(objectName);
-            describe[objectName] = await sObject.describe();
-        }
+        var _a;
+        (_a = describe[objectName]) !== null && _a !== void 0 ? _a : (describe[objectName] = await this.org.getConnection().sobject(objectName).describe());
         return describe[objectName];
     }
     isQueryResult(metadata, fieldName) {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-return
         return metadata.childRelationships.some((cr) => cr.relationshipName === fieldName);
     }
     isSpecificTypeWithMetadata(metadata, fieldName, fieldType) {
-        for (let i = 0, fld; i < metadata.fields.length; i++) {
-            fld = metadata.fields[i];
-            /* eslint-disable @typescript-eslint/no-unsafe-call */
-            if (fld.name.toLowerCase() === fieldName.toLowerCase()) {
-                if (fld.type.toLowerCase() === fieldType.toLowerCase()) {
-                    return true;
-                }
-            }
-            /* eslint-enable @typescript-eslint/no-unsafe-call */
-        }
-        return false;
+        return metadata.fields.some((f) => f.name.toLowerCase() === fieldName.toLowerCase() && f.type.toLowerCase() === fieldType.toLowerCase());
     }
     getRelationshipFieldName(metadata, parentName) {
-        const result = metadata.fields.find((field) => {
-            if (field.type === 'reference') {
-                for (const refTo of field.referenceTo) {
-                    if (refTo === parentName) {
-                        return true;
-                    }
-                }
-            }
-            return false;
-        });
+        const result = metadata.fields.find((field) => { var _a; return field.type === 'reference' && ((_a = field.referenceTo) === null || _a === void 0 ? void 0 : _a.includes(parentName)); });
         if (!result) {
             throw new core_1.SfdxError(`Unable to find relationship field name for ${metadata.name}`);
         }
         return result.name;
     }
     isRelationship(objectName, fieldName) {
-        const metadata = describe[objectName];
-        if (!metadata) {
+        if (!describe[objectName]) {
             throw new core_1.SfdxError(`Metadata not found for ${objectName}`);
         }
-        return this.isRelationshipWithMetadata(metadata, fieldName);
+        return this.isRelationshipWithMetadata(describe[objectName], fieldName);
     }
     isRelationshipWithMetadata(metadata, fieldName) {
         return this.isSpecificTypeWithMetadata(metadata, fieldName, 'reference');
     }
     getRelatedTo(objectName, fieldName) {
-        const metadata = describe[objectName];
-        if (!metadata) {
+        if (!describe[objectName]) {
             throw new core_1.SfdxError(`Metadata not found for ${objectName}`);
         }
-        return this.getRelatedToWithMetadata(metadata, fieldName);
+        return this.getRelatedToWithMetadata(describe[objectName], fieldName);
     }
     getRelatedToWithMetadata(metadata, fieldName) {
-        const result = metadata.fields.find((field) => {
-            if (field.name === fieldName) {
-                if (field.referenceTo.length) {
-                    return true;
-                }
-                return false;
-            }
-            return false;
-        });
-        if (!result) {
+        const result = metadata.fields.find((field) => { var _a; return field.name === fieldName && ((_a = field.referenceTo) === null || _a === void 0 ? void 0 : _a.length); });
+        if (!result || !result.referenceTo) {
             throw new core_1.SfdxError(`Unable to find relation for ${metadata.name}`);
         }
         return result.referenceTo[0];
     }
-    // Register object type's id to reference mapping
+    /**
+     * Register object type's id to reference mapping
+     *
+     * @param refId like '@AccountRef1'
+     * */
     saveRecordRef(obj, refId) {
+        var _a, _b;
+        if (!obj.attributes.url) {
+            return;
+        }
         const id = path.basename(obj.attributes.url);
-        const ref = refId;
         const type = obj.attributes.type;
-        if (typeof this.referenceRegistry[type] === 'undefined') {
-            this.referenceRegistry[type] = {};
-        }
-        // ensure no existing reference
-        const refEntry = this.referenceRegistry[type][id];
-        if (refEntry && refEntry !== ref) {
-            throw new core_1.SfdxError(`Overriding ${type} reference for ${id}: existing ${refEntry}, incoming ${ref}`);
+        // ensure no existing reference for that Id
+        const refEntry = (_a = this.refFromIdByType.get(type)) === null || _a === void 0 ? void 0 : _a.get(id);
+        if (refEntry && refEntry !== refId) {
+            throw new core_1.SfdxError(`Overriding ${type} reference for ${id}: existing ${refEntry}, incoming ${refId}`);
         }
-        this.referenceRegistry[type][id] = ref;
+        this.refFromIdByType.set(type, ((_b = this.refFromIdByType.get(type)) !== null && _b !== void 0 ? _b : new Map()).set(id, refId));
     }
     /**
      * Walk the final data set and split out into files.  The main queried
@@ -381,61 +309,47 @@ class ExportApi {
      * values.  All the references have been created at this point.
      */
     generateDataPlan(sobjectTree) {
-        const objects = {};
+        const objects = new Map();
         const dataPlan = [];
-        let topLevelObjectType;
         // loop thru object tree extracting type-specific records into separate tree structure
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-call
         sobjectTree.records.forEach((record) => {
-            topLevelObjectType = record.attributes.type;
-            if (!objects[topLevelObjectType]) {
-                objects[topLevelObjectType] = { records: [] };
+            var _a;
+            const topLevelObjectType = record.attributes.type;
+            if (!objects.has(topLevelObjectType)) {
+                objects.set(topLevelObjectType, []);
             }
-            Object.keys(record).map((key) => {
-                const childRecords = (0, ts_types_1.get)(record, `${key}.records`);
-                if (childRecords) {
-                    // found child records, add to type-specific registry
-                    if (childRecords.length) {
-                        const childObjectType = childRecords[0].attributes.type;
-                        if (!objects[childObjectType]) {
-                            objects[childObjectType] = { records: [] };
+            Object.entries(record).map(([key, value]) => {
+                var _a;
+                if ((0, dataSoqlQueryTypes_1.hasNestedRecords)(value)) {
+                    const childRecords = value.records;
+                    if (childRecords) {
+                        // found child records, add to type-specific registry
+                        if (childRecords.length) {
+                            const childObjectType = childRecords[0].attributes.type;
+                            objects.set(childObjectType, ((_a = objects.get(childObjectType)) !== null && _a !== void 0 ? _a : []).concat(childRecords));
                         }
-                        /* eslint-disable @typescript-eslint/no-unsafe-call */
-                        childRecords.forEach((child) => {
-                            objects[childObjectType].records.push(child);
-                        });
-                        /* eslint-enable @typescript-eslint/no-unsafe-call */
+                        // remove child from top-level object structure
+                        delete record[key];
                     }
-                    // remove child from top-level object structure
-                    delete record[key];
                 }
-                return key;
             });
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-call
-            objects[topLevelObjectType].records.push(record);
+            objects.set(topLevelObjectType, ((_a = objects.get(topLevelObjectType)) !== null && _a !== void 0 ? _a : []).concat([record]));
         });
         // sort object types based on insertion dependence
         const objectsSorted = Object.keys(this.objectTypeRegistry).sort((a, b) => this.objectTypeRegistry[a].order - this.objectTypeRegistry[b].order);
         // write data files and update data plan
-        objectsSorted.forEach((key) => {
-            const dataPlanPart = this.writeObjectTypeDataFile(key, this.objectTypeRegistry[key].saveRefs, this.objectTypeRegistry[key].resolveRefs, `${key}s.json`, objects[key]);
-            dataPlan.push(dataPlanPart);
-        });
+        dataPlan.push(...objectsSorted.map((key) => this.writeObjectTypeDataFile(key, !!this.objectTypeRegistry[key].saveRefs, !!this.objectTypeRegistry[key].resolveRefs, `${key}s.json`, { records: objects.get(key) })));
         // write data plan file
         const dataPlanFile = Object.keys(this.objectTypeRegistry).join('-') + DATA_PLAN_FILENAME_PART;
         return this.writeDataFileSync(dataPlanFile, dataPlan);
     }
     // generate data plan stanza referencing written object type file
     writeObjectTypeDataFile(type, saveRefs, resolveRefs, fileName, sObject) {
-        let finalFilename = fileName;
-        if (this.config.prefix) {
-            finalFilename = `${this.config.prefix}-${fileName}`;
-        }
         const dataPlanPart = {
             sobject: type,
             saveRefs,
             resolveRefs,
-            files: [finalFilename],
+            files: [this.getPrefixedFileName(fileName)],
         };
         this.writeDataFileSync(fileName, sObject);
         return dataPlanPart;
@@ -447,33 +361,33 @@ class ExportApi {
      */
     finalApplyRefs(sobjectTree) {
         sobjectTree.forEach((record) => {
-            Object.keys(record).map((field) => {
-                if (record[field].records) {
+            Object.entries(record).map(([field, value]) => {
+                var _a;
+                if ((0, dataSoqlQueryTypes_1.hasNestedRecords)(value)) {
                     // These are children
-                    this.finalApplyRefs(record[field].records);
+                    this.finalApplyRefs(value.records);
                 }
                 else {
                     const objType = record.attributes.type;
                     if (this.isRelationship(objType, field)) {
-                        // eslint-disable-next-line @typescript-eslint/no-unsafe-call
-                        const id = record[field].toString();
-                        if (!id.startsWith('@')) {
+                        if (typeof value === 'string' && !value.startsWith('@')) {
+                            // it's still just an ID, so we need to resolve it
+                            const id = value;
                             const refTo = this.getRelatedTo(objType, field);
-                            const ref = this.referenceRegistry[refTo][id];
+                            const ref = (_a = this.refFromIdByType.get(refTo)) === null || _a === void 0 ? void 0 : _a.get(id);
                             if (!ref) {
                                 throw new core_1.SfdxError(`${objType} reference to ${refTo} (${id}) not found in query results.`);
                             }
                             record[field] = `@${ref}`;
                             // Setup dependency ordering for later output
                             if (this.objectTypeRegistry[objType].order <= this.objectTypeRegistry[refTo].order) {
-                                this.objectTypeRegistry[objType].order = Number(this.objectTypeRegistry[refTo].order) + 1;
+                                this.objectTypeRegistry[objType].order = this.objectTypeRegistry[refTo].order + 1;
                                 this.objectTypeRegistry[refTo].saveRefs = true;
                                 this.objectTypeRegistry[objType].resolveRefs = true;
                             }
                         }
                     }
                 }
-                return field;
             });
         });
         return { records: sobjectTree };
@@ -482,28 +396,27 @@ class ExportApi {
         count += records.length;
         records.forEach((record) => {
             Object.values(record).forEach((val) => {
-                if (val === null || val === void 0 ? void 0 : val.records) {
+                if ((0, dataSoqlQueryTypes_1.hasNestedRecords)(val)) {
                     this.countRecords(val.records, count);
                 }
             });
         });
         return count;
     }
+    getPrefixedFileName(fileName) {
+        return this.config.prefix ? `${this.config.prefix}-${fileName}` : fileName;
+    }
     writeDataFileSync(fileName, jsonObject) {
         let recordCount = 0;
-        const { outputDir, prefix } = this.config;
-        if (prefix) {
-            fileName = `${prefix}-${fileName}`;
-        }
-        if (outputDir) {
-            fileName = path.join(outputDir, fileName);
-        }
-        if ((0, ts_types_1.has)(jsonObject, 'records') && (0, ts_types_1.isArray)(jsonObject.records)) {
+        const finalFilename = this.config.outputDir
+            ? path.join(this.config.outputDir, this.getPrefixedFileName(fileName))
+            : this.getPrefixedFileName(fileName);
+        if ((0, dataSoqlQueryTypes_1.hasNestedRecords)(jsonObject)) {
             recordCount = this.countRecords(jsonObject.records);
         }
-        core_1.fs.writeFileSync(fileName, JSON.stringify(jsonObject, null, 4));
+        core_1.fs.writeFileSync(finalFilename, JSON.stringify(jsonObject, null, 4));
         // TODO: move this to the command
-        this.ux.log(`Wrote ${recordCount} records to ${fileName}`);
+        this.ux.log(`Wrote ${recordCount} records to ${finalFilename}`);
         return jsonObject;
     }
 }