@ripplo/testing 0.1.1 → 0.2.0

package/dist/lockfile.d.ts

@@ -1,8 +1,8 @@
 import { Codec } from '@ripplo/spec';
 import { z } from 'zod';
 import { CompileResult } from './compiler.js';
-import './builder-c7tXey03.js';
-import './types-oYS_Yv4G.js';
+import './builder-dqXTFZ4j.js';
+import './types-yIhY8cwG.js';
 import './step-De52hTLd.js';
 
 declare const LOCKFILE_RELATIVE_PATH = ".ripplo/ripplo.lock";

package/dist/nextjs.d.ts

@@ -1,14 +1,15 @@
-import { R as RipploBuilder } from './builder-c7tXey03.js';
-import './types-oYS_Yv4G.js';
+import { P as PreconditionEngine } from './engine-CphCJ1ZS.js';
+import './builder-dqXTFZ4j.js';
+import './types-yIhY8cwG.js';
 import 'zod';
 import './step-De52hTLd.js';
 import '@ripplo/spec';
 
 interface CreateNextHandlerParams {
     readonly enabled: boolean;
-    readonly ripplo: RipploBuilder;
+    readonly engine: PreconditionEngine;
 }
 type NextHandler = (req: Request) => Promise<Response>;
-declare function createNextHandler({ enabled, ripplo }: CreateNextHandlerParams): NextHandler;
+declare function createNextHandler({ enabled, engine }: CreateNextHandlerParams): NextHandler;
 
 export { type CreateNextHandlerParams, createNextHandler };

package/dist/nextjs.js

@@ -1,21 +1,18 @@
 import {
   batchRequestSchema,
   buildSetCookieHeader,
-  createEngine,
   observerRequestSchema,
   serializeCookie,
   teardownRequestSchema,
   verifyWebhookSignature
-} from "./chunk-CD3M7H5A.js";
-import "./chunk-3IL457A7.js";
+} from "./chunk-TO3T2D2Y.js";
 
 // src/adapters/nextjs.ts
-function createNextHandler({ enabled, ripplo }) {
+function createNextHandler({ enabled, engine }) {
   if (!enabled) {
     return async () => jsonResponse({ error: "Not found" }, 404);
   }
-  const engine = createEngine(ripplo);
-  const webhookSecret = ripplo.getConfig().webhookSecret;
+  const webhookSecret = engine.getConfig().webhookSecret;
   return async function handler(req) {
     const action = lastPathSegment(req.url);
     if (action !== "execute-preconditions" && action !== "teardown-preconditions" && action !== "execute-observer") {
@@ -30,7 +27,7 @@ function createNextHandler({ enabled, ripplo }) {
 }
 function dispatchAction({ action, body, engine, req }) {
   if (action === "execute-preconditions") {
-    return handleExecuteBatch({ body, engine, req });
+    return handleExecutePreconditions({ body, engine, req });
   }
   if (action === "execute-observer") {
     return handleExecuteObserver({ body, engine });
@@ -52,7 +49,7 @@ async function handleExecuteObserver({
     200
   );
 }
-async function handleExecuteBatch({
+async function handleExecutePreconditions({
   body,
   engine,
   req
@@ -68,7 +65,7 @@ async function handleExecuteBatch({
   }
   const proto = req.headers.get("x-forwarded-proto") ?? "http";
   const appUrl = `${proto}://${host}`;
-  const result = await engine.executeBatch(parsed.data.preconditions, { appUrl });
+  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)));

package/dist/{types-oYS_Yv4G.d.ts → types-yIhY8cwG.d.ts}

@@ -112,4 +112,4 @@ interface ObserverDefinition {
     readonly run: (ctx: ObserverContext, params: Record<string, string>) => Promise<ObserverOutcome>;
 }
 
-export { type CookieEntry as C, DEFAULT_IGNORE_PATHS as D, type ObserverHandle as O, type Precondition as P, type SetupContext as S, type TeardownContext as T, type UnimplementedItems as U, type ObserverInput as a, type ObserverBudgetTier as b, type ObserverOutcome as c, type CookieOptions as d, DEFAULT_WATCH_PATHS as e, type DslConfig as f, type ObserverContext as g, type ObserverDefinition as h, type PreconditionDeps as i, type PreconditionData as j, type TestValue as k, type PreconditionDefinition as l, type TestDefinition as m };
+export { type CookieEntry as C, DEFAULT_IGNORE_PATHS as D, type ObserverHandle as O, type Precondition as P, type SetupContext as S, type TeardownContext as T, type UnimplementedItems as U, type ObserverInput as a, type ObserverBudgetTier as b, type CookieOptions as c, DEFAULT_WATCH_PATHS as d, type DslConfig as e, type ObserverContext as f, type ObserverDefinition as g, type ObserverOutcome as h, type PreconditionDeps as i, type TestDefinition as j, type PreconditionDefinition as k, type PreconditionData as l, type TestValue as m };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ripplo/testing",
   "description": "TypeScript DSL for defining and running Ripplo e2e workflow tests",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "type": "module",
   "files": [
     "dist"

package/dist/chunk-CD3M7H5A.js

@@ -1,332 +0,0 @@
-import {
-  createTestValue,
-  makeObserverHandle,
-  readTestValue
-} from "./chunk-3IL457A7.js";
-
-// src/observer.ts
-function createPassOutcome() {
-  return { kind: "pass" };
-}
-function createRetryOutcome(reason) {
-  return { kind: "retry", reason };
-}
-function createFailOutcome(reason) {
-  return { kind: "fail", reason };
-}
-function buildObserver({ name, observers }) {
-  let description = "";
-  let budget = "fast";
-  const self = {
-    budget(tier) {
-      budget = tier;
-      return self;
-    },
-    description(text) {
-      description = text;
-      return self;
-    },
-    input() {
-      return buildObserverReady({
-        name,
-        observers,
-        getBudget: () => budget,
-        getDescription: () => description
-      });
-    }
-  };
-  return self;
-}
-function buildObserverReady({
-  getBudget,
-  getDescription,
-  name,
-  observers
-}) {
-  return {
-    contract() {
-      pushObserverStub({ budget: getBudget(), description: getDescription(), name, observers });
-      return makeObserverHandle(name, getBudget());
-    },
-    notImplemented() {
-      pushObserverStub({ budget: getBudget(), description: getDescription(), name, observers });
-      return makeObserverHandle(name, getBudget());
-    }
-  };
-}
-function pushObserverStub({ budget, description, name, observers }) {
-  observers.push({
-    budget,
-    description,
-    implemented: false,
-    name,
-    run: () => Promise.resolve(createFailOutcome(`observer "${name}" not implemented`))
-  });
-}
-
-// src/engine.ts
-function createEngine(ripplo) {
-  return {
-    executeBatch: (names, options) => executeBatch(ripplo, names, options),
-    executeObserver: (name, params) => executeObserver(ripplo, name, params),
-    teardown: (names, data) => teardown(ripplo, names, data)
-  };
-}
-async function executeObserver(ripplo, name, params) {
-  const lookup = findObserver(ripplo.getObservers(), name);
-  if (lookup.error != null) {
-    return { error: lookup.error, outcome: void 0, success: false };
-  }
-  const ctx = createObserverContext(crypto.randomUUID().slice(0, 12));
-  return invokeRun(lookup.def, ctx, params);
-}
-function findObserver(defs, name) {
-  const def = defs.find((o) => o.name === name);
-  if (def == null) {
-    return { def: STUB_OBSERVER, error: `Unknown observer: "${name}"` };
-  }
-  if (!def.implemented) {
-    return { def, error: `Observer "${name}" is not implemented` };
-  }
-  return { def, error: void 0 };
-}
-var STUB_OBSERVER = {
-  budget: "fast",
-  description: "",
-  implemented: false,
-  name: "",
-  run: () => Promise.resolve(createFailOutcome("stub"))
-};
-async function invokeRun(def, ctx, params) {
-  try {
-    const outcome = await def.run(ctx, params);
-    return { error: void 0, outcome, success: true };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return { error: void 0, outcome: createFailOutcome(message), success: true };
-  }
-}
-function createObserverContext(runId) {
-  return {
-    runId,
-    fail: (reason) => createFailOutcome(reason),
-    pass: () => createPassOutcome(),
-    retry: (reason) => createRetryOutcome(reason)
-  };
-}
-async function executeBatch(ripplo, names, 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: buildDefMap(ripplo.getPreconditions()),
-    executed: [],
-    runId
-  };
-  return runBatchSequence(state, names);
-}
-async function runBatchSequence(state, names) {
-  let index = 0;
-  while (index < names.length) {
-    const name = names[index];
-    if (name == null) {
-      break;
-    }
-    const error = validatePrecondition(state.defsByName, name);
-    if (error != null) {
-      return fail(state, error);
-    }
-    const stepError = await executeOnePrecondition(state, name);
-    if (stepError != null) {
-      return fail(state, stepError);
-    }
-    index += 1;
-  }
-  return {
-    cookies: state.cookies,
-    data: state.data,
-    error: void 0,
-    executed: state.executed,
-    runId: state.runId,
-    success: true
-  };
-}
-function validatePrecondition(defsByName, name) {
-  const def = defsByName.get(name);
-  if (def == null) {
-    return `Unknown precondition: "${name}"`;
-  }
-  if (!def.implemented) {
-    return `Precondition "${name}" is not implemented`;
-  }
-  return void 0;
-}
-async function executeOnePrecondition(state, name) {
-  const def = state.defsByName.get(name);
-  if (def == null) {
-    return `Unknown precondition: "${name}"`;
-  }
-  try {
-    const result = await def.setup(state.ctx, state.data);
-    const resolved = {};
-    Object.entries(result).forEach(([key, value]) => {
-      resolved[key] = readTestValue(value);
-    });
-    state.data[name] = resolved;
-    state.executed.push(name);
-    return void 0;
-  } catch (error) {
-    return error instanceof Error ? error.message : String(error);
-  }
-}
-function fail(state, error) {
-  return {
-    cookies: state.cookies,
-    data: state.data,
-    error,
-    executed: state.executed,
-    runId: state.runId,
-    success: false
-  };
-}
-async function teardown(ripplo, names, data) {
-  const defsByName = buildDefMap(ripplo.getPreconditions());
-  const reversed = [...names].toReversed();
-  let index = 0;
-  while (index < reversed.length) {
-    const name = reversed[index];
-    if (name != null) {
-      await teardownOne(defsByName, name, data);
-    }
-    index += 1;
-  }
-}
-async function teardownOne(defsByName, name, data) {
-  const def = defsByName.get(name);
-  if (def?.teardown == null) {
-    return;
-  }
-  try {
-    await def.teardown({ data: data[name] ?? {} });
-  } catch {
-  }
-}
-function buildDefMap(defs) {
-  return new Map(defs.map((d) => [d.name, d]));
-}
-function createSetupContext({
-  cookies,
-  defaultDomain,
-  runId
-}) {
-  return {
-    runId,
-    fixed: (value) => createTestValue(value),
-    setCookie: (name, value, options) => {
-      const resolvedOptions = options != null && options.domain == null && defaultDomain != null ? { ...options, domain: defaultDomain } : options ?? void 0;
-      cookies.push({ name, options: resolvedOptions, value });
-    },
-    uniqueEmail: () => createTestValue(`ripplo-test-${runId}@test.ripplo.ai`),
-    uniqueId: (prefix) => createTestValue(`ripplo-test-${prefix}-${runId}`)
-  };
-}
-function deriveDefaultDomain(baseUrl) {
-  if (baseUrl == null) {
-    return void 0;
-  }
-  try {
-    return new URL(baseUrl).hostname;
-  } catch {
-    return void 0;
-  }
-}
-
-// src/adapters/shared.ts
-import { Webhook, WebhookVerificationError } from "standardwebhooks";
-import { z } from "zod";
-var batchRequestSchema = z.object({
-  preconditions: z.array(z.string().min(1))
-});
-var teardownRequestSchema = z.object({
-  data: z.record(z.string(), z.record(z.string(), z.string())),
-  preconditions: z.array(z.string().min(1))
-});
-var observerRequestSchema = z.object({
-  observer: z.string().min(1).max(200),
-  params: z.record(z.string().max(200), z.string())
-});
-var observerOutcomeSchema = z.discriminatedUnion("kind", [
-  z.object({ kind: z.literal("pass") }),
-  z.object({ kind: z.literal("retry"), reason: z.string() }),
-  z.object({ kind: z.literal("fail"), reason: z.string() })
-]);
-var observerResponseSchema = z.object({
-  error: z.string().optional(),
-  outcome: observerOutcomeSchema.optional(),
-  success: z.boolean()
-});
-function verifyWebhookSignature(payload, headers, secret) {
-  try {
-    const wh = new Webhook(secret);
-    wh.verify(payload, {
-      "webhook-id": headers["webhook-id"] ?? "",
-      "webhook-signature": headers["webhook-signature"] ?? "",
-      "webhook-timestamp": headers["webhook-timestamp"] ?? ""
-    });
-    return true;
-  } catch (error) {
-    if (error instanceof WebhookVerificationError) {
-      return false;
-    }
-    throw error;
-  }
-}
-function serializeCookie(cookie) {
-  return {
-    domain: cookie.options?.domain,
-    expires: cookie.options?.expires == null ? void 0 : new Date(cookie.options.expires * 1e3),
-    httpOnly: cookie.options?.httpOnly,
-    name: cookie.name,
-    path: cookie.options?.path,
-    sameSite: cookie.options?.sameSite,
-    secure: cookie.options?.secure,
-    value: cookie.value
-  };
-}
-function buildSetCookieHeader(cookie) {
-  const parts = [`${cookie.name}=${cookie.value}`];
-  if (cookie.domain != null) {
-    parts.push(`Domain=${cookie.domain}`);
-  }
-  if (cookie.path != null) {
-    parts.push(`Path=${cookie.path}`);
-  }
-  if (cookie.expires != null) {
-    parts.push(`Expires=${cookie.expires.toUTCString()}`);
-  }
-  if (cookie.httpOnly === true) {
-    parts.push("HttpOnly");
-  }
-  if (cookie.secure === true) {
-    parts.push("Secure");
-  }
-  if (cookie.sameSite != null) {
-    const capitalized = cookie.sameSite.charAt(0).toUpperCase() + cookie.sameSite.slice(1);
-    parts.push(`SameSite=${capitalized}`);
-  }
-  return parts.join("; ");
-}
-
-export {
-  buildObserver,
-  createEngine,
-  batchRequestSchema,
-  teardownRequestSchema,
-  observerRequestSchema,
-  verifyWebhookSignature,
-  serializeCookie,
-  buildSetCookieHeader
-};