fix: treat an explicit undefined parameters argument as {}

withParameterDefaults detected "no parameters" for any non-object in the
slot, then inserted the filled object after it. So calling a method with an
explicit undefined — a type-valid call, since the parameter is optional —
e.g. payments.page(undefined) or payments.get(id, undefined), left the
undefined in the parameters position and silently dropped the defaults.

Now the slot is replaced when it is occupied (an object, or an explicit
undefined/null standing in for {}); insertion only happens when no
parameters argument was passed (a leading id, or nothing). This also
flattens the branch. Adds tests covering the undefined case on both
id-less and id-methods.

Author: janpaepke

src/plumbing/withParameterDefaults.ts

@@ -63,16 +63,23 @@ export default function withParameterDefaults<T extends object>(target: T, netwo
             // (no `enumerable` ‒ the wrappers stay non-enumerable, like the prototype methods they shadow)
             value(this: unknown, ...args: unknown[]) {
               // The parameters object sits just before a trailing callback (or is the last argument). The `id` is a
-              // string and the callback is a function, so an object at that position is always the parameters.
+              // string and the callback is a function, so a non-string at that position is the parameters ‒ which the
+              // caller may have passed explicitly as `undefined`, equivalent to `{}`.
               const slot = typeof args[args.length - 1] == 'function' ? args.length - 1 : args.length;
               const parameters = args[slot - 1];
               const hasParameters = parameters != null && typeof parameters == 'object';
               const base = (hasParameters ? parameters : {}) as Record<string, unknown>;
               const filled = applyDefaults(networkClient.parameterDefaults, base, keys as Array<keyof ParameterDefaults>);
-              if (hasParameters) {
+              // Nothing was filled (no defaults apply, or the call already set them) ‒ leave the arguments untouched.
+              if (filled === base) {
+                return original.apply(this, args);
+              }
+              // Replace the parameters slot when it is occupied ‒ by an object, or by an explicit `undefined`/`null`
+              // standing in for `{}`. Otherwise only a leading `id` (a string) or nothing was passed, so insert the
+              // filled object before any trailing callback.
+              if (slot >= 1 && typeof parameters != 'string') {
                 args[slot - 1] = filled;
-              } else if (filled !== base) {
-                // No parameters object was passed, but a default applied ‒ insert it (before any trailing callback).
+              } else {
                 args.splice(slot, 0, filled);
               }
               return original.apply(this, args);

tests/unit/defaults.test.ts

@@ -51,6 +51,28 @@ test('injects the client defaults even when no parameters object is passed', ()
   });
 });
 
+test('treats an explicit undefined parameters argument the same as {}', () => {
+  return new NetworkMocker(clientWith({ testmode: true, profileId: 'pfl_mock' })).use(async ([mollieClient, networkMocker]) => {
+    networkMocker.intercept('GET', '/payments?testmode=true&profileId=pfl_mock', 200, paymentsPage).twice();
+
+    // Passing `undefined` is type-valid (the parameter is optional) and must inject just like `{}` ‒ not be dropped.
+    const payments = await bluster(mollieClient.payments.page.bind(mollieClient.payments))(undefined);
+
+    expect(payments.length).toBe(1);
+  });
+});
+
+test('treats an explicit undefined parameters argument the same as {} for id-methods', () => {
+  return new NetworkMocker(clientWith({ testmode: true, profileId: 'pfl_mock' })).use(async ([mollieClient, networkMocker]) => {
+    // payments.get accepts testmode (not profileId), so only testmode is injected into the query.
+    networkMocker.intercept('GET', '/payments/tr_mock0001?testmode=true', 200, payment).twice();
+
+    const result = await bluster(mollieClient.payments.get.bind(mollieClient.payments))('tr_mock0001', undefined);
+
+    expect(result.id).toBe('tr_mock0001');
+  });
+});
+
 test('injects the client defaults into the request body', () => {
   return new NetworkMocker(clientWith({ testmode: true, profileId: 'pfl_mock' })).use(async ([mollieClient, networkMocker]) => {
     let capturedBody: any;