PDCL-6370 Add getComponent method to utils sent to rule components and data elements.

Author: dompuiu

src/__tests__/createGetDataElementValue.test.js

@@ -260,4 +260,30 @@ describe('function returned by createGetDataElementValue', () => {
         );
       });
   });
+
+  test('provides access to getComponent method when it calls the data element module ', () => {
+    const moduleProvider = {
+      getModuleExports:
+        () =>
+        ({ utils: { getComponent } }) =>
+          getComponent()
+    };
+
+    const getDataElementValue = createGetDataElementValue(
+      {
+        settings: {},
+        id: 'DE123',
+        name: 'data element name'
+      },
+      { moduleProvider }
+    );
+
+    return getDataElementValue('testDataElement', defaultContext).then(
+      (dataElementValue) =>
+        expect(dataElementValue).toEqual({
+          id: 'DE123',
+          name: 'data element name'
+        })
+    );
+  });
 });

src/createGetDataElementValue.js

@@ -9,26 +9,29 @@ OF ANY KIND, either express or implied. See the License for the specific languag
 governing permissions and limitations under the License.
 */
 
-const cleanText = require('./cleanText');
+const cleanTextFn = require('./cleanText');
 
 const enhanceErrorMessage = (dataElementName, e) => {
   e.message = `Failed to execute module for data element "${dataElementName}". ${e.message}`;
 };
 
 module.exports =
-  (moduleProvider, getDataElementDefinition) => (name, context) => {
+  (moduleProvider, getDataElementDefinition) => (dataElementName, context) => {
     const { dataElementCallStack = [], arcAndUtils } = context;
     const { utils } = arcAndUtils;
 
-    const dataDef = getDataElementDefinition(name);
+    const dataDef = getDataElementDefinition(dataElementName);
+
     if (!dataDef) {
       return Promise.reject(
-        new Error(`Data element definition for "${name}" was not found.`)
+        new Error(
+          `Data element definition for "${dataElementName}" was not found.`
+        )
       );
     }
 
-    if (dataElementCallStack.includes(name)) {
-      dataElementCallStack.push(name);
+    if (dataElementCallStack.includes(dataElementName)) {
+      dataElementCallStack.push(dataElementName);
 
       return Promise.reject(
         new Error(
@@ -38,35 +41,48 @@ module.exports =
         )
       );
     }
-    dataElementCallStack.push(name);
+    dataElementCallStack.push(dataElementName);
 
-    const moduleExports = moduleProvider.getModuleExports(dataDef.modulePath);
+    const {
+      modulePath,
+      getSettings,
+      id,
+      name,
+      defaultValue,
+      cleanText,
+      forceLowerCase
+    } = dataDef;
 
-    const valuePromise = dataDef.getSettings(context).then((settings) => {
+    const moduleExports = moduleProvider.getModuleExports(modulePath);
+    const valuePromise = getSettings(context).then((settings) => {
       try {
         return moduleExports({
           ...arcAndUtils,
-          utils: { ...utils, getSettings: () => settings }
+          utils: {
+            ...utils,
+            getSettings: () => settings,
+            getComponent: () => ({ id, name })
+          }
         });
       } catch (e) {
-        enhanceErrorMessage(name, e);
+        enhanceErrorMessage(dataElementName, e);
         throw e;
       }
     });
 
     return valuePromise.then((resolvedValue) => {
       let value = resolvedValue;
 
-      if (value == null && dataDef.defaultValue != null) {
-        value = dataDef.defaultValue;
+      if (value == null && defaultValue != null) {
+        value = defaultValue;
       }
 
       if (typeof value === 'string') {
-        if (dataDef.cleanText) {
-          value = cleanText(value);
+        if (cleanText) {
+          value = cleanTextFn(value);
         }
 
-        if (dataDef.forceLowerCase) {
+        if (forceLowerCase) {
           value = value.toLowerCase();
         }
       }

src/executeRules.js

@@ -34,14 +34,16 @@ module.exports = (
   const freezedInitialCallData = JSON.stringify(callData);
 
   rules.forEach((rule) => {
+    const { id, name } = rule;
+
     const logger = isDebugEnabled
       ? createNewLogger({ ruleId: rule.id })
       : fakeLogger;
 
     const fetch = getRuleFetchFn(globalFetch, headersForSubrequests, logger);
 
     const utils = {
-      getRule: () => rule,
+      getRule: () => ({ id, name }),
       getBuildInfo: () => buildInfo,
       logger,
       fetch

src/rules/__tests__/executeDelegateModule.test.js

@@ -13,6 +13,24 @@ const executeDelegateModule = require('../executeDelegateModule');
 
 describe('executeDelegateModule', () => {
   test('executes the delegate module and adds the module output to the context', () => {
+    const delegateConfig = {
+      getSettings: () => Promise.resolve(),
+      moduleExports: () => 'result'
+    };
+
+    return executeDelegateModule({
+      arcAndUtils: { arc: { someValue: 1 }, utils: {} },
+      delegateConfig
+    }).then((context) => {
+      expect(context).toStrictEqual({
+        moduleOutput: 'result',
+        delegateConfig,
+        arcAndUtils: { arc: { someValue: 1 }, utils: {} }
+      });
+    });
+  });
+
+  test('sends getSettings method when the delegate module is executed', () => {
     const delegateConfig = {
       getSettings: (context) =>
         Promise.resolve({
@@ -32,4 +50,24 @@ describe('executeDelegateModule', () => {
       });
     });
   });
+
+  test('sends getComponent method when the delegate module is executed', () => {
+    const delegateConfig = {
+      id: 'RC123',
+      name: 'Delegate name',
+      getSettings: () => Promise.resolve(1),
+      moduleExports: ({ utils: { getComponent } }) => getComponent()
+    };
+
+    return executeDelegateModule({
+      arcAndUtils: {},
+      delegateConfig
+    }).then((context) => {
+      expect(context).toStrictEqual({
+        moduleOutput: { id: 'RC123', name: 'Delegate name' },
+        delegateConfig,
+        arcAndUtils: {}
+      });
+    });
+  });
 });

src/rules/executeDelegateModule.js

@@ -12,15 +12,16 @@ governing permissions and limitations under the License.
 module.exports = (context) => {
   const { arcAndUtils, delegateConfig } = context;
   const { utils } = arcAndUtils;
-  const { getSettings, moduleExports } = delegateConfig;
+  const { getSettings, moduleExports, id, name } = delegateConfig;
 
   return getSettings(context)
     .then((settings) =>
       moduleExports({
         ...arcAndUtils,
         utils: {
           ...utils,
-          getSettings: () => settings
+          getSettings: () => settings,
+          getComponent: () => ({ id, name })
         }
       })
     )