fix(util-endpoints): populate default params before checking for required values (#3928)

Author: trivikr

packages/util-endpoints/src/resolveEndpoint.spec.ts

@@ -52,6 +52,21 @@ describe(resolveEndpoint.name, () => {
     jest.resetAllMocks();
   });
 
+  it("should use the default value if a parameter is not set", () => {
+    const { paramWithDefaultKey: ignored, ...endpointParamsWithoutDefault } = mockEndpointParams;
+
+    const resolvedEndpoint = resolveEndpoint(mockRuleSetObject, { endpointParams: endpointParamsWithoutDefault });
+    expect(resolvedEndpoint).toEqual(mockResolvedEndpoint);
+
+    expect(evaluateRules).toHaveBeenCalledWith(mockRules, {
+      endpointParams: {
+        ...mockEndpointParams,
+        [paramWithDefaultKey]: mockRuleSetParameters[paramWithDefaultKey].default,
+      },
+      referenceRecord: {},
+    });
+  });
+
   it("should throw an error if a required parameter is missing", () => {
     const { requiredParamKey: ignored, ...endpointParamsWithoutRequired } = mockEndpointParams;
     expect(() => resolveEndpoint(mockRuleSetObject, { endpointParams: endpointParamsWithoutRequired })).toThrow(
@@ -60,16 +75,29 @@ describe(resolveEndpoint.name, () => {
     expect(evaluateRules).not.toHaveBeenCalled();
   });
 
-  it("should use the default value if a parameter is not set", () => {
-    const { paramWithDefaultKey: ignored, ...endpointParamsWithoutDefault } = mockEndpointParams;
+  it("should not throw an error if a default value is available for required parameter", () => {
+    const { requiredParamKey: ignored, ...endpointParamsWithoutRequired } = mockEndpointParams;
+    const requiredParamDefaultValue = "requiredParamDefaultValue";
 
-    const resolvedEndpoint = resolveEndpoint(mockRuleSetObject, { endpointParams: endpointParamsWithoutDefault });
+    const resolvedEndpoint = resolveEndpoint(
+      {
+        ...mockRuleSetObject,
+        parameters: {
+          ...mockRuleSetParameters,
+          [requiredParamKey]: {
+            ...mockRuleSetParameters[requiredParamKey],
+            default: requiredParamDefaultValue,
+          },
+        },
+      },
+      { endpointParams: endpointParamsWithoutRequired }
+    );
     expect(resolvedEndpoint).toEqual(mockResolvedEndpoint);
 
     expect(evaluateRules).toHaveBeenCalledWith(mockRules, {
       endpointParams: {
         ...mockEndpointParams,
-        [paramWithDefaultKey]: mockRuleSetParameters[paramWithDefaultKey].default,
+        [requiredParamKey]: requiredParamDefaultValue,
       },
       referenceRecord: {},
     });

packages/util-endpoints/src/resolveEndpoint.ts

@@ -10,16 +10,6 @@ export const resolveEndpoint = (ruleSetObject: RuleSetObject, options: EndpointR
   const { endpointParams, logger } = options;
   const { parameters, rules } = ruleSetObject;
 
-  const requiredParams = Object.entries(parameters)
-    .filter(([, v]) => v.required)
-    .map(([k]) => k);
-
-  for (const requiredParam of requiredParams) {
-    if (endpointParams[requiredParam] == null) {
-      throw new EndpointError(`Missing required parameter: '${requiredParam}'`);
-    }
-  }
-
   // @ts-ignore Type 'undefined' is not assignable to type 'string | boolean' (2322)
   const paramsWithDefault: [string, string | boolean][] = Object.entries(parameters)
     .filter(([, v]) => v.default != null)
@@ -31,5 +21,15 @@ export const resolveEndpoint = (ruleSetObject: RuleSetObject, options: EndpointR
     }
   }
 
+  const requiredParams = Object.entries(parameters)
+    .filter(([, v]) => v.required)
+    .map(([k]) => k);
+
+  for (const requiredParam of requiredParams) {
+    if (endpointParams[requiredParam] == null) {
+      throw new EndpointError(`Missing required parameter: '${requiredParam}'`);
+    }
+  }
+
   return evaluateRules(rules, { endpointParams, logger, referenceRecord: {} });
 };