@hyperframes/aws-lambda 0.8.177 → 0.8.179

package/scripts/build-zip.ts

@@ -111,10 +111,10 @@ async function main(): Promise<void> {
   const opts = parseArgs(process.argv);
   const start = Date.now();
 
-  rmSync(distDir, { recursive: true, force: true });
-  mkdirSync(distDir, { recursive: true });
-
+  // Leave the package build in dist/: the release job zips after `bun run build`.
   const stagingDir = join(distDir, "staging");
+  rmSync(stagingDir, { recursive: true, force: true });
+  rmSync(join(distDir, "handler.zip"), { force: true });
   mkdirSync(stagingDir, { recursive: true });
 
   console.log(`[build-zip] source=${opts.source}`);

package/scripts/pin-handler-zip.test.ts

@@ -0,0 +1,101 @@
+import { afterEach, describe, expect, it } from "bun:test";
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { adapterPackageRoot, prebuiltHandler } from "../src/sdk/prebuiltHandler.js";
+import { pinHandlerZip } from "./pin-handler-zip.js";
+
+const realTemplate = readFileSync(
+  join(import.meta.dir, "..", "..", "..", "examples", "aws-lambda", "template.yaml"),
+  "utf-8",
+);
+const dirs: string[] = [];
+
+function fixtureRepo(): { root: string; pkgDir: string } {
+  const root = mkdtempSync(join(tmpdir(), "hf-pin-zip-"));
+  dirs.push(root);
+  const pkgDir = join(root, "packages", "aws-lambda");
+  mkdirSync(join(pkgDir, "dist"), { recursive: true });
+  writeFileSync(
+    join(pkgDir, "package.json"),
+    JSON.stringify({
+      name: "@hyperframes/aws-lambda",
+      version: "9.8.7",
+      repository: { url: "https://github.com/heygen-com/hyperframes" },
+    }),
+  );
+  mkdirSync(join(root, "examples", "aws-lambda"), { recursive: true });
+  writeFileSync(join(root, "examples", "aws-lambda", "template.yaml"), realTemplate);
+  return { root, pkgDir };
+}
+
+afterEach(() => {
+  for (const dir of dirs.splice(0)) rmSync(dir, { recursive: true, force: true });
+});
+
+describe("pinHandlerZip", () => {
+  it("moves the built zip out of the package and pins its URL and sha256 for this version", () => {
+    const { root, pkgDir } = fixtureRepo();
+    const zip = Buffer.from("zip bytes");
+    writeFileSync(join(pkgDir, "dist", "handler.zip"), zip);
+    writeFileSync(join(pkgDir, "dist", "handler.zip.manifest.json"), "{}");
+    const sha256 = createHash("sha256").update(zip).digest("hex");
+
+    const manifest = pinHandlerZip(root);
+
+    expect(manifest).toEqual({
+      version: "9.8.7",
+      url: "https://github.com/heygen-com/hyperframes/releases/download/v9.8.7/hyperframes-lambda-handler.zip",
+      sha256,
+      bytes: zip.length,
+    });
+    // Nothing large is left for npm to pack.
+    expect(existsSync(join(pkgDir, "dist", "handler.zip"))).toBe(false);
+    expect(existsSync(join(pkgDir, "dist", "handler.zip.manifest.json"))).toBe(false);
+    expect(readFileSync(join(root, "dist", "hyperframes-lambda-handler.zip"))).toEqual(zip);
+    expect(readFileSync(join(root, "dist", "hyperframes-lambda-handler.sha256"), "utf-8")).toBe(
+      `${sha256}  hyperframes-lambda-handler.zip\n`,
+    );
+
+    const pinned = prebuiltHandler(pkgDir);
+    expect(pinned).toEqual({
+      ...manifest,
+      templatePath: join(pkgDir, "prebuilt", "template.yaml"),
+    });
+    const template = readFileSync(pinned!.templatePath, "utf-8");
+    expect(template).toContain("      CodeUri: handler.zip\n");
+    expect(template).not.toContain("packages/aws-lambda/dist/handler.zip\n");
+  });
+
+  it("pins a zip a previous run already attached to the release", () => {
+    const { root, pkgDir } = fixtureRepo();
+    mkdirSync(join(root, "dist"));
+    writeFileSync(join(root, "dist", "hyperframes-lambda-handler.zip"), "attached");
+
+    expect(pinHandlerZip(root).sha256).toBe(createHash("sha256").update("attached").digest("hex"));
+    expect(prebuiltHandler(pkgDir)?.sha256).toBe(pinHandlerZip(root).sha256);
+  });
+
+  it("refuses a template whose CodeUri it cannot rewrite", () => {
+    const { root, pkgDir } = fixtureRepo();
+    writeFileSync(join(pkgDir, "dist", "handler.zip"), "zip");
+    writeFileSync(
+      join(root, "examples", "aws-lambda", "template.yaml"),
+      "CodeUri: elsewhere.zip\n",
+    );
+
+    expect(() => pinHandlerZip(root)).toThrow(/expected exactly one/);
+  });
+});
+
+describe("prebuiltHandler", () => {
+  it("reads from its own package root", () => {
+    expect(adapterPackageRoot()).toBe(join(import.meta.dir, ".."));
+  });
+
+  it("is undefined when the package carries no pinned zip", () => {
+    const { pkgDir } = fixtureRepo();
+    expect(prebuiltHandler(pkgDir)).toBeUndefined();
+  });
+});

package/scripts/pin-handler-zip.ts

@@ -0,0 +1,59 @@
+#!/usr/bin/env bun
+// Release step: writes the handler ZIP's pin (asset URL + sha256) and the SAM template into the
+// package. A retried release run reuses the ZIP already on the release.
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+  HANDLER_MANIFEST_FILE,
+  HANDLER_ZIP_ASSET,
+  type HandlerZipManifest,
+  PREBUILT_DIR,
+} from "../src/sdk/prebuiltHandler.js";
+
+const CHECKOUT_CODE_URI = "CodeUri: ../../packages/aws-lambda/dist/handler.zip";
+
+export function pinHandlerZip(repoRoot: string): HandlerZipManifest {
+  const pkgDir = join(repoRoot, "packages", "aws-lambda");
+  const pkg = JSON.parse(readFileSync(join(pkgDir, "package.json"), "utf-8")) as {
+    version: string;
+    repository: { url: string };
+  };
+  const asset = join(repoRoot, "dist", HANDLER_ZIP_ASSET);
+  const built = join(pkgDir, "dist", "handler.zip");
+  if (existsSync(built)) {
+    mkdirSync(dirname(asset), { recursive: true });
+    renameSync(built, asset);
+    rmSync(`${built}.manifest.json`, { force: true });
+  }
+  const bytes = readFileSync(asset);
+  const sha256 = createHash("sha256").update(bytes).digest("hex");
+  writeFileSync(asset.replace(/\.zip$/, ".sha256"), `${sha256}  ${HANDLER_ZIP_ASSET}\n`);
+
+  const template = readFileSync(join(repoRoot, "examples", "aws-lambda", "template.yaml"), "utf-8");
+  if (template.split(CHECKOUT_CODE_URI).length !== 2) {
+    throw new Error(
+      `[pin-handler-zip] expected exactly one "${CHECKOUT_CODE_URI}" in the template`,
+    );
+  }
+  const outDir = join(pkgDir, PREBUILT_DIR);
+  mkdirSync(outDir, { recursive: true });
+  writeFileSync(
+    join(outDir, "template.yaml"),
+    template.replace(CHECKOUT_CODE_URI, "CodeUri: handler.zip"),
+  );
+  const manifest: HandlerZipManifest = {
+    version: pkg.version,
+    url: `${pkg.repository.url}/releases/download/v${pkg.version}/${HANDLER_ZIP_ASSET}`,
+    sha256,
+    bytes: bytes.length,
+  };
+  writeFileSync(join(outDir, HANDLER_MANIFEST_FILE), `${JSON.stringify(manifest, null, 2)}\n`);
+  return manifest;
+}
+
+if (import.meta.main) {
+  const repoRoot = resolve(dirname(fileURLToPath(import.meta.url)), "../../..");
+  console.log(JSON.stringify(pinHandlerZip(repoRoot), null, 2));
+}