Merge pull request #422 from shaurabh-tiwari-git/metadataAPI

@W-19701061 - Validate and Update OmniStudio metadata API

Author: sf-aastha-paruthi

messages/assess.json

@@ -198,5 +198,7 @@
   "invalidTypeAssessErrorMessage": "We couldn't assess your Omnistudio components in the %s namespace. Select the correct namespace and try again",
   "assessmentSuccessfulMessage": "Migration assessment for org %s is complete and reports are ready for review in the folder %s",
   "needManualInterventionAsSpecialCharsInChildFlexcardName": "Need manual intervention as child flexcards have special characters in their name",
-  "needManualInterventionAsSpecialCharsInFlexcardName": "Need manual intervention as flexcard has special characters in name"
+  "needManualInterventionAsSpecialCharsInFlexcardName": "Need manual intervention as flexcard has special characters in name",
+  "errorCheckingOmniStudioMetadata": "We couldn't check whether the Omnistudio Metadata is enabled: %s. Try again later.",
+  "omniStudioSettingsMetadataAlreadyEnabled": "The Omnistudio Metadata setting is already enabled with standard data model. No need for migration."
 }

messages/migrate.json

@@ -254,5 +254,13 @@
   "errorCheckingMetadataTables": "Error checking Omnistudio metadata tables: %s",
   "metadataCleanupCompleted": "The Omnistudio metadata table cleanup process is complete. Total records cleaned: %s",
   "metadataCleanupConsentMessage": "By proceeding further, you hereby consent to clean up the Omnistudio metadata tables. Proceeding with the cleanup process will permanently delete all records from OmniUiCardConfig, OmniScriptConfig, OmniIntegrationProcConfig, and OmniDataTransformConfig tables. Do you want to proceed? [y/n]",
-  "metadataCleanupConsentNotGiven": "You’ve not consented to proceed with the Omnistudio metadata table cleanup. We’ll not be able to proceed with the migration."
+  "metadataCleanupConsentNotGiven": "You’ve not consented to proceed with the Omnistudio metadata table cleanup. We’ll not be able to proceed with the migration.",
+  "omniStudioMetadataEnableConsentMessage": "As part of the migration process, the Omnistudio Metadata setting will be enabled. After the setting is enabled, you cannot disable it. Do you want to proceed? [y/n]",
+  "errorCheckingOmniStudioMetadata": "We couldn't check whether the Omnistudio Metadata is enabled: %s. Try again later.",
+  "omniStudioSettingsMetadataAlreadyEnabled": "The Omnistudio Metadata setting is already enabled with standard data model. No need for migration.",
+  "omniStudioSettingsMetadataEnabled": "The Omnistudio Metadata setting is enabled with standard data model.",
+  "errorEnablingOmniStudioSettingsMetadata": "We couldn't enable the Omnistudio Metadata setting: %s. Enable it manually.",
+  "manuallyEnableOmniStudioSettingsMetadata": "Manually enable the Omnistudio Metadata setting in your org’s Omnistudio Settings page.",
+  "omniStudioMetadataEnableConsentNotGiven": "You’ve not consented to proceed with enabling the Omnistudio Metadata setting. We’ll not be able to proceed with the migration.",
+  "enablingOmniStudioSettingsMetadataStatus": "Enabling OmniStudio Settings Metadata..."
 }

src/commands/omnistudio/migration/migrate.ts

@@ -131,8 +131,15 @@ export default class Migrate extends OmniStudioBaseCommand {
     const preMigrate: PreMigrate = new PreMigrate(namespace, conn, this.logger, messages, this.ux);
     const isExperienceBundleMetadataAPIProgramaticallyEnabled: { value: boolean } = { value: false };
 
-    // Handle config tables cleanup for standard data model migration
     if (isStandardDataModel()) {
+      // Get user consent to enable OmniStudio Metadata for standard data model migration
+      const omniStudioMetadataEnableConsent = await preMigrate.getOmniStudioMetadataEnableConsent();
+      if (!omniStudioMetadataEnableConsent) {
+        Logger.error(messages.getMessage('omniStudioMetadataEnableConsentNotGiven'));
+        return;
+      }
+
+      // Handle config tables cleanup for standard data model migration
       const isMetadataCleanupSuccess = await preMigrate.handleOmniStudioMetadataCleanup();
       if (!isMetadataCleanupSuccess) {
         return;

src/migration/postMigrate.ts

@@ -12,6 +12,8 @@ import { BaseMigrationTool } from './base';
 import { Deployer } from './deployer';
 import * as fs from 'fs';
 import * as path from 'path';
+import { isStandardDataModel } from '../utils/dataModelService';
+import { OmniStudioMetadataCleanupService } from '../utils/config/OmniStudioMetadataCleanupService';
 
 export class PostMigrate extends BaseMigrationTool {
   private readonly org: Org;
@@ -48,6 +50,9 @@ export class PostMigrate extends BaseMigrationTool {
     if (designerOk) {
       await this.enableStandardRuntimeIfNeeded(userActionMessage);
     }
+    if (isStandardDataModel()) {
+      await this.enableOmniStudioSettingsMetadataIfNeeded(userActionMessage);
+    }
     return userActionMessage;
   }
 
@@ -125,6 +130,48 @@ export class PostMigrate extends BaseMigrationTool {
     }
   }
 
+  private async enableOmniStudioSettingsMetadataIfNeeded(userActionMessage: string[]): Promise<void> {
+    try {
+      Logger.log(this.messages.getMessage('enablingOmniStudioSettingsMetadataStatus'));
+      const result = await this.settingsPrefManager.enableOmniStudioSettingsMetadata();
+      if (result === null) {
+        Logger.logVerbose(this.messages.getMessage('omniStudioSettingsMetadataAlreadyEnabled'));
+      } else if (result?.success === true) {
+        /* The API call returns true if the metadata enabling call was successful.
+        But it takes time for the checks to run and the metadata to be enabled or reverted back.
+        We need to wait and check if the config tables are populated or not.
+        That will ensure that the metadata is enabled.
+        */
+        const maxAttempts = 6;
+        let attempts = 0;
+        while (attempts < maxAttempts) {
+          await new Promise((resolve) => setTimeout(resolve, 20000));
+          const metadataService = new OmniStudioMetadataCleanupService(this.connection, this.messages);
+          const isConfigTablesEmpty = await metadataService.hasCleanOmniStudioMetadataTables(); //Check is the config tables are populated or not.
+          if (!isConfigTablesEmpty) {
+            // If the config tables are populated, means the metadata is enabled.
+            Logger.log(this.messages.getMessage('omniStudioSettingsMetadataEnabled'));
+            break;
+          }
+          attempts++;
+        }
+        if (attempts === maxAttempts) {
+          // TODO: We need to figure out and show the user that what is the actual issue which is causing the metadata to not be enabled.
+          Logger.error(this.messages.getMessage('errorEnablingOmniStudioSettingsMetadata', ['Unknown error']));
+          userActionMessage.push(this.messages.getMessage('manuallyEnableOmniStudioSettingsMetadata'));
+        }
+      } else {
+        const errors = result?.errors?.join(', ') || 'Unknown error';
+        Logger.error(this.messages.getMessage('errorEnablingOmniStudioSettingsMetadata', [errors]));
+        userActionMessage.push(this.messages.getMessage('manuallyEnableOmniStudioSettingsMetadata'));
+      }
+    } catch (error) {
+      const errMsg = error instanceof Error ? error.message : String(error);
+      Logger.error(this.messages.getMessage('errorEnablingOmniStudioSettingsMetadata', [errMsg]));
+      userActionMessage.push(this.messages.getMessage('manuallyEnableOmniStudioSettingsMetadata'));
+    }
+  }
+
   // If we processed exp sites and switched metadata api from off->on then only we revert it
   public async restoreExperienceAPIMetadataSettings(
     isExperienceBundleMetadataAPIProgramaticallyEnabled: {

src/migration/premigrate.ts

@@ -110,6 +110,41 @@ export class PreMigrate extends BaseMigrationTool {
     return deploymentConfig;
   }
 
+  /**
+   * Gets user consent for OmniStudio metadata cleanup
+   *
+   * @returns Promise<boolean> - true if user consents, false otherwise
+   */
+  public async getOmniStudioMetadataEnableConsent(): Promise<boolean> {
+    const askWithTimeOut = PromptUtil.askWithTimeOut(this.messages);
+    let validResponse = false;
+    let consent = false;
+
+    while (!validResponse) {
+      try {
+        const resp = await askWithTimeOut(
+          Logger.prompt.bind(Logger),
+          this.messages.getMessage('omniStudioMetadataEnableConsentMessage')
+        );
+        const response = typeof resp === 'string' ? resp.trim().toLowerCase() : '';
+
+        if (response === YES_SHORT || response === YES_LONG) {
+          consent = true;
+          validResponse = true;
+        } else if (response === NO_SHORT || response === NO_LONG) {
+          consent = false;
+          validResponse = true;
+        } else {
+          Logger.error(this.messages.getMessage('invalidYesNoResponse'));
+        }
+      } catch (err) {
+        Logger.error(this.messages.getMessage('requestTimedOut'));
+        process.exit(1);
+      }
+    }
+    return consent;
+  }
+
   /**
    * Handles OmniStudio metadata tables cleanup with user consent
    *

src/utils/OmnistudioSettingsPrefManager.ts

@@ -78,4 +78,36 @@ export class OmnistudioSettingsPrefManager {
     }
     return null; // Already enabled, no action needed
   }
+
+  // OmniStudio Metadata methods
+  public async isOmniStudioSettingsMetadataEnabled(): Promise<boolean> {
+    try {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      const result = (await this.connection.metadata.read('OmniStudioSettings', ['OmniStudio'])) as unknown;
+
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      const metadata = result as MetadataInfo;
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+      return metadata?.enableOmniStudioMetadata === 'true' || false;
+    } catch (error) {
+      const errMsg = error instanceof Error ? error.message : String(error);
+      Logger.error(this.messages.getMessage('errorCheckingOmniStudioMetadata', [errMsg]));
+      return false;
+    }
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  public async enableOmniStudioSettingsMetadata(): Promise<any> {
+    const isMetadataEnabled = await this.isOmniStudioSettingsMetadataEnabled();
+    if (isMetadataEnabled) {
+      return null;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    return await this.connection.metadata.update('OmniStudioSettings', [
+      {
+        fullName: 'OmniStudio',
+        enableOmniStudioMetadata: 'true',
+      } as MetadataInfo,
+    ]);
+  }
 }

src/utils/validatorService.ts

@@ -2,6 +2,7 @@ import { Connection, Messages } from '@salesforce/core';
 import { Logger } from '../utils/logger';
 import { OmnistudioOrgDetails } from './orgUtils';
 import { isStandardDataModel } from './dataModelService';
+import { OmnistudioSettingsPrefManager } from './OmnistudioSettingsPrefManager';
 
 export class ValidatorService {
   private readonly messages: Messages;
@@ -20,9 +21,16 @@ export class ValidatorService {
     }
 
     // If data model is standard no need to check for the licences
-    // TODO: Add metadata toggle validation
     const isStandard = isStandardDataModel();
     if (isStandard) {
+      // Check if OmniStudio Metadata is already enabled for standard data model
+      const omniStudioSettingsPrefManager = new OmnistudioSettingsPrefManager(this.connection, this.messages);
+      const isOmniStudioSettingsMetadataEnabled =
+        await omniStudioSettingsPrefManager.isOmniStudioSettingsMetadataEnabled();
+      if (isOmniStudioSettingsMetadataEnabled) {
+        Logger.error(this.messages.getMessage('omniStudioSettingsMetadataAlreadyEnabled'));
+        return false;
+      }
       return true;
     }
 

test/utils/OmnistudioSettingsPrefManager.test.ts

@@ -250,4 +250,107 @@ describe('OmnistudioSettingsPrefManager', () => {
       });
     });
   });
+
+  // OmniStudio Metadata Tests
+  describe('OmniStudio Metadata functionality', () => {
+    describe('isOmniStudioSettingsMetadataEnabled()', () => {
+      it('should return true when omni studio metadata is enabled', async () => {
+        const readStub = connection.metadata.read as sinon.SinonStub;
+        readStub.resolves({ enableOmniStudioMetadata: 'true' });
+
+        const result = await prefManager.isOmniStudioSettingsMetadataEnabled();
+
+        expect(result).to.be.true;
+        expect(readStub.calledOnce).to.be.true;
+        expect(readStub.firstCall.args[0]).to.equal('OmniStudioSettings');
+        expect(readStub.firstCall.args[1]).to.deep.equal(['OmniStudio']);
+      });
+
+      it('should return false when omni studio metadata is disabled', async () => {
+        const readStub = connection.metadata.read as sinon.SinonStub;
+        readStub.resolves({ enableOmniStudioMetadata: 'false' });
+
+        const result = await prefManager.isOmniStudioSettingsMetadataEnabled();
+
+        expect(result).to.be.false;
+      });
+
+      it('should return false when omni studio metadata preference is not set', async () => {
+        const readStub = connection.metadata.read as sinon.SinonStub;
+        readStub.resolves({});
+
+        const result = await prefManager.isOmniStudioSettingsMetadataEnabled();
+
+        expect(result).to.be.false;
+      });
+
+      it('should handle metadata read failures', async () => {
+        const readStub = connection.metadata.read as sinon.SinonStub;
+        readStub.rejects(new Error('Metadata read failed'));
+
+        const result = await prefManager.isOmniStudioSettingsMetadataEnabled();
+
+        expect(result).to.be.false;
+      });
+
+      it('should return false when metadata is null', async () => {
+        const readStub = connection.metadata.read as sinon.SinonStub;
+        readStub.resolves(null);
+
+        const result = await prefManager.isOmniStudioSettingsMetadataEnabled();
+
+        expect(result).to.be.false;
+      });
+    });
+
+    describe('enableOmniStudioSettingsMetadata()', () => {
+      it('should return null when metadata is already enabled', async () => {
+        const readStub = connection.metadata.read as sinon.SinonStub;
+        const updateStub = connection.metadata.update as sinon.SinonStub;
+        readStub.resolves({ enableOmniStudioMetadata: 'true' });
+
+        const result = await prefManager.enableOmniStudioSettingsMetadata();
+
+        expect(result).to.be.null;
+        expect(readStub.calledOnce).to.be.true;
+        expect(updateStub.called).to.be.false;
+      });
+
+      it('should enable metadata when disabled', async () => {
+        const readStub = connection.metadata.read as sinon.SinonStub;
+        const updateStub = connection.metadata.update as sinon.SinonStub;
+        const expectedResult = { success: true };
+        readStub.resolves({ enableOmniStudioMetadata: 'false' });
+        updateStub.resolves(expectedResult);
+
+        const result = await prefManager.enableOmniStudioSettingsMetadata();
+
+        expect(result).to.deep.equal(expectedResult);
+        expect(readStub.calledOnce).to.be.true;
+        expect(updateStub.calledOnce).to.be.true;
+        expect(updateStub.firstCall.args[0]).to.equal('OmniStudioSettings');
+        expect(updateStub.firstCall.args[1]).to.deep.equal([
+          {
+            fullName: 'OmniStudio',
+            enableOmniStudioMetadata: 'true',
+          },
+        ]);
+      });
+
+      it('should handle update errors', async () => {
+        const readStub = connection.metadata.read as sinon.SinonStub;
+        const updateStub = connection.metadata.update as sinon.SinonStub;
+        const error = new Error('Update failed');
+        readStub.resolves({ enableOmniStudioMetadata: 'false' });
+        updateStub.rejects(error);
+
+        try {
+          await prefManager.enableOmniStudioSettingsMetadata();
+          expect.fail('Expected an error to be thrown');
+        } catch (err) {
+          expect(err).to.equal(error);
+        }
+      });
+    });
+  });
 });

test/utils/validatorService.test.ts

@@ -5,6 +5,7 @@ import { ValidatorService } from '../../src/utils/validatorService';
 import { Logger } from '../../src/utils/logger';
 import { OmnistudioOrgDetails } from '../../src/utils/orgUtils';
 import * as dataModelService from '../../src/utils/dataModelService';
+import { OmnistudioSettingsPrefManager } from '../../src/utils/OmnistudioSettingsPrefManager';
 
 describe('ValidatorService', () => {
   let connection: Connection;
@@ -13,6 +14,7 @@ describe('ValidatorService', () => {
   let loggerWarnStub: sinon.SinonStub;
   let loggerErrorStub: sinon.SinonStub;
   let isStandardDataModelStub: sinon.SinonStub;
+  let omnistudioSettingsPrefManagerStub: sinon.SinonStub;
 
   beforeEach(() => {
     sandbox = sinon.createSandbox();
@@ -33,6 +35,12 @@ describe('ValidatorService', () => {
 
     // Mock dataModelService
     isStandardDataModelStub = sandbox.stub(dataModelService, 'isStandardDataModel');
+
+    // Mock OmnistudioSettingsPrefManager
+    omnistudioSettingsPrefManagerStub = sandbox.stub(
+      OmnistudioSettingsPrefManager.prototype,
+      'isOmniStudioSettingsMetadataEnabled'
+    );
   });
 
   afterEach(() => {
@@ -392,14 +400,15 @@ describe('ValidatorService', () => {
       expect(result).to.be.true;
     });
 
-    it('should return true for standard data model without checking licenses', async () => {
+    it('should return true for standard data model when metadata is not enabled', async () => {
       // Arrange
       const orgs: OmnistudioOrgDetails = {
         hasValidNamespace: true,
         packageDetails: { namespace: 'TestNamespace' },
         omniStudioOrgPermissionEnabled: true,
       } as OmnistudioOrgDetails;
       isStandardDataModelStub.returns(true); // Standard data model
+      omnistudioSettingsPrefManagerStub.resolves(false); // Metadata not enabled
       const validator = new ValidatorService(orgs, messages, connection);
 
       // Act
@@ -408,6 +417,31 @@ describe('ValidatorService', () => {
       // Assert
       expect(result).to.be.true;
       expect((connection.query as sinon.SinonStub).called).to.be.false; // License validation should be skipped
+      expect(omnistudioSettingsPrefManagerStub.calledOnce).to.be.true;
+    });
+
+    it('should return false for standard data model when metadata is already enabled', async () => {
+      // Arrange
+      const orgs: OmnistudioOrgDetails = {
+        hasValidNamespace: true,
+        packageDetails: { namespace: 'TestNamespace' },
+        omniStudioOrgPermissionEnabled: true,
+      } as OmnistudioOrgDetails;
+      isStandardDataModelStub.returns(true); // Standard data model
+      omnistudioSettingsPrefManagerStub.resolves(true); // Metadata already enabled
+      (messages.getMessage as sinon.SinonStub)
+        .withArgs('omniStudioSettingsMetadataAlreadyEnabled')
+        .returns('OmniStudio Metadata is already enabled');
+      const validator = new ValidatorService(orgs, messages, connection);
+
+      // Act
+      const result = await validator.validate();
+
+      // Assert
+      expect(result).to.be.false;
+      expect(loggerErrorStub.calledOnce).to.be.true;
+      expect(loggerErrorStub.firstCall.args[0]).to.equal('OmniStudio Metadata is already enabled');
+      expect(omnistudioSettingsPrefManagerStub.calledOnce).to.be.true;
     });
 
     it('should return false when package validation fails', async () => {