@hyperframes/aws-lambda 0.8.181 → 0.8.184

package/scripts/build-zip.test.ts

@@ -1,77 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { spawnSync } from "node:child_process";
-import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { pathToFileURL } from "node:url";
-import * as esbuild from "esbuild";
-import { HANDLER_BANNER } from "./_handlerBanner.js";
-
-// The handler ships as ESM (.mjs) but inlines CJS deps that assume Node's CJS
-// globals exist at module scope: postcss et al. call top-level `require(...)`,
-// and wawoff2's emscripten build reads `__dirname`. A freshly deployed stack
-// crashed on every render (#1932) with "__dirname is not defined in ES module
-// scope"; the fix is the require/__filename/__dirname shim in HANDLER_BANNER.
-//
-// This bundles a fixture touching all three globals with the REAL banner and
-// imports the output, so it catches a dropped/renamed shim behaviourally
-// rather than by grepping for literals (which survives a broken refactor).
-//
-// The import MUST run under Node, not the `bun test` runtime: Bun defines
-// `__dirname`/`__filename` even in ESM, which would mask a missing shim and
-// green-light a broken bundle. Lambda runs Node, so we spawn `node` (guaranteed
-// present in CI alongside bun) to reproduce the deploy target faithfully.
-describe("build-zip handler banner", () => {
-  it("shims require/__filename/__dirname so inlined CJS deps import under Node", () => {
-    const dir = mkdtempSync(join(tmpdir(), "hf-banner-test-"));
-    try {
-      const entry = join(dir, "fixture.ts");
-      const outfile = join(dir, "out.mjs");
-      // Reference each CJS global at module top level, the way inlined deps do.
-      // If any shim is missing, importing `out.mjs` throws at eval time.
-      writeFileSync(
-        entry,
-        [
-          "const cjsDir = __dirname;",
-          "const cjsFile = __filename;",
-          "const path = require('node:path');",
-          "if (typeof cjsDir !== 'string') throw new Error('__dirname missing');",
-          "if (typeof cjsFile !== 'string') throw new Error('__filename missing');",
-          "if (typeof path.join !== 'function') throw new Error('require missing');",
-          "console.log('BANNER_OK');",
-        ].join("\n"),
-      );
-
-      esbuild.buildSync({
-        bundle: true,
-        platform: "node",
-        target: "node22",
-        format: "esm",
-        entryPoints: [entry],
-        outfile,
-        banner: { js: HANDLER_BANNER },
-      });
-
-      // Import under real Node — Lambda's runtime — not the bun test runtime.
-      const res = spawnSync(
-        "node",
-        [
-          "--input-type=module",
-          "-e",
-          `await import(${JSON.stringify(pathToFileURL(outfile).href)});`,
-        ],
-        { encoding: "utf8" },
-      );
-
-      // A missing shim surfaces as a non-zero exit + ReferenceError on stderr.
-      // Guard against a silent skip if `node` isn't on PATH (it is in CI).
-      expect(res.error).toBeUndefined();
-      expect(res.stderr).not.toContain("is not defined in ES module scope");
-      expect(res.stderr).not.toContain("Dynamic require");
-      expect(res.status).toBe(0);
-      expect(res.stdout).toContain("BANNER_OK");
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-});

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

@@ -1,101 +0,0 @@
-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/probe-beginframe.test.ts

@@ -1,80 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join, resolve } from "node:path";
-import {
-  _awaitBeforeDeadlineForTests,
-  _closeBrowserForProbeTests,
-  parseProbeArgs,
-} from "./probe-beginframe.js";
-
-describe("parseProbeArgs", () => {
-  it("defaults to the @sparticuz/chromium source", () => {
-    expect(parseProbeArgs([])).toEqual({});
-  });
-
-  it("accepts a standalone executable path", () => {
-    expect(parseProbeArgs(["--executable-path", "/opt/chrome/chrome-headless-shell"])).toEqual({
-      executablePath: "/opt/chrome/chrome-headless-shell",
-    });
-  });
-
-  it("accepts the equals form and resolves relative paths", () => {
-    expect(parseProbeArgs(["--executable-path=./chrome"])).toEqual({
-      executablePath: resolve("./chrome"),
-    });
-  });
-
-  it("loads exact production launch arguments from JSON", () => {
-    const dir = mkdtempSync(join(tmpdir(), "hf-probe-args-"));
-    const argsPath = join(dir, "args.json");
-    writeFileSync(argsPath, JSON.stringify(["--enable-begin-frame-control", "--no-sandbox"]));
-    try {
-      expect(parseProbeArgs(["--launch-args-json", argsPath])).toEqual({
-        launchArgs: ["--enable-begin-frame-control", "--no-sandbox"],
-      });
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-
-  it("rejects missing values and unknown arguments", () => {
-    expect(() => parseProbeArgs(["--executable-path"])).toThrow(
-      "--executable-path requires a path",
-    );
-    expect(() => parseProbeArgs(["--source", "chrome"])).toThrow("Unknown argument: --source");
-    expect(() => parseProbeArgs(["--launch-args-json"])).toThrow(
-      "--launch-args-json requires a path",
-    );
-  });
-
-  it("bounds a CDP operation that never resolves", async () => {
-    const never = new Promise<never>(() => {});
-    await expect(
-      _awaitBeforeDeadlineForTests(never, Date.now() + 25, "screenshot beginFrame"),
-    ).rejects.toThrow("timeout during screenshot beginFrame");
-  });
-
-  it("force-kills and disconnects when graceful cleanup never resolves", async () => {
-    let killedWith: NodeJS.Signals | number | undefined;
-    let disconnected = false;
-    await _closeBrowserForProbeTests(
-      {
-        close: () => new Promise<never>(() => {}),
-        process: () => ({
-          kill: (signal) => {
-            killedWith = signal;
-            return true;
-          },
-        }),
-        disconnect: async () => {
-          disconnected = true;
-        },
-      },
-      25,
-    );
-
-    expect(killedWith).toBe("SIGKILL");
-    expect(disconnected).toBe(true);
-  });
-});