@ripplo/testing 0.6.1 → 0.7.1

package/dist/chunk-YFOTJIVF.js

@@ -1,134 +0,0 @@
-import {
-  createStep,
-  readStep
-} from "./chunk-MGATMMCZ.js";
-
-// src/compiler.ts
-function compile(ripplo) {
-  const preconditionDefs = ripplo.getPreconditions();
-  const observerDefs = ripplo.getObservers();
-  const testDefs = ripplo.getTests();
-  validateUniqueIds(testDefs);
-  const preconditions = {};
-  preconditionDefs.forEach((def) => {
-    preconditions[def.name] = {
-      depends: [...def.dependsOn],
-      description: def.description,
-      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 { fixtures: {}, observers, preconditions, 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, preconditionDefs) {
-  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, def.uiOnly);
-  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()"
-    );
-  }
-  const resolvedPreconditions = resolveDependencyChain(def.requires, preconditionDefs);
-  return {
-    additionalChecks: [],
-    coverage: def.coverage,
-    description: def.description,
-    expectedOutcome: def.expectedOutcome,
-    implemented: def.implemented,
-    name: def.name,
-    preconditions: resolvedPreconditions,
-    requiresKeys: { ...def.requiresKeys },
-    slug,
-    sourcePath: def.sourcePath,
-    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, uiOnly) {
-  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, uiOnly, variableNamespaces, variables };
-}
-function compileNode(step, id, next) {
-  const { label, node: raw } = readStep(step);
-  return { ...raw, id, label, next };
-}
-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;
-}
-
-export {
-  compile
-};

package/dist/chunk-YQAEOH5W.js

@@ -1,111 +0,0 @@
-// src/types.ts
-var DEFAULT_WATCH_PATHS = [
-  "**/src/**",
-  "**/app/**",
-  "**/apps/**",
-  "**/pages/**",
-  "**/routes/**",
-  "**/components/**",
-  "**/server/**",
-  "**/api/**",
-  "**/backend/**",
-  "**/features/**",
-  "**/modules/**",
-  "**/views/**",
-  "**/ui/**",
-  "**/hooks/**",
-  "**/contexts/**",
-  "**/providers/**",
-  "**/controllers/**",
-  "**/handlers/**",
-  "**/resolvers/**",
-  "**/services/**",
-  "**/middleware/**",
-  "**/lib/**"
-];
-var DEFAULT_IGNORE_PATHS = [
-  "**/*.gen.*",
-  "**/generated/**",
-  "**/*.d.ts",
-  "**/*.test.*",
-  "**/*.spec.*",
-  "**/node_modules/**",
-  "**/dist/**",
-  "**/build/**",
-  ".ripplo/**",
-  "**/*.md",
-  "**/.next/**",
-  "**/.turbo/**",
-  "**/.vercel/**",
-  "**/.svelte-kit/**",
-  "**/.nuxt/**",
-  "**/.astro/**",
-  "**/coverage/**",
-  "**/storybook-static/**",
-  "**/*.stories.*",
-  "**/*.story.*",
-  "**/cli/**",
-  "**/scripts/**",
-  "**/tools/**",
-  "**/__tests__/**",
-  "**/__mocks__/**",
-  "**/__fixtures__/**",
-  "**/*.config.*",
-  "**/*.setup.*",
-  "**/public/**",
-  "**/static/**",
-  "**/assets/**",
-  "**/migrations/**",
-  "**/prisma/migrations/**",
-  "**/scripts/**"
-];
-function brandTestValue(value) {
-  return value;
-}
-function isPrimitive(value) {
-  const t = typeof value;
-  return t === "string" || t === "number" || t === "boolean";
-}
-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 readObserverDescription(o) {
-  return o.description;
-}
-function makeObserverHandle({
-  budget,
-  description,
-  name
-}) {
-  return { budget, description, name };
-}
-
-export {
-  DEFAULT_WATCH_PATHS,
-  DEFAULT_IGNORE_PATHS,
-  brandTestValue,
-  isPrimitive,
-  readPreconditionName,
-  readPreconditionDescription,
-  readPreconditionDependsOn,
-  readPreconditionDepMapping,
-  readObserverName,
-  readObserverBudget,
-  readObserverDescription,
-  makeObserverHandle
-};

package/dist/compiler.d.ts

@@ -1,32 +0,0 @@
-import { Observer, Precondition, WorkflowSpec } from '@ripplo/spec';
-import { f as RipploBuilder } from './builder-SsgqYqSC.js';
-import './types-BzZrl65Z.js';
-import './step-De52hTLd.js';
-
-interface CompiledFixture {
-    readonly sha256: string;
-    readonly size: number;
-}
-interface CompileResult {
-    readonly fixtures: Record<string, CompiledFixture>;
-    readonly observers: Record<string, Observer>;
-    readonly preconditions: Record<string, Precondition>;
-    readonly tests: ReadonlyArray<CompiledTest>;
-}
-interface CompiledTest {
-    readonly additionalChecks: ReadonlyArray<string>;
-    readonly coverage: ReadonlyArray<string>;
-    readonly description: string;
-    readonly expectedOutcome: string;
-    readonly implemented: boolean;
-    readonly name: string;
-    readonly preconditions: ReadonlyArray<string>;
-    readonly requiresKeys: Record<string, string>;
-    readonly slug: string;
-    readonly sourcePath: string | undefined;
-    readonly spec: WorkflowSpec;
-    readonly warnings: ReadonlyArray<string>;
-}
-declare function compile(ripplo: RipploBuilder): CompileResult;
-
-export { type CompileResult, type CompiledFixture, type CompiledTest, compile };

package/dist/compiler.js

@@ -1,8 +0,0 @@
-import {
-  compile
-} from "./chunk-YFOTJIVF.js";
-import "./chunk-MGATMMCZ.js";
-import "./chunk-4MGIQFAJ.js";
-export {
-  compile
-};

package/dist/control.d.ts

@@ -1,45 +0,0 @@
-import { U as UnlabeledStep } from './step-De52hTLd.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 a runtime placeholder, bound later by `extract()` and consumed by
- * actions/assertions. Use for values produced mid-test (e.g. an ID rendered
- * into the DOM). Precondition data is already typed and injected — reach for
- * `variable` only when the value isn't known until the test runs.
- */
-declare function variable<TName extends string>(name: TName): Variable<TName>;
-declare function readVariable(v: Variable<string>): string;
-declare function isVariable(v: unknown): v is Variable<string>;
-interface StaticStringRef {
-    readonly type: "static";
-    readonly value: string;
-}
-interface VariableRef {
-    readonly name: string;
-    readonly type: "variable";
-}
-declare function toStringValueRef(value: string | Variable<string>): StaticStringRef | VariableRef;
-/**
- * Capture the text of the matched element into `target` (a `variable()`).
- * Pairs by name — downstream steps referencing the same `variable` see the
- * extracted value.
- */
-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 StaticStringRef, type Variable, type VariableRef, extract, isVariable, readVariable, toStringValueRef, variable };

package/dist/control.js

@@ -1,17 +0,0 @@
-import {
-  extract,
-  isVariable,
-  readVariable,
-  toStringValueRef,
-  variable
-} from "./chunk-2YLI7VD4.js";
-import "./chunk-DCJBLS2U.js";
-import "./chunk-MGATMMCZ.js";
-import "./chunk-4MGIQFAJ.js";
-export {
-  extract,
-  isVariable,
-  readVariable,
-  toStringValueRef,
-  variable
-};

package/dist/elysia.d.ts

@@ -1,78 +0,0 @@
-import { Elysia } from 'elysia';
-import { R as RipploEngine } from './engine-BOqzK_go.js';
-import './builder-SsgqYqSC.js';
-import './types-BzZrl65Z.js';
-import './step-De52hTLd.js';
-import '@ripplo/spec';
-
-interface CreateElysiaHandlerParams {
-    readonly enabled: boolean;
-    readonly engine: RipploEngine;
-}
-declare function createElysiaHandler(params: CreateElysiaHandlerParams): ReturnType<typeof build>;
-declare function build({ enabled, engine }: CreateElysiaHandlerParams): Elysia<"", {
-    decorator: {};
-    store: {};
-    derive: {};
-    resolve: {};
-}, {
-    typebox: {};
-    error: {};
-}, {
-    schema: {};
-    standaloneSchema: {};
-    macro: {};
-    macroFn: {};
-    parser: {};
-    response: {};
-}, {
-    "execute-preconditions": {
-        put: {
-            body: unknown;
-            params: {};
-            query: unknown;
-            headers: unknown;
-            response: {
-                200: Response;
-            };
-        };
-    };
-} & {
-    "execute-observer": {
-        put: {
-            body: unknown;
-            params: {};
-            query: unknown;
-            headers: unknown;
-            response: {
-                200: Response;
-            };
-        };
-    };
-} & {
-    "teardown-preconditions": {
-        put: {
-            body: unknown;
-            params: {};
-            query: unknown;
-            headers: unknown;
-            response: {
-                200: Response;
-            };
-        };
-    };
-}, {
-    derive: {};
-    resolve: {};
-    schema: {};
-    standaloneSchema: {};
-    response: {};
-}, {
-    derive: {};
-    resolve: {};
-    schema: {};
-    standaloneSchema: {};
-    response: {};
-}>;
-
-export { type CreateElysiaHandlerParams, createElysiaHandler };

package/dist/elysia.js

@@ -1,114 +0,0 @@
-import {
-  batchRequestSchema,
-  observerRequestSchema,
-  readAdapterWebhookSecret,
-  teardownRequestSchema,
-  toBatchRunResults,
-  toTeardownResults,
-  verifyWebhookSignature
-} from "./chunk-XO36IU66.js";
-import "./chunk-4MGIQFAJ.js";
-
-// src/adapters/elysia.ts
-import { Elysia } from "elysia";
-function createElysiaHandler(params) {
-  return build(params);
-}
-function build({ enabled, engine }) {
-  const app = new Elysia();
-  if (!enabled) {
-    return app.put("/execute-preconditions", () => notFoundResponse()).put("/execute-observer", () => notFoundResponse()).put("/teardown-preconditions", () => notFoundResponse());
-  }
-  const webhookSecret = readAdapterWebhookSecret();
-  return app.put("/execute-preconditions", async ({ request }) => {
-    const gate = await verifyAndReadBody(request, webhookSecret);
-    if ("response" in gate) {
-      return gate.response;
-    }
-    const parsed = parseWith(gate.body, batchRequestSchema);
-    if (parsed == null) {
-      return jsonResponse({ error: "Invalid request body" }, 400);
-    }
-    const host = request.headers.get("host");
-    if (host == null || host.length === 0) {
-      return jsonResponse({ error: "Missing host header" }, 400);
-    }
-    const proto = request.headers.get("x-forwarded-proto") ?? "http";
-    const appUrl = `${proto}://${host}`;
-    const items = parsed.batch.map((b) => ({ names: b.preconditions, runId: b.runId }));
-    const results = await engine.executePreconditions(items, { appUrl });
-    return jsonResponse({ results: toBatchRunResults(results) }, 200);
-  }).put("/execute-observer", async ({ request }) => {
-    const gate = await verifyAndReadBody(request, webhookSecret);
-    if ("response" in gate) {
-      return gate.response;
-    }
-    const parsed = parseWith(gate.body, observerRequestSchema);
-    if (parsed == null) {
-      return jsonResponse({ error: "Invalid request body", success: false }, 400);
-    }
-    const result = await engine.executeObserver(parsed.observer, parsed.params);
-    return jsonResponse(
-      { error: result.error, outcome: result.outcome, success: result.success },
-      200
-    );
-  }).put("/teardown-preconditions", async ({ request }) => {
-    const gate = await verifyAndReadBody(request, webhookSecret);
-    if ("response" in gate) {
-      return gate.response;
-    }
-    const parsed = parseWith(gate.body, teardownRequestSchema);
-    if (parsed == null) {
-      return jsonResponse({ error: "Invalid request body" }, 400);
-    }
-    const items = parsed.batch.map((b) => ({
-      data: b.data,
-      names: b.preconditions,
-      runId: b.runId
-    }));
-    const results = await engine.teardown(items);
-    return jsonResponse({ results: toTeardownResults(results) }, 200);
-  });
-}
-async function verifyAndReadBody(req, webhookSecret) {
-  if (webhookSecret.length === 0) {
-    return { response: jsonResponse({ error: "Webhook secret not configured" }, 403) };
-  }
-  const body = await req.text();
-  const headers = {
-    "webhook-id": req.headers.get("webhook-id") ?? void 0,
-    "webhook-signature": req.headers.get("webhook-signature") ?? void 0,
-    "webhook-timestamp": req.headers.get("webhook-timestamp") ?? void 0
-  };
-  if (!verifyWebhookSignature(body, headers, webhookSecret)) {
-    return { response: jsonResponse({ error: "Invalid webhook signature" }, 401) };
-  }
-  return { body };
-}
-function parseWith(body, schema) {
-  const json = tryParseJson(body);
-  if (json == null) {
-    return null;
-  }
-  const result = schema.safeParse(json);
-  return result.success ? result.data : null;
-}
-function tryParseJson(body) {
-  try {
-    return JSON.parse(body);
-  } catch {
-    return null;
-  }
-}
-function jsonResponse(payload, status) {
-  return new Response(JSON.stringify(payload), {
-    headers: { "content-type": "application/json" },
-    status
-  });
-}
-function notFoundResponse() {
-  return jsonResponse({ error: "Not found" }, 404);
-}
-export {
-  createElysiaHandler
-};

package/dist/engine-BOqzK_go.d.ts

@@ -1,61 +0,0 @@
-import { c as PreconditionRegistry, a as ObserverRegistry, O as ObserverImplFn, P as PreconditionImpl, g as RipploInstance } from './builder-SsgqYqSC.js';
-import { P as Primitive, g as ObserverOutcome, C as CookieEntry, f as ObserverDefinition, l as PreconditionDefinition, U as UnimplementedItems, O as ObserverHandle, h as Precondition } from './types-BzZrl65Z.js';
-
-declare const TEST_ID_PREFIX = "ripplo-test-";
-interface EngineRunResult {
-    readonly cookies: ReadonlyArray<CookieEntry>;
-    readonly data: Record<string, Record<string, Primitive>>;
-    readonly error: string | undefined;
-    readonly executed: ReadonlyArray<string>;
-    readonly runId: string;
-    readonly success: boolean;
-}
-interface ExecuteBatchOptions {
-    readonly appUrl: string | undefined;
-}
-interface ExecuteBatchItem {
-    readonly names: ReadonlyArray<string>;
-    readonly runId: string;
-}
-interface TeardownBatchItem {
-    readonly data: Record<string, Record<string, Primitive>>;
-    readonly names: ReadonlyArray<string>;
-    readonly runId: string;
-}
-interface TeardownRunResult {
-    readonly error: string | undefined;
-    readonly runId: string;
-    readonly success: boolean;
-}
-interface ObserverExecutionResult {
-    readonly error: string | undefined;
-    readonly outcome: ObserverOutcome | undefined;
-    readonly success: boolean;
-}
-interface RipploEngine {
-    readonly executeObserver: (name: string, params: Record<string, Primitive>) => Promise<ObserverExecutionResult>;
-    readonly executePreconditions: (items: ReadonlyArray<ExecuteBatchItem>, options?: ExecuteBatchOptions) => Promise<ReadonlyArray<EngineRunResult>>;
-    readonly getObservers: () => ReadonlyArray<ObserverDefinition>;
-    readonly getPreconditions: () => ReadonlyArray<PreconditionDefinition>;
-    readonly getUnimplemented: () => UnimplementedItems;
-    readonly teardown: (items: ReadonlyArray<TeardownBatchItem>) => Promise<ReadonlyArray<TeardownRunResult>>;
-}
-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, Primitive> ? 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>): RipploEngine;
-
-export { type EngineRunResult as E, type NotImplemented as N, type ObserverImplFnFor as O, type PreconditionImplFor as P, type RipploEngine as R, type TeardownRunResult as T, type EngineImpls as a, type ExecuteBatchItem as b, type ExecuteBatchOptions as c, TEST_ID_PREFIX as d, type TeardownBatchItem as e, createEngine as f, notImplemented as n };

package/dist/fastify.d.ts

@@ -1,14 +0,0 @@
-import { FastifyInstance } from 'fastify';
-import { R as RipploEngine } from './engine-BOqzK_go.js';
-import './builder-SsgqYqSC.js';
-import './types-BzZrl65Z.js';
-import './step-De52hTLd.js';
-import '@ripplo/spec';
-
-interface RegisterFastifyHandlerParams {
-    readonly enabled: boolean;
-    readonly engine: RipploEngine;
-}
-declare function registerFastifyHandler({ enabled, engine, }: RegisterFastifyHandlerParams): (fastify: FastifyInstance) => Promise<void>;
-
-export { type RegisterFastifyHandlerParams, registerFastifyHandler };