@ripplo/testing 0.0.11 → 0.1.1

package/dist/{chunk-7ETQVVAA.js → chunk-CD3M7H5A.js}

@@ -1,50 +1,119 @@
-// src/types.ts
-import { z } from "zod";
-var DEFAULT_WATCH_PATHS = [
-  "src/**",
-  "app/**",
-  "apps/**",
-  "pages/**",
-  "routes/**",
-  "components/**"
-];
-var DEFAULT_IGNORE_PATHS = [
-  "**/*.gen.*",
-  "**/generated/**",
-  "**/*.d.ts",
-  "**/*.test.*",
-  "**/*.spec.*",
-  "**/node_modules/**",
-  "**/dist/**",
-  "**/build/**",
-  ".ripplo/**",
-  "**/*.md"
-];
-var dslConfigSchema = z.object({
-  appUrl: z.string(),
-  ignorePaths: z.array(z.string()).optional(),
-  preconditionsUrl: z.string(),
-  projectId: z.string(),
-  watchPaths: z.array(z.string()).optional(),
-  webhookSecret: z.string()
-});
-function readTestValue(value) {
-  return value.value;
+import {
+  createTestValue,
+  makeObserverHandle,
+  readTestValue
+} from "./chunk-3IL457A7.js";
+
+// src/observer.ts
+function createPassOutcome() {
+  return { kind: "pass" };
 }
-function createTestValue(value) {
-  return { value };
+function createRetryOutcome(reason) {
+  return { kind: "retry", reason };
 }
-function readPreconditionName(p) {
-  return p.name;
+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 = [];
@@ -177,13 +246,27 @@ function deriveDefaultDomain(baseUrl) {
 
 // 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))
+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 teardownRequestSchema = z2.object({
-  data: z2.record(z2.string(), z2.record(z2.string(), z2.string())),
-  preconditions: z2.array(z2.string().min(1))
+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 {
@@ -238,13 +321,11 @@ function buildSetCookieHeader(cookie) {
 }
 
 export {
-  DEFAULT_WATCH_PATHS,
-  DEFAULT_IGNORE_PATHS,
-  dslConfigSchema,
-  readPreconditionName,
+  buildObserver,
   createEngine,
   batchRequestSchema,
   teardownRequestSchema,
+  observerRequestSchema,
   verifyWebhookSignature,
   serializeCookie,
   buildSetCookieHeader

package/dist/{chunk-LEIKZ6BE.js → chunk-KNF4K4JH.js}

@@ -6,6 +6,7 @@ import {
 // src/compiler.ts
 function compile(ripplo) {
   const preconditionDefs = ripplo.getPreconditions();
+  const observerDefs = ripplo.getObservers();
   const testDefs = ripplo.getTests();
   validateUniqueIds(testDefs);
   const preconditions = {};
@@ -16,8 +17,15 @@ function compile(ripplo) {
       returns: [...def.returns]
     };
   });
+  const observers = {};
+  observerDefs.forEach((def) => {
+    observers[def.name] = {
+      budget: def.budget,
+      description: def.description
+    };
+  });
   const tests = testDefs.map((def) => compileTest(def, preconditionDefs));
-  return { config: ripplo.getConfig(), preconditions, tests };
+  return { config: ripplo.getConfig(), observers, preconditions, tests };
 }
 function validateUniqueIds(defs) {
   const seen = /* @__PURE__ */ new Map();
@@ -35,7 +43,7 @@ function compileTest(def, preconditionDefs) {
   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 spec = compileSteps(allSteps, accessedKeys, def.requiresKeys, def.uiOnly);
   const warnings = [];
   const hasRequires = Object.keys(def.requiresKeys).length > 0;
   if (hasRequires && accessedKeys.size === 0 && def.implemented) {
@@ -81,7 +89,7 @@ function buildPlaceholderVars(requiresKeys) {
   });
   return { accessedKeys, vars };
 }
-function compileSteps(steps, accessedKeys, requiresKeys) {
+function compileSteps(steps, accessedKeys, requiresKeys, uiOnly) {
   const nodes = {};
   steps.forEach((step, index) => {
     const id = `step-${String(index)}`;
@@ -93,7 +101,7 @@ function compileSteps(steps, accessedKeys, requiresKeys) {
     variables[key] = { default: `test-${key}`, type: "string" };
   });
   const variableNamespaces = { ...requiresKeys };
-  return { entryNode: "step-0", nodes, variableNamespaces, variables };
+  return { entryNode: "step-0", nodes, uiOnly, variableNamespaces, variables };
 }
 function compileNode(step, id, next) {
   const { label, node: raw } = readStep(step);

package/dist/compiler.d.ts

@@ -1,10 +1,12 @@
-import { Precondition, WorkflowSpec } from '@ripplo/spec';
-import { c as DslConfig, R as RipploBuilder } from './builder-1kySbit_.js';
+import { Observer, Precondition, WorkflowSpec } from '@ripplo/spec';
+import { R as RipploBuilder } from './builder-c7tXey03.js';
+import { f as DslConfig } from './types-oYS_Yv4G.js';
+import './step-De52hTLd.js';
 import 'zod';
-import './step-DLfkKI3V.js';
 
 interface CompileResult {
     readonly config: DslConfig;
+    readonly observers: Record<string, Observer>;
     readonly preconditions: Record<string, Precondition>;
     readonly tests: ReadonlyArray<CompiledTest>;
 }

package/dist/compiler.js

@@ -1,6 +1,6 @@
 import {
   compile
-} from "./chunk-LEIKZ6BE.js";
+} from "./chunk-KNF4K4JH.js";
 import "./chunk-MGATMMCZ.js";
 export {
   compile

package/dist/control.d.ts

@@ -1,4 +1,4 @@
-import { U as UnlabeledStep } from './step-DLfkKI3V.js';
+import { U as UnlabeledStep } from './step-De52hTLd.js';
 import { AnyLocator } from './locators.js';
 import '@ripplo/spec';
 

package/dist/express.d.ts

@@ -1,7 +1,8 @@
 import { Router } from 'express';
-import { R as RipploBuilder } from './builder-1kySbit_.js';
+import { R as RipploBuilder } from './builder-c7tXey03.js';
+import './types-oYS_Yv4G.js';
 import 'zod';
-import './step-DLfkKI3V.js';
+import './step-De52hTLd.js';
 import '@ripplo/spec';
 
 interface CreateExpressHandlerParams {

package/dist/express.js

@@ -1,10 +1,12 @@
 import {
   batchRequestSchema,
   createEngine,
+  observerRequestSchema,
   serializeCookie,
   teardownRequestSchema,
   verifyWebhookSignature
-} from "./chunk-7ETQVVAA.js";
+} from "./chunk-CD3M7H5A.js";
+import "./chunk-3IL457A7.js";
 
 // src/adapters/express.ts
 import { Router, json } from "express";
@@ -29,7 +31,7 @@ function createExpressHandler({ enabled, ripplo }) {
     }
     next();
   });
-  router.put("/execute-batch", (req, res) => {
+  router.put("/execute-preconditions", (req, res) => {
     const parsed = batchRequestSchema.safeParse(req.body);
     if (!parsed.success) {
       res.status(400).json({ error: "Invalid request body", success: false });
@@ -50,7 +52,21 @@ function createExpressHandler({ enabled, ripplo }) {
       });
     });
   });
-  router.put("/teardown", (req, res) => {
+  router.put("/execute-observer", (req, res) => {
+    const parsed = observerRequestSchema.safeParse(req.body);
+    if (!parsed.success) {
+      res.status(400).json({ error: "Invalid request body", success: false });
+      return;
+    }
+    void engine.executeObserver(parsed.data.observer, parsed.data.params).then((result) => {
+      res.json({
+        error: result.error,
+        outcome: result.outcome,
+        success: result.success
+      });
+    });
+  });
+  router.put("/teardown-preconditions", (req, res) => {
     const parsed = teardownRequestSchema.safeParse(req.body);
     if (!parsed.success) {
       res.status(400).json({ error: "Invalid request body", success: false });

package/dist/fastify.d.ts

@@ -1,7 +1,8 @@
 import { FastifyInstance } from 'fastify';
-import { R as RipploBuilder } from './builder-1kySbit_.js';
+import { R as RipploBuilder } from './builder-c7tXey03.js';
+import './types-oYS_Yv4G.js';
 import 'zod';
-import './step-DLfkKI3V.js';
+import './step-De52hTLd.js';
 import '@ripplo/spec';
 
 interface RegisterFastifyHandlerParams {

package/dist/fastify.js

@@ -2,10 +2,12 @@ import {
   batchRequestSchema,
   buildSetCookieHeader,
   createEngine,
+  observerRequestSchema,
   serializeCookie,
   teardownRequestSchema,
   verifyWebhookSignature
-} from "./chunk-7ETQVVAA.js";
+} from "./chunk-CD3M7H5A.js";
+import "./chunk-3IL457A7.js";
 
 // src/adapters/fastify.ts
 function registerFastifyHandler({
@@ -33,7 +35,7 @@ function registerFastifyHandler({
         return reply.code(401).send({ error: "Invalid webhook signature" });
       }
     });
-    fastify.put("/execute-batch", async (req, reply) => {
+    fastify.put("/execute-preconditions", async (req, reply) => {
       const parsed = batchRequestSchema.safeParse(req.body);
       if (!parsed.success) {
         return reply.code(400).send({ error: "Invalid request body", success: false });
@@ -52,7 +54,19 @@ function registerFastifyHandler({
         success: result.success
       });
     });
-    fastify.put("/teardown", async (req, reply) => {
+    fastify.put("/execute-observer", async (req, reply) => {
+      const parsed = observerRequestSchema.safeParse(req.body);
+      if (!parsed.success) {
+        return reply.code(400).send({ error: "Invalid request body", success: false });
+      }
+      const result = await engine.executeObserver(parsed.data.observer, parsed.data.params);
+      return reply.send({
+        error: result.error,
+        outcome: result.outcome,
+        success: result.success
+      });
+    });
+    fastify.put("/teardown-preconditions", async (req, reply) => {
       const parsed = teardownRequestSchema.safeParse(req.body);
       if (!parsed.success) {
         return reply.code(400).send({ error: "Invalid request body", success: false });

package/dist/index.d.ts

@@ -1,10 +1,12 @@
-import { C as CookieEntry, R as RipploBuilder } from './builder-1kySbit_.js';
-export { a as CookieOptions, D as DEFAULT_IGNORE_PATHS, b as DEFAULT_WATCH_PATHS, c as DslConfig, P as Precondition, d as PreconditionDeps, e as PreconditionImpl, f as PreconditionRecord, g as ResolveDeps, S as SetupContext, T as TeardownContext, h as createRipplo } from './builder-1kySbit_.js';
+import { R as RipploBuilder } from './builder-c7tXey03.js';
+export { O as ObserverImplFn, P as PreconditionImpl, a as PreconditionRecord, b as ResolveDeps, c as createRipplo } from './builder-c7tXey03.js';
 import { CompileResult } from './compiler.js';
 export { CompiledTest, compile } from './compiler.js';
-export { D as DslNodeInput } from './step-DLfkKI3V.js';
-import 'zod';
+import { C as CookieEntry, c as ObserverOutcome } from './types-oYS_Yv4G.js';
+export { d as CookieOptions, D as DEFAULT_IGNORE_PATHS, e as DEFAULT_WATCH_PATHS, f as DslConfig, g as ObserverContext, h as ObserverDefinition, O as ObserverHandle, a as ObserverInput, P as Precondition, i as PreconditionDeps, S as SetupContext, T as TeardownContext } from './types-oYS_Yv4G.js';
+export { D as DslNodeInput } from './step-De52hTLd.js';
 import '@ripplo/spec';
+import 'zod';
 
 interface LintDiagnostic {
     readonly message: string;
@@ -28,8 +30,14 @@ interface EngineResult {
 interface ExecuteBatchOptions {
     readonly appUrl: string | undefined;
 }
+interface ObserverExecutionResult {
+    readonly error: string | undefined;
+    readonly outcome: ObserverOutcome | undefined;
+    readonly success: boolean;
+}
 interface PreconditionEngine {
     readonly executeBatch: (names: ReadonlyArray<string>, options?: ExecuteBatchOptions) => Promise<EngineResult>;
+    readonly executeObserver: (name: string, params: Record<string, string>) => Promise<ObserverExecutionResult>;
     readonly teardown: (names: ReadonlyArray<string>, data: Record<string, Record<string, string>>) => Promise<void>;
 }
 declare function createEngine(ripplo: RipploBuilder): PreconditionEngine;
@@ -53,4 +61,4 @@ interface SerializedCookie {
 declare function serializeCookie(cookie: CookieEntry): SerializedCookie;
 declare function buildSetCookieHeader(cookie: SerializedCookie): string;
 
-export { CompileResult, CookieEntry, type EngineResult, type ExecuteBatchOptions, type LintDiagnostic, type LintResult, type PreconditionEngine, RipploBuilder, type SerializedCookie, buildSetCookieHeader, createEngine, lint, serializeCookie, verifyWebhookSignature };
+export { CompileResult, CookieEntry, type EngineResult, type ExecuteBatchOptions, type LintDiagnostic, type LintResult, ObserverOutcome, type PreconditionEngine, RipploBuilder, type SerializedCookie, buildSetCookieHeader, createEngine, lint, serializeCookie, verifyWebhookSignature };