fix: graphql upload for all versions

Author: Moumouls

package-lock.json

@@ -6835,7 +6835,7 @@ describe('ParseGraphQLServer', () => {
 
       describe('Files Mutations', () => {
         describe('Create', () => {
-          it_only_node_version('<17')('should return File object', async () => {
+          it('should return File object', async () => {
             const clientMutationId = uuidv4();
 
             parseServer = await global.reconfigureServer({
@@ -9301,7 +9301,7 @@ describe('ParseGraphQLServer', () => {
           expect(result6[0].node.name).toEqual('imACountry3');
         });
 
-        it_only_node_version('<17')('should support files', async () => {
+        it('should support files', async () => {
           try {
             parseServer = await global.reconfigureServer({
               publicServerURL: 'http://localhost:13377/parse',
@@ -9452,7 +9452,9 @@ describe('ParseGraphQLServer', () => {
               body: body2,
             });
             expect(res.status).toEqual(200);
-            const result2 = JSON.parse(await res.text());
+            const resText = await res.text();
+            const result2 = JSON.parse(resText);
+            console.log('result2', resText);
             expect(result2.data.createSomeClass1.someClass.someField.name).toEqual(
               jasmine.stringMatching(/_myFileName.txt$/)
             );
@@ -9510,7 +9512,6 @@ describe('ParseGraphQLServer', () => {
                 id: result2.data.createSomeClass1.someClass.id,
               },
             });
-
             expect(typeof getResult.data.someClass.someField).toEqual('object');
             expect(getResult.data.someClass.someField.name).toEqual(
               result.data.createFile.fileInfo.name
@@ -9549,9 +9550,14 @@ describe('ParseGraphQLServer', () => {
           }
         });
 
-        it_only_node_version('<17')('should not upload if file is too large', async () => {
+        it('should not upload if file is too large', async () => {
           parseGraphQLServer.parseServer.config.maxUploadSize = '1kb';
-
+          const options = await parseGraphQLServer._getGraphQLOptions();
+          expect(new options.fetchApi.Body().options).toEqual({
+            formDataLimits: {
+              fileSize: 1024,
+            },
+          });
           const body = new FormData();
           body.append(
             'operations',
@@ -9588,9 +9594,9 @@ describe('ParseGraphQLServer', () => {
             headers,
             body,
           });
-
           const result = JSON.parse(await res.text());
-          expect(res.status).toEqual(500);
+          console.log(result);
+          expect(res.status).toEqual(413);
           expect(result.errors[0].message).toEqual('File size limit exceeded: 1024 bytes');
         });
 

spec/ParseGraphQLServer.spec.js

@@ -32,6 +32,11 @@ class ParseGraphQLServer {
 
   async _getGraphQLOptions() {
     try {
+      const formDataLimits = {
+        fileSize: this._transformMaxUploadSizeToBytes(
+          this.parseServer.config.maxUploadSize || '20mb'
+        ),
+      };
       return {
         schema: await this.parseGraphQLSchema.load(),
         context: ({ req: { info, config, auth } }) => ({
@@ -40,13 +45,19 @@ class ParseGraphQLServer {
           auth,
         }),
         maskedErrors: false,
+        // Needed to ensure formDataLimits since it seems to not working
+        // this is a temporary fix until the issue is resolved
+        // we need to ask graphql-yoga team
+        plugins: [
+          {
+            onRequestParse: ({ request }) => {
+              request.options.formDataLimits = formDataLimits;
+            },
+          },
+        ],
         fetchApi: createFetch({
           useNodeFetch: true,
-          formDataLimits: {
-            fileSize: this._transformMaxUploadSizeToBytes(
-              this.parseServer.config.maxUploadSize || '20mb'
-            ),
-          },
+          formDataLimits,
         }),
       };
     } catch (e) {
@@ -89,6 +100,7 @@ class ParseGraphQLServer {
     app.use(this.config.graphQLPath, handleParseSession);
     app.use(this.config.graphQLPath, handleParseErrors);
     app.use(this.config.graphQLPath, async (req, res) => {
+      // console.log("here", req)
       const server = await this._getServer();
       return server(req, res);
     });

src/GraphQL/ParseGraphQLServer.js

@@ -5,10 +5,10 @@ import * as defaultGraphQLTypes from './defaultGraphQLTypes';
 import logger from '../../logger';
 
 const handleUpload = async (upload, config) => {
-  const data = Buffer.from(upload.arrayBuffer ? await upload.arrayBuffer() : upload.blobParts);
+  const data = await upload.buffer();
   const fileName = upload.name;
   const type = upload.type;
-
+  console.log('data.length', data.length);
   if (!data || !data.length) {
     throw new Parse.Error(Parse.Error.FILE_SAVE_ERROR, 'Invalid file upload.');
   }

src/GraphQL/loaders/filesMutations.js

@@ -82,6 +82,7 @@ const load = function (parseGraphQLSchema, parseClass, parseClassConfig: ?ParseG
           const parseFields = await transformTypes('create', fields, {
             className,
             parseGraphQLSchema,
+            originalFields: args.fields || {},
             req: { config, auth, info },
           });
 
@@ -190,6 +191,7 @@ const load = function (parseGraphQLSchema, parseClass, parseClassConfig: ?ParseG
           const parseFields = await transformTypes('update', fields, {
             className,
             parseGraphQLSchema,
+            originalFields: args.fields || {},
             req: { config, auth, info },
           });
 

src/GraphQL/loaders/parseClassMutations.js

@@ -38,6 +38,7 @@ const load = parseGraphQLSchema => {
         const parseFields = await transformTypes('create', fields, {
           className: '_User',
           parseGraphQLSchema,
+          originalFields: args.fields || {},
           req: { config, auth, info },
         });
 
@@ -114,6 +115,7 @@ const load = parseGraphQLSchema => {
         const parseFields = await transformTypes('create', fields, {
           className: '_User',
           parseGraphQLSchema,
+          originalFields: args.fields || {},
           req: { config, auth, info },
         });
 

src/GraphQL/loaders/usersMutations.js

@@ -3,11 +3,12 @@ import { fromGlobalId } from 'graphql-relay';
 import { handleUpload } from '../loaders/filesMutations';
 import * as defaultGraphQLTypes from '../loaders/defaultGraphQLTypes';
 import * as objectsMutations from '../helpers/objectsMutations';
+import deepcopy from 'deepcopy';
 
 const transformTypes = async (
   inputType: 'create' | 'update',
   fields,
-  { className, parseGraphQLSchema, req }
+  { className, parseGraphQLSchema, req, originalFields }
 ) => {
   const {
     classGraphQLCreateType,
@@ -44,7 +45,9 @@ const transformTypes = async (
             fields[field] = transformers.polygon(fields[field]);
             break;
           case inputTypeField.type === defaultGraphQLTypes.FILE_INPUT:
-            fields[field] = await transformers.file(fields[field], req);
+            // fields are a deepcopy, but we can't deepcopy a stream so
+            // we use the original fields from the graphql request
+            fields[field] = await transformers.file(originalFields[field], req);
             break;
           case parseClass.fields[field].type === 'Relation':
             fields[field] = await transformers.relation(
@@ -152,9 +155,10 @@ const transformers = {
       nestedObjectsToAdd = (
         await Promise.all(
           value.createAndAdd.map(async input => {
-            const parseFields = await transformTypes('create', input, {
+            const parseFields = await transformTypes('create', deepcopy(input), {
               className: targetClass,
               parseGraphQLSchema,
+              originalFields: input || {},
               req: { config, auth, info },
             });
             return objectsMutations.createObject(targetClass, parseFields, config, auth, info);
@@ -213,9 +217,10 @@ const transformers = {
 
     let nestedObjectToAdd;
     if (value.createAndLink) {
-      const parseFields = await transformTypes('create', value.createAndLink, {
+      const parseFields = await transformTypes('create', deepcopy(value.createAndLink), {
         className: targetClass,
         parseGraphQLSchema,
+        originalFields: value.createAndLink || {},
         req: { config, auth, info },
       });
       nestedObjectToAdd = await objectsMutations.createObject(