salesforce-alm
Version:
This package contains tools, and APIs, for an improved salesforce.com developer experience.
263 lines (261 loc) • 10.2 kB
JavaScript
"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
*/
/* eslint-disable @typescript-eslint/no-unused-vars */
Object.defineProperty(exports, "__esModule", { value: true });
exports.DefaultMetadataType = void 0;
const path = require("path");
const fs = require("fs-extra");
const Debug = require("debug");
const PathUtil = require("../sourcePathUtil");
const MetadataRegistry = require("../metadataRegistry");
const srcDevUtil = require("../../core/srcDevUtil");
const Messages = require("../../messages");
const messages = Messages();
/**
* Default type obj is any atomic (non-decomposed) metadata type
*/
class DefaultMetadataType {
constructor(typeDefObj) {
this._debug = Debug(`sfdx:${this.constructor.name}`);
this.typeDefObj = typeDefObj;
}
getAggregateMetadataName() {
return this.getMetadataName();
}
getMetadataName() {
return this.typeDefObj.metadataName;
}
getBaseTypeName() {
return this.typeDefObj.metadataName;
}
isAddressable() {
return this.typeDefObj.isAddressable;
}
getDecompositionConfig() {
return this.typeDefObj.decompositionConfig;
}
resolveSourcePath(sourcePath) {
return sourcePath;
}
getFullNameFromFilePath(filePath) {
return PathUtil.getFileName(filePath);
}
getAggregateFullNameFromFilePath(filePath) {
return PathUtil.getFileName(filePath);
}
getAggregateMetadataFilePathFromWorkspacePath(filePath) {
return DefaultMetadataType.getPathWithMetadataExtension(filePath);
}
getDefaultAggregateMetadataPath(fullName, defaultSourceDir, bundleFileProperties) {
return this.getAggregateMetadataPathInDir(defaultSourceDir, fullName);
}
getAggregateMetadataPathInDir(dirName, fullName) {
const pathToDir = path.join(dirName, this.typeDefObj.defaultDirectory);
const fileName = `${fullName}.${this.typeDefObj.ext}${MetadataRegistry.getMetadataFileExt()}`;
return path.join(pathToDir, fileName);
}
getAggregateFullNameFromSourceMemberName(sourceMemberName) {
return PathUtil.encodeMetadataString(sourceMemberName);
}
getAggregateFullNameFromWorkspaceFullName(workspaceFullName) {
return workspaceFullName;
}
getAggregateFullNameFromFileProperty(fileProperty, namespace) {
return fileProperty.fullName;
}
getMdapiMetadataPath(metadataFilePath, aggregateFullName, mdDir) {
const mdapiSourceDir = this.getPathToMdapiSourceDir(aggregateFullName, mdDir);
const mdapiMetadataFileName = this.getMdapiFormattedMetadataFileName(metadataFilePath);
return path.join(mdapiSourceDir, mdapiMetadataFileName);
}
getPathToMdapiSourceDir(aggregateFullName, mdDir) {
return path.join(mdDir, this.typeDefObj.defaultDirectory);
}
static getPathWithMetadataExtension(filePath) {
if (!filePath.endsWith(MetadataRegistry.getMetadataFileExt())) {
return `${filePath}${MetadataRegistry.getMetadataFileExt()}`;
}
return filePath;
}
getMdapiFormattedMetadataFileName(metadataFilePath) {
const fileName = path.basename(metadataFilePath);
if (!this.typeDefObj.hasContent) {
return PathUtil.removeMetadataFileExtFrom(fileName);
}
return fileName;
}
hasIndividuallyAddressableChildWorkspaceElements() {
return false;
}
requiresIndividuallyAddressableMembersInPackage() {
return false;
}
isStandardMember(workspaceFullName) {
return this.typeDefObj.hasStandardMembers && !workspaceFullName.includes('__');
}
getWorkspaceElementsToDelete(aggregateMetadataPath, fileProperty) {
return [];
}
getRetrievedMetadataPath(fileProperty, retrieveRoot, bundlefileProperties) {
const retrievedMetadataPath = this.getRetrievedMetadataPathFromFileProperty(fileProperty, retrieveRoot);
return this.validateRetrievedMetadataPathExists(retrievedMetadataPath);
}
validateRetrievedMetadataPathExists(retrievedMetadataPath) {
if (srcDevUtil.pathExistsSync(retrievedMetadataPath)) {
return retrievedMetadataPath;
}
else {
const err = new Error();
err['name'] = 'Missing metadata file';
err['message'] = messages.getMessage('MissingMetadataFile', retrievedMetadataPath);
throw err;
}
}
getRetrievedMetadataPathFromFileProperty(fileProperty, retrieveRoot) {
let fileName = fileProperty.fileName;
if (this.typeDefObj.hasContent) {
fileName = `${fileName}${MetadataRegistry.getMetadataFileExt()}`;
}
return path.join(retrieveRoot, fileName);
}
getRetrievedContentPath(fileProperty, retrieveRoot) {
if (this.typeDefObj.hasContent) {
const retrievedContentPath = path.join(retrieveRoot, fileProperty.fileName);
if (srcDevUtil.pathExistsSync(retrievedContentPath)) {
return retrievedContentPath;
}
}
return null;
}
getWorkspaceContentFilePath(metadataFilePath, retrievedContentFilePath) {
const workspaceDir = path.dirname(metadataFilePath);
const fileName = path.basename(retrievedContentFilePath);
return path.join(workspaceDir, fileName);
}
getOriginContentPathsForSourceConvert(metadataFilePath, workspaceVersion, unsupportedMimeTypes, forceIgnore) {
return Promise.resolve([metadataFilePath.replace(MetadataRegistry.getMetadataFileExt(), '')]);
}
getMdapiContentPathForSourceConvert(originContentPath, aggregateFullName, mdDir) {
const mdapiSourceDir = this.getPathToMdapiSourceDir(aggregateFullName, mdDir);
const mdapiContentFileName = this.getMdapiFormattedContentFileName(originContentPath, aggregateFullName);
return this.getMdapiFormattedContentPath(mdapiSourceDir, mdapiContentFileName);
}
getMdapiFormattedContentPath(mdapiSourceDir, contentFileName) {
return path.join(mdapiSourceDir, contentFileName);
}
getMdapiFormattedContentFileName(originContentPath, aggregateFullName) {
return path.basename(originContentPath);
}
isFolderType() {
return false;
}
/**
* @param {string} metadataFilePath
* @returns {boolean}
*/
mainContentFileExists(metadataFilePath) {
const contentFilePath = PathUtil.removeMetadataFileExtFrom(metadataFilePath);
return srcDevUtil.pathExistsSync(contentFilePath);
}
displayAggregateRemoteChangesOnly() {
return false;
}
getExt() {
return this.typeDefObj.ext;
}
sourceMemberFullNameCorrespondsWithWorkspaceFullName(sourceMemberFullName, workspaceFullName) {
return PathUtil.encodeMetadataString(sourceMemberFullName) === workspaceFullName;
}
sourceMemberFullNameConflictsWithWorkspaceFullName(sourceMemberFullName, workspaceFullName) {
return sourceMemberFullName === workspaceFullName;
}
handleSlashesForSourceMemberName(sourceMemberFullName) {
return sourceMemberFullName;
}
conflictDetected(remoteChangeType, remoteChangeFullName, workspaceFullName) {
return (this.sourceMemberFullNameConflictsWithWorkspaceFullName(remoteChangeFullName, workspaceFullName) &&
remoteChangeType === this.typeDefObj.metadataName);
}
trackRemoteChangeForSourceMemberName(sourceMemberName) {
return true;
}
onlyDisplayOneConflictPerAggregate() {
return false;
}
getDisplayPathForLocalConflict(workspaceFilePath) {
return workspaceFilePath;
}
hasContent() {
return this.typeDefObj.hasContent;
}
hasParent() {
return !!this.typeDefObj.parent;
}
getAggregateFullNameFromComponentFailure(componentFailure) {
return componentFailure.fullName;
}
getAggregateFullNameFromMdapiPackagePath(mdapiPackagePath) {
return PathUtil.getFileName(mdapiPackagePath);
}
getDisplayNameForRemoteChange(sourceMemberType) {
return this.typeDefObj.metadataName;
}
deleteSupported(workspaceFullName) {
return this.typeDefObj.deleteSupported && !this.isStandardMember(workspaceFullName);
}
getChildMetadataTypes() {
if (this.typeDefObj.childXmlNames) {
return this.typeDefObj.childXmlNames;
}
return [];
}
entityExistsInWorkspace(metadataFilePath) {
return fs.existsSync(metadataFilePath);
}
validateDeletedContentPath(deletedContentPath, contentPaths, metadataRegistry) {
return;
}
isContentPath(sourcePath) {
return this.typeDefObj.hasContent && !sourcePath.endsWith(MetadataRegistry.getMetadataFileExt());
}
getComponentFailureWorkspaceContentPath(metadataFilePath, workspaceContentPaths) {
return workspaceContentPaths[0];
}
getWorkspaceFullNameFromComponentFailure(componentFailure) {
return this.getAggregateFullNameFromComponentFailure(componentFailure);
}
getDeprecationMessage(fullName) {
return;
}
componentFailureIsInMetadataFile(componentFileName) {
return componentFileName.endsWith(MetadataRegistry.getMetadataFileExt()) || !this.typeDefObj.hasContent;
}
parseSourceMemberForMetadataRetrieve(sourceMemberName, sourceMemberType, isNameObsolete) {
return {
fullName: sourceMemberName,
type: sourceMemberType,
isNameObsolete,
};
}
isContainerValid(container) {
return true;
}
shouldGetMetadataTranslation() {
return true;
}
shouldDeleteWorkspaceAggregate(metadataType) {
return metadataType === this.getAggregateMetadataName();
}
debug(message) {
if (this._debug.enabled) {
this._debug(message());
}
}
}
exports.DefaultMetadataType = DefaultMetadataType;
//# sourceMappingURL=defaultMetadataType.js.map