donobu 5.28.0 → 5.30.0

package/dist/esm/persistence/tests/TestsPersistence.d.ts

@@ -1,5 +1,5 @@
 import type { PaginatedResult } from '../../models/PaginatedResult';
-import type { TestMetadata, TestsQuery } from '../../models/TestMetadata';
+import type { TestListItem, TestMetadata, TestsQuery } from '../../models/TestMetadata';
 /**
  * Persistence interface for test metadata.
  *
@@ -15,7 +15,7 @@ export interface TestsPersistence {
     /** Get a test by ID. Throws TestNotFoundException if not found. */
     getTestById(testId: string): Promise<TestMetadata>;
     /** List tests with optional filtering and pagination. */
-    getTests(query: TestsQuery): Promise<PaginatedResult<TestMetadata>>;
+    getTests(query: TestsQuery): Promise<PaginatedResult<TestListItem>>;
     /** Delete a test. */
     deleteTest(testId: string): Promise<void>;
 }

package/dist/esm/persistence/tests/TestsPersistenceDonobuApi.d.ts

@@ -1,5 +1,5 @@
-import type { PaginatedResult } from '../../models/PaginatedResult';
-import { type TestMetadata, type TestsQuery } from '../../models/TestMetadata';
+import { type PaginatedResult } from '../../models/PaginatedResult';
+import { type TestListItem, type TestMetadata, type TestsQuery } from '../../models/TestMetadata';
 import { DonobuApiClient } from '../DonobuApiClient';
 import type { TestsPersistence } from './TestsPersistence';
 export declare class TestsPersistenceDonobuApi extends DonobuApiClient implements TestsPersistence {
@@ -7,7 +7,7 @@ export declare class TestsPersistenceDonobuApi extends DonobuApiClient implement
     createTest(testMetadata: TestMetadata): Promise<void>;
     updateTest(testMetadata: TestMetadata): Promise<void>;
     getTestById(testId: string): Promise<TestMetadata>;
-    getTests(query: TestsQuery): Promise<PaginatedResult<TestMetadata>>;
+    getTests(query: TestsQuery): Promise<PaginatedResult<TestListItem>>;
     deleteTest(testId: string): Promise<void>;
 }
 //# sourceMappingURL=TestsPersistenceDonobuApi.d.ts.map

package/dist/esm/persistence/tests/TestsPersistenceDonobuApi.js

@@ -2,8 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TestsPersistenceDonobuApi = void 0;
 const TestNotFoundException_1 = require("../../exceptions/TestNotFoundException");
+const PaginatedResult_1 = require("../../models/PaginatedResult");
 const TestMetadata_1 = require("../../models/TestMetadata");
 const DonobuApiClient_1 = require("../DonobuApiClient");
+const normalizeFlowMetadata_1 = require("../normalizeFlowMetadata");
 class TestsPersistenceDonobuApi extends DonobuApiClient_1.DonobuApiClient {
     constructor(baseUrl, apiKey) {
         super(baseUrl, apiKey);
@@ -76,9 +78,23 @@ class TestsPersistenceDonobuApi extends DonobuApiClient_1.DonobuApiClient {
         if (!response.ok) {
             throw new Error(`Failed to list tests: ${response.status} ${response.statusText}`);
         }
-        const json = (await response.json());
+        // Validate the basic pagination shape of the API response, but keep the
+        // items as `unknown` for now.
+        const json = PaginatedResult_1.PaginatedResultSchema.parse(await response.json());
         return {
-            items: json.items.map((item) => TestMetadata_1.TestMetadataSchema.parse(item)),
+            items: json.items.map((item) => {
+                // Cast this enough to be able to easily pull out the `latestFlow`
+                // field. It'll be properly validated by the schema in the `return`
+                // statement below, after normalizing the flow metadata.
+                const testListItem = item;
+                // Run full validation after normalizing the flow metadata.
+                return TestMetadata_1.TestListItemSchema.parse({
+                    ...testListItem,
+                    latestFlow: testListItem.latestFlow
+                        ? (0, normalizeFlowMetadata_1.normalizeFlowMetadata)(testListItem.latestFlow)
+                        : null,
+                });
+            }),
             nextPageToken: json.nextPageToken,
         };
     }

package/dist/esm/persistence/tests/TestsPersistenceRegistry.d.ts

@@ -1,5 +1,6 @@
 import type { EnvPick } from 'env-struct';
 import type { env } from '../../envVars';
+import type { FlowsPersistenceRegistry } from '../flows/FlowsPersistenceRegistry';
 import { PersistencePluginRegistry } from '../PersistencePlugin';
 import type { TestsPersistence } from './TestsPersistence';
 export interface TestsPersistenceRegistry {
@@ -11,7 +12,14 @@ export interface TestsPersistenceRegistry {
 export declare class TestsPersistenceRegistryImpl implements TestsPersistenceRegistry {
     private readonly layers;
     constructor(layers: TestsPersistence[]);
-    static fromEnvironment(environ: EnvPick<typeof env, 'DONOBU_API_BASE_URL' | 'DONOBU_API_KEY' | 'PERSISTENCE_PRIORITY'>, persistencePlugins?: PersistencePluginRegistry): Promise<TestsPersistenceRegistryImpl>;
+    static fromEnvironment(environ: EnvPick<typeof env, 'DONOBU_API_BASE_URL' | 'DONOBU_API_KEY' | 'PERSISTENCE_PRIORITY'>, 
+    /**
+     * Flows registry — used by the volatile tests layer to compute
+     * flow-derived sort keys (flow_count, latest_flow_created_at).
+     * Optional: when omitted, the volatile layer falls back to
+     * best-effort no-op sorting on those keys.
+     */
+    flowsRegistry?: FlowsPersistenceRegistry, persistencePlugins?: PersistencePluginRegistry): Promise<TestsPersistenceRegistryImpl>;
     get(): Promise<TestsPersistence>;
     getAll(): Promise<TestsPersistence[]>;
 }

package/dist/esm/persistence/tests/TestsPersistenceRegistry.js

@@ -13,7 +13,14 @@ class TestsPersistenceRegistryImpl {
             throw new Error('No valid test persistence implementation available!');
         }
     }
-    static async fromEnvironment(environ, persistencePlugins = new PersistencePlugin_1.PersistencePluginRegistry()) {
+    static async fromEnvironment(environ, 
+    /**
+     * Flows registry — used by the volatile tests layer to compute
+     * flow-derived sort keys (flow_count, latest_flow_created_at).
+     * Optional: when omitted, the volatile layer falls back to
+     * best-effort no-op sorting on those keys.
+     */
+    flowsRegistry, persistencePlugins = new PersistencePlugin_1.PersistencePluginRegistry()) {
         const donobuApiBaseUrl = environ.data.DONOBU_API_BASE_URL;
         const donobuApiKey = environ.data.DONOBU_API_KEY;
         const layers = [];
@@ -28,7 +35,7 @@ class TestsPersistenceRegistryImpl {
                     layers.push(await TestsPersistenceSqlite_1.TestsPersistenceSqlite.create(await (0, DonobuSqliteDb_1.getDonobuSqliteDatabase)()));
                     break;
                 case 'RAM':
-                    layers.push(new TestsPersistenceVolatile_1.TestsPersistenceVolatile());
+                    layers.push(new TestsPersistenceVolatile_1.TestsPersistenceVolatile(undefined, flowsRegistry ? () => flowsRegistry.get() : undefined));
                     break;
                 default: {
                     const plugin = persistencePlugins.get(key);

package/dist/esm/persistence/tests/TestsPersistenceSqlite.d.ts

@@ -1,5 +1,6 @@
 import type Database from 'better-sqlite3';
 import type { PaginatedResult } from '../../models/PaginatedResult';
+import type { TestListItem } from '../../models/TestMetadata';
 import { type TestMetadata, type TestsQuery } from '../../models/TestMetadata';
 import type { TestsPersistence } from './TestsPersistence';
 export declare class TestsPersistenceSqlite implements TestsPersistence {
@@ -9,7 +10,7 @@ export declare class TestsPersistenceSqlite implements TestsPersistence {
     createTest(testMetadata: TestMetadata): Promise<void>;
     updateTest(testMetadata: TestMetadata): Promise<void>;
     getTestById(testId: string): Promise<TestMetadata>;
-    getTests(query: TestsQuery): Promise<PaginatedResult<TestMetadata>>;
+    getTests(query: TestsQuery): Promise<PaginatedResult<TestListItem>>;
     deleteTest(testId: string): Promise<void>;
 }
 //# sourceMappingURL=TestsPersistenceSqlite.d.ts.map

package/dist/esm/persistence/tests/TestsPersistenceSqlite.js

@@ -2,7 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TestsPersistenceSqlite = void 0;
 const TestNotFoundException_1 = require("../../exceptions/TestNotFoundException");
+const FlowMetadata_1 = require("../../models/FlowMetadata");
 const TestMetadata_1 = require("../../models/TestMetadata");
+const normalizeFlowMetadata_1 = require("../normalizeFlowMetadata");
 class TestsPersistenceSqlite {
     constructor(db) {
         this.db = db;
@@ -70,13 +72,60 @@ class TestsPersistenceSqlite {
             whereConditions.push('suite_id = ?');
             params.push(query.suiteId);
         }
-        let sql = 'SELECT metadata FROM test_metadata';
-        if (whereConditions.length > 0) {
-            sql += ' WHERE ' + whereConditions.join(' AND ');
+        // LEFT JOIN against a per-test aggregate of flow_metadata so the
+        // `flow_count` and `latest_flow_created_at` columns are queryable for
+        // ORDER BY without a separate round-trip per test. A second LEFT JOIN
+        // uses ROW_NUMBER() OVER (PARTITION BY test_id …) to pick the single
+        // most-recent flow per test, so we can return its full metadata blob
+        // alongside the count without an N+1 fetch.
+        let sql = `
+      SELECT
+        t.metadata AS metadata,
+        COALESCE(fc.flow_count, 0) AS flow_count,
+        fc.latest_flow_created_at AS latest_flow_created_at,
+        lf.metadata AS latest_flow_metadata
+      FROM test_metadata t
+      LEFT JOIN (
+        SELECT test_id,
+               COUNT(*) AS flow_count,
+               MAX(created_at) AS latest_flow_created_at
+        FROM flow_metadata
+        WHERE test_id IS NOT NULL
+        GROUP BY test_id
+      ) fc ON fc.test_id = t.id
+      LEFT JOIN (
+        SELECT test_id, metadata,
+               ROW_NUMBER() OVER (
+                 PARTITION BY test_id
+                 ORDER BY created_at DESC, id DESC
+               ) AS rn
+        FROM flow_metadata
+        WHERE test_id IS NOT NULL
+      ) lf ON lf.test_id = t.id AND lf.rn = 1
+    `;
+        // The WHERE clauses still target test_metadata columns; rewrite them to
+        // the aliased table.
+        const aliasedWhere = whereConditions.map((c) => `t.${c}`);
+        if (aliasedWhere.length > 0) {
+            sql += ' WHERE ' + aliasedWhere.join(' AND ');
         }
-        const sortCol = query.sortBy ?? 'created_at';
+        // Map the API-level sortBy to the actual SQL column. test_metadata
+        // columns are referenced through the `t.` alias; the join-derived
+        // columns are referenced by the alias defined in the SELECT list.
+        const sortColMap = {
+            created_at: 't.created_at',
+            name: 't.name',
+            suite_id: 't.suite_id',
+            next_run_mode: 't.next_run_mode',
+            flow_count: 'flow_count',
+            latest_flow_created_at: 'latest_flow_created_at',
+        };
+        const sortCol = sortColMap[query.sortBy ?? 'created_at'] ?? 't.created_at';
         const sortDir = query.sortOrder === 'asc' ? 'ASC' : 'DESC';
-        sql += ` ORDER BY ${sortCol} ${sortDir} LIMIT ? OFFSET ?`;
+        // Stable secondary sort by created_at so flows with identical sort keys
+        // (e.g. flow_count = 0 across many tests) come back in a deterministic
+        // order across requests.
+        sql += ` ORDER BY ${sortCol} ${sortDir}, t.created_at DESC LIMIT ? OFFSET ?`;
         params.push(validLimit + 1);
         params.push(offset);
         const stmt = this.db.prepare(sql);
@@ -85,7 +134,17 @@ class TestsPersistenceSqlite {
         const results = hasMore ? rows.slice(0, validLimit) : rows;
         const nextPageToken = hasMore ? `${offset + validLimit}` : undefined;
         return {
-            items: results.map((row) => TestMetadata_1.TestMetadataSchema.parse(JSON.parse(row.metadata))),
+            items: results.map((row) => {
+                const test = TestMetadata_1.TestMetadataSchema.parse(JSON.parse(row.metadata));
+                const latestFlow = row.latest_flow_metadata
+                    ? FlowMetadata_1.FlowMetadataSchema.parse((0, normalizeFlowMetadata_1.normalizeFlowMetadata)(JSON.parse(row.latest_flow_metadata)))
+                    : null;
+                return {
+                    ...test,
+                    flowCount: row.flow_count,
+                    latestFlow,
+                };
+            }),
             nextPageToken,
         };
     }

package/dist/esm/persistence/tests/TestsPersistenceVolatile.d.ts

@@ -1,16 +1,35 @@
 import type { PaginatedResult } from '../../models/PaginatedResult';
-import type { TestMetadata, TestsQuery } from '../../models/TestMetadata';
+import type { TestListItem, TestMetadata, TestsQuery } from '../../models/TestMetadata';
+import type { FlowsPersistence } from '../flows/FlowsPersistence';
 import type { TestsPersistence } from './TestsPersistence';
 /**
  * A volatile (in-memory) implementation of TestsPersistence.
  */
 export declare class TestsPersistenceVolatile implements TestsPersistence {
     private readonly tests;
-    constructor(tests?: Map<string, TestMetadata>);
+    /**
+     * Optional flows-source callback used to compute flow-derived sort
+     * keys (`flow_count`, `latest_flow_created_at`). When supplied, the
+     * volatile layer can natively sort by those keys; otherwise they
+     * fall back to the existing best-effort string-index lookup. The
+     * callback is async so the registry can resolve the flows
+     * persistence layer lazily.
+     */
+    private readonly flowsSource?;
+    constructor(tests?: Map<string, TestMetadata>, 
+    /**
+     * Optional flows-source callback used to compute flow-derived sort
+     * keys (`flow_count`, `latest_flow_created_at`). When supplied, the
+     * volatile layer can natively sort by those keys; otherwise they
+     * fall back to the existing best-effort string-index lookup. The
+     * callback is async so the registry can resolve the flows
+     * persistence layer lazily.
+     */
+    flowsSource?: (() => Promise<FlowsPersistence>) | undefined);
     createTest(testMetadata: TestMetadata): Promise<void>;
     updateTest(testMetadata: TestMetadata): Promise<void>;
     getTestById(testId: string): Promise<TestMetadata>;
-    getTests(query: TestsQuery): Promise<PaginatedResult<TestMetadata>>;
+    getTests(query: TestsQuery): Promise<PaginatedResult<TestListItem>>;
     deleteTest(testId: string): Promise<void>;
 }
 //# sourceMappingURL=TestsPersistenceVolatile.d.ts.map

package/dist/esm/persistence/tests/TestsPersistenceVolatile.js

@@ -9,8 +9,18 @@ function deepCopy(test) {
  * A volatile (in-memory) implementation of TestsPersistence.
  */
 class TestsPersistenceVolatile {
-    constructor(tests = new Map()) {
+    constructor(tests = new Map(), 
+    /**
+     * Optional flows-source callback used to compute flow-derived sort
+     * keys (`flow_count`, `latest_flow_created_at`). When supplied, the
+     * volatile layer can natively sort by those keys; otherwise they
+     * fall back to the existing best-effort string-index lookup. The
+     * callback is async so the registry can resolve the flows
+     * persistence layer lazily.
+     */
+    flowsSource) {
         this.tests = tests;
+        this.flowsSource = flowsSource;
     }
     async createTest(testMetadata) {
         this.tests.set(testMetadata.id, deepCopy(testMetadata));
@@ -44,9 +54,57 @@ class TestsPersistenceVolatile {
         }
         const sortCol = query.sortBy ?? 'created_at';
         const sortAsc = query.sortOrder === 'asc';
+        // Pre-compute a per-test summary (count + latest flow) from the flows
+        // source (volatile flows layer in the typical RAM setup; can be any
+        // FlowsPersistence). Done in parallel; results populate `summaries`
+        // before the synchronous sort comparator and the final TestListItem
+        // construction below. Without a flows source we still serve the list
+        // — flowCount defaults to 0 and latestFlow to null.
+        const summaries = new Map();
+        if (this.flowsSource) {
+            const flowsLayer = await this.flowsSource();
+            await Promise.all(filtered.map(async (test) => {
+                let count = 0;
+                let latestCreatedAt = 0;
+                let latestFlow = null;
+                let pageToken = undefined;
+                do {
+                    const page = await flowsLayer.getFlowsMetadata({
+                        testId: test.id,
+                        limit: 100,
+                        pageToken,
+                    });
+                    count += page.items.length;
+                    for (const flow of page.items) {
+                        // Volatile flows don't track a separate created_at column;
+                        // startedAt is the closest proxy and the same value the
+                        // SQLite migration uses for backfilled rows.
+                        const ts = flow.startedAt ?? 0;
+                        if (ts > latestCreatedAt) {
+                            latestCreatedAt = ts;
+                            latestFlow = flow;
+                        }
+                    }
+                    pageToken = page.nextPageToken;
+                } while (pageToken);
+                summaries.set(test.id, { count, latestCreatedAt, latestFlow });
+            }));
+        }
         filtered.sort((a, b) => {
-            const aVal = String(a[sortCol] ?? '');
-            const bVal = String(b[sortCol] ?? '');
+            let aVal;
+            let bVal;
+            if (sortCol === 'flow_count') {
+                aVal = summaries.get(a.id)?.count ?? 0;
+                bVal = summaries.get(b.id)?.count ?? 0;
+            }
+            else if (sortCol === 'latest_flow_created_at') {
+                aVal = summaries.get(a.id)?.latestCreatedAt ?? 0;
+                bVal = summaries.get(b.id)?.latestCreatedAt ?? 0;
+            }
+            else {
+                aVal = String(a[sortCol] ?? '');
+                bVal = String(b[sortCol] ?? '');
+            }
             const cmp = aVal < bVal ? -1 : aVal > bVal ? 1 : 0;
             return sortAsc ? cmp : -cmp;
         });
@@ -54,7 +112,14 @@ class TestsPersistenceVolatile {
         const paged = filtered.slice(offset, offset + validLimit);
         const hasMore = offset + validLimit < filtered.length;
         return {
-            items: paged.map(deepCopy),
+            items: paged.map((test) => {
+                const summary = summaries.get(test.id);
+                return {
+                    ...deepCopy(test),
+                    flowCount: summary?.count ?? 0,
+                    latestFlow: summary?.latestFlow ?? null,
+                };
+            }),
             nextPageToken: hasMore ? (offset + validLimit).toString() : undefined,
         };
     }

package/dist/esm/reporter/renderMarkdown.js

@@ -152,7 +152,7 @@ function renderMarkdown(report) {
                 }
                 if (result.status === 'failed' && result.error) {
                     markdown += `\n<details>\n<summary>⚠️ Error Details</summary>\n\n`;
-                    markdown += `\`\`\`\n${result.error.message || 'No error message available'}\n\`\`\`\n\n`;
+                    markdown += `\`\`\`\n${(0, ansi_1.stripAnsi)(result.error.message || '') || 'No error message available'}\n\`\`\`\n\n`;
                     if (result.error.snippet) {
                         markdown += `**Code Snippet**:\n\`\`\`\n${(0, ansi_1.stripAnsi)(result.error.snippet)}\n\`\`\`\n\n`;
                     }

package/dist/lib/test/testExtension.d.ts

@@ -1,4 +1,4 @@
-import type { PlaywrightWorkerOptions } from '@playwright/test';
+import type { PlaywrightWorkerOptions, TestInfo } from '@playwright/test';
 import type { GptClient } from '../../clients/GptClient';
 import type { BrowserStorageState } from '../../models/BrowserStorageState';
 import { FlowLogBuffer } from '../../utils/FlowLogBuffer';
@@ -9,6 +9,7 @@ export declare const test: import("@playwright/test").TestType<import("@playwrig
         flowId: string;
         logBuffer: FlowLogBuffer;
     };
+    pwApiStepLogger: void;
     storageState?: BrowserStorageState | Promise<BrowserStorageState>;
     gptClient?: GptClient;
     page: DonobuExtendedPage;
@@ -26,4 +27,33 @@ export declare const test: import("@playwright/test").TestType<import("@playwrig
      */
     donobuFileUploadDrainGuard: void;
 }>;
+export declare function emitPlaywrightStepLog(step: any): void;
+/** Reset the source-line cache. Test-only. */
+export declare function _resetSourceLineCacheForTests(): void;
+/**
+ * Monkey-patch `testInfo._callbacks.onStepEnd` so each Playwright step in
+ * the `pw:api` / `expect` categories emits an `appLogger.info` entry once
+ * Playwright signals the step has finished. Returns a teardown function
+ * that restores the original callback.
+ *
+ * Why patch `onStepEnd` and not `_addStep`:
+ * Playwright captures the step's source location with a stack walk inside
+ * `_addStep` (see playwright/lib/worker/testInfo.js). Patching `_addStep`
+ * inserts a Donobu library frame into that stack, and Playwright's
+ * built-in filter only excludes `@playwright/test` / `playwright-core`
+ * paths — so for steps that don't pre-set `data.location` (most notably
+ * `expect`), the captured location lands inside our wrapper in
+ * `node_modules/donobu/...`. The downstream node_modules filter would
+ * then drop the entry. `_callbacks.onStepEnd` runs AFTER the stack
+ * capture, so this hook is invisible to Playwright's location resolution.
+ *
+ * Verified against @playwright/test 1.57+. `_callbacks` / `_stepMap` and
+ * the step shape (category, title, params, endWallTime, error, location)
+ * are private Playwright internals — install and per-step logging are
+ * wrapped in try/catch so any shape drift degrades to a no-op rather than
+ * failing the test.
+ *
+ * Exported for unit testing.
+ */
+export declare function installPlaywrightStepLogger(testInfo: TestInfo): () => void;
 //# sourceMappingURL=testExtension.d.ts.map