@ripplo/testing 0.4.7 → 0.5.0

package/dist/lockfile.js

@@ -1,6 +1,7 @@
 import "./chunk-4MGIQFAJ.js";
 
 // src/lockfile.ts
+import { createHash } from "crypto";
 import fs from "fs/promises";
 import path from "path";
 
@@ -500,6 +501,7 @@ var observerSchema = z9.object({
 // src/lockfile.ts
 import { z as z10 } from "zod";
 var LOCKFILE_RELATIVE_PATH = ".ripplo/ripplo.lock";
+var FIXTURES_RELATIVE_PATH = ".ripplo/fixtures";
 var MAX_TESTS = 5e3;
 var requiresKeysSchema = z10.record(z10.string().max(200), z10.string().max(200));
 var compiledTestSchema = z10.object({
@@ -512,14 +514,32 @@ var compiledTestSchema = z10.object({
   sourcePath: z10.string().max(500).optional(),
   spec: workflowSpecSchema
 });
-var lockfileBodySchema = z10.object({
+var fixtureEntrySchema = z10.object({
+  sha256: z10.string().regex(/^[0-9a-f]{64}$/u),
+  size: z10.number().int().nonnegative()
+});
+var fixturesMapSchema = z10.record(z10.string().min(1).max(500), fixtureEntrySchema);
+var lockfileBodyV1Schema = z10.object({
+  observers: z10.record(z10.string().max(200), observerSchema),
+  preconditions: z10.record(z10.string().max(200), preconditionSchema),
+  tests: z10.array(compiledTestSchema).max(MAX_TESTS)
+});
+var lockfileBodyV2Schema = z10.object({
+  fixtures: fixturesMapSchema,
   observers: z10.record(z10.string().max(200), observerSchema),
   preconditions: z10.record(z10.string().max(200), preconditionSchema),
   tests: z10.array(compiledTestSchema).max(MAX_TESTS)
 });
-var lockfileCodec = defineCodec("ripplo-lockfile").initial(lockfileBodySchema).build();
+var lockfileCodec = defineCodec("ripplo-lockfile").initial(lockfileBodyV1Schema).upgrade(
+  lockfileBodyV2Schema,
+  (prev) => ({
+    ...prev,
+    fixtures: {}
+  })
+).build();
 function compileResultToLockfile(result) {
   return {
+    fixtures: { ...result.fixtures },
     observers: result.observers,
     preconditions: result.preconditions,
     tests: result.tests.filter((test) => test.implemented).map((test) => ({
@@ -547,12 +567,76 @@ async function readLockfile({ cwd }) {
   }
   return decodeJson(lockfileCodec, raw);
 }
+var MAX_FIXTURE_BYTES = 10 * 1024 * 1024;
+var MAX_TOTAL_FIXTURE_BYTES = 50 * 1024 * 1024;
 async function writeLockfile({ cwd, result }) {
-  const lockfile = compileResultToLockfile(result);
+  const hydrated = await hashFixturesIntoCompileResult({ cwd, result });
+  const lockfile = compileResultToLockfile(hydrated);
   const lockfilePath = path.join(cwd, LOCKFILE_RELATIVE_PATH);
   await fs.mkdir(path.dirname(lockfilePath), { recursive: true });
   await fs.writeFile(lockfilePath, serializeLockfile(lockfile), "utf8");
 }
+async function hashFixturesIntoCompileResult({
+  cwd,
+  result
+}) {
+  const referenced = collectFixtureReferences(result);
+  if (referenced.size === 0) {
+    return { ...result, fixtures: {} };
+  }
+  const fixturesRoot = path.join(cwd, FIXTURES_RELATIVE_PATH);
+  const sortedNames = [...referenced].toSorted((a, b) => a.localeCompare(b));
+  const hashed = await Promise.all(
+    sortedNames.map(async (name) => {
+      const entry = await hashOneFixture({ fixturesRoot, name });
+      if (entry.size > MAX_FIXTURE_BYTES) {
+        throw new Error(
+          `Fixture "${name}" is ${String(entry.size)} bytes; exceeds per-file limit of ${String(MAX_FIXTURE_BYTES)} bytes`
+        );
+      }
+      return [name, entry];
+    })
+  );
+  const total = hashed.reduce((sum, [, entry]) => sum + entry.size, 0);
+  if (total > MAX_TOTAL_FIXTURE_BYTES) {
+    throw new Error(
+      `Total fixtures size exceeds limit of ${String(MAX_TOTAL_FIXTURE_BYTES)} bytes`
+    );
+  }
+  return { ...result, fixtures: Object.fromEntries(hashed) };
+}
+async function hashOneFixture({ fixturesRoot, name }) {
+  if (name.includes("..") || path.isAbsolute(name)) {
+    throw new Error(`Invalid fixture name "${name}": must be a path under .ripplo/fixtures/`);
+  }
+  const abs = path.join(fixturesRoot, name);
+  const stat = await fs.lstat(abs).catch((error) => {
+    if (isNodeError(error) && error.code === "ENOENT") {
+      throw new Error(`Fixture "${name}" not found at ${abs}`);
+    }
+    throw error;
+  });
+  if (stat.isSymbolicLink()) {
+    throw new Error(`Fixture "${name}" is a symlink; symlinks are not allowed`);
+  }
+  if (!stat.isFile()) {
+    throw new Error(`Fixture "${name}" is not a regular file`);
+  }
+  const bytes = await fs.readFile(abs);
+  const sha256 = createHash("sha256").update(bytes).digest("hex");
+  return { sha256, size: bytes.byteLength };
+}
+function collectFixtureReferences(result) {
+  const names = /* @__PURE__ */ new Set();
+  result.tests.forEach((test) => {
+    Object.values(test.spec.nodes).forEach((node) => {
+      if (node.type === "upload") {
+        node.files.forEach((name) => names.add(name));
+      }
+    });
+  });
+  return names;
+}
 function compareCompileToLockfile({
   compiled,
   existing
@@ -589,9 +673,11 @@ function isPlainObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 export {
+  FIXTURES_RELATIVE_PATH,
   LOCKFILE_RELATIVE_PATH,
   compareCompileToLockfile,
   compileResultToLockfile,
+  hashFixturesIntoCompileResult,
   lockfileCodec,
   readLockfile,
   serializeLockfile,

package/dist/nestjs.d.ts

@@ -1,7 +1,7 @@
 import { DynamicModule } from '@nestjs/common';
-import { R as RipploEngine } from './engine-DMOkJdjd.js';
-import './builder-BMjy83Iy.js';
-import './types-16SB7zjP.js';
+import { R as RipploEngine } from './engine-DVbF4E5A.js';
+import './builder-DiVz3t1D.js';
+import './types-BzZrl65Z.js';
 import './step-De52hTLd.js';
 import '@ripplo/spec';
 

package/dist/nestjs.js

@@ -1,12 +1,12 @@
 import {
   batchRequestSchema,
-  buildSetCookieHeader,
   observerRequestSchema,
   readAdapterWebhookSecret,
-  serializeCookie,
   teardownRequestSchema,
+  toBatchRunResults,
+  toTeardownResults,
   verifyWebhookSignature
-} from "./chunk-V6LMXKGL.js";
+} from "./chunk-XO36IU66.js";
 import {
   __decorateClass,
   __decorateParam
@@ -45,25 +45,15 @@ function createController(path) {
       }
       const parsed = batchRequestSchema.safeParse(req.body);
       if (!parsed.success) {
-        res.status(400).json({ error: "Invalid request body", success: false });
+        res.status(400).json({ error: "Invalid request body" });
         return;
       }
       const host = req.get("host") ?? "";
       const proto = req.get("x-forwarded-proto") ?? req.protocol;
       const appUrl = `${proto}://${host}`;
-      const result = await this.opts.engine.executePreconditions(parsed.data.preconditions, {
-        appUrl
-      });
-      result.cookies.forEach((cookie) => {
-        res.append("Set-Cookie", buildSetCookieHeader(serializeCookie(cookie)));
-      });
-      res.status(200).json({
-        data: result.data,
-        error: result.error,
-        executed: result.executed,
-        runId: result.runId,
-        success: result.success
-      });
+      const items = parsed.data.batch.map((b) => ({ names: b.preconditions, runId: b.runId }));
+      const results = await this.opts.engine.executePreconditions(items, { appUrl });
+      res.status(200).json({ results: toBatchRunResults(results) });
     }
     async executeObserver(req, res) {
       if (!guard(req, res, this.opts)) {
@@ -86,11 +76,16 @@ function createController(path) {
       }
       const parsed = teardownRequestSchema.safeParse(req.body);
       if (!parsed.success) {
-        res.status(400).json({ error: "Invalid request body", success: false });
+        res.status(400).json({ error: "Invalid request body" });
         return;
       }
-      await this.opts.engine.teardown(parsed.data.preconditions, parsed.data.data);
-      res.status(200).json({ success: true });
+      const items = parsed.data.batch.map((b) => ({
+        data: b.data,
+        names: b.preconditions,
+        runId: b.runId
+      }));
+      const results = await this.opts.engine.teardown(items);
+      res.status(200).json({ results: toTeardownResults(results) });
     }
   };
   __decorateClass([

package/dist/nextjs.d.ts

@@ -1,6 +1,6 @@
-import { R as RipploEngine } from './engine-DMOkJdjd.js';
-import './builder-BMjy83Iy.js';
-import './types-16SB7zjP.js';
+import { R as RipploEngine } from './engine-DVbF4E5A.js';
+import './builder-DiVz3t1D.js';
+import './types-BzZrl65Z.js';
 import './step-De52hTLd.js';
 import '@ripplo/spec';
 

package/dist/nextjs.js

@@ -1,12 +1,12 @@
 import {
   batchRequestSchema,
-  buildSetCookieHeader,
   observerRequestSchema,
   readAdapterWebhookSecret,
-  serializeCookie,
   teardownRequestSchema,
+  toBatchRunResults,
+  toTeardownResults,
   verifyWebhookSignature
-} from "./chunk-V6LMXKGL.js";
+} from "./chunk-XO36IU66.js";
 import "./chunk-4MGIQFAJ.js";
 
 // src/adapters/nextjs.ts
@@ -59,38 +59,31 @@ async function handleExecutePreconditions({
   const json = tryParseJson(body);
   const parsed = json == null ? null : batchRequestSchema.safeParse(json);
   if (parsed == null || !parsed.success) {
-    return jsonResponse({ error: "Invalid request body", success: false }, 400);
+    return jsonResponse({ error: "Invalid request body" }, 400);
   }
   const host = req.headers.get("host");
   if (host == null || host.length === 0) {
-    return jsonResponse({ error: "Missing host header", success: false }, 400);
+    return jsonResponse({ error: "Missing host header" }, 400);
   }
   const proto = req.headers.get("x-forwarded-proto") ?? "http";
   const appUrl = `${proto}://${host}`;
-  const result = await engine.executePreconditions(parsed.data.preconditions, { appUrl });
-  const headers = new Headers({ "content-type": "application/json" });
-  result.cookies.forEach((cookie) => {
-    headers.append("Set-Cookie", buildSetCookieHeader(serializeCookie(cookie)));
-  });
-  return new Response(
-    JSON.stringify({
-      data: result.data,
-      error: result.error,
-      executed: result.executed,
-      runId: result.runId,
-      success: result.success
-    }),
-    { headers, status: 200 }
-  );
+  const items = parsed.data.batch.map((b) => ({ names: b.preconditions, runId: b.runId }));
+  const results = await engine.executePreconditions(items, { appUrl });
+  return jsonResponse({ results: toBatchRunResults(results) }, 200);
 }
 async function handleTeardown({ body, engine }) {
   const json = tryParseJson(body);
   const parsed = json == null ? null : teardownRequestSchema.safeParse(json);
   if (parsed == null || !parsed.success) {
-    return jsonResponse({ error: "Invalid request body", success: false }, 400);
+    return jsonResponse({ error: "Invalid request body" }, 400);
   }
-  await engine.teardown(parsed.data.preconditions, parsed.data.data);
-  return jsonResponse({ success: true }, 200);
+  const items = parsed.data.batch.map((b) => ({
+    data: b.data,
+    names: b.preconditions,
+    runId: b.runId
+  }));
+  const results = await engine.teardown(items);
+  return jsonResponse({ results: toTeardownResults(results) }, 200);
 }
 async function verifyAndReadBody(req, webhookSecret) {
   if (webhookSecret.length === 0) {

package/dist/{types-16SB7zjP.d.ts → types-BzZrl65Z.d.ts}

@@ -40,6 +40,13 @@ interface Precondition<TData extends Record<string, Primitive> = Record<string,
 }
 type PreconditionData<T extends Precondition> = T[typeof PRECONDITION_DATA];
 type PreconditionDeps<T extends Precondition> = T[typeof PRECONDITION_DEPS];
+interface PreconditionDefinitionSetupItem {
+    readonly ctx: SetupContext;
+    readonly deps: Record<string, Record<string, Primitive>>;
+}
+interface PreconditionDefinitionTeardownItem {
+    readonly ctx: TeardownContext<Record<string, Primitive>>;
+}
 interface PreconditionDefinition {
     readonly dependsOn: ReadonlyArray<string>;
     readonly depMapping: ReadonlyArray<readonly [string, string]>;
@@ -47,8 +54,8 @@ interface PreconditionDefinition {
     readonly implemented: boolean;
     readonly name: string;
     readonly returns: ReadonlyArray<string>;
-    readonly teardown: ((ctx: TeardownContext<Record<string, Primitive>>) => Promise<void>) | undefined;
-    readonly setup: (ctx: SetupContext, deps: Record<string, Record<string, Primitive>>) => Promise<Record<string, Primitive>>;
+    readonly teardown: ((items: ReadonlyArray<PreconditionDefinitionTeardownItem>) => Promise<void>) | undefined;
+    readonly setup: (items: ReadonlyArray<PreconditionDefinitionSetupItem>) => Promise<ReadonlyArray<Record<string, Primitive>>>;
 }
 type VarsFn<T> = (vars: Record<string, Record<string, Primitive>>) => T;
 interface TestDefinition {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ripplo/testing",
   "description": "TypeScript DSL for defining and running Ripplo e2e workflow tests",
-  "version": "0.4.7",
+  "version": "0.5.0",
   "type": "module",
   "files": [
     "dist"
@@ -99,8 +99,8 @@
     "tsup": "^8.5.1",
     "typescript": "catalog:",
     "vitest": "^4.1.4",
-    "@ripplo/spec": "^0.0.0",
-    "@ripplo/eslint-config": "0.0.0"
+    "@ripplo/eslint-config": "0.0.0",
+    "@ripplo/spec": "^0.0.0"
   },
   "peerDependencies": {
     "@nestjs/common": "^10.0.0 || ^11.0.0",