feat: Implemented playwright-reporter and helper

apps/npm/package.json

@@ -52,6 +52,7 @@
         "@babel/core": "^7.27.4",
         "@babel/preset-react": "^7.27.1",
         "@babel/preset-typescript": "^7.27.1",
+        "@playwright/test": "^1.59.1",
         "@repo/eslint-config": "workspace:*",
         "@repo/typescript-config": "workspace:*",
         "@rollup/plugin-babel": "^6.0.4",

apps/npm/src/helper/context.ts

@@ -1 +1,91 @@
-// Detects current test framework runtime
+type Framework = 'playwright' | 'jest' | 'vitest' | 'unknown';
+
+function detectFramework(): Framework {
+    const env = process.env;
+    if (env['TEST_WORKER_INDEX'] !== undefined) return 'playwright';
+    if (env['JEST_WORKER_ID'] !== undefined) return 'jest';
+    if (env['VITEST'] !== undefined) return 'vitest';
+    return 'unknown';
+}
+
+interface ContextAdapter {
+    set(type: string, value: string): void;
+}
+
+/**
+ * Pushes metadata into test.info().annotations.
+ * The reporter reads these back via test.annotations in onTestEnd.
+ */
+class PlaywrightContext implements ContextAdapter {
+    set(type: string, value: string): void {
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            const { test } = require('@playwright/test');
+            const info = test.info();
+            if (info) {
+                info.annotations.push({ type, description: value });
+            }
+        } catch {
+            // Not inside a Playwright worker — silently ignore.
+        }
+    }
+}
+
+/**
+ * For runners without per-test annotation APIs, we use a module-level Map.
+ * Key = current test name (from expect.getState()), value = annotations.
+ */
+const globalStore = new Map<
+    string,
+    Array<{ type: string; description: string }>
+>();
+
+class GlobalStoreContext implements ContextAdapter {
+    set(type: string, value: string): void {
+        const testName = this.currentTestName() ?? '__default__';
+        let entries = globalStore.get(testName);
+        if (!entries) {
+            entries = [];
+            globalStore.set(testName, entries);
+        }
+        entries.push({ type, description: value });
+    }
+
+    private currentTestName(): string | undefined {
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            const { expect } = require('expect');
+            const state = expect.getState() as {
+                currentTestName?: string;
+            };
+            return state.currentTestName ?? undefined;
+        } catch {
+            return undefined;
+        }
+    }
+}
+
+/** Drain and clear stored annotations for a Jest/Vitest test name. */
+export function drainGlobalStore(
+    testName: string,
+): Array<{ type: string; description: string }> {
+    const key = globalStore.has(testName) ? testName : '__default__';
+    const entries = globalStore.get(key) ?? [];
+    globalStore.delete(key);
+    return entries;
+}
+
+let cachedContext: ContextAdapter | null = null;
+
+export function getContext(): ContextAdapter {
+    if (!cachedContext) {
+        const fw = detectFramework();
+        cachedContext =
+            fw === 'playwright'
+                ? new PlaywrightContext()
+                : new GlobalStoreContext();
+    }
+    return cachedContext;
+}
+
+

apps/npm/src/helper/flush.ts

@@ -1 +1,62 @@
-// Exposes collected metadata to reporters
+import type { AssertiveMetadata } from './types';
+import { drainGlobalStore } from './context';
+
+/**
+ * Parse an array of { type, description } annotations
+ * (from Playwright's test.annotations or the global store)
+ * into a structured AssertiveMetadata object.
+ */
+export function parseAnnotations(
+    annotations: ReadonlyArray<{ type: string; description?: string }>,
+): AssertiveMetadata {
+    const meta: AssertiveMetadata = {
+        testId: undefined,
+        tags: [],
+        owner: undefined,
+        priority: undefined,
+        testType: undefined,
+        customFields: {},
+        attachments: {},
+    };
+
+    for (const ann of annotations) {
+        const val = ann.description ?? '';
+
+        switch (ann.type) {
+            case 'assertive_id':
+                meta.testId = val;
+                break;
+            case 'assertive_tag':
+                meta.tags.push(val);
+                break;
+            case 'assertive_owner':
+                meta.owner = val;
+                break;
+            case 'assertive_priority':
+                meta.priority = val;
+                break;
+            case 'assertive_type':
+                meta.testType = val;
+                break;
+            default:
+                if (ann.type.startsWith('assertive_field_')) {
+                    meta.customFields[ann.type.slice('assertive_field_'.length)] =
+                        val;
+                } else if (ann.type.startsWith('assertive_attach_')) {
+                    meta.attachments[ann.type.slice('assertive_attach_'.length)] =
+                        val;
+                }
+                break;
+        }
+    }
+
+    return meta;
+}
+
+/**
+ * For Jest / Vitest: drain the global store for a given test name
+ * and return parsed metadata.
+ */
+export function flushGlobalStore(testName: string): AssertiveMetadata {
+    return parseAnnotations(drainGlobalStore(testName));
+}

apps/npm/src/helper/index.ts

@@ -1 +1,59 @@
-// assertive.id(), .tags(), .owner()
+import type { Priority, TestType } from './types';
+import { getContext } from './context';
+
+/**
+ * Universal helper client — import this in test files.
+ *
+ *   import { assertive } from 'getassertive/helper';
+ *
+ *   test('User can checkout', async ({ page }) => {
+ *       assertive.id('TST-123');
+ *       assertive.tags('checkout', 'smoke');
+ *       assertive.owner('aayush');
+ *       assertive.priority('high');
+ *       // … test code …
+ *   });
+ */
+class AssertiveHelper {
+    /** Link this test to a unique assertive ID (e.g. "TST-123"). */
+    id(testId: string): void {
+        getContext().set('assertive_id', testId);
+    }
+
+    /** Attach one or more tags to the current test. */
+    tags(...tags: string[]): void {
+        for (const tag of tags) {
+            getContext().set('assertive_tag', tag);
+        }
+    }
+
+    /** Set the owner / assignee for the current test. */
+    owner(name: string): void {
+        getContext().set('assertive_owner', name);
+    }
+
+    /** Set the priority level — full autocomplete for the four levels. */
+    priority(level: Priority): void {
+        getContext().set('assertive_priority', level);
+    }
+
+    /** Set the test type. */
+    type(testType: TestType): void {
+        getContext().set('assertive_type', testType);
+    }
+
+    /** Attach an arbitrary custom field. */
+    field(key: string, value: string): void {
+        getContext().set(`assertive_field_${key}`, value);
+    }
+
+    /** Attach contextual data (e.g. a cart total, a screenshot path). */
+    attach(key: string, data: string): void {
+        getContext().set(`assertive_attach_${key}`, data);
+    }
+}
+
+/** Singleton — import this in test files. */
+export const assertive = new AssertiveHelper();
+
+export type { Priority, TestType };