mirror of
https://github.com/heygen-com/hyperframes.git
synced 2026-09-05 00:56:23 +00:00
James Russo
34d1f0e1d0
* feat(lambda): add TypeScript SDK and CDK construct
Adds the client-side surface on top of the Phase 6a Lambda handler so
adopters can drive a deployed stack from Node without writing AWS-SDK
boilerplate:
- renderToLambda(opts) starts a Step Functions execution and returns a
handle. Does NOT poll.
- getRenderProgress({ executionArn }) returns a snapshot of progress,
frames rendered, cost (Lambda GB-seconds + SFN transitions), errors,
and the final output object once Assemble completes.
- deploySite({ projectDir, bucketName }) content-addresses the project
tree, tar.gzs it, and uploads to S3 with a HeadObject short-circuit so
re-renders of the same tree skip the tar+PUT.
- validateDistributedRenderConfig throws a typed InvalidConfigError
before StartExecution, so shape errors surface synchronously.
- computeRenderCost is exposed for callers who want to format cost out
of band.
Also ships HyperframesRenderStack, an aws-cdk-lib L2 construct that
emits the same topology as examples/aws-lambda/template.yaml. Lives on
the ./cdk subpath export so SDK-only consumers don't pull aws-cdk-lib
into their runtime graph (declared as an optional peer dependency).
Tests: 24 new unit tests across the SDK plus 9 CDK synth / contract /
snapshot tests. All 83 tests in packages/aws-lambda/src pass.
* refactor(lambda): /simplify pass on the SDK + CDK PR
Pulls shared logic out so the SDK doesn't re-invent things the handler
and the producer already have:
- `formatExtension` extracted to packages/aws-lambda/src/formatExtension.ts.
handler.ts and renderToLambda.ts both used identical 12-line copies of
this switch.
- `PLAN_PROJECT_DIR_SKIP_SEGMENTS` is now exported from
@hyperframes/producer/distributed. deploySite consumes it instead of
its own duplicate SKIP_TOP_LEVEL set; the two lists were trivially
identical and would have drifted silently.
- `FakeS3` + `drainBody` factored out of the two SDK test files into
src/sdk/__fixtures__/fakeS3.ts. Drops ~110 lines of test-file
duplication and gives future SDK tests a one-line FakeS3 import.
- S3 URI building in deploySite and renderToLambda routes through the
existing `formatS3Uri` helper instead of inline `s3://...`
concatenation; matches the convention already in handler.ts.
Net -133 lines across the touched files. All 83 aws-lambda tests still
pass; all 60 producer distributed tests still pass.
* fix(lambda): bump CDK test timeouts for CI cold-start synth
The bun:test default 5s timeout tripped the first CDK snapshot test
in CI when the cold-start `Template.fromStack(stack)` synth took ~5-8s
on the slowest GitHub Actions runner. Locally on a warm shell the
synth measures <1s, so the failure didn't reproduce until PR #909 hit
CI.
Two changes:
- Both CDK test files cache one synth in `beforeAll(..., 30000)` and
reuse the result across every test that uses the default props.
Each individual test now runs in microseconds (pure assertions
against the already-synthed template), so the 5s timeout no longer
applies on the hot path.
- The two contract tests that exercise non-default props
(reservedConcurrency, projectName) still synth fresh per-test; they
get a per-test `it(..., 30000)` timeout.
No behavior changes.
* fix(lambda): address PR review on SDK + CDK construct
Three correctness + ergonomics fixes raised in Vai's review:
- getRenderProgress over-counted SFN transitions by 3-5×. Step
Functions Standard Workflows bill per state-entry, not per
history event. Each Task produces ~5-7 history events
(Scheduled / Started / Succeeded / TaskStateExited / …);
counting `events.length` reported the runaway. Switch to
counting `*StateEntered` events explicitly.
- assembleComplete + outputFile detection was coupled to the
Lambda payload's `Action` field. Move both signals onto the
enclosing state name (`StateExited.name === "Assemble"`), which
is the state-machine identity rather than the Lambda event
contract. framesRendered increment moves to the same boundary
(RenderChunk state).
- SiteHandle now carries `bucketName` directly so README + CLI
callers don't have to re-parse `projectS3Uri.split("/")[2]`.
Test updates: getRenderProgress tests wrap renderChunk/assemble
events in matching StateEntered + StateExited pairs so the new
state-name-driven dispatch is exercised end-to-end. SiteHandle
fixture in renderToLambda.test.ts gets the new bucketName field.
All 83 aws-lambda tests still pass.
149 lines
4.5 KiB
TypeScript
149 lines
4.5 KiB
TypeScript
import { afterEach, beforeEach, describe, expect, it } from "bun:test";
|
|
import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
|
|
import { tmpdir } from "node:os";
|
|
import { join } from "node:path";
|
|
import type { S3Client } from "@aws-sdk/client-s3";
|
|
import { asS3Client, FakeS3 } from "./__fixtures__/fakeS3.js";
|
|
import { deploySite } from "./deploySite.js";
|
|
|
|
let projectDir: string;
|
|
|
|
beforeEach(() => {
|
|
projectDir = mkdtempSync(join(tmpdir(), "hf-deploy-site-test-"));
|
|
mkdirSync(join(projectDir, "assets"));
|
|
writeFileSync(join(projectDir, "index.html"), "<html><body>hi</body></html>");
|
|
writeFileSync(join(projectDir, "assets", "style.css"), "body { color: red; }");
|
|
});
|
|
|
|
afterEach(() => {
|
|
rmSync(projectDir, { recursive: true, force: true });
|
|
});
|
|
|
|
describe("deploySite", () => {
|
|
it("uploads the tarball when no matching object exists", async () => {
|
|
const s3 = new FakeS3();
|
|
const result = await deploySite({
|
|
projectDir,
|
|
bucketName: "test-bucket",
|
|
s3: asS3Client(s3),
|
|
});
|
|
|
|
expect(result.uploaded).toBe(true);
|
|
expect(result.siteId).toMatch(/^[0-9a-f]{16}$/);
|
|
expect(result.bucketName).toBe("test-bucket");
|
|
expect(result.projectS3Uri).toBe(`s3://test-bucket/sites/${result.siteId}/project.tar.gz`);
|
|
expect(result.bytes).toBeGreaterThan(0);
|
|
expect(s3.ops).toEqual([
|
|
{ kind: "head", bucket: "test-bucket", key: `sites/${result.siteId}/project.tar.gz` },
|
|
{ kind: "put", bucket: "test-bucket", key: `sites/${result.siteId}/project.tar.gz` },
|
|
]);
|
|
});
|
|
|
|
it("yields a stable siteId across re-runs of the same tree", async () => {
|
|
const s3a = new FakeS3();
|
|
const a = await deploySite({
|
|
projectDir,
|
|
bucketName: "test-bucket",
|
|
s3: asS3Client(s3a),
|
|
});
|
|
const s3b = new FakeS3();
|
|
const b = await deploySite({
|
|
projectDir,
|
|
bucketName: "test-bucket",
|
|
s3: asS3Client(s3b),
|
|
});
|
|
expect(a.siteId).toBe(b.siteId);
|
|
});
|
|
|
|
it("changes siteId when a file's content changes", async () => {
|
|
const s3 = new FakeS3();
|
|
const before = await deploySite({
|
|
projectDir,
|
|
bucketName: "test-bucket",
|
|
s3: asS3Client(s3),
|
|
});
|
|
|
|
writeFileSync(join(projectDir, "index.html"), "<html><body>changed</body></html>");
|
|
const s3b = new FakeS3();
|
|
const after = await deploySite({
|
|
projectDir,
|
|
bucketName: "test-bucket",
|
|
s3: asS3Client(s3b),
|
|
});
|
|
expect(after.siteId).not.toBe(before.siteId);
|
|
});
|
|
|
|
it("short-circuits on HEAD 200 (skips PUT)", async () => {
|
|
const s3 = new FakeS3();
|
|
const first = await deploySite({
|
|
projectDir,
|
|
bucketName: "test-bucket",
|
|
s3: asS3Client(s3),
|
|
});
|
|
|
|
const second = await deploySite({
|
|
projectDir,
|
|
bucketName: "test-bucket",
|
|
s3: asS3Client(s3),
|
|
});
|
|
|
|
expect(second.uploaded).toBe(false);
|
|
expect(second.siteId).toBe(first.siteId);
|
|
// Only one PUT total, plus two HEADs.
|
|
expect(s3.ops.filter((op) => op.kind === "put")).toHaveLength(1);
|
|
expect(s3.ops.filter((op) => op.kind === "head")).toHaveLength(2);
|
|
});
|
|
|
|
it("honours a caller-supplied siteId", async () => {
|
|
const s3 = new FakeS3();
|
|
const result = await deploySite({
|
|
projectDir,
|
|
bucketName: "test-bucket",
|
|
siteId: "release-v1.2.3",
|
|
s3: asS3Client(s3),
|
|
});
|
|
expect(result.siteId).toBe("release-v1.2.3");
|
|
expect(result.projectS3Uri).toBe("s3://test-bucket/sites/release-v1.2.3/project.tar.gz");
|
|
});
|
|
|
|
it("propagates non-404 S3 errors", async () => {
|
|
const errS3 = {
|
|
async send(_cmd: unknown): Promise<unknown> {
|
|
const err = new Error("Access Denied") as Error & {
|
|
$metadata: { httpStatusCode: number };
|
|
};
|
|
err.$metadata = { httpStatusCode: 403 };
|
|
throw err;
|
|
},
|
|
};
|
|
await expect(
|
|
deploySite({
|
|
projectDir,
|
|
bucketName: "test-bucket",
|
|
s3: errS3 as unknown as S3Client,
|
|
}),
|
|
).rejects.toThrow(/Access Denied/);
|
|
});
|
|
|
|
it("ignores SKIP_TOP_LEVEL dirs when hashing", async () => {
|
|
const s3 = new FakeS3();
|
|
const before = await deploySite({
|
|
projectDir,
|
|
bucketName: "test-bucket",
|
|
s3: asS3Client(s3),
|
|
});
|
|
|
|
mkdirSync(join(projectDir, "node_modules"));
|
|
writeFileSync(join(projectDir, "node_modules", "junk.bin"), "x".repeat(100));
|
|
const s3b = new FakeS3();
|
|
const after = await deploySite({
|
|
projectDir,
|
|
bucketName: "test-bucket",
|
|
s3: asS3Client(s3b),
|
|
});
|
|
|
|
// node_modules contents shouldn't move the hash.
|
|
expect(after.siteId).toBe(before.siteId);
|
|
});
|
|
});
|