@ripplo/testing 0.0.11 → 0.1.0

package/dist/nextjs.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/nextjs.ts
 function createNextHandler({ enabled, ripplo }) {
@@ -16,18 +18,40 @@ function createNextHandler({ enabled, ripplo }) {
   const webhookSecret = ripplo.getConfig().webhookSecret;
   return async function handler(req) {
     const action = lastPathSegment(req.url);
-    if (action !== "execute-batch" && action !== "teardown") {
+    if (action !== "execute-preconditions" && action !== "teardown-preconditions" && action !== "execute-observer") {
       return jsonResponse({ error: "Not found" }, 404);
     }
     const verified = await verifyAndReadBody(req, webhookSecret);
     if ("error" in verified) {
       return verified.error;
     }
-    return runGuarded(
-      () => action === "execute-batch" ? handleExecuteBatch({ body: verified.body, engine, req }) : handleTeardown({ body: verified.body, engine })
-    );
+    return runGuarded(() => dispatchAction({ action, body: verified.body, engine, req }));
   };
 }
+function dispatchAction({ action, body, engine, req }) {
+  if (action === "execute-preconditions") {
+    return handleExecuteBatch({ body, engine, req });
+  }
+  if (action === "execute-observer") {
+    return handleExecuteObserver({ body, engine });
+  }
+  return handleTeardown({ body, engine });
+}
+async function handleExecuteObserver({
+  body,
+  engine
+}) {
+  const json = tryParseJson(body);
+  const parsed = json == null ? null : observerRequestSchema.safeParse(json);
+  if (parsed == null || !parsed.success) {
+    return jsonResponse({ error: "Invalid request body", success: false }, 400);
+  }
+  const result = await engine.executeObserver(parsed.data.observer, parsed.data.params);
+  return jsonResponse(
+    { error: result.error, outcome: result.outcome, success: result.success },
+    200
+  );
+}
 async function handleExecuteBatch({
   body,
   engine,

package/dist/{step-DLfkKI3V.d.ts → step-De52hTLd.d.ts}

@@ -1,6 +1,6 @@
 import { SpecNode } from '@ripplo/spec';
 
-type DslNodeType = "assertAttribute" | "assertChecked" | "assertCount" | "assertDisabled" | "assertEnabled" | "assertFocused" | "assertNotChecked" | "assertNotFocused" | "assertNotVisible" | "assertText" | "assertUrl" | "assertValue" | "assertVisible" | "check" | "clear" | "click" | "clipboard" | "dblclick" | "drag" | "extractText" | "fill" | "focus" | "goto" | "handleDialog" | "hover" | "press" | "rightClick" | "scrollIntoView" | "select" | "setPermission" | "setViewport" | "type" | "uncheck" | "upload";
+type DslNodeType = "assertAttribute" | "assertChecked" | "assertCount" | "assertDisabled" | "assertEnabled" | "assertFocused" | "assertNotChecked" | "assertNotFocused" | "assertNotVisible" | "assertObserver" | "assertText" | "assertUrl" | "assertValue" | "assertVisible" | "check" | "clear" | "click" | "clipboard" | "dblclick" | "drag" | "extractText" | "fill" | "focus" | "goto" | "handleDialog" | "hover" | "press" | "rightClick" | "scrollIntoView" | "select" | "setPermission" | "setViewport" | "type" | "uncheck" | "upload";
 type StepBaseFields = "comment" | "id" | "label" | "next" | "timeout";
 type DslNodeInput = SpecNode extends infer N ? N extends SpecNode ? N["type"] extends DslNodeType ? Omit<N, StepBaseFields> : never : never : never;
 

package/dist/types-oYS_Yv4G.d.ts

@@ -0,0 +1,115 @@
+import { z } from 'zod';
+import { S as Step } from './step-De52hTLd.js';
+
+declare const DEFAULT_WATCH_PATHS: ReadonlyArray<string>;
+declare const DEFAULT_IGNORE_PATHS: ReadonlyArray<string>;
+declare const dslConfigSchema: z.ZodObject<{
+    appUrl: z.ZodString;
+    engineUrl: z.ZodString;
+    ignorePaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    projectId: z.ZodString;
+    watchPaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    webhookSecret: z.ZodString;
+}, z.core.$strip>;
+type DslConfig = z.infer<typeof dslConfigSchema>;
+interface CookieOptions {
+    readonly domain: string | undefined;
+    readonly expires: number | undefined;
+    readonly httpOnly: boolean | undefined;
+    readonly path: string | undefined;
+    readonly sameSite: "lax" | "none" | "strict" | undefined;
+    readonly secure: boolean | undefined;
+}
+interface CookieEntry {
+    readonly name: string;
+    readonly options: CookieOptions | undefined;
+    readonly value: string;
+}
+declare const TEST_VALUE_BRAND: unique symbol;
+interface TestValue {
+    readonly [TEST_VALUE_BRAND]: true;
+}
+interface SetupContext {
+    readonly runId: string;
+    fixed(value: string): TestValue;
+    setCookie(name: string, value: string, options?: CookieOptions): void;
+    uniqueEmail(): TestValue;
+    uniqueId(prefix: string): TestValue;
+}
+interface TeardownContext<TData extends Record<string, string>> {
+    readonly data: TData;
+}
+declare const PRECONDITION_DATA: unique symbol;
+declare const PRECONDITION_DEPS: unique symbol;
+declare const PRECONDITION_NAME: unique symbol;
+interface Precondition<TData extends Record<string, string> = Record<string, string>, TDeps extends Record<string, Record<string, string>> = Record<string, Record<string, string>>> {
+    readonly [PRECONDITION_DATA]: TData;
+    readonly [PRECONDITION_DEPS]: TDeps;
+    readonly [PRECONDITION_NAME]: string;
+}
+type PreconditionData<T extends Precondition> = T[typeof PRECONDITION_DATA];
+type PreconditionDeps<T extends Precondition> = T[typeof PRECONDITION_DEPS];
+interface PreconditionDefinition {
+    readonly dependsOn: ReadonlyArray<string>;
+    readonly depMapping: ReadonlyArray<readonly [string, string]>;
+    readonly description: string;
+    readonly implemented: boolean;
+    readonly name: string;
+    readonly returns: ReadonlyArray<string>;
+    readonly teardown: ((ctx: TeardownContext<Record<string, string>>) => Promise<void>) | undefined;
+    readonly setup: (ctx: SetupContext, deps: Record<string, Record<string, string>>) => Promise<Record<string, TestValue>>;
+}
+type VarsFn<T> = (vars: Record<string, Record<string, string>>) => T;
+interface TestDefinition {
+    readonly description: string;
+    readonly expectedOutcome: string;
+    readonly id: string;
+    readonly implemented: boolean;
+    readonly name: string;
+    readonly requires: ReadonlyArray<string>;
+    readonly requiresKeys: Record<string, string>;
+    readonly startsAtFn: VarsFn<string> | undefined;
+    readonly stepsFn: VarsFn<ReadonlyArray<Step>> | undefined;
+    readonly uiOnly: boolean | undefined;
+}
+interface UnimplementedItems {
+    readonly observers: ReadonlyArray<string>;
+    readonly preconditions: ReadonlyArray<string>;
+    readonly tests: ReadonlyArray<string>;
+}
+declare const OBSERVER_INPUT: unique symbol;
+declare const OBSERVER_NAME: unique symbol;
+interface ObserverHandle<TInput = unknown> {
+    readonly [OBSERVER_INPUT]: TInput;
+    readonly [OBSERVER_NAME]: string;
+}
+type ObserverInput<T extends ObserverHandle> = T[typeof OBSERVER_INPUT];
+declare const OBSERVER_OUTCOME_BRAND: unique symbol;
+type ObserverOutcome = {
+    readonly kind: "pass";
+    readonly [OBSERVER_OUTCOME_BRAND]: true;
+} | {
+    readonly kind: "retry";
+    readonly [OBSERVER_OUTCOME_BRAND]: true;
+    readonly reason: string;
+} | {
+    readonly kind: "fail";
+    readonly [OBSERVER_OUTCOME_BRAND]: true;
+    readonly reason: string;
+};
+interface ObserverContext {
+    readonly runId: string;
+    fail(reason: string): ObserverOutcome;
+    pass(): ObserverOutcome;
+    retry(reason: string): ObserverOutcome;
+}
+type ObserverBudgetTier = "async" | "fast" | "slow";
+interface ObserverDefinition {
+    readonly budget: ObserverBudgetTier;
+    readonly description: string;
+    readonly implemented: boolean;
+    readonly name: string;
+    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 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ripplo/testing",
   "description": "TypeScript DSL for defining and running Ripplo e2e workflow tests",
-  "version": "0.0.11",
+  "version": "0.1.0",
   "type": "module",
   "files": [
     "dist"
@@ -71,8 +71,8 @@
     "tsup": "^8.5.1",
     "typescript": "catalog:",
     "vitest": "^4.1.4",
-    "@ripplo/spec": "^0.0.0",
-    "@ripplo/eslint-config": "0.0.0"
+    "@ripplo/eslint-config": "0.0.0",
+    "@ripplo/spec": "^0.0.0"
   },
   "peerDependencies": {
     "dotenv": "^16.0.0 || ^17.0.0",

package/dist/builder-1kySbit_.d.ts

@@ -1,137 +0,0 @@
-import { z } from 'zod';
-import { S as Step } from './step-DLfkKI3V.js';
-
-declare const DEFAULT_WATCH_PATHS: ReadonlyArray<string>;
-declare const DEFAULT_IGNORE_PATHS: ReadonlyArray<string>;
-declare const dslConfigSchema: z.ZodObject<{
-    appUrl: z.ZodString;
-    ignorePaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    preconditionsUrl: z.ZodString;
-    projectId: z.ZodString;
-    watchPaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    webhookSecret: z.ZodString;
-}, z.core.$strip>;
-type DslConfig = z.infer<typeof dslConfigSchema>;
-interface CookieOptions {
-    readonly domain: string | undefined;
-    readonly expires: number | undefined;
-    readonly httpOnly: boolean | undefined;
-    readonly path: string | undefined;
-    readonly sameSite: "lax" | "none" | "strict" | undefined;
-    readonly secure: boolean | undefined;
-}
-interface CookieEntry {
-    readonly name: string;
-    readonly options: CookieOptions | undefined;
-    readonly value: string;
-}
-declare const TEST_VALUE_BRAND: unique symbol;
-interface TestValue {
-    readonly [TEST_VALUE_BRAND]: true;
-}
-interface SetupContext {
-    readonly runId: string;
-    fixed(value: string): TestValue;
-    setCookie(name: string, value: string, options?: CookieOptions): void;
-    uniqueEmail(): TestValue;
-    uniqueId(prefix: string): TestValue;
-}
-interface TeardownContext<TData extends Record<string, string>> {
-    readonly data: TData;
-}
-declare const PRECONDITION_DATA: unique symbol;
-declare const PRECONDITION_DEPS: unique symbol;
-declare const PRECONDITION_NAME: unique symbol;
-interface Precondition<TData extends Record<string, string> = Record<string, string>, TDeps extends Record<string, Record<string, string>> = Record<string, Record<string, string>>> {
-    readonly [PRECONDITION_DATA]: TData;
-    readonly [PRECONDITION_DEPS]: TDeps;
-    readonly [PRECONDITION_NAME]: string;
-}
-type PreconditionData<T extends Precondition> = T[typeof PRECONDITION_DATA];
-type PreconditionDeps<T extends Precondition> = T[typeof PRECONDITION_DEPS];
-interface PreconditionDefinition {
-    readonly dependsOn: ReadonlyArray<string>;
-    readonly depMapping: ReadonlyArray<readonly [string, string]>;
-    readonly description: string;
-    readonly implemented: boolean;
-    readonly name: string;
-    readonly returns: ReadonlyArray<string>;
-    readonly teardown: ((ctx: TeardownContext<Record<string, string>>) => Promise<void>) | undefined;
-    readonly setup: (ctx: SetupContext, deps: Record<string, Record<string, string>>) => Promise<Record<string, TestValue>>;
-}
-type VarsFn<T> = (vars: Record<string, Record<string, string>>) => T;
-interface TestDefinition {
-    readonly description: string;
-    readonly expectedOutcome: string;
-    readonly id: string;
-    readonly implemented: boolean;
-    readonly name: string;
-    readonly requires: ReadonlyArray<string>;
-    readonly requiresKeys: Record<string, string>;
-    readonly startsAtFn: VarsFn<string> | undefined;
-    readonly stepsFn: VarsFn<ReadonlyArray<Step>> | undefined;
-}
-interface UnimplementedItems {
-    readonly preconditions: ReadonlyArray<string>;
-    readonly tests: ReadonlyArray<string>;
-}
-
-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;
-}
-interface TestNeedsRequires {
-    readonly description: (text: string) => 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 startsAt: (fn: (vars: TVars) => string) => TestNeedsSteps<TVars>;
-}
-interface TestNeedsSteps<TVars extends Record<string, Record<string, string>>> {
-    readonly steps: (fn: (vars: TVars) => ReadonlyArray<Step>) => void;
-}
-
-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 teardown: (ctx: TeardownContext<TData>) => Promise<void>;
-}
-interface RipploBuilder {
-    readonly getConfig: () => DslConfig;
-    readonly getPreconditions: () => ReadonlyArray<PreconditionDefinition>;
-    readonly getTests: () => ReadonlyArray<TestDefinition>;
-    readonly getUnimplemented: () => UnimplementedItems;
-    readonly implement: <TData extends Record<string, string>, TDeps extends Record<string, Record<string, string>>>(handle: Precondition<TData, TDeps>, impl: PreconditionImpl<TData, TDeps>) => void;
-    readonly precondition: (name: string) => PreconditionNeedsSetup;
-    readonly test: (id: string) => TestNeedsName;
-}
-declare function createRipplo(rawConfig: DslConfig): RipploBuilder;
-
-export { type CookieEntry as C, DEFAULT_IGNORE_PATHS as D, type Precondition as P, type RipploBuilder as R, type SetupContext as S, type TeardownContext as T, type CookieOptions as a, DEFAULT_WATCH_PATHS as b, type DslConfig as c, type PreconditionDeps as d, type PreconditionImpl as e, type PreconditionRecord as f, type ResolveDeps as g, createRipplo as h };