all basic functionality done

Author: danielcondemarin

packages/s3-static-assets/src/index.ts

@@ -1,14 +1,31 @@
+import AWS from "aws-sdk";
 import path from "path";
 import fse from "fs-extra";
-import mime from "mime-types";
-import AWS from "aws-sdk";
 import readDirectoryFiles from "./lib/readDirectoryFiles";
+import filterOutDirectories from "./lib/filterOutDirectories";
+import { IMMUTABLE_CACHE_CONTROL_HEADER } from "./lib/constants";
+import S3ClientFactory, { S3Client } from "./lib/s3";
 
 type UploadStaticAssetsOptions = {
   bucketName: string;
   nextConfigDir: string;
 };
 
+const uploadPublicOrStaticDirectory = async (
+  s3: S3Client,
+  directory: "public" | "static",
+  nextConfigDir: string
+): Promise<Promise<AWS.S3.ManagedUpload.SendData>[]> => {
+  const files = await readDirectoryFiles(path.join(nextConfigDir, directory));
+
+  return files.filter(filterOutDirectories).map(fileItem =>
+    s3.uploadFile({
+      filePath: fileItem.path,
+      s3Key: path.posix.relative(path.resolve(nextConfigDir), fileItem.path)
+    })
+  );
+};
+
 const filePathToS3Key = (filePath: string): string => {
   const relevantFilePathPart = filePath.substring(
     filePath.indexOf(".next" + path.sep)
@@ -18,10 +35,12 @@ const filePathToS3Key = (filePath: string): string => {
 
 const uploadStaticAssets = async (
   options: UploadStaticAssetsOptions
-): Promise<void> => {
+): Promise<AWS.S3.ManagedUpload.SendData> => {
   const { bucketName, nextConfigDir } = options;
 
-  const s3 = new AWS.S3();
+  const s3 = S3ClientFactory({
+    bucketName
+  });
 
   const dotNextDirectory = path.join(nextConfigDir, ".next");
 
@@ -33,54 +52,56 @@ const uploadStaticAssets = async (
     path.join(dotNextDirectory, "static", BUILD_ID)
   );
 
-  const uploadTasks = buildStaticFiles
-    .filter(item => !item.stats.isDirectory())
+  const nextBuildFileUploads = buildStaticFiles
+    .filter(filterOutDirectories)
     .map(async fileItem => {
-      const fileBody = await fse.readFile(fileItem.path);
-
       const s3Key = filePathToS3Key(fileItem.path);
 
-      return s3
-        .upload({
-          Bucket: bucketName,
-          Key: s3Key,
-          Body: fileBody,
-          ContentType:
-            mime.lookup(path.basename(fileItem.path)) ||
-            "application/octet-stream",
-          CacheControl: "public, max-age=31536000, immutable"
-        })
-        .promise();
+      return s3.uploadFile({
+        s3Key,
+        filePath: fileItem.path,
+        cacheControl: IMMUTABLE_CACHE_CONTROL_HEADER
+      });
     });
 
   const pagesManifest = await fse.readJSON(
     path.join(dotNextDirectory, "serverless/pages-manifest.json")
   );
 
-  const htmlPageUploadTasks = Object.values(pagesManifest)
+  const htmlPageUploads = Object.values(pagesManifest)
     .filter(pageFile => (pageFile as string).endsWith(".html"))
-    .map(async pageFile => {
-      const fileBody = await fse.readFile(
-        path.join(dotNextDirectory, `serverless/${pageFile}`)
+    .map(relativePageFilePath => {
+      const pageFilePath = path.join(
+        dotNextDirectory,
+        `serverless/${relativePageFilePath}`
       );
 
-      return s3
-        .upload({
-          Bucket: bucketName,
-          Key: `static-pages/${(pageFile as string).replace(/^pages\//, "")}`,
-          Body: fileBody,
-          ContentType: "text/html",
-          CacheControl: undefined
-        })
-        .promise();
+      return s3.uploadFile({
+        s3Key: `static-pages/${relativePageFilePath.replace(/^pages\//, "")}`,
+        filePath: pageFilePath
+      });
     });
 
-  uploadTasks.concat(htmlPageUploadTasks);
+  const publicDirUploads = await uploadPublicOrStaticDirectory(
+    s3,
+    "public",
+    nextConfigDir
+  );
+
+  const staticDirUploads = await uploadPublicOrStaticDirectory(
+    s3,
+    "static",
+    nextConfigDir
+  );
+
+  const allUploads = [
+    ...nextBuildFileUploads,
+    ...htmlPageUploads,
+    ...publicDirUploads,
+    ...staticDirUploads
+  ];
 
-  await Promise.all(uploadTasks);
-  // read public/ folder and upload files
-  // read static/ folder and upload files
-  // get JSON data files from prerender manifest
+  return Promise.all(allUploads);
 };
 
 export default uploadStaticAssets;

packages/s3-static-assets/src/lib/filterOutDirectories.ts

@@ -0,0 +1,3 @@
+import { Item } from "klaw";
+
+export default (fileItem: Item): boolean => !fileItem.stats.isDirectory();

packages/s3-static-assets/src/lib/getMimeType.ts

@@ -0,0 +1,5 @@
+import mime from "mime-types";
+import path from "path";
+
+export default (filePath: string): string =>
+  mime.lookup(path.basename(filePath)) || "application/octet-stream";

packages/s3-static-assets/src/lib/s3.ts

@@ -0,0 +1,43 @@
+import getMimeType from "./getMimeType";
+import fse from "fs-extra";
+import AWS from "aws-sdk";
+
+type S3ClientFactoryOptions = {
+  bucketName: string;
+};
+
+type UploadFileOptions = {
+  filePath: string;
+  cacheControl?: string;
+  s3Key?: string;
+};
+
+export type S3Client = {
+  uploadFile: (
+    options: UploadFileOptions
+  ) => Promise<AWS.S3.ManagedUpload.SendData>;
+};
+
+export default ({ bucketName }: S3ClientFactoryOptions): S3Client => {
+  const s3 = new AWS.S3();
+
+  return {
+    uploadFile: async (
+      options: UploadFileOptions
+    ): Promise<AWS.S3.ManagedUpload.SendData> => {
+      const { filePath, cacheControl, s3Key } = options;
+
+      const fileBody = await fse.readFile(filePath);
+
+      return s3
+        .upload({
+          Bucket: bucketName,
+          Key: s3Key || filePath,
+          Body: fileBody,
+          ContentType: getMimeType(filePath),
+          CacheControl: cacheControl || undefined
+        })
+        .promise();
+    }
+  };
+};

packages/s3-static-assets/tests/fixtures/basic-next-app/public/robots.txt

@@ -1,6 +1,6 @@
 import path from "path";
 import uploadStaticAssets from "../src/index";
-import { IMMUTABLE_CACHE_CONTROL_HEADER } from "../src/constants";
+import { IMMUTABLE_CACHE_CONTROL_HEADER } from "../src/lib/constants";
 import { mockUpload } from "aws-sdk";
 
 declare module "aws-sdk" {
@@ -16,8 +16,6 @@ describe("Upload assets tests", () => {
   });
 
   it("uploads any contents inside build directory specified in BUILD_ID", async () => {
-    expect(mockUpload).toBeCalledTimes(2);
-
     expect(mockUpload).toBeCalledWith({
       Bucket: "test-bucket-name",
       Key: "_next/static/a_test_build_id/two.js",
@@ -47,10 +45,45 @@ describe("Upload assets tests", () => {
     expect(mockUpload).toBeCalledWith(
       expect.objectContaining({
         Key: "static-pages/todos/terms/[section].html",
-        Body: expect.any(Buffer),
         ContentType: "text/html",
         CacheControl: undefined
       })
     );
   });
+
+  it("uploads files in the public folder", async () => {
+    expect(mockUpload).toBeCalledWith(
+      expect.objectContaining({
+        Key: "public/robots.txt",
+        ContentType: "text/plain",
+        CacheControl: undefined
+      })
+    );
+
+    expect(mockUpload).toBeCalledWith(
+      expect.objectContaining({
+        Key: "public/scripts/test-script.js",
+        ContentType: "application/javascript",
+        CacheControl: undefined
+      })
+    );
+  });
+
+  it("uploads files in the static folder", async () => {
+    expect(mockUpload).toBeCalledWith(
+      expect.objectContaining({
+        Key: "static/robots.txt",
+        ContentType: "text/plain",
+        CacheControl: undefined
+      })
+    );
+
+    expect(mockUpload).toBeCalledWith(
+      expect.objectContaining({
+        Key: "static/scripts/test-script.js",
+        ContentType: "application/javascript",
+        CacheControl: undefined
+      })
+    );
+  });
 });