Add postinstall & hash handling step

Author: codenem

packages/cli-v3/e2e/compile.ts

@@ -233,5 +233,10 @@ export async function compile(options: CompileOptions) {
   // Save the entryPoint outputFile to /tmp/dir/index.js
   await writeFile(join(tempDir, "index.js"), entryPointOutputFile.text);
 
-  return { metaOutput, entryPointMetaOutput };
+  return {
+    workerMetaOutput: metaOutput,
+    workerOutputFile,
+    entryPointMetaOutput,
+    entryPointOutputFile,
+  };
 }

packages/cli-v3/e2e/createContainerFile.ts

@@ -0,0 +1,38 @@
+import { readFileSync } from "node:fs";
+import { writeFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { cliRootPath } from "../src/utilities/resolveInternalFilePath";
+import { ReadConfigResult } from "../src/utilities/configFiles";
+
+type CreateContainerFileOptions = {
+  resolvedConfig: ReadConfigResult;
+  tempDir: string;
+};
+
+export async function createContainerFile(options: CreateContainerFileOptions) {
+  if (options.resolvedConfig.status === "error") {
+    throw new Error("cannot resolve config");
+  }
+  const {
+    resolvedConfig: { config },
+    tempDir,
+  } = options;
+
+  // COPIED FROM compileProject()
+  // Write the Containerfile to /mpt / dir / Containerfile;
+  // const containerFilePath = join(cliRootPath(), "Containerfile.prod");
+  const containerFilePath = resolve("./src/Containerfile.prod");
+
+  let containerFileContents = readFileSync(containerFilePath, "utf-8");
+
+  if (config.postInstall) {
+    containerFileContents = containerFileContents.replace(
+      "__POST_INSTALL__",
+      `RUN ${config.postInstall}`
+    );
+  } else {
+    containerFileContents = containerFileContents.replace("__POST_INSTALL__", "");
+  }
+
+  await writeFile(join(tempDir, "Containerfile"), containerFileContents);
+}

packages/cli-v3/e2e/createDeployHash.ts

@@ -0,0 +1,28 @@
+import { createHash } from "node:crypto";
+import { OutputFile } from "esbuild";
+
+type CreateDeployHashOptions = {
+  dependencies: { [k: string]: string };
+  entryPointOutputFile: OutputFile;
+  workerOutputFile: OutputFile;
+};
+
+export async function createDeployHash(options: CreateDeployHashOptions) {
+  const { entryPointOutputFile, workerOutputFile } = options;
+
+  // COPIED FROM compileProject()
+  const contentHasher = createHash("sha256");
+  contentHasher.update(Buffer.from(entryPointOutputFile.text));
+  contentHasher.update(Buffer.from(workerOutputFile.text));
+  contentHasher.update(Buffer.from(JSON.stringify(dependencies)));
+
+  const contentHash = contentHasher.digest("hex");
+
+  // span.setAttributes({
+  //   contentHash: contentHash,
+  // });
+
+  // span.end();
+
+  return { contentHash };
+}

packages/cli-v3/e2e/handleDependencies.ts

@@ -109,4 +109,6 @@ export async function handleDependencies(options: HandleDependenciesOptions) {
   if (!resolvingDependenciesResult) {
     throw new SkipLoggingError("Failed to resolve dependencies");
   }
+
+  return { dependencies };
 }

packages/cli-v3/e2e/index.test.ts

@@ -10,6 +10,8 @@ import { PackageManager } from "../src/utilities/getUserPackageManager";
 import { logger } from "../src/utilities/logger";
 import { compile } from "./compile";
 import { handleDependencies } from "./handleDependencies";
+import { createContainerFile } from "./createContainerFile";
+import { createDeployHash } from "./createDeployHash";
 
 type TestCase = {
   name: string;
@@ -175,12 +177,19 @@ if (testCases.length > 0) {
           async () => {
             const expectation = expect(
               (async () => {
-                const { entryPointMetaOutput, metaOutput } = await compile({
+                const {
+                  workerMetaOutput,
+                  workerOutputFile,
+                  entryPointMetaOutput,
+                  entryPointOutputFile,
+                } = await compile({
                   resolvedConfig: global.resolvedConfig!,
                   tempDir: global.tempDir!,
                 });
                 global.entryPointMetaOutput = entryPointMetaOutput;
-                global.metaOutput = metaOutput;
+                global.entryPointOutputFile = entryPointOutputFile;
+                global.workerMetaOutput = workerMetaOutput;
+                global.workerOutputFile = workerOutputFile;
               })()
             );
 
@@ -196,21 +205,24 @@ if (testCases.length > 0) {
         describe.skipIf(wantCompilationError)("with successful compilation", () => {
           afterAll(() => {
             delete global.entryPointMetaOutput;
-            delete global.metaOutput;
+            delete global.entryPointOutputFile;
+            delete global.workerMetaOutput;
+            delete global.workerOutputFile;
           });
 
           test(
             wantDependenciesError ? "does not resolve dependencies" : "resolves dependencies",
             async () => {
               const expectation = expect(
                 (async () => {
-                  await handleDependencies({
+                  const { dependencies } = await handleDependencies({
                     entryPointMetaOutput: global.entryPointMetaOutput!,
-                    metaOutput: global.metaOutput!,
+                    metaOutput: global.workerMetaOutput!,
                     resolvedConfig: global.resolvedConfig!,
                     tempDir: global.tempDir!,
                     packageManager,
                   });
+                  global.dependencies = dependencies;
                 })()
               );
 
@@ -222,6 +234,35 @@ if (testCases.length > 0) {
             },
             { timeout: 60_000 }
           );
+
+          describe.skipIf(wantDependenciesError)("with resolved dependencies", () => {
+            afterAll(() => {
+              delete global.dependencies;
+            });
+
+            test("copies postinstall command into Containerfile.prod", async () => {
+              await expect(
+                (async () => {
+                  await createContainerFile({
+                    resolvedConfig: global.resolvedConfig!,
+                    tempDir: global.tempDir!,
+                  });
+                })()
+              ).resolves.not.toThrowError();
+            });
+
+            test("creates deploy hash", async () => {
+              await expect(
+                (async () => {
+                  await createDeployHash({
+                    dependencies: global.dependencies!,
+                    entryPointOutputFile: global.entryPointOutputFile!,
+                    workerOutputFile: global.workerOutputFile!,
+                  });
+                })()
+              ).resolves.not.toThrowError();
+            });
+          });
         });
       });
     }

packages/cli-v3/e2e/vitest.d.ts

@@ -1,10 +1,13 @@
-import { Metafile } from "esbuild";
+import { Metafile, OutputFile } from "esbuild";
 
 import { ReadConfigResult } from "../src/utilities/configFiles";
 
 declare global {
+  var dependencies: { [k: string]: string } | undefined;
+  var entryPointMetaOutput: Metafile["outputs"]["out/stdin.js"] | undefined;
+  var entryPointOutputFile: OutputFile | undefined;
   var resolvedConfig: ReadConfigResult | undefined;
   var tempDir: string | undefined;
-  var metaOutput: Metafile["outputs"]["out/stdin.js"] | undefined;
-  var entryPointMetaOutput: Metafile["outputs"]["out/stdin.js"] | undefined;
+  var workerMetaOutput: Metafile["outputs"]["out/stdin.js"] | undefined;
+  var workerOutputFile: OutputFile | undefined;
 }