feat: Allow File adapter to create file with specific locations or dynamic filenames

Author: AdrianCurtin

spec/CloudCode.spec.js

@@ -4144,11 +4144,13 @@ describe('saveFile hooks', () => {
         foo: 'bar',
       },
     };
+
     expect(createFileSpy).toHaveBeenCalledWith(
       jasmine.any(String),
       newData,
       'text/plain',
-      newOptions
+      newOptions,
+      jasmine.objectContaining({ applicationId: 'test', mount: Parse.serverURL })
     );
   });
 
@@ -4176,11 +4178,13 @@ describe('saveFile hooks', () => {
         foo: 'bar',
       },
     };
+
     expect(createFileSpy).toHaveBeenCalledWith(
       jasmine.any(String),
       newData,
       newContentType,
-      newOptions
+      newOptions,
+      jasmine.objectContaining({ applicationId: 'test', mount: Parse.serverURL })
     );
     const expectedFileName = 'donald_duck.pdf';
     expect(file._name.indexOf(expectedFileName)).toBe(file._name.length - expectedFileName.length);
@@ -4206,11 +4210,13 @@ describe('saveFile hooks', () => {
       metadata: { foo: 'bar' },
       tags: { bar: 'foo' },
     };
+
     expect(createFileSpy).toHaveBeenCalledWith(
       jasmine.any(String),
       jasmine.any(Buffer),
       'text/plain',
-      options
+      options,
+      jasmine.objectContaining({ applicationId: 'test', mount: Parse.serverURL })
     );
   });
 

spec/FilesController.spec.js

@@ -218,4 +218,102 @@ describe('FilesController', () => {
     expect(gridFSAdapter.validateFilename(fileName)).not.toBe(null);
     done();
   });
+
+  it('should return filename and url when adapter returns both', async () => {
+    const config = Config.get(Parse.applicationId);
+    const adapterWithReturn = { ...mockAdapter };
+    adapterWithReturn.createFile = () => {
+      return Promise.resolve({
+        name: 'newFilename.txt',
+        url: 'http://example.com/newFilename.txt'
+      });
+    };
+    adapterWithReturn.getFileLocation = () => {
+      return Promise.resolve('http://example.com/file.txt');
+    };
+    const controllerWithReturn = new FilesController(adapterWithReturn, null, { preserveFileName: true });
+
+    const result = await controllerWithReturn.createFile(
+      config,
+      'originalFile.txt',
+      'data',
+      'text/plain'
+    );
+
+    expect(result.name).toBe('newFilename.txt');
+    expect(result.url).toBe('http://example.com/newFilename.txt');
+  });
+
+  it('should use original filename and generate url when adapter returns nothing', async () => {
+    const config = Config.get(Parse.applicationId);
+    const adapterWithoutReturn = { ...mockAdapter };
+    adapterWithoutReturn.createFile = () => {
+      return Promise.resolve();
+    };
+    adapterWithoutReturn.getFileLocation = (config, filename) => {
+      return Promise.resolve(`http://example.com/${filename}`);
+    };
+
+    const controllerWithoutReturn = new FilesController(adapterWithoutReturn, null, { preserveFileName: true });
+    const result = await controllerWithoutReturn.createFile(
+      config,
+      'originalFile.txt',
+      'data',
+      'text/plain',
+      {}
+    );
+
+    expect(result.name).toBe('originalFile.txt');
+    expect(result.url).toBe('http://example.com/originalFile.txt');
+  });
+
+  it('should use original filename when adapter returns only url', async () => {
+    const config = Config.get(Parse.applicationId);
+    const adapterWithOnlyURL = { ...mockAdapter };
+    adapterWithOnlyURL.createFile = () => {
+      return Promise.resolve({
+        url: 'http://example.com/partialFile.txt'
+      });
+    };
+    adapterWithOnlyURL.getFileLocation = () => {
+      return Promise.resolve('http://example.com/file.txt');
+    };
+
+    const controllerWithPartial = new FilesController(adapterWithOnlyURL, null, { preserveFileName: true });
+    const result = await controllerWithPartial.createFile(
+      config,
+      'originalFile.txt',
+      'data',
+      'text/plain',
+      {}
+    );
+
+    expect(result.name).toBe('originalFile.txt');
+    expect(result.url).toBe('http://example.com/partialFile.txt');
+  });
+
+  it('should use adapter filename and generate url when adapter returns only filename', async () => {
+    const config = Config.get(Parse.applicationId);
+    const adapterWithOnlyFilename = { ...mockAdapter };
+    adapterWithOnlyFilename.createFile = () => {
+      return Promise.resolve({
+        name: 'newname.txt'
+      });
+    };
+    adapterWithOnlyFilename.getFileLocation = (config, filename) => {
+      return Promise.resolve(`http://example.com/${filename}`);
+    };
+
+    const controllerWithOnlyFilename = new FilesController(adapterWithOnlyFilename, null, { preserveFileName: true });
+    const result = await controllerWithOnlyFilename.createFile(
+      config,
+      'originalFile.txt',
+      'data',
+      'text/plain',
+      {}
+    );
+
+    expect(result.name).toBe('newname.txt');
+    expect(result.url).toBe('http://example.com/newname.txt');
+  });
 });

src/Adapters/Files/FilesAdapter.js

@@ -31,12 +31,14 @@ export class FilesAdapter {
    * @discussion the contentType can be undefined if the controller was not able to determine it
    * @param {object} options - (Optional) options to be passed to file adapter (S3 File Adapter Only)
    * - tags: object containing key value pairs that will be stored with file
-   * - metadata: object containing key value pairs that will be sotred with file (https://docs.aws.amazon.com/AmazonS3/latest/user-guide/add-object-metadata.html)
+   * - metadata: object containing key value pairs that will be stored with file (https://docs.aws.amazon.com/AmazonS3/latest/user-guide/add-object-metadata.html)
    * @discussion options are not supported by all file adapters. Check the your adapter's documentation for compatibility
+   * @param {Config} config - (Optional) server configuration
+   * @discussion config may be passed to adapter to allow for more complex configuration and internal call of getFileLocation (if needed). This argument is not supported by all file adapters. Check the your adapter's documentation for compatibility
    *
-   * @return {Promise} a promise that should fail if the storage didn't succeed
+   * @return {Promise<{url?: string, name?: string, location?: string}>|Promise<undefined>} Either a plain promise that should fail if storage didn't succeed, or a promise resolving to an object containing url and/or an updated filename and/or location (if relevant)
    */
-  createFile(filename: string, data, contentType: string, options: Object): Promise {}
+  createFile(filename: string, data, contentType: string, options: Object, config: Config): Promise {}
 
   /** Whether this adapter supports receiving Readable streams in createFile().
    * If false (default), streams are buffered to a Buffer before being passed.

src/Controllers/FilesController.js

@@ -46,11 +46,23 @@ export class FilesController extends AdaptableController {
       });
     }
 
-    const location = await this.adapter.getFileLocation(config, filename);
-    await this.adapter.createFile(filename, data, contentType, options);
+    // The adapter receives the server config so that it can derive a location
+    // itself, and may report back a filename it changed and a url it already
+    // resolved. An adapter that returns nothing keeps the previous behavior.
+    const createResult = await this.adapter.createFile(
+      filename,
+      data,
+      contentType,
+      options,
+      config
+    );
+    // The location has to be resolved after creation, not before, because the
+    // adapter may have renamed the file.
+    const name = createResult?.name || filename;
+    const url = createResult?.url || (await this.adapter.getFileLocation(config, name));
     return {
-      url: location,
-      name: filename,
+      url,
+      name,
     }
   }