fix: Use JSON.parse(JSON.stringify()) for HTTP parity, strip query params, add tests

- Replace custom stripUndefined with JSON.parse(JSON.stringify()) for correct
  JSON.stringify semantics (handles toJSON, nested objects, special types)
- Strip undefined from GET query params for full HTTP parity
- Add nested undefined assertions to existing update tests
- Add POST (create) tests with undefined values for both directAccess and HTTP mode

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: yog27ray

spec/ParseServerRESTController.spec.js

@@ -745,13 +745,31 @@ describe('ParseServerRESTController', () => {
     await RESTController.request('PUT', `/classes/MyObject/${createRes.objectId}`, {
       presentField: 'updated',
       absentField: undefined,
+      nested: { absentField: undefined, presentField: 'value' },
     });
 
     const getRes = await RESTController.request('GET', `/classes/MyObject/${createRes.objectId}`);
 
     expect(getRes.presentField).toBe('updated');
     expect(getRes.absentField).toBeUndefined();
     expect('absentField' in getRes).toBe(false);
+    expect(getRes.nested).toBeDefined();
+    expect(getRes.nested.presentField).toBe('value');
+    expect('absentField' in getRes.nested).toBe(false);
+  });
+
+  it('should not convert undefined values to null on create with directAccess', async () => {
+    const createRes = await RESTController.request('POST', '/classes/MyObject', {
+      presentField: 'hello',
+      absentField: undefined,
+    });
+    expect(createRes.objectId).toBeDefined();
+
+    const getRes = await RESTController.request('GET', `/classes/MyObject/${createRes.objectId}`);
+
+    expect(getRes.presentField).toBe('hello');
+    expect(getRes.absentField).toBeUndefined();
+    expect('absentField' in getRes).toBe(false);
   });
 
   it('should not convert undefined values to null on update without directAccess (HTTP mode)', async () => {
@@ -774,7 +792,7 @@ describe('ParseServerRESTController', () => {
       method: 'PUT',
       headers,
       url: `${serverURL}/classes/MyObject/${createRes.data.objectId}`,
-      body: { presentField: 'updated', absentField: undefined },
+      body: { presentField: 'updated', absentField: undefined, nested: { absentField: undefined, presentField: 'value' } },
     });
 
     const getRes = await request({
@@ -786,5 +804,35 @@ describe('ParseServerRESTController', () => {
     expect(getRes.data.presentField).toBe('updated');
     expect(getRes.data.absentField).toBeUndefined();
     expect('absentField' in getRes.data).toBe(false);
+    expect(getRes.data.nested).toBeDefined();
+    expect(getRes.data.nested.presentField).toBe('value');
+    expect('absentField' in getRes.data.nested).toBe(false);
+  });
+
+  it('should not convert undefined values to null on create without directAccess (HTTP mode)', async () => {
+    const serverURL = 'http://localhost:8378/1';
+    const headers = {
+      'Content-Type': 'application/json',
+      'X-Parse-Application-Id': Parse.applicationId,
+      'X-Parse-Master-Key': Parse.masterKey,
+    };
+
+    const createRes = await request({
+      method: 'POST',
+      headers,
+      url: `${serverURL}/classes/MyObject`,
+      body: { presentField: 'hello', absentField: undefined },
+    });
+    expect(createRes.data.objectId).toBeDefined();
+
+    const getRes = await request({
+      method: 'GET',
+      headers,
+      url: `${serverURL}/classes/MyObject/${createRes.data.objectId}`,
+    });
+
+    expect(getRes.data.presentField).toBe('hello');
+    expect(getRes.data.absentField).toBeUndefined();
+    expect('absentField' in getRes.data).toBe(false);
   });
 });

src/ParseServerRESTController.js

@@ -29,22 +29,6 @@ function getAuth(options = {}, config) {
   });
 }
 
-function stripUndefined(obj) {
-  if (obj === null || obj === undefined || typeof obj !== 'object') {
-    return obj;
-  }
-  if (Array.isArray(obj)) {
-    return obj.map(item => item === undefined ? null : stripUndefined(item));
-  }
-  const result = {};
-  for (const key of Object.keys(obj)) {
-    if (obj[key] !== undefined) {
-      result[key] = stripUndefined(obj[key]);
-    }
-  }
-  return result;
-}
-
 function ParseServerRESTController(applicationId, router) {
   function handleRequest(method, path, data = {}, options = {}, config) {
     // Store the arguments, for later use if internal fails
@@ -129,7 +113,7 @@ function ParseServerRESTController(applicationId, router) {
     return new Promise((resolve, reject) => {
       getAuth(options, config).then(auth => {
         const request = {
-          body: stripUndefined(data),
+          body: JSON.parse(JSON.stringify(data)),
           config,
           auth,
           info: {
@@ -138,7 +122,7 @@ function ParseServerRESTController(applicationId, router) {
             installationId: options.installationId,
             context: options.context || {},
           },
-          query,
+          query: query ? JSON.parse(JSON.stringify(query)) : query,
         };
         return Promise.resolve()
           .then(() => {
@@ -147,7 +131,7 @@ function ParseServerRESTController(applicationId, router) {
           .then(
             resp => {
               const { response, status, headers = {} } = resp;
-              const strippedResponse = stripUndefined(response);
+              const strippedResponse = JSON.parse(JSON.stringify(response));
               if (options.returnStatus) {
                 resolve({ ...strippedResponse, _status: status, _headers: headers });
               } else {