@ripplo/testing 0.1.0 → 0.2.0

package/dist/{builder-c7tXey03.d.ts → builder-dqXTFZ4j.d.ts}

@@ -1,4 +1,4 @@
-import { O as ObserverHandle, P as Precondition, j as PreconditionData, k as TestValue, S as SetupContext, T as TeardownContext, f as DslConfig, h as ObserverDefinition, l as PreconditionDefinition, m as TestDefinition, U as UnimplementedItems, g as ObserverContext, c as ObserverOutcome, a as ObserverInput } from './types-oYS_Yv4G.js';
+import { O as ObserverHandle, P as Precondition, l as PreconditionData, j as TestDefinition, e as DslConfig, g as ObserverDefinition, k as PreconditionDefinition, U as UnimplementedItems, f as ObserverContext, h as ObserverOutcome, S as SetupContext, m as TestValue, T as TeardownContext } from './types-yIhY8cwG.js';
 import { ObserverBudget } from '@ripplo/spec';
 import { S as Step } from './step-De52hTLd.js';
 
@@ -9,32 +9,19 @@ interface ObserverNeedsInput {
 }
 interface ObserverReady<TInput extends Record<string, string>> {
     readonly contract: () => ObserverHandle<TInput>;
-    readonly notImplemented: () => ObserverHandle<TInput>;
 }
 
 type PreconditionRecord = Record<string, Precondition>;
 type ResolveDeps<TDeps extends PreconditionRecord> = {
     readonly [K in keyof TDeps]: PreconditionData<TDeps[K]>;
 };
-type ResolveData<T extends Record<string, TestValue>> = {
-    readonly [K in keyof T]: string;
-};
 interface PreconditionNeedsSetup {
     readonly contract: <TData extends Record<string, string>>() => Precondition<TData>;
     readonly description: (text: string) => PreconditionNeedsSetup;
-    readonly notImplemented: () => Precondition<Record<string, never>>;
     readonly requires: <TDeps extends PreconditionRecord>(deps: TDeps) => PreconditionNeedsSetupWithDeps<TDeps>;
-    readonly setup: <TData extends Record<string, TestValue>>(fn: (ctx: SetupContext) => Promise<TData>) => PreconditionHasSetup<ResolveData<TData>>;
 }
 interface PreconditionNeedsSetupWithDeps<TDeps extends PreconditionRecord> {
     readonly contract: <TData extends Record<string, string>>() => Precondition<TData, ResolveDeps<TDeps>>;
-    readonly description: (text: string) => PreconditionNeedsSetupWithDeps<TDeps>;
-    readonly notImplemented: () => Precondition<Record<string, never>>;
-    readonly requires: <TDeps2 extends PreconditionRecord>(deps: TDeps2) => PreconditionNeedsSetupWithDeps<TDeps2>;
-    readonly setup: <TData extends Record<string, TestValue>>(fn: (ctx: SetupContext, deps: ResolveDeps<TDeps>) => Promise<TData>) => PreconditionHasSetup<ResolveData<TData>>;
-}
-interface PreconditionHasSetup<TData extends Record<string, string>> {
-    readonly teardown: (fn: (ctx: TeardownContext<TData>) => Promise<void>) => Precondition<TData>;
 }
 interface TestNeedsName {
     readonly name: (displayName: string) => TestNeedsRequires;
@@ -44,37 +31,50 @@ interface TestNeedsRequires {
     readonly requires: <TReqs extends PreconditionRecord>(reqs: TReqs) => TestNeedsOutcome<ResolveDeps<TReqs>>;
 }
 interface TestNeedsOutcome<TVars extends Record<string, Record<string, string>>> {
-    readonly description: (text: string) => TestNeedsOutcome<TVars>;
     readonly expectedOutcome: (text: string) => TestNeedsStartsAt<TVars>;
 }
+
 interface TestNeedsStartsAt<TVars extends Record<string, Record<string, string>>> {
-    readonly notImplemented: () => void;
+    readonly notImplemented: () => TestDefinition;
     readonly startsAt: (fn: (vars: TVars) => string) => TestNeedsSteps<TVars>;
 }
 interface TestNeedsSteps<TVars extends Record<string, Record<string, string>>> {
-    readonly steps: (fn: (vars: TVars) => ReadonlyArray<Step>) => void;
+    readonly steps: (fn: (vars: TVars) => ReadonlyArray<Step>) => TestDefinition;
 }
 
+type PreconditionSetupResult<TData extends Record<string, string>> = {
+    readonly [K in keyof TData]: TestValue;
+};
 interface PreconditionImpl<TData extends Record<string, string>, TDeps extends Record<string, Record<string, string>>> {
-    readonly setup: (ctx: SetupContext, deps: TDeps) => Promise<Record<string, TestValue>>;
+    readonly setup: (ctx: SetupContext, deps: TDeps) => Promise<PreconditionSetupResult<TData>>;
     readonly teardown: (ctx: TeardownContext<TData>) => Promise<void>;
 }
 type ObserverImplFn<TInput extends Record<string, string>> = (ctx: ObserverContext, params: TInput) => Promise<ObserverOutcome>;
-interface RipploBuilder {
+interface TestOptions {
+    readonly uiOnly?: boolean;
+}
+type PreconditionRegistry = Record<string, Precondition>;
+type ObserverRegistry = Record<string, ObserverHandle<Record<string, string>>>;
+interface RipploRegistries<P extends PreconditionRegistry, O extends ObserverRegistry> {
+    readonly observers: O;
+    readonly preconditions: P;
+    readonly tests: ReadonlyArray<TestDefinition>;
+}
+interface RipploInstance<P extends PreconditionRegistry = PreconditionRegistry, O extends ObserverRegistry = ObserverRegistry> {
+    readonly config: DslConfig;
+    readonly observers: O;
+    readonly preconditions: P;
+    readonly tests: ReadonlyArray<TestDefinition>;
     readonly getConfig: () => DslConfig;
     readonly getObservers: () => ReadonlyArray<ObserverDefinition>;
     readonly getPreconditions: () => ReadonlyArray<PreconditionDefinition>;
     readonly getTests: () => ReadonlyArray<TestDefinition>;
     readonly getUnimplemented: () => UnimplementedItems;
-    readonly implementObserver: <THandle extends ObserverHandle>(handle: THandle, impl: ObserverImplFn<ObserverInput<THandle> & Record<string, string>>) => void;
-    readonly implementPrecondition: <TData extends Record<string, string>, TDeps extends Record<string, Record<string, string>>>(handle: Precondition<TData, TDeps>, impl: PreconditionImpl<TData, TDeps>) => void;
-    readonly observer: (name: string) => ObserverNeedsInput;
-    readonly precondition: (name: string) => PreconditionNeedsSetup;
-    readonly test: (id: string, options?: TestOptions) => TestNeedsName;
-}
-interface TestOptions {
-    readonly uiOnly?: boolean;
 }
-declare function createRipplo(rawConfig: DslConfig): RipploBuilder;
+type RipploBuilder = RipploInstance;
+declare function precondition(name: string): PreconditionNeedsSetup;
+declare function observer(name: string): ObserverNeedsInput;
+declare function test(id: string, options?: TestOptions): TestNeedsName;
+declare function createRipplo<P extends PreconditionRegistry, O extends ObserverRegistry>(rawConfig: DslConfig, registries: RipploRegistries<P, O>): RipploInstance<P, O>;
 
-export { type ObserverImplFn as O, type PreconditionImpl as P, type RipploBuilder as R, type PreconditionRecord as a, type ResolveDeps as b, createRipplo as c };
+export { type ObserverImplFn as O, type PreconditionImpl as P, type ResolveDeps as R, type ObserverRegistry as a, type PreconditionRecord as b, type PreconditionRegistry as c, type RipploBuilder as d, type RipploInstance as e, type RipploRegistries as f, createRipplo as g, observer as o, precondition as p, test as t };

package/dist/{chunk-3IL457A7.js → chunk-P4ZI7G5M.js}

@@ -37,14 +37,30 @@ function createTestValue(value) {
 function readPreconditionName(p) {
   return p.name;
 }
+function readPreconditionDescription(p) {
+  return p.description;
+}
+function readPreconditionDependsOn(p) {
+  return p.dependsOn;
+}
+function readPreconditionDepMapping(p) {
+  return p.depMapping;
+}
 function readObserverName(o) {
   return o.name;
 }
 function readObserverBudget(o) {
   return o.budget;
 }
-function makeObserverHandle(name, budget) {
-  return { budget, name };
+function readObserverDescription(o) {
+  return o.description;
+}
+function makeObserverHandle({
+  budget,
+  description,
+  name
+}) {
+  return { budget, description, name };
 }
 
 export {
@@ -54,7 +70,11 @@ export {
   readTestValue,
   createTestValue,
   readPreconditionName,
+  readPreconditionDescription,
+  readPreconditionDependsOn,
+  readPreconditionDepMapping,
   readObserverName,
   readObserverBudget,
+  readObserverDescription,
   makeObserverHandle
 };

package/dist/chunk-TO3T2D2Y.js

@@ -0,0 +1,84 @@
+// 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 {
+  batchRequestSchema,
+  teardownRequestSchema,
+  observerRequestSchema,
+  verifyWebhookSignature,
+  serializeCookie,
+  buildSetCookieHeader
+};

package/dist/compiler.d.ts

@@ -1,6 +1,6 @@
 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 { d as RipploBuilder } from './builder-dqXTFZ4j.js';
+import { e as DslConfig } from './types-yIhY8cwG.js';
 import './step-De52hTLd.js';
 import 'zod';
 

package/dist/engine-CphCJ1ZS.d.ts

@@ -0,0 +1,47 @@
+import { c as PreconditionRegistry, a as ObserverRegistry, O as ObserverImplFn, P as PreconditionImpl, e as RipploInstance } from './builder-dqXTFZ4j.js';
+import { h as ObserverOutcome, C as CookieEntry, e as DslConfig, g as ObserverDefinition, k as PreconditionDefinition, U as UnimplementedItems, O as ObserverHandle, P as Precondition } from './types-yIhY8cwG.js';
+
+interface EngineResult {
+    readonly cookies: ReadonlyArray<CookieEntry>;
+    readonly data: Record<string, Record<string, string>>;
+    readonly error: string | undefined;
+    readonly executed: ReadonlyArray<string>;
+    readonly runId: string;
+    readonly success: boolean;
+}
+interface ExecuteBatchOptions {
+    readonly appUrl: string | undefined;
+}
+interface ObserverExecutionResult {
+    readonly error: string | undefined;
+    readonly outcome: ObserverOutcome | undefined;
+    readonly success: boolean;
+}
+interface PreconditionEngine {
+    readonly executeObserver: (name: string, params: Record<string, string>) => Promise<ObserverExecutionResult>;
+    readonly executePreconditions: (names: ReadonlyArray<string>, options?: ExecuteBatchOptions) => Promise<EngineResult>;
+    readonly getConfig: () => DslConfig;
+    readonly getObservers: () => ReadonlyArray<ObserverDefinition>;
+    readonly getPreconditions: () => ReadonlyArray<PreconditionDefinition>;
+    readonly getUnimplemented: () => UnimplementedItems;
+    readonly teardown: (names: ReadonlyArray<string>, data: Record<string, Record<string, string>>) => Promise<void>;
+}
+declare const NOT_IMPLEMENTED_BRAND: unique symbol;
+interface NotImplemented {
+    readonly [NOT_IMPLEMENTED_BRAND]: true;
+    readonly reason: string;
+}
+declare function notImplemented(reason?: string): NotImplemented;
+type PreconditionImplFor<P> = P extends Precondition<infer TData, infer TDeps> ? PreconditionImpl<TData, TDeps> : never;
+type ObserverImplFnFor<O> = O extends ObserverHandle<infer TInput> ? TInput extends Record<string, string> ? ObserverImplFn<TInput> : never : never;
+interface EngineImpls<P extends PreconditionRegistry, O extends ObserverRegistry> {
+    readonly observers: {
+        readonly [K in keyof O]: NotImplemented | ObserverImplFnFor<O[K]>;
+    };
+    readonly preconditions: {
+        readonly [K in keyof P]: NotImplemented | PreconditionImplFor<P[K]>;
+    };
+}
+declare function createEngine<P extends PreconditionRegistry, O extends ObserverRegistry>(ripplo: RipploInstance<P, O>, impls: EngineImpls<P, O>): PreconditionEngine;
+
+export { type EngineImpls as E, type NotImplemented as N, type ObserverImplFnFor as O, type PreconditionEngine as P, type EngineResult as a, type ExecuteBatchOptions as b, type PreconditionImplFor as c, createEngine as d, notImplemented as n };

package/dist/express.d.ts

@@ -1,14 +1,15 @@
 import { Router } from 'express';
-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 CreateExpressHandlerParams {
     readonly enabled: boolean;
-    readonly ripplo: RipploBuilder;
+    readonly engine: PreconditionEngine;
 }
-declare function createExpressHandler({ enabled, ripplo }: CreateExpressHandlerParams): Router;
+declare function createExpressHandler({ enabled, engine }: CreateExpressHandlerParams): Router;
 
 export { type CreateExpressHandlerParams, createExpressHandler };

package/dist/express.js

@@ -1,22 +1,19 @@
 import {
   batchRequestSchema,
-  createEngine,
   observerRequestSchema,
   serializeCookie,
   teardownRequestSchema,
   verifyWebhookSignature
-} from "./chunk-CD3M7H5A.js";
-import "./chunk-3IL457A7.js";
+} from "./chunk-TO3T2D2Y.js";
 
 // src/adapters/express.ts
 import { Router, json } from "express";
-function createExpressHandler({ enabled, ripplo }) {
+function createExpressHandler({ enabled, engine }) {
   const router = Router();
   if (!enabled) {
     return router;
   }
-  const engine = createEngine(ripplo);
-  const webhookSecret = ripplo.getConfig().webhookSecret;
+  const webhookSecret = engine.getConfig().webhookSecret;
   router.use(json());
   router.use((req, res, next) => {
     if (webhookSecret.length === 0) {
@@ -38,7 +35,7 @@ function createExpressHandler({ enabled, ripplo }) {
       return;
     }
     const appUrl = `${req.protocol}://${req.get("host") ?? ""}`;
-    void engine.executeBatch(parsed.data.preconditions, { appUrl }).then((result) => {
+    void engine.executePreconditions(parsed.data.preconditions, { appUrl }).then((result) => {
       result.cookies.forEach((cookie) => {
         const s = serializeCookie(cookie);
         res.cookie(s.name, s.value, buildExpressCookieOptions(s));

package/dist/fastify.d.ts

@@ -1,14 +1,15 @@
 import { FastifyInstance } from 'fastify';
-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 RegisterFastifyHandlerParams {
     readonly enabled: boolean;
-    readonly ripplo: RipploBuilder;
+    readonly engine: PreconditionEngine;
 }
-declare function registerFastifyHandler({ enabled, ripplo, }: RegisterFastifyHandlerParams): (fastify: FastifyInstance) => Promise<void>;
+declare function registerFastifyHandler({ enabled, engine, }: RegisterFastifyHandlerParams): (fastify: FastifyInstance) => Promise<void>;
 
 export { type RegisterFastifyHandlerParams, registerFastifyHandler };

package/dist/fastify.js

@@ -1,25 +1,22 @@
 import {
   batchRequestSchema,
   buildSetCookieHeader,
-  createEngine,
   observerRequestSchema,
   serializeCookie,
   teardownRequestSchema,
   verifyWebhookSignature
-} from "./chunk-CD3M7H5A.js";
-import "./chunk-3IL457A7.js";
+} from "./chunk-TO3T2D2Y.js";
 
 // src/adapters/fastify.ts
 function registerFastifyHandler({
   enabled,
-  ripplo
+  engine
 }) {
   if (!enabled) {
     return async () => {
     };
   }
-  const engine = createEngine(ripplo);
-  const webhookSecret = ripplo.getConfig().webhookSecret;
+  const webhookSecret = engine.getConfig().webhookSecret;
   return async (fastify) => {
     fastify.addHook("preHandler", async (req, reply) => {
       if (webhookSecret.length === 0) {
@@ -41,7 +38,7 @@ function registerFastifyHandler({
         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 });
+      const result = await engine.executePreconditions(parsed.data.preconditions, { appUrl });
       result.cookies.forEach((cookie) => {
         const s = serializeCookie(cookie);
         reply.header("Set-Cookie", buildSetCookieHeader(s));

package/dist/index.d.ts

@@ -1,9 +1,9 @@
-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';
+export { O as ObserverImplFn, a as ObserverRegistry, P as PreconditionImpl, b as PreconditionRecord, c as PreconditionRegistry, R as ResolveDeps, d as RipploBuilder, e as RipploInstance, f as RipploRegistries, g as createRipplo, o as observer, p as precondition, t as test } from './builder-dqXTFZ4j.js';
 import { CompileResult } from './compiler.js';
 export { CompiledTest, compile } from './compiler.js';
-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 { E as EngineImpls, a as EngineResult, b as ExecuteBatchOptions, N as NotImplemented, O as ObserverImplFnFor, P as PreconditionEngine, c as PreconditionImplFor, d as createEngine, n as notImplemented } from './engine-CphCJ1ZS.js';
+import { C as CookieEntry } from './types-yIhY8cwG.js';
+export { c as CookieOptions, D as DEFAULT_IGNORE_PATHS, d as DEFAULT_WATCH_PATHS, e as DslConfig, f as ObserverContext, g as ObserverDefinition, O as ObserverHandle, a as ObserverInput, h as ObserverOutcome, P as Precondition, i as PreconditionDeps, S as SetupContext, T as TeardownContext, j as TestDefinition } from './types-yIhY8cwG.js';
 export { D as DslNodeInput } from './step-De52hTLd.js';
 import '@ripplo/spec';
 import 'zod';
@@ -19,29 +19,6 @@ interface LintResult {
 }
 declare function lint(result: CompileResult): LintResult;
 
-interface EngineResult {
-    readonly cookies: ReadonlyArray<CookieEntry>;
-    readonly data: Record<string, Record<string, string>>;
-    readonly error: string | undefined;
-    readonly executed: ReadonlyArray<string>;
-    readonly runId: string;
-    readonly success: boolean;
-}
-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;
-
 interface WebhookHeaders {
     readonly "webhook-id": string | undefined;
     readonly "webhook-signature": string | undefined;
@@ -61,4 +38,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, ObserverOutcome, type PreconditionEngine, RipploBuilder, type SerializedCookie, buildSetCookieHeader, createEngine, lint, serializeCookie, verifyWebhookSignature };
+export { CompileResult, CookieEntry, type LintDiagnostic, type LintResult, type SerializedCookie, buildSetCookieHeader, lint, serializeCookie, verifyWebhookSignature };