@ripplo/testing 0.0.1

package/dist/chunk-KWUKVAGI.js

@@ -0,0 +1,227 @@
+// src/types.ts
+import { z } from "zod";
+var dslConfigSchema = z.object({
+  appUrl: z.string(),
+  preconditionsUrl: z.string(),
+  projectId: z.string(),
+  webhookSecret: z.string()
+});
+function readTestValue(value) {
+  return value.value;
+}
+function createTestValue(value) {
+  return { value };
+}
+function readPreconditionName(p) {
+  return p.name;
+}
+
+// src/engine.ts
+function createEngine(ripplo) {
+  return {
+    executeBatch: (names, options) => executeBatch(ripplo, names, options),
+    teardown: (names, data) => teardown(ripplo, names, data)
+  };
+}
+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 as z2 } from "zod";
+var batchRequestSchema = z2.object({
+  preconditions: z2.array(z2.string().min(1))
+});
+var teardownRequestSchema = z2.object({
+  data: z2.record(z2.string(), z2.record(z2.string(), z2.string())),
+  preconditions: z2.array(z2.string().min(1))
+});
+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 {
+  dslConfigSchema,
+  readPreconditionName,
+  createEngine,
+  batchRequestSchema,
+  teardownRequestSchema,
+  verifyWebhookSignature,
+  serializeCookie,
+  buildSetCookieHeader
+};

package/dist/chunk-MGATMMCZ.js

@@ -0,0 +1,16 @@
+// src/steps/step.ts
+function readStep(step) {
+  return step.data;
+}
+function createStep(node) {
+  return {
+    as(label) {
+      return { data: { label, node } };
+    }
+  };
+}
+
+export {
+  readStep,
+  createStep
+};

package/dist/chunk-X2FROZPN.js

@@ -0,0 +1,149 @@
+import {
+  createStep,
+  readStep
+} from "./chunk-MGATMMCZ.js";
+
+// src/compiler.ts
+function compile(ripplo) {
+  const preconditionDefs = ripplo.getPreconditions();
+  const testDefs = ripplo.getTests();
+  validateUniqueIds(testDefs);
+  const tests = testDefs.map((def) => compileTest(def));
+  const graph = compileGraph(preconditionDefs, testDefs);
+  return { config: ripplo.getConfig(), graph, tests };
+}
+function validateUniqueIds(defs) {
+  const seen = /* @__PURE__ */ new Map();
+  defs.forEach((def) => {
+    const existing = seen.get(def.id);
+    if (existing != null) {
+      throw new Error(`Duplicate test id "${def.id}" used by "${existing}" and "${def.name}"`);
+    }
+    seen.set(def.id, def.name);
+  });
+}
+function compileTest(def) {
+  const slug = def.id;
+  const { accessedKeys, vars } = buildPlaceholderVars(def.requiresKeys);
+  const startsAtUrl = def.startsAtFn == null ? void 0 : def.startsAtFn(vars);
+  const userSteps = def.stepsFn == null ? [] : def.stepsFn(vars);
+  const allSteps = startsAtUrl == null ? userSteps : [createGotoStep(startsAtUrl), ...userSteps];
+  const spec = compileSteps(allSteps, accessedKeys, def.requiresKeys);
+  const warnings = [];
+  const hasRequires = Object.keys(def.requiresKeys).length > 0;
+  if (hasRequires && accessedKeys.size === 0 && def.implemented) {
+    warnings.push(
+      "Test requires preconditions but never references their data \u2014 destructure and use precondition data in steps()"
+    );
+  }
+  return {
+    additionalChecks: [],
+    description: def.description,
+    expectedOutcome: def.expectedOutcome,
+    name: def.name,
+    slug,
+    spec,
+    warnings
+  };
+}
+function createGotoStep(url) {
+  return createStep({ type: "goto", url: { type: "static", value: url } }).as(
+    `navigate to ${url}`
+  );
+}
+function buildPlaceholderVars(requiresKeys) {
+  const accessedKeys = /* @__PURE__ */ new Set();
+  const vars = {};
+  Object.keys(requiresKeys).forEach((ns) => {
+    vars[ns] = new Proxy(
+      {},
+      {
+        get(_target, prop) {
+          if (typeof prop === "string") {
+            const qualifiedKey = `${ns}.${prop}`;
+            accessedKeys.add(qualifiedKey);
+            return `{{${qualifiedKey}}}`;
+          }
+        }
+      }
+    );
+  });
+  return { accessedKeys, vars };
+}
+function compileSteps(steps, accessedKeys, requiresKeys) {
+  const nodes = {};
+  steps.forEach((step, index) => {
+    const id = `step-${String(index)}`;
+    const next = index < steps.length - 1 ? `step-${String(index + 1)}` : void 0;
+    nodes[id] = compileNode(step, id, next);
+  });
+  const variables = {};
+  accessedKeys.forEach((key) => {
+    variables[key] = { default: `test-${key}`, type: "string" };
+  });
+  const variableNamespaces = { ...requiresKeys };
+  return { entryNode: "step-0", nodes, variableNamespaces, variables, version: 2 };
+}
+function compileNode(step, id, next) {
+  const { label, node: raw } = readStep(step);
+  return { ...raw, id, label, next };
+}
+function compileGraph(preconditionDefs, testDefs) {
+  const preconditions = {};
+  preconditionDefs.forEach((def) => {
+    preconditions[def.name] = {
+      depends: [...def.dependsOn],
+      description: def.description,
+      returns: [...def.returns]
+    };
+  });
+  const states = {};
+  const edges = [];
+  testDefs.forEach((def) => {
+    if (!def.implemented || def.startsAtFn == null) {
+      return;
+    }
+    const resolved = resolveDependencyChain(def.requires, preconditionDefs);
+    const { vars } = buildPlaceholderVars(def.requiresKeys);
+    const route = def.startsAtFn(vars);
+    const stateId = deriveStateId(resolved, route);
+    states[stateId] = { preconditions: [...resolved], route };
+    edges.push({
+      from: stateId,
+      requiresKeys: def.requiresKeys,
+      to: stateId,
+      workflow: def.id
+    });
+  });
+  return { edges, preconditions, states, version: 3 };
+}
+function resolveDependencyChain(requires, preconditionDefs) {
+  const defsByName = new Map(preconditionDefs.map((d) => [d.name, d]));
+  const resolved = [];
+  const visited = /* @__PURE__ */ new Set();
+  function visit(name) {
+    if (visited.has(name)) {
+      return;
+    }
+    visited.add(name);
+    defsByName.get(name)?.dependsOn.forEach((dep) => {
+      visit(dep);
+    });
+    resolved.push(name);
+  }
+  requires.forEach((name) => {
+    visit(name);
+  });
+  return resolved;
+}
+function deriveStateId(preconditions, route) {
+  const sorted = preconditions.toSorted((a, b) => a.localeCompare(b));
+  return slugify(`${sorted.join("-")}-${route}`);
+}
+function slugify(input) {
+  return input.toLowerCase().replaceAll(/[^a-z0-9]+/g, "-").replaceAll(/^-|-$/g, "");
+}
+
+export {
+  compile
+};

package/dist/compiler.d.ts

@@ -0,0 +1,22 @@
+import { StateGraph, WorkflowSpec } from '@ripplo/spec';
+import { D as DslConfig, R as RipploBuilder } from './builder-DTWMrbuv.js';
+import 'zod';
+import './step-DLfkKI3V.js';
+
+interface CompileResult {
+    readonly config: DslConfig;
+    readonly graph: StateGraph;
+    readonly tests: ReadonlyArray<CompiledTest>;
+}
+interface CompiledTest {
+    readonly additionalChecks: ReadonlyArray<string>;
+    readonly description: string;
+    readonly expectedOutcome: string;
+    readonly name: string;
+    readonly slug: string;
+    readonly spec: WorkflowSpec;
+    readonly warnings: ReadonlyArray<string>;
+}
+declare function compile(ripplo: RipploBuilder): CompileResult;
+
+export { type CompileResult, type CompiledTest, compile };

package/dist/compiler.js

@@ -0,0 +1,7 @@
+import {
+  compile
+} from "./chunk-X2FROZPN.js";
+import "./chunk-MGATMMCZ.js";
+export {
+  compile
+};

package/dist/control.d.ts

@@ -0,0 +1,24 @@
+import { U as UnlabeledStep } from './step-DLfkKI3V.js';
+import { AnyLocator } from './locators.js';
+import '@ripplo/spec';
+
+declare const VARIABLE_INTERNAL: unique symbol;
+interface Variable<_TName extends string> {
+    readonly [VARIABLE_INTERNAL]: _TName;
+}
+declare function variable<TName extends string>(name: TName): Variable<TName>;
+declare function readVariable(v: Variable<string>): string;
+declare function extract(locator: AnyLocator, target: Variable<string>): UnlabeledStep<{
+    locator: {
+        by: "testId";
+        value: string;
+    } | {
+        by: "role";
+        role: string;
+        name?: string | undefined;
+    };
+    type: "extractText";
+    variable: string;
+}>;
+
+export { type Variable, extract, readVariable, variable };

package/dist/control.js

@@ -0,0 +1,27 @@
+import {
+  toSpecLocator
+} from "./chunk-2VUWFRR5.js";
+import {
+  createStep
+} from "./chunk-MGATMMCZ.js";
+import "./chunk-DCJBLS2U.js";
+
+// src/steps/control.ts
+function variable(name) {
+  return { name };
+}
+function readVariable(v) {
+  return v.name;
+}
+function extract(locator, target) {
+  return createStep({
+    locator: toSpecLocator(locator),
+    type: "extractText",
+    variable: readVariable(target)
+  });
+}
+export {
+  extract,
+  readVariable,
+  variable
+};

package/dist/express.d.ts

@@ -0,0 +1,12 @@
+import { Router } from 'express';
+import { R as RipploBuilder } from './builder-DTWMrbuv.js';
+import 'zod';
+import './step-DLfkKI3V.js';
+import '@ripplo/spec';
+
+interface CreateExpressHandlerParams {
+    readonly ripplo: RipploBuilder;
+}
+declare function createExpressHandler({ ripplo }: CreateExpressHandlerParams): Router;
+
+export { type CreateExpressHandlerParams, createExpressHandler };

package/dist/express.js

@@ -0,0 +1,102 @@
+import {
+  batchRequestSchema,
+  createEngine,
+  serializeCookie,
+  teardownRequestSchema,
+  verifyWebhookSignature
+} from "./chunk-KWUKVAGI.js";
+
+// src/adapters/express.ts
+import { Router, json } from "express";
+function createExpressHandler({ ripplo }) {
+  const engine = createEngine(ripplo);
+  const webhookSecret = ripplo.getConfig().webhookSecret;
+  const router = Router();
+  router.use(json());
+  router.use((req, res, next) => {
+    if (webhookSecret.length === 0) {
+      res.status(403).json({ error: "Webhook secret not configured" });
+      return;
+    }
+    const payload = JSON.stringify(req.body);
+    const headers = extractWebhookHeaders(req);
+    if (!verifyWebhookSignature(payload, headers, webhookSecret)) {
+      res.status(401).json({ error: "Invalid webhook signature" });
+      return;
+    }
+    next();
+  });
+  router.put("/execute-batch", (req, res) => {
+    const parsed = batchRequestSchema.safeParse(req.body);
+    if (!parsed.success) {
+      res.status(400).json({ error: "Invalid request body", success: false });
+      return;
+    }
+    const appUrl = `${req.protocol}://${req.get("host") ?? ""}`;
+    void engine.executeBatch(parsed.data.preconditions, { appUrl }).then((result) => {
+      result.cookies.forEach((cookie) => {
+        const s = serializeCookie(cookie);
+        res.cookie(s.name, s.value, buildExpressCookieOptions(s));
+      });
+      res.json({
+        data: result.data,
+        error: result.error,
+        executed: result.executed,
+        runId: result.runId,
+        success: result.success
+      });
+    });
+  });
+  router.put("/teardown", (req, res) => {
+    const parsed = teardownRequestSchema.safeParse(req.body);
+    if (!parsed.success) {
+      res.status(400).json({ error: "Invalid request body", success: false });
+      return;
+    }
+    void engine.teardown(parsed.data.preconditions, parsed.data.data).then(() => {
+      res.json({ success: true });
+    });
+  });
+  return router;
+}
+function extractWebhookHeaders(req) {
+  return {
+    "webhook-id": asString(req.headers["webhook-id"]),
+    "webhook-signature": asString(req.headers["webhook-signature"]),
+    "webhook-timestamp": asString(req.headers["webhook-timestamp"])
+  };
+}
+function asString(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value[0] ?? void 0;
+  }
+  return void 0;
+}
+function buildExpressCookieOptions(s) {
+  const opts = {};
+  if (s.domain != null) {
+    opts.domain = s.domain;
+  }
+  if (s.expires != null) {
+    opts.expires = s.expires;
+  }
+  if (s.httpOnly != null) {
+    opts.httpOnly = s.httpOnly;
+  }
+  if (s.path != null) {
+    opts.path = s.path;
+  }
+  if (s.sameSite != null) {
+    opts.sameSite = s.sameSite;
+  }
+  if (s.secure != null) {
+    opts.secure = s.secure;
+  }
+  return opts;
+}
+export {
+  createExpressHandler
+};

package/dist/fastify.d.ts

@@ -0,0 +1,12 @@
+import { FastifyInstance } from 'fastify';
+import { R as RipploBuilder } from './builder-DTWMrbuv.js';
+import 'zod';
+import './step-DLfkKI3V.js';
+import '@ripplo/spec';
+
+interface RegisterFastifyHandlerParams {
+    readonly ripplo: RipploBuilder;
+}
+declare function registerFastifyHandler({ ripplo, }: RegisterFastifyHandlerParams): (fastify: FastifyInstance) => Promise<void>;
+
+export { type RegisterFastifyHandlerParams, registerFastifyHandler };

package/dist/fastify.js

@@ -0,0 +1,72 @@
+import {
+  batchRequestSchema,
+  buildSetCookieHeader,
+  createEngine,
+  serializeCookie,
+  teardownRequestSchema,
+  verifyWebhookSignature
+} from "./chunk-KWUKVAGI.js";
+
+// src/adapters/fastify.ts
+function registerFastifyHandler({
+  ripplo
+}) {
+  const engine = createEngine(ripplo);
+  const webhookSecret = ripplo.getConfig().webhookSecret;
+  return async (fastify) => {
+    fastify.addHook("preHandler", async (req, reply) => {
+      if (webhookSecret.length === 0) {
+        return reply.code(403).send({ error: "Webhook secret not configured" });
+      }
+      const payload = JSON.stringify(req.body);
+      const headers = {
+        "webhook-id": extractHeader(req, "webhook-id"),
+        "webhook-signature": extractHeader(req, "webhook-signature"),
+        "webhook-timestamp": extractHeader(req, "webhook-timestamp")
+      };
+      if (!verifyWebhookSignature(payload, headers, webhookSecret)) {
+        return reply.code(401).send({ error: "Invalid webhook signature" });
+      }
+    });
+    fastify.put("/execute-batch", async (req, reply) => {
+      const parsed = batchRequestSchema.safeParse(req.body);
+      if (!parsed.success) {
+        return reply.code(400).send({ error: "Invalid request body", success: false });
+      }
+      const appUrl = `${req.protocol}://${req.hostname}`;
+      const result = await engine.executeBatch(parsed.data.preconditions, { appUrl });
+      result.cookies.forEach((cookie) => {
+        const s = serializeCookie(cookie);
+        reply.header("Set-Cookie", buildSetCookieHeader(s));
+      });
+      return reply.send({
+        data: result.data,
+        error: result.error,
+        executed: result.executed,
+        runId: result.runId,
+        success: result.success
+      });
+    });
+    fastify.put("/teardown", async (req, reply) => {
+      const parsed = teardownRequestSchema.safeParse(req.body);
+      if (!parsed.success) {
+        return reply.code(400).send({ error: "Invalid request body", success: false });
+      }
+      await engine.teardown(parsed.data.preconditions, parsed.data.data);
+      return reply.send({ success: true });
+    });
+  };
+}
+function extractHeader(req, name) {
+  const value = req.headers[name];
+  if (typeof value === "string") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value[0] ?? void 0;
+  }
+  return void 0;
+}
+export {
+  registerFastifyHandler
+};