perf(util-endpoints): reduce temporary object allocations

.changeset/nasty-beers-invite.md

@@ -0,0 +1,5 @@
+---
+"@smithy/util-endpoints": patch
+---
+
+Reduce temporary object allocations

packages/util-endpoints/src/utils/evaluateCondition.ts

@@ -3,16 +3,20 @@ import type { ConditionObject, EvaluateOptions } from "../types";
 import { EndpointError } from "../types";
 import { callFunction } from "./callFunction";
 
-export const evaluateCondition = ({ assign, ...fnArgs }: ConditionObject, options: EvaluateOptions) => {
+export const evaluateCondition = (condition: ConditionObject, options: EvaluateOptions) => {
+  const { assign } = condition;
+
   if (assign && assign in options.referenceRecord) {
     throw new EndpointError(`'${assign}' is already defined in Reference Record.`);
   }
-  const value = callFunction(fnArgs, options);
+  const value = callFunction(condition, options);
+
+  options.logger?.debug?.(`${debugId} evaluateCondition: ${toDebugString(condition)} = ${toDebugString(value)}`);
 
-  options.logger?.debug?.(`${debugId} evaluateCondition: ${toDebugString(fnArgs)} = ${toDebugString(value)}`);
+  const result = value === "" ? true : !!value;
 
-  return {
-    result: value === "" ? true : !!value,
-    ...(assign != null && { toAssign: { name: assign, value } }),
-  };
+  if (assign != null) {
+    return { result, toAssign: { name: assign, value } };
+  }
+  return { result };
 };

packages/util-endpoints/src/utils/evaluateConditions.spec.ts

@@ -50,26 +50,26 @@ describe(evaluateConditions.name, () => {
     const value1 = "value1";
     const value2 = "value2";
 
-    vi.mocked(evaluateCondition).mockReturnValueOnce({
-      result: true,
-      toAssign: { name: mockCn1.assign!, value: value1 },
-    });
-    vi.mocked(evaluateCondition).mockReturnValueOnce({
-      result: true,
-      toAssign: { name: mockCn2.assign!, value: value2 },
-    });
+    const capturedReferenceRecords: Record<string, unknown>[] = [];
+
+    vi.mocked(evaluateCondition)
+      .mockImplementationOnce((_condition, options) => {
+        capturedReferenceRecords.push({ ...options.referenceRecord });
+        return { result: true, toAssign: { name: mockCn1.assign!, value: value1 } };
+      })
+      .mockImplementationOnce((_condition, options) => {
+        capturedReferenceRecords.push({ ...options.referenceRecord });
+        return { result: true, toAssign: { name: mockCn2.assign!, value: value2 } };
+      });
 
     const { result, referenceRecord } = evaluateConditions([mockCn1, mockCn2], { ...mockOptions });
     expect(result).toBe(true);
     expect(referenceRecord).toEqual({
       [mockCn1.assign!]: value1,
       [mockCn2.assign!]: value2,
     });
-    expect(evaluateCondition).toHaveBeenNthCalledWith(1, mockCn1, mockOptions);
-    expect(evaluateCondition).toHaveBeenNthCalledWith(2, mockCn2, {
-      ...mockOptions,
-      referenceRecord: { [mockCn1.assign!]: value1 },
-    });
+    expect(capturedReferenceRecords[0]).toEqual({});
+    expect(capturedReferenceRecords[1]).toEqual({ [mockCn1.assign!]: value1 });
     expect(mockLogger.debug).nthCalledWith(1, `${debugId} assign: ${mockCn1.assign} := ${toDebugString(value1)}`);
     expect(mockLogger.debug).nthCalledWith(2, `${debugId} assign: ${mockCn2.assign} := ${toDebugString(value2)}`);
   });

packages/util-endpoints/src/utils/evaluateConditions.ts

@@ -4,22 +4,21 @@ import { evaluateCondition } from "./evaluateCondition";
 
 export const evaluateConditions = (conditions: ConditionObject[] = [], options: EvaluateOptions) => {
   const conditionsReferenceRecord: Record<string, FunctionReturn> = {};
+  const conditionOptions: EvaluateOptions = {
+    ...options,
+    referenceRecord: { ...options.referenceRecord },
+  };
 
   for (const condition of conditions) {
-    const { result, toAssign } = evaluateCondition(condition, {
-      ...options,
-      referenceRecord: {
-        ...options.referenceRecord,
-        ...conditionsReferenceRecord,
-      },
-    });
+    const { result, toAssign } = evaluateCondition(condition, conditionOptions);
 
     if (!result) {
       return { result };
     }
 
     if (toAssign) {
       conditionsReferenceRecord[toAssign.name] = toAssign.value;
+      conditionOptions.referenceRecord[toAssign.name] = toAssign.value;
       options.logger?.debug?.(`${debugId} assign: ${toAssign.name} := ${toDebugString(toAssign.value)}`);
     }
   }

packages/util-endpoints/src/utils/evaluateEndpointRule.ts

@@ -27,13 +27,13 @@ export const evaluateEndpointRule = (
 
   options.logger?.debug?.(`${debugId} Resolving endpoint from template: ${toDebugString(endpoint)}`);
 
-  return {
-    ...(headers != undefined && {
-      headers: getEndpointHeaders(headers, endpointRuleOptions),
-    }),
-    ...(properties != undefined && {
-      properties: getEndpointProperties(properties, endpointRuleOptions),
-    }),
-    url: getEndpointUrl(url, endpointRuleOptions),
-  };
+  const endpointToReturn: EndpointV2 = { url: getEndpointUrl(url, endpointRuleOptions) };
+  if (headers != undefined) {
+    endpointToReturn.headers = getEndpointHeaders(headers, endpointRuleOptions);
+  }
+  if (properties != undefined) {
+    endpointToReturn.properties = getEndpointProperties(properties, endpointRuleOptions);
+  }
+
+  return endpointToReturn;
 };

packages/util-endpoints/src/utils/evaluateRules.ts

@@ -35,10 +35,12 @@ export const evaluateTreeRule = (treeRule: TreeRuleObject, options: EvaluateOpti
     return;
   }
 
-  return group.evaluateRules(rules, {
-    ...options,
-    referenceRecord: { ...options.referenceRecord, ...referenceRecord },
-  });
+  const treeRuleOptions =
+    Object.keys(referenceRecord ?? {}).length > 0
+      ? { ...options, referenceRecord: { ...options.referenceRecord, ...referenceRecord } }
+      : options;
+
+  return group.evaluateRules(rules, treeRuleOptions);
 };
 
 export const group = {

packages/util-endpoints/src/utils/getEndpointHeaders.ts

@@ -4,15 +4,15 @@ import { evaluateExpression } from "./evaluateExpression";
 
 export const getEndpointHeaders = (headers: EndpointObjectHeaders, options: EvaluateOptions) =>
   Object.entries(headers ?? {}).reduce(
-    (acc, [headerKey, headerVal]) => ({
-      ...acc,
-      [headerKey]: headerVal.map((headerValEntry) => {
+    (acc, [headerKey, headerVal]) => {
+      acc[headerKey] = headerVal.map((headerValEntry) => {
         const processedExpr = evaluateExpression(headerValEntry, "Header value entry", options);
         if (typeof processedExpr !== "string") {
           throw new EndpointError(`Header '${headerKey}' value '${processedExpr}' is not a string`);
         }
         return processedExpr;
-      }),
-    }),
-    {}
+      });
+      return acc;
+    },
+    {} as Record<string, string[]>
   );

packages/util-endpoints/src/utils/getEndpointProperties.ts

@@ -6,11 +6,11 @@ import { evaluateTemplate } from "./evaluateTemplate";
 
 export const getEndpointProperties = (properties: EndpointObjectProperties, options: EvaluateOptions) =>
   Object.entries(properties).reduce(
-    (acc, [propertyKey, propertyVal]) => ({
-      ...acc,
-      [propertyKey]: group.getEndpointProperty(propertyVal, options),
-    }),
-    {}
+    (acc, [propertyKey, propertyVal]) => {
+      acc[propertyKey] = group.getEndpointProperty(propertyVal, options);
+      return acc;
+    },
+    {} as Record<string, EndpointObjectProperty>
   );
 
 export const getEndpointProperty = (