@ripplo/testing 0.6.1 → 0.7.0

package/dist/express.d.ts

@@ -1,14 +1,12 @@
 import { Router } from 'express';
-import { R as RipploEngine } from './engine-BOqzK_go.js';
-import './builder-SsgqYqSC.js';
-import './types-BzZrl65Z.js';
-import './step-De52hTLd.js';
-import '@ripplo/spec';
+import { E as Engine } from './engine-BT7hUouB.js';
+import 'neverthrow';
+import 'zod';
 
-interface CreateExpressHandlerParams {
+interface CreateEngineHandlerParams {
     readonly enabled: boolean;
-    readonly engine: RipploEngine;
+    readonly engine: Engine;
 }
-declare function createExpressHandler({ enabled, engine }: CreateExpressHandlerParams): Router;
+declare function createEngineHandler({ enabled, engine }: CreateEngineHandlerParams): Router;
 
-export { type CreateExpressHandlerParams, createExpressHandler };
+export { type CreateEngineHandlerParams, createEngineHandler };

package/dist/express.js

@@ -1,87 +1,461 @@
-import {
-  batchRequestSchema,
-  observerRequestSchema,
-  readAdapterWebhookSecret,
-  teardownRequestSchema,
-  toBatchRunResults,
-  toTeardownResults,
-  verifyWebhookSignature
-} from "./chunk-XO36IU66.js";
-import "./chunk-4MGIQFAJ.js";
+// src/adapters/express.ts
+import { json, Router } from "express";
+
+// ../spec/src/leaves.ts
+import { z } from "zod";
+var budgetSchema = z.enum(["fast", "slow", "async"]);
+var valueRefSchema = z.object({ ref: z.string().min(1) });
+var primitiveSchema = z.union([z.string(), z.number(), z.boolean()]);
+var templateSchema = z.object({
+  template: z.array(z.union([z.string(), valueRefSchema])).min(1)
+});
+var setValueSchema = z.union([valueRefSchema, primitiveSchema, templateSchema, z.null()]);
+var changedSchema = z.object({ kind: z.literal("changed") });
+var updateValueSchema = z.union([setValueSchema, changedSchema]);
+var stringValueSchema = z.union([z.string(), valueRefSchema, templateSchema]);
+var roleLocatorSchema = z.object({
+  by: z.literal("role"),
+  name: z.union([stringValueSchema, z.undefined()]).optional().transform((value) => value),
+  role: z.string().min(1)
+});
+var testIdLocatorSchema = z.object({ by: z.literal("testId"), value: stringValueSchema });
+var insideLocatorSchema = z.object({
+  by: z.literal("inside"),
+  scope: z.lazy(() => locatorSchema),
+  target: z.lazy(() => locatorSchema)
+});
+var locatorSchema = z.discriminatedUnion("by", [
+  roleLocatorSchema,
+  testIdLocatorSchema,
+  insideLocatorSchema
+]);
+var primitiveTypeSchema = z.enum(["string", "number", "boolean"]);
+var consistencyClassSchema = z.enum(["strict", "eventual"]);
+var stringConstraintsSchema = z.object({
+  kind: z.literal("string"),
+  maxLength: z.number().int().positive().optional(),
+  minLength: z.number().int().nonnegative().optional(),
+  pattern: z.string().optional()
+});
+var numberConstraintsSchema = z.object({
+  kind: z.literal("number"),
+  max: z.number().int().optional(),
+  min: z.number().int().optional()
+});
+var datetimeConstraintsSchema = z.object({
+  kind: z.literal("datetime"),
+  maxOffsetDays: z.number().int(),
+  minOffsetDays: z.number().int()
+});
+var constraintsSchema = z.discriminatedUnion("kind", [
+  stringConstraintsSchema,
+  numberConstraintsSchema,
+  datetimeConstraintsSchema
+]);
+var generatorSchema = z.enum([
+  "company.name",
+  "date.iso",
+  "internet.email",
+  "internet.url",
+  "person.fullName",
+  "lorem.slug",
+  "lorem.word"
+]);
+var valueSpaceSchema = z.object({
+  constraints: constraintsSchema.optional(),
+  generator: generatorSchema,
+  name: z.string().min(1),
+  type: primitiveTypeSchema,
+  values: z.array(primitiveSchema).min(1).optional()
+});
+var propSpecSchema = z.object({
+  consistency: consistencyClassSchema.default("strict"),
+  optional: z.boolean(),
+  stable: z.boolean(),
+  type: primitiveTypeSchema,
+  valueSpace: z.string().min(1).optional()
+});
+var sourceSchema = z.enum(["backend", "client"]);
+var entitySchemaSchema = z.object({
+  description: z.string().optional(),
+  identity: z.array(z.string().min(1)).min(1),
+  identityKind: z.enum(["surrogate", "natural"]),
+  name: z.string().min(1),
+  props: z.record(z.string().min(1), propSpecSchema),
+  source: sourceSchema.default("backend")
+});
+var singletonSchemaSchema = z.object({
+  consistency: consistencyClassSchema.default("strict"),
+  default: primitiveSchema,
+  description: z.string().optional(),
+  name: z.string().min(1),
+  source: sourceSchema.default("backend"),
+  type: primitiveTypeSchema,
+  valueSpace: z.string().min(1).optional()
+});
+var browserSingletonSchema = z.enum(["url", "title", "viewport"]);
+
+// ../spec/src/predicate.ts
+import { z as z2 } from "zod";
+var stateAssertionSchema = z2.discriminatedUnion("kind", [
+  z2.object({
+    as: z2.string().min(1),
+    kind: z2.literal("created"),
+    props: z2.record(z2.string().min(1), setValueSchema)
+  }),
+  z2.object({
+    as: z2.string().min(1),
+    kind: z2.literal("updated"),
+    props: z2.record(z2.string().min(1), updateValueSchema)
+  }),
+  z2.object({ kind: z2.literal("deleted") })
+]);
+var singletonAssertionSchema = z2.object({ kind: z2.literal("is"), value: setValueSchema });
+var whereValueSchema = z2.lazy(
+  () => z2.union([setValueSchema, withinSchema])
+);
+var selectionSchema = z2.object({
+  entity: z2.string().min(1),
+  where: z2.record(z2.string().min(1), whereValueSchema)
+});
+var withinSchema = z2.object({
+  field: z2.string().min(1),
+  kind: z2.literal("within"),
+  selection: selectionSchema
+});
+var wait = z2.union([budgetSchema, z2.undefined()]).optional().transform((value) => value);
+var predicateSchema = z2.lazy(
+  () => z2.discriminatedUnion("kind", [
+    z2.object({ kind: z2.literal("visible"), locator: locatorSchema, wait }),
+    z2.object({ kind: z2.literal("disabled"), locator: locatorSchema, wait }),
+    z2.object({ kind: z2.literal("enabled"), locator: locatorSchema, wait }),
+    z2.object({ kind: z2.literal("focused"), locator: locatorSchema, wait }),
+    z2.object({ kind: z2.literal("value"), locator: locatorSchema, value: stringValueSchema, wait }),
+    z2.object({ kind: z2.literal("text"), locator: locatorSchema, value: stringValueSchema, wait }),
+    z2.object({
+      assertion: singletonAssertionSchema,
+      kind: z2.literal("singleton"),
+      singleton: z2.string().min(1),
+      wait
+    }),
+    z2.object({
+      kind: z2.literal("browser"),
+      name: browserSingletonSchema,
+      value: stringValueSchema,
+      wait
+    }),
+    z2.object({
+      assertion: stateAssertionSchema,
+      entity: z2.string().min(1),
+      key: z2.record(z2.string().min(1), whereValueSchema),
+      kind: z2.literal("state"),
+      wait
+    }),
+    z2.object({ kind: z2.literal("not"), predicate: predicateSchema }),
+    z2.object({ kind: z2.literal("and"), predicates: z2.array(predicateSchema) }),
+    z2.object({
+      entity: z2.string().min(1),
+      kind: z2.literal("count"),
+      value: z2.number().int().nonnegative()
+    }),
+    z2.object({
+      condition: predicateSchema,
+      consequence: predicateSchema,
+      kind: z2.literal("when"),
+      otherwise: z2.union([predicateSchema, z2.undefined()]).optional().transform((value) => value)
+    })
+  ])
+);
+
+// ../spec/src/codec.ts
+import { z as z3 } from "zod";
+var envelopeSchema = z3.object({
+  __codec: z3.string().min(1),
+  data: z3.unknown(),
+  version: z3.number().int().positive()
+});
+var CodecVersionError = class extends Error {
+  codec;
+  currentVersion;
+  gotVersion;
+  constructor(params) {
+    super(
+      `Unsupported ${params.codec} version ${String(params.gotVersion)} (current ${String(params.currentVersion)}). Upgrade Ripplo or rebuild with a compatible CLI.`
+    );
+    this.name = "CodecVersionError";
+    this.codec = params.codec;
+    this.currentVersion = params.currentVersion;
+    this.gotVersion = params.gotVersion;
+  }
+};
+var CodecMismatchError = class extends Error {
+  constructor(params) {
+    super(`Codec mismatch: expected "${params.expected}", got "${params.got}"`);
+    this.name = "CodecMismatchError";
+  }
+};
+function defineCodec({
+  name,
+  schema
+}) {
+  return {
+    currentVersion: 1,
+    name,
+    decode: (raw) => decode({ name, raw, schema }),
+    encode: (value) => ({
+      __codec: name,
+      data: value,
+      version: 1
+    })
+  };
+}
+function decode({
+  name,
+  raw,
+  schema
+}) {
+  const envelope = envelopeSchema.parse(raw);
+  if (envelope.__codec !== name) {
+    throw new CodecMismatchError({ expected: name, got: envelope.__codec });
+  }
+  if (envelope.version !== 1) {
+    throw new CodecVersionError({ codec: name, currentVersion: 1, gotVersion: envelope.version });
+  }
+  return schema.parse(envelope.data);
+}
+
+// ../spec/src/lockfile.ts
+import { z as z4 } from "zod";
+var actionSchema = z4.discriminatedUnion("kind", [
+  z4.object({ kind: z4.literal("goto"), url: stringValueSchema }),
+  z4.object({ kind: z4.literal("fill"), locator: locatorSchema, value: setValueSchema }),
+  z4.object({ kind: z4.literal("clear"), locator: locatorSchema }),
+  z4.object({ kind: z4.literal("click"), locator: locatorSchema }),
+  z4.object({ kind: z4.literal("dblclick"), locator: locatorSchema }),
+  z4.object({ kind: z4.literal("select"), locator: locatorSchema, value: setValueSchema }),
+  z4.object({ kind: z4.literal("check"), locator: locatorSchema }),
+  z4.object({ kind: z4.literal("uncheck"), locator: locatorSchema }),
+  z4.object({ kind: z4.literal("hover"), locator: locatorSchema }),
+  z4.object({
+    files: z4.array(z4.string().min(1)).min(1),
+    kind: z4.literal("upload"),
+    locator: locatorSchema
+  }),
+  z4.object({ key: z4.string().min(1), kind: z4.literal("press"), locator: locatorSchema.optional() })
+]);
+var stepSchema = z4.object({
+  action: actionSchema,
+  expect: z4.array(predicateSchema).default([])
+});
+var paramSchema = z4.object({
+  example: primitiveSchema.optional(),
+  valueSpace: z4.string().min(1)
+});
+var setupSchema = z4.object({
+  as: z4.string().min(1),
+  entity: z4.string().min(1),
+  set: z4.record(z4.string().min(1), setValueSchema)
+});
+var absenceSchema = z4.object({
+  entity: z4.string().min(1),
+  where: z4.record(z4.string().min(1), setValueSchema)
+});
+var testSchema = z4.object({
+  absent: z4.array(absenceSchema).default([]),
+  exclusive: z4.array(z4.string().min(1)).default([]),
+  intent: z4.string().min(1),
+  maybe: z4.array(setupSchema).default([]),
+  name: z4.string().min(1),
+  params: z4.record(z4.string().min(1), paramSchema),
+  singletons: z4.record(z4.string().min(1), setValueSchema).default({}),
+  sourcePath: z4.string().min(1).optional(),
+  steps: z4.array(stepSchema).default([]),
+  stub: z4.boolean().default(false),
+  world: z4.array(setupSchema).default([])
+});
+var fixtureEntrySchema = z4.object({
+  sha256: z4.string().regex(/^[0-9a-f]{64}$/u),
+  size: z4.number().int().nonnegative()
+});
+var lockfileSchema = z4.object({
+  entities: z4.array(entitySchemaSchema),
+  fixtures: z4.record(z4.string().min(1), fixtureEntrySchema).default({}),
+  singletons: z4.array(singletonSchemaSchema).default([]),
+  tests: z4.array(testSchema),
+  valueSpaces: z4.array(valueSpaceSchema)
+});
+var lockfileCodec = defineCodec({ name: "ripplo-lockfile", schema: lockfileSchema });
+
+// ../spec/src/sync-payload.ts
+import { z as z5 } from "zod";
+var stepDescriptorSchema = z5.object({
+  index: z5.number().int().nonnegative(),
+  kind: z5.string(),
+  target: z5.string(),
+  value: z5.string()
+});
+var workflowSpecSchema = z5.object({
+  steps: z5.array(stepDescriptorSchema),
+  stub: z5.boolean().default(false)
+});
+
+// ../spec/src/session.ts
+import { z as z6 } from "zod";
+var sameSiteSchema = z6.enum(["Strict", "Lax", "None"]);
+var cookieSchema = z6.object({
+  domain: z6.string().min(1),
+  expires: z6.number(),
+  httpOnly: z6.boolean(),
+  name: z6.string().min(1),
+  path: z6.string().min(1),
+  sameSite: sameSiteSchema,
+  secure: z6.boolean(),
+  value: z6.string()
+});
+var originSchema = z6.object({
+  localStorage: z6.array(z6.object({ name: z6.string().min(1), value: z6.string() })),
+  origin: z6.string().min(1)
+});
+var sessionSchema = z6.object({
+  cookies: z6.array(cookieSchema),
+  headers: z6.record(z6.string().min(1), z6.string()).optional(),
+  origins: z6.array(originSchema)
+});
+
+// ../spec/src/engine.ts
+import { z as z7 } from "zod";
+var cellSchema = z7.union([primitiveSchema, z7.null()]);
+var rowSchema = z7.record(z7.string().min(1), cellSchema);
+var setupSpecSchema = z7.object({
+  as: z7.string().min(1),
+  entity: z7.string().min(1),
+  fields: z7.record(z7.string().min(1), setValueSchema)
+});
+var setupRequestSchema = z7.object({
+  entities: z7.array(setupSpecSchema),
+  runId: z7.string().min(1),
+  singletons: z7.record(z7.string().min(1), cellSchema).default({})
+});
+var setupRowSchema = z7.object({
+  as: z7.string().min(1),
+  row: rowSchema,
+  session: sessionSchema.optional()
+});
+var setupResponseSchema = z7.object({
+  rows: z7.array(setupRowSchema)
+});
+var stateRequestSchema = z7.object({
+  entities: z7.array(z7.string().min(1)),
+  runId: z7.string().min(1),
+  singletons: z7.array(z7.string().min(1)).default([])
+});
+var stateResponseSchema = z7.object({
+  entities: z7.record(z7.string().min(1), z7.array(rowSchema)),
+  singletons: z7.record(z7.string().min(1), cellSchema).default({})
+});
+var teardownRequestSchema = z7.object({
+  runId: z7.string().min(1)
+});
+var teardownResponseSchema = z7.object({
+  ok: z7.literal(true)
+});
 
 // src/adapters/express.ts
-import { Router, json } from "express";
-function createExpressHandler({ enabled, engine }) {
+import { Webhook, WebhookVerificationError } from "standardwebhooks";
+function createEngineHandler({ enabled, engine }) {
   const router = Router();
   if (!enabled) {
     return router;
   }
-  const webhookSecret = readAdapterWebhookSecret();
+  const secret = readWebhookSecret();
   router.use(json());
   router.use((req, res, next) => {
-    const payload = JSON.stringify(req.body);
-    const headers = extractWebhookHeaders(req);
-    if (!verifyWebhookSignature(payload, headers, webhookSecret)) {
+    if (!verify(JSON.stringify(req.body), req, secret)) {
       res.status(401).json({ error: "Invalid webhook signature" });
       return;
     }
     next();
   });
-  router.put("/execute-preconditions", (req, res) => {
-    const parsed = batchRequestSchema.safeParse(req.body);
+  router.put("/setup", (req, res) => {
+    const parsed = setupRequestSchema.safeParse(req.body);
     if (!parsed.success) {
       res.status(400).json({ error: "Invalid request body" });
       return;
     }
-    const appUrl = `${req.protocol}://${req.get("host") ?? ""}`;
-    const items = parsed.data.batch.map((b) => ({ names: b.preconditions, runId: b.runId }));
-    void engine.executePreconditions(items, { appUrl }).then((results) => {
-      res.json({ results: toBatchRunResults(results) });
-    });
+    const { entities, runId, singletons } = parsed.data;
+    void engine.seed({ entities, singletons }, runId).match(
+      (rows) => res.json({ rows }),
+      (error) => {
+        fail(res, error);
+      }
+    );
   });
-  router.put("/execute-observer", (req, res) => {
-    const parsed = observerRequestSchema.safeParse(req.body);
+  router.put("/state", (req, res) => {
+    const parsed = stateRequestSchema.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;
     }
-    void engine.executeObserver(parsed.data.observer, parsed.data.params).then((result) => {
-      res.json({ error: result.error, outcome: result.outcome, success: result.success });
-    });
+    const { entities, runId, singletons } = parsed.data;
+    void engine.read({ entities, singletons }, runId).match(
+      (read) => res.json(read),
+      (error) => {
+        fail(res, error);
+      }
+    );
   });
-  router.put("/teardown-preconditions", (req, res) => {
+  router.put("/teardown", (req, res) => {
     const parsed = teardownRequestSchema.safeParse(req.body);
     if (!parsed.success) {
       res.status(400).json({ error: "Invalid request body" });
       return;
     }
-    const items = parsed.data.batch.map((b) => ({
-      data: b.data,
-      names: b.preconditions,
-      runId: b.runId
-    }));
-    void engine.teardown(items).then((results) => {
-      res.json({ results: toTeardownResults(results) });
-    });
+    void engine.teardown(parsed.data.runId).match(
+      () => res.json({ ok: true }),
+      (error) => {
+        fail(res, error);
+      }
+    );
   });
   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 readWebhookSecret() {
+  const value = process.env["RIPPLO_WEBHOOK_SECRET"];
+  if (value == null || value.length === 0) {
+    throw new Error(
+      "ripplo: RIPPLO_WEBHOOK_SECRET is not set. The engine adapter needs it to verify calls."
+    );
+  }
+  return value;
 }
-function asString(value) {
+function verify(payload, req, secret) {
+  try {
+    new Webhook(secret).verify(payload, {
+      "webhook-id": header(req, "webhook-id"),
+      "webhook-signature": header(req, "webhook-signature"),
+      "webhook-timestamp": header(req, "webhook-timestamp")
+    });
+    return true;
+  } catch (error) {
+    if (error instanceof WebhookVerificationError) {
+      return false;
+    }
+    throw error;
+  }
+}
+function header(req, name) {
+  const value = req.headers[name];
   if (typeof value === "string") {
     return value;
   }
   if (Array.isArray(value)) {
-    return value[0] ?? void 0;
+    return value[0] ?? "";
   }
-  return void 0;
+  return "";
+}
+function fail(res, error) {
+  res.status(500).json({ error: error.message });
 }
 export {
-  createExpressHandler
+  createEngineHandler
 };