@ripplo/testing 0.4.7 → 0.5.0

package/dist/index.js

@@ -14,13 +14,15 @@ import {
 } from "./chunk-YQAEOH5W.js";
 import {
   compile
-} from "./chunk-DL3HLCD7.js";
+} from "./chunk-YFOTJIVF.js";
 import "./chunk-MGATMMCZ.js";
 import {
-  buildSetCookieHeader,
+  readAdapterWebhookSecret,
   serializeCookie,
+  toBatchRunResults,
+  toTeardownResults,
   verifyWebhookSignature
-} from "./chunk-V6LMXKGL.js";
+} from "./chunk-XO36IU66.js";
 import "./chunk-4MGIQFAJ.js";
 
 // src/chainable.ts
@@ -149,7 +151,7 @@ function stubPreconditionDef(p) {
     name,
     returns: [],
     teardown: void 0,
-    setup: () => Promise.resolve({})
+    setup: () => Promise.resolve([])
   };
 }
 function stubObserverDef(o) {
@@ -780,6 +782,30 @@ function observerParamsReferenceVariables(nodes, test2, report) {
     });
   });
 }
+function uploadFixtureName(nodes, _test, report) {
+  nodes.forEach((node) => {
+    if (node.type !== "upload") {
+      return;
+    }
+    node.files.forEach((name) => {
+      if (name.length === 0) {
+        report({
+          message: `upload "${node.label ?? node.id}" references an empty fixture name`,
+          rule: "upload-fixture-name",
+          step: node.label ?? node.id
+        });
+        return;
+      }
+      if (name.includes("..") || name.startsWith("/")) {
+        report({
+          message: `upload "${node.label ?? node.id}" references "${name}" \u2014 fixture names must be relative paths under .ripplo/fixtures/, no ".." or absolute paths`,
+          rule: "upload-fixture-name",
+          step: node.label ?? node.id
+        });
+      }
+    });
+  });
+}
 function noLiteralTemplateStrings(nodes, test2, report) {
   const declaredKeys = new Set(Object.keys(test2.spec.variables ?? {}));
   const pattern = /\{\{([^{}]+?)\}\}/g;
@@ -818,7 +844,8 @@ var RULES = [
   tautologicalPostClickAssert,
   expectedOutcomeKeywordCoverage,
   mutationWithoutObserverCoverage,
-  observerParamsReferenceVariables
+  observerParamsReferenceVariables,
+  uploadFixtureName
 ];
 
 // src/engine.ts
@@ -835,7 +862,7 @@ function createEngine(ripplo, impls) {
   const observersByName = new Map(observerDefs.map((d) => [d.name, d]));
   return {
     executeObserver: (name, params) => executeObserver(observersByName, name, params),
-    executePreconditions: (names, options) => executePreconditions({ defsByName: preconditionsByName, names, options }),
+    executePreconditions: (items, options) => executePreconditions({ defsByName: preconditionsByName, items, options }),
     getObservers: () => observerDefs,
     getPreconditions: () => preconditionDefs,
     getUnimplemented: () => ({
@@ -843,7 +870,7 @@ function createEngine(ripplo, impls) {
       preconditions: preconditionDefs.filter((p) => !p.implemented).map((p) => p.name),
       tests: ripplo.tests.filter((t) => !t.implemented).map((t) => t.id)
     }),
-    teardown: (names, data) => teardown(preconditionsByName, names, data)
+    teardown: (items) => teardown({ defsByName: preconditionsByName, items })
   };
 }
 function wirePreconditions(registry, impls) {
@@ -888,17 +915,34 @@ function makeWiredPreconditionDef(handle, impl) {
     implemented: true,
     name,
     returns: [],
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- typedImpl.teardown has narrower TData, wider context at engine boundary
-    teardown: typedImpl.teardown,
-    setup: async (ctx, allDeps) => {
-      const resolved = {};
-      mapping.forEach(([key, depName]) => {
-        const data = allDeps[depName];
-        if (data != null) {
-          resolved[key] = data;
-        }
+    setup: async (items) => {
+      const resolvedItems = items.map((item) => {
+        const resolved = {};
+        mapping.forEach(([key, depName]) => {
+          const data = item.deps[depName];
+          if (data != null) {
+            resolved[key] = data;
+          }
+        });
+        return { ctx: item.ctx, deps: resolved };
+      });
+      const results = await typedImpl.setup(resolvedItems);
+      return results.map((r) => {
+        const out = {};
+        Object.entries(r).forEach(([key, value]) => {
+          if (!isPrimitive(value)) {
+            throw new TypeError(
+              `Precondition "${name}" returned non-primitive value at key "${key}". Setup return values must be string, number, or boolean \u2014 produced via ctx.fixed/uniqueEmail/uniqueId.`
+            );
+          }
+          out[key] = value;
+        });
+        return out;
       });
-      return typedImpl.setup(ctx, resolved);
+    },
+    teardown: async (items) => {
+      const typed = items;
+      await typedImpl.teardown(typed);
     }
   };
 }
@@ -939,88 +983,170 @@ function readBudgetOf(handle) {
 }
 async function executePreconditions({
   defsByName,
-  names,
+  items,
   options
 }) {
-  const runId = crypto.randomUUID().slice(0, 12);
-  const cookies = [];
   const defaultDomain = deriveDefaultDomain(options?.appUrl);
-  const state = {
-    cookies,
-    ctx: createSetupContext({ cookies, defaultDomain, runId }),
-    data: {},
-    defsByName,
-    executed: [],
-    runId
-  };
-  return runBatchSequence(state, names);
+  const initial = items.map((item) => {
+    const cookiesRef = [];
+    return {
+      cookies: cookiesRef,
+      cookiesRef,
+      ctx: createSetupContext({ cookies: cookiesRef, defaultDomain, runId: item.runId }),
+      data: {},
+      executed: [],
+      failure: void 0,
+      names: item.names,
+      runId: item.runId
+    };
+  });
+  const order = topoOrder(defsByName, items);
+  const orderError = order.error;
+  if (orderError != null) {
+    return initial.map((s) => failResult(s, orderError));
+  }
+  const sequence = order.names ?? [];
+  let states = initial;
+  let i = 0;
+  while (i < sequence.length) {
+    const name = sequence[i];
+    if (name != null) {
+      states = await executeStep({ defsByName, name, states });
+    }
+    i += 1;
+  }
+  return states.map(
+    (s) => s.failure == null ? {
+      cookies: s.cookiesRef,
+      data: s.data,
+      error: void 0,
+      executed: s.executed,
+      runId: s.runId,
+      success: true
+    } : failResult(s, s.failure)
+  );
 }
-async function runBatchSequence(state, names) {
-  let index = 0;
-  while (index < names.length) {
-    const name = names[index];
-    if (name == null) {
-      break;
+function topoOrder(defsByName, items) {
+  const seen = /* @__PURE__ */ new Set();
+  const order = [];
+  const visiting = /* @__PURE__ */ new Set();
+  const visitDeps = (deps) => {
+    const found = deps.find((d) => visit(d) != null);
+    return found == null ? void 0 : visit(found);
+  };
+  const visit = (name) => {
+    if (seen.has(name)) {
+      return void 0;
     }
-    const error = validatePrecondition(state.defsByName, name);
-    if (error != null) {
-      return fail(state, error);
+    if (visiting.has(name)) {
+      return `Cycle detected at precondition "${name}"`;
     }
-    const stepError = await executeOnePrecondition(state, name);
-    if (stepError != null) {
-      return fail(state, stepError);
+    const def = defsByName.get(name);
+    if (def == null) {
+      return `Unknown precondition: "${name}"`;
     }
-    index += 1;
-  }
-  return {
-    cookies: state.cookies,
-    data: state.data,
-    error: void 0,
-    executed: state.executed,
-    runId: state.runId,
-    success: true
+    visiting.add(name);
+    const deps = def.depMapping.map(([, depName]) => depName);
+    const cycleError = visitDeps(deps);
+    visiting.delete(name);
+    if (cycleError != null) {
+      return cycleError;
+    }
+    seen.add(name);
+    order.push(name);
+    return void 0;
   };
+  let err;
+  let k = 0;
+  const allNames = items.flatMap((item) => item.names);
+  while (k < allNames.length && err == null) {
+    const n = allNames[k];
+    if (n != null) {
+      err = visit(n);
+    }
+    k += 1;
+  }
+  if (err != null) {
+    return { error: err, names: void 0 };
+  }
+  return { error: void 0, names: order };
 }
-function validatePrecondition(defsByName, name) {
+async function executeStep({
+  defsByName,
+  name,
+  states
+}) {
+  const isActive = (s) => s.failure == null && s.names.includes(name);
+  const active = states.filter((s) => isActive(s));
+  if (active.length === 0) {
+    return states;
+  }
   const def = defsByName.get(name);
   if (def == null) {
-    return `Unknown precondition: "${name}"`;
+    return states.map(
+      (s) => isActive(s) ? { ...s, failure: `Unknown precondition: "${name}"` } : s
+    );
   }
   if (!def.implemented) {
-    return `Precondition "${name}" is not implemented`;
+    return states.map(
+      (s) => isActive(s) ? { ...s, failure: `Precondition "${name}" is not implemented` } : s
+    );
   }
-  return void 0;
+  const stepResult = await runSetup({ active, def, name });
+  return states.map((s) => isActive(s) ? mergeStepResult(s, name, stepResult) : s);
 }
-async function executeOnePrecondition(state, name) {
-  const def = state.defsByName.get(name);
-  if (def == null) {
-    return `Unknown precondition: "${name}"`;
-  }
+async function runSetup({ active, def, name }) {
+  const itemsForCall = active.map((s) => ({ ctx: s.ctx, deps: s.data }));
   try {
-    const result = await def.setup(state.ctx, state.data);
-    const resolved = {};
-    Object.entries(result).forEach(([key, value]) => {
-      if (!isPrimitive(value)) {
-        throw new TypeError(
-          `Precondition "${name}" returned non-primitive value at key "${key}". Setup return values must be string, number, or boolean \u2014 produced via ctx.fixed/uniqueEmail/uniqueId.`
-        );
-      }
-      resolved[key] = value;
+    const results = await def.setup(itemsForCall);
+    if (results.length !== active.length) {
+      return {
+        batchError: `Precondition "${name}" returned ${String(results.length)} results for ${String(active.length)} items`,
+        perItem: /* @__PURE__ */ new Map()
+      };
+    }
+    const entries = active.map((s, idx) => {
+      const r = results[idx];
+      return r == null ? void 0 : [s.runId, r];
     });
-    state.data[name] = resolved;
-    state.executed.push(name);
-    return void 0;
+    const valid = entries.filter(
+      (e) => e != null
+    );
+    if (valid.length !== active.length) {
+      return {
+        batchError: `Precondition "${name}" returned a null result for at least one item`,
+        perItem: /* @__PURE__ */ new Map()
+      };
+    }
+    return { batchError: void 0, perItem: new Map(valid) };
   } catch (error) {
-    return error instanceof Error ? error.message : String(error);
+    return {
+      batchError: error instanceof Error ? error.message : String(error),
+      perItem: /* @__PURE__ */ new Map()
+    };
   }
 }
-function fail(state, error) {
+function mergeStepResult(s, name, result) {
+  if (result.batchError != null) {
+    return { ...s, failure: result.batchError };
+  }
+  const data = result.perItem.get(s.runId);
+  if (data == null) {
+    return { ...s, failure: `Precondition "${name}" produced no result for run "${s.runId}"` };
+  }
   return {
-    cookies: state.cookies,
-    data: state.data,
+    ...s,
+    data: { ...s.data, [name]: data },
+    executed: [...s.executed, name]
+  };
+}
+function failResult(s, error) {
+  return {
+    cookies: s.cookies,
+    data: s.data,
     error,
-    executed: state.executed,
-    runId: state.runId,
+    executed: s.executed,
+    runId: s.runId,
     success: false
   };
 }
@@ -1049,25 +1175,56 @@ function createObserverContext(runId) {
     retry: (reason) => createRetryOutcome(reason)
   };
 }
-async function teardown(defsByName, names, data) {
-  const reversed = [...names].toReversed();
-  let index = 0;
-  while (index < reversed.length) {
-    const name = reversed[index];
+async function teardown({
+  defsByName,
+  items
+}) {
+  const errors = /* @__PURE__ */ new Map();
+  const allNamesUnique = [...new Set(items.flatMap((i2) => i2.names))];
+  const order = topoOrder(
+    defsByName,
+    allNamesUnique.map((n) => ({ names: [n], runId: "" }))
+  );
+  const reversed = (order.names ?? []).toReversed();
+  let i = 0;
+  while (i < reversed.length) {
+    const name = reversed[i];
     if (name != null) {
-      await teardownOne(defsByName, name, data);
+      await teardownStep({ defsByName, errors, items, name });
     }
-    index += 1;
+    i += 1;
   }
+  return items.map((it) => {
+    const err = errors.get(it.runId);
+    return { error: err, runId: it.runId, success: err == null };
+  });
 }
-async function teardownOne(defsByName, name, data) {
+async function teardownStep({
+  defsByName,
+  errors,
+  items,
+  name
+}) {
   const def = defsByName.get(name);
   if (def?.teardown == null) {
     return;
   }
+  const active = items.filter((i) => i.names.includes(name));
+  if (active.length === 0) {
+    return;
+  }
+  const teardownItems = active.map((it) => ({
+    ctx: { data: it.data[name] ?? {} }
+  }));
   try {
-    await def.teardown({ data: data[name] ?? {} });
-  } catch {
+    await def.teardown(teardownItems);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    active.forEach((it) => {
+      if (!errors.has(it.runId)) {
+        errors.set(it.runId, message);
+      }
+    });
   }
 }
 function createSetupContext({
@@ -1099,7 +1256,6 @@ function deriveDefaultDomain(baseUrl) {
 export {
   DEFAULT_IGNORE_PATHS,
   DEFAULT_WATCH_PATHS,
-  buildSetCookieHeader,
   compile,
   createEngine,
   createRipplo,
@@ -1107,7 +1263,10 @@ export {
   notImplemented,
   observer,
   precondition,
+  readAdapterWebhookSecret,
   serializeCookie,
   test,
+  toBatchRunResults,
+  toTeardownResults,
   verifyWebhookSignature
 };

package/dist/koa.d.ts

@@ -1,7 +1,7 @@
 import { Middleware } from 'koa';
-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/koa.js

@@ -1,18 +1,18 @@
 import {
   batchRequestSchema,
-  buildSetCookieHeader,
   observerRequestSchema,
   readAdapterWebhookSecret,
-  serializeCookie,
   teardownRequestSchema,
+  toBatchRunResults,
+  toTeardownResults,
   verifyWebhookSignature
-} from "./chunk-V6LMXKGL.js";
+} from "./chunk-XO36IU66.js";
 import "./chunk-4MGIQFAJ.js";
 
 // src/adapters/koa.ts
 function createKoaHandler({ enabled, engine }) {
   if (!enabled) {
-    return async (ctx, next) => {
+    return async (_ctx, next) => {
       await next();
     };
   }
@@ -57,29 +57,21 @@ async function handleExecutePreconditions({ body, ctx, engine }) {
   const parsed = json == null ? null : batchRequestSchema.safeParse(json);
   if (parsed == null || !parsed.success) {
     ctx.status = 400;
-    ctx.body = { error: "Invalid request body", success: false };
+    ctx.body = { error: "Invalid request body" };
     return;
   }
   const host = ctx.get("host");
   if (host.length === 0) {
     ctx.status = 400;
-    ctx.body = { error: "Missing host header", success: false };
+    ctx.body = { error: "Missing host header" };
     return;
   }
   const proto = ctx.get("x-forwarded-proto").length > 0 ? ctx.get("x-forwarded-proto") : "http";
   const appUrl = `${proto}://${host}`;
-  const result = await engine.executePreconditions(parsed.data.preconditions, { appUrl });
-  result.cookies.forEach((cookie) => {
-    ctx.append("Set-Cookie", buildSetCookieHeader(serializeCookie(cookie)));
-  });
+  const items = parsed.data.batch.map((b) => ({ names: b.preconditions, runId: b.runId }));
+  const results = await engine.executePreconditions(items, { appUrl });
   ctx.status = 200;
-  ctx.body = {
-    data: result.data,
-    error: result.error,
-    executed: result.executed,
-    runId: result.runId,
-    success: result.success
-  };
+  ctx.body = { results: toBatchRunResults(results) };
 }
 async function handleExecuteObserver({ body, ctx, engine }) {
   const json = tryParseJson(body);
@@ -98,12 +90,17 @@ async function handleTeardown({ body, ctx, engine }) {
   const parsed = json == null ? null : teardownRequestSchema.safeParse(json);
   if (parsed == null || !parsed.success) {
     ctx.status = 400;
-    ctx.body = { error: "Invalid request body", success: false };
+    ctx.body = { error: "Invalid request body" };
     return;
   }
-  await engine.teardown(parsed.data.preconditions, parsed.data.data);
+  const items = parsed.data.batch.map((b) => ({
+    data: b.data,
+    names: b.preconditions,
+    runId: b.runId
+  }));
+  const results = await engine.teardown(items);
   ctx.status = 200;
-  ctx.body = { success: true };
+  ctx.body = { results: toTeardownResults(results) };
 }
 function lastPathSegment(path) {
   const segments = path.split("/").filter((s) => s.length > 0);

package/dist/lockfile.d.ts

@@ -1,12 +1,22 @@
 import { Codec } from '@ripplo/spec';
 import { z } from 'zod';
 import { CompileResult } from './compiler.js';
-import './builder-BMjy83Iy.js';
-import './types-16SB7zjP.js';
+import './builder-DiVz3t1D.js';
+import './types-BzZrl65Z.js';
 import './step-De52hTLd.js';
 
 declare const LOCKFILE_RELATIVE_PATH = ".ripplo/ripplo.lock";
-declare const lockfileBodySchema: z.ZodObject<{
+declare const FIXTURES_RELATIVE_PATH = ".ripplo/fixtures";
+declare const fixtureEntrySchema: z.ZodObject<{
+    sha256: z.ZodString;
+    size: z.ZodNumber;
+}, z.core.$strip>;
+type FixtureEntry = z.infer<typeof fixtureEntrySchema>;
+declare const lockfileBodyV2Schema: z.ZodObject<{
+    fixtures: z.ZodRecord<z.ZodString, z.ZodObject<{
+        sha256: z.ZodString;
+        size: z.ZodNumber;
+    }, z.core.$strip>>;
     observers: z.ZodRecord<z.ZodString, z.ZodObject<{
         budget: z.ZodEnum<{
             fast: "fast";
@@ -677,7 +687,7 @@ declare const lockfileBodySchema: z.ZodObject<{
         }, z.core.$strip>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
-type Lockfile = z.infer<typeof lockfileBodySchema>;
+type Lockfile = z.infer<typeof lockfileBodyV2Schema>;
 declare const lockfileCodec: Codec<Lockfile>;
 declare function compileResultToLockfile(result: CompileResult): Lockfile;
 declare function serializeLockfile(lockfile: Lockfile): string;
@@ -690,6 +700,11 @@ interface WriteLockfileParams {
     readonly result: CompileResult;
 }
 declare function writeLockfile({ cwd, result }: WriteLockfileParams): Promise<void>;
+interface HashFixturesParams {
+    readonly cwd: string;
+    readonly result: CompileResult;
+}
+declare function hashFixturesIntoCompileResult({ cwd, result, }: HashFixturesParams): Promise<CompileResult>;
 type LockfileComparison = "match" | "missing" | "stale";
 interface CompareLockfileParams {
     readonly compiled: CompileResult;
@@ -697,4 +712,4 @@ interface CompareLockfileParams {
 }
 declare function compareCompileToLockfile({ compiled, existing, }: CompareLockfileParams): LockfileComparison;
 
-export { type CompareLockfileParams, LOCKFILE_RELATIVE_PATH, type Lockfile, type LockfileComparison, type ReadLockfileParams, type WriteLockfileParams, compareCompileToLockfile, compileResultToLockfile, lockfileCodec, readLockfile, serializeLockfile, writeLockfile };
+export { type CompareLockfileParams, FIXTURES_RELATIVE_PATH, type FixtureEntry, LOCKFILE_RELATIVE_PATH, type Lockfile, type LockfileComparison, type ReadLockfileParams, type WriteLockfileParams, compareCompileToLockfile, compileResultToLockfile, hashFixturesIntoCompileResult, lockfileCodec, readLockfile, serializeLockfile, writeLockfile };