refactor: tidy up uploadStaticAssets

Author: danielcondemarin

packages/serverless-nextjs-plugin/lib/__tests__/uploadStaticAssets.test.js

@@ -1,13 +1,13 @@
 const path = require("path");
-const fs = require("fs");
+const fse = require("fs-extra");
 const { when } = require("jest-when");
 const uploadStaticAssets = require("../uploadStaticAssets");
 const parseNextConfiguration = require("../parseNextConfiguration");
 const parsedNextConfigurationFactory = require("../../utils/test/parsedNextConfigurationFactory");
 const ServerlessPluginBuilder = require("../../utils/test/ServerlessPluginBuilder");
 const uploadDirToS3Factory = require("../../utils/s3/upload");
 
-jest.mock("fs");
+jest.mock("fs-extra");
 jest.mock("../../utils/s3/upload");
 jest.mock("../parseNextConfiguration");
 
@@ -19,7 +19,7 @@ describe("uploadStaticAssets", () => {
     uploadDirToS3Factory.mockReturnValue(uploadDirToS3);
   });
 
-  it("should NOT upload build assets when there isn't a bucket available", () => {
+  it("does NOT upload build assets when there isn't a bucket available", () => {
     parseNextConfiguration.mockReturnValueOnce(
       parsedNextConfigurationFactory({}, null)
     );
@@ -31,7 +31,7 @@ describe("uploadStaticAssets", () => {
     });
   });
 
-  it("should upload next build assets", () => {
+  it("uploads next build assets", () => {
     const distDir = "build";
     parseNextConfiguration.mockReturnValueOnce(
       parsedNextConfigurationFactory({
@@ -54,7 +54,7 @@ describe("uploadStaticAssets", () => {
     });
   });
 
-  it("should upload next build assets using bucketName from plugin config", () => {
+  it("uploads next build assets using bucketName from plugin config", () => {
     const distDir = "build";
     parseNextConfiguration.mockReturnValueOnce(
       parsedNextConfigurationFactory({
@@ -80,80 +80,59 @@ describe("uploadStaticAssets", () => {
     });
   });
 
-  it("should upload staticDir", () => {
-    const staticDir = "/path/to/assets";
+  it("uploads static directory", () => {
+    const plugin = new ServerlessPluginBuilder().build();
+    const staticDir = path.join(plugin.nextConfigDir, "static");
 
-    when(fs.readdirSync)
+    when(fse.pathExists)
       .calledWith(staticDir)
-      .mockReturnValueOnce(["foo/bar.js"]);
+      .mockResolvedValueOnce(true);
 
     parseNextConfiguration.mockReturnValueOnce(
       parsedNextConfigurationFactory()
     );
 
-    const plugin = new ServerlessPluginBuilder()
-      .withPluginConfig({
-        staticDir
-      })
-      .build();
-
     return uploadStaticAssets.call(plugin).then(() => {
       expect(uploadDirToS3).toBeCalledWith(staticDir, {
         bucket: "my-bucket",
-        truncate: "assets"
+        truncate: "static"
       });
     });
   });
 
-  it("should upload publicDir", () => {
-    const publicDir = "/path/to/assets";
+  it("uploads public directory", () => {
+    const plugin = new ServerlessPluginBuilder().build();
+    const publicDir = path.join(plugin.nextConfigDir, "public");
 
-    when(fs.readdirSync)
+    when(fse.pathExists)
       .calledWith(publicDir)
-      .mockReturnValueOnce(["foo/bar.js"]);
+      .mockResolvedValueOnce(true);
 
     parseNextConfiguration.mockReturnValueOnce(
       parsedNextConfigurationFactory()
     );
 
-    const plugin = new ServerlessPluginBuilder()
-      .withPluginConfig({
-        publicDir
-      })
-      .build();
-
     return uploadStaticAssets.call(plugin).then(() => {
       expect(uploadDirToS3).toBeCalledWith(publicDir, {
         bucket: "my-bucket",
-        truncate: "assets"
+        truncate: "public"
       });
     });
   });
 
-  it("should not upload build assets", () => {
-    const staticDir = "/path/to/assets";
-
-    when(fs.readdirSync)
-      .calledWith(staticDir)
-      .mockReturnValueOnce(["foo/bar.js"]);
-
+  it("does not upload build assets", () => {
     parseNextConfiguration.mockReturnValueOnce(
       parsedNextConfigurationFactory()
     );
 
     const plugin = new ServerlessPluginBuilder()
       .withPluginConfig({
-        uploadBuildAssets: false,
-        staticDir
+        uploadBuildAssets: false
       })
       .build();
 
     return uploadStaticAssets.call(plugin).then(() => {
-      expect(uploadDirToS3).toBeCalledTimes(1);
-      expect(uploadDirToS3).toBeCalledWith(staticDir, {
-        bucket: "my-bucket",
-        truncate: "assets"
-      });
+      expect(uploadDirToS3).not.toBeCalled();
     });
   });
 });

packages/serverless-nextjs-plugin/lib/uploadStaticAssets.js

@@ -1,21 +1,14 @@
-const fs = require("fs");
+const fse = require("fs-extra");
 const path = require("path");
 const uploadDirToS3Factory = require("../utils/s3/upload");
 
-module.exports = function() {
+module.exports = async function() {
   const uploadDirToS3 = uploadDirToS3Factory(this.providerRequest);
 
   let { nextConfiguration, staticAssetsBucket } = this.configuration;
 
-  const [
-    bucketNameFromConfig,
-    staticDir = "static",
-    publicDir = "public",
-    uploadBuildAssets
-  ] = this.getPluginConfigValues(
+  const [bucketNameFromConfig, uploadBuildAssets] = this.getPluginConfigValues(
     "assetsBucketName",
-    "staticDir",
-    "publicDir",
     "uploadBuildAssets"
   );
 
@@ -29,6 +22,20 @@ module.exports = function() {
 
   const uploadPromises = [];
 
+  const uploadStaticOrPublicDirectory = async dirName => {
+    const dir = path.join(this.nextConfigDir, dirName);
+    const dirExists = await fse.pathExists(dir);
+
+    if (dirExists) {
+      const uploadPromise = uploadDirToS3(dir, {
+        bucket: staticAssetsBucket,
+        truncate: dirName
+      });
+
+      uploadPromises.push(uploadPromise);
+    }
+  };
+
   if (uploadBuildAssets !== false) {
     const buildAssetsUpload = uploadDirToS3(
       path.join(this.nextConfigDir, nextConfiguration.distDir, "static"),
@@ -41,27 +48,8 @@ module.exports = function() {
     uploadPromises.push(buildAssetsUpload);
   }
 
-  const staticFiles = fs.readdirSync(staticDir);
-
-  if (staticFiles) {
-    const staticDirUpload = uploadDirToS3(staticDir, {
-      bucket: staticAssetsBucket,
-      truncate: path.basename(staticDir)
-    });
-
-    uploadPromises.push(staticDirUpload);
-  }
-
-  const publicFiles = fs.readdirSync(publicDir);
-
-  if (publicFiles) {
-    const staticDirUpload = uploadDirToS3(publicDir, {
-      bucket: staticAssetsBucket,
-      truncate: path.basename(publicDir)
-    });
-
-    uploadPromises.push(staticDirUpload);
-  }
+  uploadStaticOrPublicDirectory("static");
+  uploadStaticOrPublicDirectory("public");
 
   return Promise.all(uploadPromises);
 };