feat(oas-to-har): retain null values in array (#998)

| 🚥 Resolves ISSUE_ID |
| :------------------- |

## 🧰 Changes

This PR is part of the work for the readme ticket [RM-9906 Not
displaying null values in an
array](https://linear.app/readme-io/issue/RM-9906/not-displaying-null-values-in-an-array)
and should get merged ONLY after the corresponding PR changes in the
`remove-undefined-objects` repo is shipped

The aim of the ticket is we want user-added null values in arrays to be
visible in requests.

This requires adjustments in the oas-to-har package, with two separate
causes of why the nulls in array are being dropped
1. For postData (body):
- Issue: remove-undefined-objects was filtering out null values in
arrays.
- Fix: Replaced JSON.parse/stringify approach with a custom function to
distinguish actual null vs. undefined.
Updated stripEmptyObjects to stop removing null values in arrays, while
still removing undefined, empty objects, and empty arrays.
2. For Non-postData (parameters, cookies, etc.):
- Issue: encodeArray in style-serializer used .join, which dropped null
values.
- Fix: Convert null values to the string "null" before joining, so
they’re preserved.

TODO Before Merging:
- [ ] Update the remove-undefined-object package version once this PR is
shipped:
[https://github.com/readmeio/remove-undefined-objects/pull/149](https://github.com/readmeio/remove-undefined-objects/pull/149)

## 🧬 QA & Testing

- Temporarily migrated tests for remove-undefined-objects to show the
changes works
- Run oasToHar or oasToSnippet in a script with an OAS object containing
arrays of null, undefined, and undefined objects

---------

Co-authored-by: Jon Ursenbach <[email protected]>

Author: eaglethrost

package-lock.json

@@ -150,7 +150,7 @@ function isPrimitive(val: unknown) {
 }
 
 function stringify(json: Record<string | 'RAW_BODY', unknown>) {
-  return JSON.stringify(removeUndefinedObjects(typeof json.RAW_BODY !== 'undefined' ? json.RAW_BODY : json));
+  return JSON.stringify(removeUndefinedObjects(typeof json.RAW_BODY !== 'undefined' ? json.RAW_BODY : json, { preserveNullishArrays: true }));
 }
 
 function stringifyParameter(param: any): string {
@@ -420,7 +420,8 @@ export default function oasToHar(
 
     if (operation.isFormUrlEncoded()) {
       if (Object.keys(formData.formData || {}).length) {
-        const cleanFormData = removeUndefinedObjects(JSON.parse(JSON.stringify(formData.formData)));
+        const cleanFormData = removeUndefinedObjects(formData.formData, { preserveNullishArrays: true });
+
         if (cleanFormData !== undefined) {
           const postData: PostData = { params: [], mimeType: 'application/x-www-form-urlencoded' };
 
@@ -444,7 +445,7 @@ export default function oasToHar(
 
       if (isMultipart || isJSON) {
         try {
-          let cleanBody = removeUndefinedObjects(JSON.parse(JSON.stringify(formData.body)));
+          let cleanBody = removeUndefinedObjects(formData.body, { preserveNullishArrays: true });
 
           if (isMultipart) {
             har.postData = { params: [], mimeType: 'multipart/form-data' };

packages/oas-to-har/src/index.ts

@@ -119,13 +119,21 @@ function encodeArray({
   escape,
   isAllowedReserved = false,
 }: Omit<StylizerConfig, 'value'> & { value: string[] }) {
-  const valueEncoder = (str: string) =>
-    encodeDisallowedCharacters(str, {
+  const valueEncoder = (str: string) => {
+    // Handle null values explicitly to prevent join() from converting to empty string
+    if (str === null) {
+      return 'null';
+    }
+
+    const result = encodeDisallowedCharacters(str, {
       escape,
       returnIfEncoded: location === 'query',
       isAllowedReserved,
     });
 
+    return result;
+  };
+
   switch (style) {
     /**
      * @example <caption>`style: simple`</caption>

packages/oas-to-har/src/lib/style-formatting/style-serializer.ts

@@ -172,7 +172,7 @@ describe('parameter handling', () => {
           parameters: [{ name: 'id', in: 'query' }],
         },
         { query: { id: [null, null] } },
-        [{ name: 'id', value: '&id=' }],
+        [{ name: 'id', value: 'null&id=null' }],
       ),
     );
 
@@ -207,6 +207,28 @@ describe('parameter handling', () => {
           ],
         },
         { query: {} },
+        [{ name: 'id', value: 'null&id=null' }],
+      ),
+    );
+
+    it(
+      'should handle mixed array with null, undefined, and normal values',
+      assertQueryParams(
+        {
+          parameters: [{ name: 'id', in: 'query' }],
+        },
+        { query: { id: [null, undefined, 'normal', null, 'test'] } },
+        [{ name: 'id', value: 'null&id=&id=normal&id=null&id=test' }],
+      ),
+    );
+
+    it(
+      'should handle array with only undefined values',
+      assertQueryParams(
+        {
+          parameters: [{ name: 'id', in: 'query' }],
+        },
+        { query: { id: [undefined, undefined] } },
         [{ name: 'id', value: '&id=' }],
       ),
     );

packages/oas-to-har/test/parameters.test.ts

@@ -1085,6 +1085,52 @@ describe('request body handling', () => {
       expect(har.log.entries[0].request.postData).toBeUndefined();
     });
 
+    it('should preserve null values in arrays & still remove undefined values', () => {
+      const spec = Oas.init({
+        paths: {
+          '/requestBody': {
+            post: {
+              requestBody: {
+                content: {
+                  'application/x-www-form-urlencoded': {
+                    schema: {
+                      type: 'object',
+                      properties: {
+                        foo: {
+                          type: 'array',
+                          items: {
+                            type: 'string',
+                            nullable: true,
+                          },
+                        },
+                        foo2: {
+                          type: 'array',
+                          items: {
+                            type: 'number',
+                          },
+                        },
+                      },
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+      });
+
+      const har = oasToHar(spec, spec.operation('/requestBody', 'post'), {
+        formData: { foo: [null, null, undefined], foo2: [1, 2] },
+      });
+
+      expect(har.log.entries[0].request.postData?.params).toStrictEqual([
+        // Since null is not a primitive, it will be JSON stringified which retains the square brackets
+        // See line 156-164 of src/index.ts
+        { name: 'foo', value: '[null,null]' },
+        { name: 'foo2', value: '1,2' },
+      ]);
+    });
+
     it('should pass in value if one is set and prioritize provided values', () => {
       const spec = Oas.init({
         paths: {