@stanterprise/playwright-reporter 0.0.1 → 0.0.6

package/dist/client/grpcClient.d.ts

@@ -0,0 +1,7 @@
+import { StanterpriseReporterOptions } from "../types";
+import * as grpc from "@grpc/grpc-js";
+export default function getClient(options: StanterpriseReporterOptions): grpc.Client | null;
+export declare function reportUnary(options: StanterpriseReporterOptions, grpcClient: grpc.Client, path: string, message: {
+    serialize?: (w?: any) => Uint8Array;
+    serializeBinary?: () => Uint8Array;
+}, deadlineMs?: number): Promise<Buffer>;

package/dist/client/grpcClient.js

@@ -0,0 +1,79 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = getClient;
+exports.reportUnary = reportUnary;
+const grpc = __importStar(require("@grpc/grpc-js"));
+function getClient(options) {
+    try {
+        return new grpc.Client(options.grpcAddress, grpc.credentials.createInsecure());
+    }
+    catch (e) {
+        console.error("Failed to create gRPC client", e);
+    }
+    return null;
+}
+// Helper: generic unary call using raw method path
+async function reportUnary(options, grpcClient, path, message, deadlineMs = 1000) {
+    if (!options.grpcEnabled || !grpcClient) {
+        return Buffer.alloc(0);
+    }
+    const reqSerialize = (arg) => {
+        const m = arg;
+        const bytes = m?.serializeBinary
+            ? m.serializeBinary()
+            : m?.serialize
+                ? m.serialize()
+                : new Uint8Array(0);
+        return Buffer.from(bytes);
+    };
+    const resDeserialize = (bytes) => bytes;
+    const metadata = new grpc.Metadata();
+    const callOptions = {
+        deadline: new Date(Date.now() + deadlineMs),
+    };
+    return new Promise((resolve, reject) => {
+        try {
+            grpcClient.makeUnaryRequest(path, reqSerialize, resDeserialize, message, metadata, callOptions, (err, response) => {
+                if (err)
+                    return reject(err);
+                resolve(response);
+            });
+        }
+        catch (e) {
+            reject(e);
+        }
+    });
+}

package/dist/handlers/index.d.ts

@@ -0,0 +1,9 @@
+import { handleOnBeginEvent } from "./onBeginHandler";
+import { handleOnEndEvent } from "./onEndHandler";
+import { handleOnStepBeginEvent } from "./onStepBeginHandler";
+import { handleOnStepEndEvent } from "./onStepEndHandler";
+import { handleOnTestBeginEvent } from "./onTestBeginHandler";
+import { handleOnTestEndEvent } from "./onTestEndHandler";
+import { handleOnTestFailEvent } from "./onTestFailHandler";
+import { handleOnErrorEvent } from "./onErrorHandler";
+export { handleOnBeginEvent, handleOnEndEvent, handleOnStepBeginEvent, handleOnStepEndEvent, handleOnTestBeginEvent, handleOnTestEndEvent, handleOnTestFailEvent, handleOnErrorEvent, };

package/dist/handlers/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleOnErrorEvent = exports.handleOnTestFailEvent = exports.handleOnTestEndEvent = exports.handleOnTestBeginEvent = exports.handleOnStepEndEvent = exports.handleOnStepBeginEvent = exports.handleOnEndEvent = exports.handleOnBeginEvent = void 0;
+const onBeginHandler_1 = require("./onBeginHandler");
+Object.defineProperty(exports, "handleOnBeginEvent", { enumerable: true, get: function () { return onBeginHandler_1.handleOnBeginEvent; } });
+const onEndHandler_1 = require("./onEndHandler");
+Object.defineProperty(exports, "handleOnEndEvent", { enumerable: true, get: function () { return onEndHandler_1.handleOnEndEvent; } });
+const onStepBeginHandler_1 = require("./onStepBeginHandler");
+Object.defineProperty(exports, "handleOnStepBeginEvent", { enumerable: true, get: function () { return onStepBeginHandler_1.handleOnStepBeginEvent; } });
+const onStepEndHandler_1 = require("./onStepEndHandler");
+Object.defineProperty(exports, "handleOnStepEndEvent", { enumerable: true, get: function () { return onStepEndHandler_1.handleOnStepEndEvent; } });
+const onTestBeginHandler_1 = require("./onTestBeginHandler");
+Object.defineProperty(exports, "handleOnTestBeginEvent", { enumerable: true, get: function () { return onTestBeginHandler_1.handleOnTestBeginEvent; } });
+const onTestEndHandler_1 = require("./onTestEndHandler");
+Object.defineProperty(exports, "handleOnTestEndEvent", { enumerable: true, get: function () { return onTestEndHandler_1.handleOnTestEndEvent; } });
+const onTestFailHandler_1 = require("./onTestFailHandler");
+Object.defineProperty(exports, "handleOnTestFailEvent", { enumerable: true, get: function () { return onTestFailHandler_1.handleOnTestFailEvent; } });
+const onErrorHandler_1 = require("./onErrorHandler");
+Object.defineProperty(exports, "handleOnErrorEvent", { enumerable: true, get: function () { return onErrorHandler_1.handleOnErrorEvent; } });

package/dist/handlers/onBeginHandler.d.ts

@@ -0,0 +1,5 @@
+import { FullConfig } from "@playwright/test";
+import { Suite } from "@playwright/test/reporter";
+import { StanterpriseReporterOptions } from "../types";
+import * as grpc from "@grpc/grpc-js";
+export declare function handleOnBeginEvent(config: FullConfig, suite: Suite, name: string, runId: string, client: grpc.Client, options: StanterpriseReporterOptions): void;

package/dist/handlers/onBeginHandler.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleOnBeginEvent = handleOnBeginEvent;
+const events_1 = require("@stanterprise/protobuf/testsystem/v1/events");
+const grpcClient_1 = require("../client/grpcClient");
+const entities_1 = require("@stanterprise/protobuf/testsystem/v1/entities");
+const utils_1 = require("../utils");
+function handleOnBeginEvent(config, suite, name, runId, client, options) {
+    // Report root suite and all child suites recursively
+    const request = new events_1.MapTestRunEventRequest({
+        run_id: runId,
+        name: name,
+        test_suites: mapSuites(suite, runId),
+        total_tests: suite.allTests().length,
+    });
+    (0, grpcClient_1.reportUnary)(options, client, "/testsystem.v1.observer.TestEventCollector/MapTestRun", request, options.grpcTimeout).catch((e) => {
+        const details = e instanceof Error ? `${e.message}` : String(e);
+        console.warn(`onBegin. gRPC disabled for the remainder of the run. Address=${options.grpcAddress}. Details: ${details}`);
+    });
+}
+function mapSuites(suite, runId) {
+    let allSuites = getAllSuites(suite);
+    return allSuites.map((currentSuite) => mapSingleSuite(currentSuite, runId));
+}
+function getAllSuites(suite) {
+    let suites = [];
+    suites.push(suite);
+    suite.suites.forEach((childSuite) => {
+        suites = suites.concat(getAllSuites(childSuite));
+    });
+    return suites;
+}
+function mapSingleSuite(suite, runId) {
+    const suiteId = (0, utils_1.generateSuiteId)(suite);
+    const parentSuiteId = suite.parent
+        ? (0, utils_1.generateSuiteId)(suite.parent)
+        : undefined;
+    let type;
+    switch (suite.type) {
+        case "root":
+            type = entities_1.SuiteType.ROOT;
+            break;
+        case "describe":
+            type = entities_1.SuiteType.SUBSUITE;
+            break;
+        case "file":
+            type = entities_1.SuiteType.SUBSUITE;
+            break;
+        case "project":
+            type = entities_1.SuiteType.PROJECT;
+            break;
+    }
+    return new entities_1.TestSuiteRun({
+        id: suiteId,
+        name: suite.title,
+        run_id: runId,
+        parent_suite_id: parentSuiteId,
+        test_cases: suite.tests.map((test) => new entities_1.TestCaseRun({
+            id: test.id,
+            name: test.title,
+            run_id: runId,
+        })),
+        test_case_ids: suite.tests.map((test) => test.id),
+        type: type,
+        // start_time: createTimestamp(startTime),
+        // metadata: metadata,
+    });
+}

package/dist/handlers/onEndHandler.d.ts

@@ -0,0 +1,4 @@
+import { FullResult } from "@playwright/test/reporter";
+import { StanterpriseReporterOptions } from "../types";
+import * as grpc from "@grpc/grpc-js";
+export declare function handleOnEndEvent(result: FullResult, runId: string, client: grpc.Client, options: StanterpriseReporterOptions): void;

package/dist/handlers/onEndHandler.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleOnEndEvent = handleOnEndEvent;
+const grpcClient_1 = require("../client/grpcClient");
+const utils_1 = require("../utils");
+const events_1 = require("@stanterprise/protobuf/testsystem/v1/events");
+const common_1 = require("@stanterprise/protobuf/testsystem/v1/common");
+function mapTestStatus(status) {
+    switch (status) {
+        case "passed":
+            return common_1.TestStatus.PASSED;
+        case "failed":
+            return common_1.TestStatus.FAILED;
+        case "timedout":
+            return common_1.TestStatus.TIMEDOUT;
+        case "interrupted":
+            return common_1.TestStatus.INTERRUPTED;
+        default:
+            return common_1.TestStatus.UNKNOWN;
+    }
+}
+function handleOnEndEvent(result, runId, client, options) {
+    const request = new events_1.TestRunEndEventRequest({
+        run_id: runId,
+        final_status: mapTestStatus(result.status),
+        start_time: (0, utils_1.createTimestampFromMs)(result.startTime.getTime()),
+        duration: (0, utils_1.createDuration)(result.duration),
+    });
+    (0, grpcClient_1.reportUnary)(options, client, "/testsystem.v1.observer.TestEventCollector/ReportEnd", request, options.grpcTimeout).catch((error) => {
+        if (error instanceof Error) {
+            console.error(`Failed to report end event: ${error.message}`, {
+                stack: error.stack,
+            });
+        }
+        else {
+            console.error("Failed to report end event: Unknown error type", {
+                error,
+            });
+        }
+    });
+}

package/dist/handlers/onErrorHandler.d.ts

@@ -0,0 +1,4 @@
+import { TestError } from "@playwright/test/reporter";
+import { StanterpriseReporterOptions } from "../types";
+import * as grpc from "@grpc/grpc-js";
+export declare function handleOnErrorEvent(error: TestError, runId: string, grpcClient: grpc.Client, options: StanterpriseReporterOptions): void;

package/dist/handlers/onErrorHandler.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleOnErrorEvent = handleOnErrorEvent;
+const events_1 = require("@stanterprise/protobuf/testsystem/v1/events");
+const timeHelpers_1 = require("../utils/timeHelpers");
+const grpcClient_1 = require("../client/grpcClient");
+function handleOnErrorEvent(error, runId, grpcClient, options) {
+    const request = new events_1.StdErrorEventRequest({
+        run_id: runId,
+        message: error.message,
+        timestamp: (0, timeHelpers_1.createTimestampFromMs)(Date.now()),
+    });
+    // Fire-and-forget to avoid slowing tests
+    (0, grpcClient_1.reportUnary)(options, grpcClient, "/testsystem.v1.observer.TestEventCollector/ReportStdError", request, options.grpcTimeout).catch((e) => console.error("Failed to report standard error", e));
+}

package/dist/handlers/onStepBeginHandler.d.ts

@@ -0,0 +1,4 @@
+import { TestCase, TestResult, TestStep } from "@playwright/test/reporter";
+import { StanterpriseReporterOptions } from "../types";
+import * as grpc from "@grpc/grpc-js";
+export declare function handleOnStepBeginEvent(test: TestCase, result: TestResult, step: TestStep, runId: string, client: grpc.Client, options: StanterpriseReporterOptions): void;

package/dist/handlers/onStepBeginHandler.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleOnStepBeginEvent = handleOnStepBeginEvent;
+const entities_1 = require("@stanterprise/protobuf/testsystem/v1/entities");
+const events_1 = require("@stanterprise/protobuf/testsystem/v1/events");
+const utils_1 = require("../utils");
+const grpcClient_1 = require("../client/grpcClient");
+const utils_2 = require("../utils");
+function handleOnStepBeginEvent(test, result, step, runId, client, options) {
+    // Build metadata from step annotations
+    const metadata = new Map();
+    metadata.set("category", step.category);
+    step.annotations.forEach((annotation, index) => {
+        metadata.set(`annotation_${index}_type`, annotation.type);
+        if (annotation.description) {
+            metadata.set(`annotation_${index}_description`, annotation.description);
+        }
+    });
+    // Get parent step ID if this step has a parent
+    const stepId = (0, utils_2.generateStepId)(step, test);
+    // Build and send the StepBegin event
+    const request = new events_1.StepBeginEventRequest({
+        step: new entities_1.StepRun({
+            id: stepId,
+            run_id: runId,
+            test_case_run_id: test.id,
+            title: step.title,
+            type: step.category,
+            start_time: (0, utils_1.createTimestamp)(step.startTime),
+            location: step.location
+                ? `${step.location.file}:${step.location.line}:${step.location.column}`
+                : "",
+            metadata: metadata,
+            parent_step_id: step.parent
+                ? (0, utils_2.generateStepId)(step.parent, test)
+                : undefined,
+            worker_index: result.workerIndex.toString(),
+        }),
+    });
+    // Fire-and-forget to avoid slowing tests
+    (0, grpcClient_1.reportUnary)(options, client, "/testsystem.v1.observer.TestEventCollector/ReportStepBegin", request, options.grpcTimeout).catch((e) => console.error("Failed to report step begin", e));
+}

package/dist/handlers/onStepEndHandler.d.ts

@@ -0,0 +1,4 @@
+import { TestCase, TestResult, TestStep } from "@playwright/test/reporter";
+import { StanterpriseReporterOptions } from "../types";
+import * as grpc from "@grpc/grpc-js";
+export declare function handleOnStepEndEvent(test: TestCase, result: TestResult, step: TestStep, runId: string, client: grpc.Client, options: StanterpriseReporterOptions): void;

package/dist/handlers/onStepEndHandler.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleOnStepEndEvent = handleOnStepEndEvent;
+const entities_1 = require("@stanterprise/protobuf/testsystem/v1/entities");
+const events_1 = require("@stanterprise/protobuf/testsystem/v1/events");
+const utils_1 = require("../utils");
+const grpcClient_1 = require("../client/grpcClient");
+const utils_2 = require("../utils");
+function handleOnStepEndEvent(test, result, step, runId, client, options) {
+    // Map step error to status
+    const stepStatus = (0, utils_1.mapStepStatus)(!!step.error);
+    // Build metadata from step annotations
+    const metadata = new Map();
+    metadata.set("category", step.category);
+    step.annotations.forEach((annotation, index) => {
+        metadata.set(`annotation_${index}_type`, annotation.type);
+        if (annotation.description) {
+            metadata.set(`annotation_${index}_description`, annotation.description);
+        }
+    });
+    const stepId = (0, utils_2.generateStepId)(step, test);
+    // Build and send the StepEnd event
+    const request = new events_1.StepEndEventRequest({
+        step: new entities_1.StepRun({
+            id: stepId,
+            run_id: runId,
+            test_case_run_id: test.id,
+            title: step.title,
+            type: step.category,
+            start_time: (0, utils_1.createTimestamp)(step.startTime),
+            duration: (0, utils_1.createDuration)(step.duration),
+            status: stepStatus,
+            error: step.error ? step.error.message || "" : "",
+            errors: step.error ? [step.error.message || ""] : [],
+            location: step.location
+                ? `${step.location.file}:${step.location.line}:${step.location.column}`
+                : "",
+            metadata: metadata,
+            parent_step_id: step.parent
+                ? (0, utils_2.generateStepId)(step.parent, test)
+                : undefined,
+            worker_index: result.workerIndex.toString(),
+        }),
+    });
+    // Fire-and-forget to avoid slowing tests
+    (0, grpcClient_1.reportUnary)(options, client, "/testsystem.v1.observer.TestEventCollector/ReportStepEnd", request, options.grpcTimeout).catch((e) => console.error("Failed to report step end", e));
+}

package/dist/handlers/onTestBeginHandler.d.ts

@@ -0,0 +1,4 @@
+import { TestCase, TestResult } from "@playwright/test/reporter";
+import { StanterpriseReporterOptions } from "../types";
+import * as grpc from "@grpc/grpc-js";
+export declare function handleOnTestBeginEvent(test: TestCase, result: TestResult, runId: string, client: grpc.Client, options: StanterpriseReporterOptions): void;

package/dist/handlers/onTestBeginHandler.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleOnTestBeginEvent = handleOnTestBeginEvent;
+const entities_1 = require("@stanterprise/protobuf/testsystem/v1/entities");
+const events_1 = require("@stanterprise/protobuf/testsystem/v1/events");
+const utils_1 = require("../utils");
+const grpcClient_1 = require("../client/grpcClient");
+function handleOnTestBeginEvent(test, result, runId, client, options) {
+    // Build and send the TestBegin event via generic unary call.
+    const request = new events_1.TestBeginEventRequest({
+        test_case: new entities_1.TestCaseRun({
+            id: test.id,
+            name: test.title,
+            run_id: runId,
+            test_suite_run_id: (0, utils_1.generateSuiteId)(test.parent),
+            start_time: (0, utils_1.createTimestamp)(result.startTime),
+            tags: test.tags,
+        }),
+    });
+    // Fire-and-forget to avoid slowing tests; log errors once.
+    (0, grpcClient_1.reportUnary)(options, client, "/testsystem.v1.observer.TestEventCollector/ReportTestBegin", request, options.grpcTimeout).catch((e) => {
+        const details = e instanceof Error ? `${e.message}` : String(e);
+        console.warn(`Failed to report test begin. Details: ${details}`);
+    });
+}

package/dist/handlers/onTestEndHandler.d.ts

@@ -0,0 +1,4 @@
+import { TestCase, TestResult } from "@playwright/test/reporter";
+import { StanterpriseReporterOptions } from "../types";
+import * as grpc from "@grpc/grpc-js";
+export declare function handleOnTestEndEvent(test: TestCase, result: TestResult, runId: string, client: grpc.Client, options: StanterpriseReporterOptions): void;

package/dist/handlers/onTestEndHandler.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleOnTestEndEvent = handleOnTestEndEvent;
+const entities_1 = require("@stanterprise/protobuf/testsystem/v1/entities");
+const events_1 = require("@stanterprise/protobuf/testsystem/v1/events");
+const utils_1 = require("../utils");
+const grpcClient_1 = require("../client/grpcClient");
+const utils_2 = require("../utils");
+function handleOnTestEndEvent(test, result, runId, client, options) {
+    // Map Playwright test status to protobuf TestStatus
+    const testStatus = (0, utils_1.mapTestStatus)(result.status);
+    // Process attachments (screenshots, videos, etc.)
+    const attachments = (0, utils_1.processAttachments)(result);
+    // Extract error information if the test failed
+    const { errorMessage, stackTrace, errors } = (0, utils_1.extractErrorInfo)(result);
+    // Get test suite run ID from parent suite if available, ensuring suite is reported
+    const suiteId = (0, utils_2.generateSuiteId)(test.parent);
+    // Build metadata from test annotations and result metadata
+    const metadata = new Map();
+    test.annotations.forEach((annotation, index) => {
+        metadata.set(`annotation_${index}_type`, annotation.type);
+        if (annotation.description) {
+            metadata.set(`annotation_${index}_description`, annotation.description);
+        }
+    });
+    result.annotations.forEach((annotation, index) => {
+        metadata.set(`result_annotation_${index}_type`, annotation.type);
+        if (annotation.description) {
+            metadata.set(`result_annotation_${index}_description`, annotation.description);
+        }
+    });
+    // Build and send the TestEnd event
+    const request = new events_1.TestEndEventRequest({
+        test_case: new entities_1.TestCaseRun({
+            id: test.id,
+            name: test.title,
+            run_id: runId,
+            test_suite_run_id: suiteId,
+            status: testStatus,
+            start_time: (0, utils_1.createTimestamp)(result.startTime),
+            attachments: attachments,
+            error_message: errorMessage,
+            stack_trace: stackTrace,
+            errors: errors,
+            metadata: metadata,
+            tags: test.tags,
+        }),
+    });
+    // Fire-and-forget to avoid slowing tests
+    (0, grpcClient_1.reportUnary)(options, client, "/testsystem.v1.observer.TestEventCollector/ReportTestEnd", request, options.grpcTimeout).catch((e) => console.error("Failed to report test end", e));
+}

package/dist/handlers/onTestFailHandler.d.ts

@@ -0,0 +1,4 @@
+import { TestCase, TestResult } from "@playwright/test/reporter";
+import { StanterpriseReporterOptions } from "../types";
+import * as grpc from "@grpc/grpc-js";
+export declare function handleOnTestFailEvent(test: TestCase, result: TestResult, runId: string, grpcClient: grpc.Client, options: StanterpriseReporterOptions): void;

package/dist/handlers/onTestFailHandler.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleOnTestFailEvent = handleOnTestFailEvent;
+const utils_1 = require("../utils");
+const events_1 = require("@stanterprise/protobuf/testsystem/v1/events");
+const grpcClient_1 = require("../client/grpcClient");
+function handleOnTestFailEvent(test, result, runId, grpcClient, options) {
+    // Extract failure details
+    const { errorMessage: failureMessage, stackTrace } = (0, utils_1.extractErrorInfo)(result);
+    // Process attachments for failed tests
+    const attachments = (0, utils_1.processAttachments)(result);
+    // Build and send the TestFailure event
+    const request = new events_1.TestFailureEventRequest({
+        test_id: test.id,
+        run_id: runId,
+        failure_message: failureMessage,
+        stack_trace: stackTrace,
+        timestamp: (0, utils_1.createTimestampFromMs)(Date.now()),
+        attachments: attachments,
+    });
+    // Fire-and-forget to avoid slowing tests
+    (0, grpcClient_1.reportUnary)(options, grpcClient, "/testsystem.v1.observer.TestEventCollector/ReportTestFailure", request, options.grpcTimeout).catch((e) => console.error("Failed to report test failure", e));
+}

package/dist/reporter.d.ts

@@ -2,20 +2,12 @@ import type { Reporter, FullConfig, Suite, TestCase, TestResult, FullResult, Tes
 import { StanterpriseReporterOptions } from "./types";
 export default class StanterpriseReporter implements Reporter {
     private grpcClient;
-    private grpcAddress;
-    private grpcEnabled;
-    private grpcTimeout;
-    private grpcFirstErrorLogged;
-    private verbose;
+    private options;
     private runId;
     private runStartTime;
-    private rootSuite;
-    private reportedSuites;
     constructor(options?: StanterpriseReporterOptions);
     onBegin(config: FullConfig, suite: Suite): void;
     onExit(): Promise<void>;
-    getRunId(): string;
-    getRunStartTime(): Date;
     onEnd(result: FullResult): Promise<{
         status?: FullResult["status"];
     } | undefined | void> | void;
@@ -27,10 +19,4 @@ export default class StanterpriseReporter implements Reporter {
     onError(error: TestError): void;
     onStdErr(chunk: string | Buffer, test: void | TestCase, result: void | TestResult): void;
     onStdOut(chunk: string | Buffer, test: void | TestCase, result: void | TestResult): void;
-    private getSuiteId;
-    private reportSuiteBegin;
-    private reportSuiteEnd;
-    private mapSuiteStatus;
-    private logGrpcErrorOnce;
-    private reportUnary;
 }

package/dist/reporter.js

@@ -1,104 +1,54 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-const protobuf_1 = require("@stanterprise/protobuf");
-const grpc = __importStar(require("@grpc/grpc-js"));
 const crypto_1 = require("crypto");
-const utils_1 = require("./utils");
-// Create shortcuts for the protobuf classes
-const EventsNS = protobuf_1.events.v1.events;
-const TestCaseEntities = protobuf_1.testCase.v1.entities;
-const TestSuiteEntities = protobuf_1.testSuite.v1.entities;
-const TestStatus = protobuf_1.common.v1.common.TestStatus;
+const optionsMapper_1 = __importDefault(require("./utils/optionsMapper"));
+const grpcClient_1 = __importDefault(require("./client/grpcClient"));
+const handlers_1 = require("./handlers");
 class StanterpriseReporter {
     constructor(options = {}) {
         // Generic gRPC client (we call unary methods by path directly).
         this.grpcClient = null;
-        this.grpcFirstErrorLogged = false;
+        this.options = {};
         // Generate a unique run ID for this test run
         this.runId = "";
         this.runStartTime = new Date();
-        this.rootSuite = null;
-        // Track reported suites to ensure we only report each suite once and can reference correct IDs
-        this.reportedSuites = new Map();
-        this.grpcAddress =
-            options.grpcAddress ||
-                process.env.STANTERPRISE_GRPC_ADDRESS ||
-                "localhost:50051";
-        this.grpcEnabled =
-            options.grpcEnabled ??
-                (process.env.STANTERPRISE_GRPC_ENABLED || "true").toLowerCase() !==
-                    "false";
-        this.grpcTimeout = options.grpcTimeout || 1000;
-        this.verbose = options.verbose || false;
-        if (this.verbose) {
+        this.options = (0, optionsMapper_1.default)(options);
+        if (this.options.verbose) {
             console.log("Stanterprise Reporter: Initialized with options:", {
-                grpcAddress: this.grpcAddress,
-                grpcEnabled: this.grpcEnabled,
-                grpcTimeout: this.grpcTimeout,
-                verbose: this.verbose,
+                grpcAddress: this.options.grpcAddress,
+                grpcEnabled: this.options.grpcEnabled,
+                grpcTimeout: this.options.grpcTimeout,
+                verbose: this.options.verbose,
             });
         }
+        // Generate a UUID for runId
+        this.runId = process.env.STANTERPRISE_RUN_ID || (0, crypto_1.randomUUID)();
     }
     onBegin(config, suite) {
-        // Generate a UUID for runId
-        this.runId = (0, crypto_1.randomUUID)();
-        this.rootSuite = suite;
         // Lazily create the client if enabled.
-        if (this.grpcEnabled) {
-            try {
-                this.grpcClient = new grpc.Client(this.grpcAddress, grpc.credentials.createInsecure());
-            }
-            catch (e) {
-                this.logGrpcErrorOnce("Failed to create gRPC client", e);
+        if (this.options.grpcEnabled) {
+            this.grpcClient = (0, grpcClient_1.default)(this.options);
+            if (!this.grpcClient) {
+                console.warn(`Stanterprise Reporter: Failed to create gRPC client. Disabling gRPC reporting.`);
+                this.options.grpcEnabled = false;
             }
         }
         else {
-            if (this.verbose) {
+            if (this.options.verbose) {
                 console.log("Stanterprise Reporter: gRPC disabled via STANTERPRISE_GRPC_ENABLED=false");
             }
         }
-        if (this.verbose) {
+        if (this.options.verbose) {
             console.log(`Stanterprise Reporter: Test run started with ID: ${this.runId}`);
             console.log(`Number of tests: ${suite.allTests().length}`);
             console.log(`Run started at: ${this.runStartTime.toISOString()}`);
         }
-        // Report root suite begin and track its ID
-        const rootSuiteId = this.getSuiteId(suite);
-        // Report the suite begin event
-        this.reportSuiteBegin(suite, rootSuiteId);
+        if (this.options.grpcEnabled) {
+            (0, handlers_1.handleOnBeginEvent)(config, suite, process.env.STANTERPRISE_TEST_RUN_NAME || "Playwright Test Run", this.runId, this.grpcClient, this.options);
+        }
     }
     async onExit() {
         console.log(`Stanterprise Reporter: Test run completed - Run ID: ${this.runId}`);
@@ -110,207 +60,66 @@ class StanterpriseReporter {
             console.error("Stanterprise Reporter: Error during gRPC client cleanup in onExit:", e);
         }
     }
-    // Getter to access the current run ID
-    getRunId() {
-        return this.runId;
-    }
-    // Getter to access the run start time
-    getRunStartTime() {
-        return this.runStartTime;
-    }
     onEnd(result) {
         const runDuration = Date.now() - this.runStartTime.getTime();
-        console.log(`Stanterprise Reporter: Test run ended - Run ID: ${this.runId}`);
-        console.log(`Final result: ${result.status}`);
-        console.log(`Run duration: ${runDuration}ms (Playwright duration: ${result.duration}ms)`);
-        console.log(`Run start time: ${this.runStartTime.toISOString()}`);
-        console.log(`Playwright start time: ${result.startTime.toISOString()}`);
-        // Report root suite end
-        if (this.rootSuite) {
-            this.reportSuiteEnd(this.rootSuite, result);
+        if (this.options.verbose) {
+            console.log(`Stanterprise Reporter: Test run ended - Run ID: ${this.runId}`);
+            console.log(`Final result: ${result.status}`);
+            console.log(`Run duration: ${runDuration}ms (Playwright duration: ${result.duration}ms)`);
+            console.log(`Run start time: ${this.runStartTime.toISOString()}`);
+            console.log(`Playwright start time: ${result.startTime.toISOString()}`);
+        }
+        if (this.options.grpcEnabled) {
+            (0, handlers_1.handleOnEndEvent)(result, this.runId, this.grpcClient, this.options);
         }
         return Promise.resolve();
     }
     onTestBegin(test, result) {
         // Create unique test execution ID combining run ID and test ID
-        const uniqueTestExecutionId = `${this.runId}-${test.id}`;
-        console.log(`Stanterprise Reporter: Test started - ${test.title}`);
-        console.log(`  Run ID: ${this.runId}`);
-        console.log(`  Test ID (static): ${test.id}`);
-        console.log(`  Unique Execution ID: ${uniqueTestExecutionId}`);
-        // Get test suite run ID from parent suite if available, ensuring suite is reported
-        const testSuiteRunId = test.parent ? this.getSuiteId(test.parent) : "";
-        // Build metadata from test annotations
-        const metadata = new Map();
-        test.annotations.forEach((annotation, index) => {
-            metadata.set(`annotation_${index}_type`, annotation.type);
-            if (annotation.description) {
-                metadata.set(`annotation_${index}_description`, annotation.description);
-            }
-        });
-        // Build and send the TestBegin event via generic unary call.
-        const request = new EventsNS.TestBeginEventRequest({
-            test_case: new TestCaseEntities.TestCaseRun({
-                id: test.id,
-                name: test.title,
-                run_id: this.runId,
-                test_suite_run_id: testSuiteRunId,
-                start_time: (0, utils_1.createTimestamp)(result.startTime),
-                metadata: metadata,
-                tags: test.tags,
-            }),
-        });
-        // Fire-and-forget to avoid slowing tests; log errors once.
-        this.reportUnary("/testsystem.v1.observer.TestEventCollector/ReportTestBegin", request, this.grpcTimeout).catch((e) => this.logGrpcErrorOnce("Failed to report test begin", e));
+        if (this.options.verbose) {
+            console.log(`Stanterprise Reporter: Test started - ${test.title}`);
+            console.log(`  Run ID: ${this.runId}`);
+            console.log(`  Test ID: ${test.id}`);
+        }
+        if (this.options.grpcEnabled) {
+            (0, handlers_1.handleOnTestBeginEvent)(test, result, this.runId, this.grpcClient, this.options);
+        }
     }
     async onStepBegin(test, result, step) {
-        const uniqueTestExecutionId = `${this.runId}-${test.id}`;
-        const uniqueStepId = `${uniqueTestExecutionId}-${step.title}-${step.startTime.getTime()}`;
-        console.log(`Stanterprise Reporter: Step started - ${step.title}`);
-        console.log(`  Category: ${step.category}`);
-        // Build metadata from step annotations
-        const metadata = new Map();
-        metadata.set("category", step.category);
-        step.annotations.forEach((annotation, index) => {
-            metadata.set(`annotation_${index}_type`, annotation.type);
-            if (annotation.description) {
-                metadata.set(`annotation_${index}_description`, annotation.description);
-            }
-        });
-        // Get parent step ID if this step has a parent
-        const parentStepId = step.parent
-            ? `${uniqueTestExecutionId}-${step.parent.title}-${step.parent.startTime.getTime()}`
-            : "";
-        // Build and send the StepBegin event
-        const request = new EventsNS.StepBeginEventRequest({
-            step: new TestCaseEntities.StepRun({
-                id: uniqueStepId,
-                run_id: this.runId,
-                test_case_run_id: uniqueTestExecutionId,
-                title: step.title,
-                type: step.category,
-                start_time: (0, utils_1.createTimestamp)(step.startTime),
-                location: step.location
-                    ? `${step.location.file}:${step.location.line}:${step.location.column}`
-                    : "",
-                metadata: metadata,
-                parent_step_id: parentStepId,
-                worker_index: result.workerIndex.toString(),
-            }),
-        });
-        // Fire-and-forget to avoid slowing tests
-        this.reportUnary("/testsystem.v1.observer.TestEventCollector/ReportStepBegin", request, this.grpcTimeout).catch((e) => this.logGrpcErrorOnce("Failed to report step begin", e));
+        if (this.options.verbose) {
+            console.log(`Stanterprise Reporter: Step started - ${step.title}`);
+            console.log(`  Category: ${step.category}`);
+        }
+        if (this.options.grpcEnabled) {
+            (0, handlers_1.handleOnStepBeginEvent)(test, result, step, this.runId, this.grpcClient, this.options);
+        }
     }
     onStepEnd(test, result, step) {
-        const uniqueTestExecutionId = `${this.runId}-${test.id}`;
-        const uniqueStepId = `${uniqueTestExecutionId}-${step.title}-${step.startTime.getTime()}`;
-        console.log(`Stanterprise Reporter: Step ended - ${step.title}`);
-        console.log(`  Duration: ${step.duration}ms`);
-        // Map step error to status
-        const stepStatus = (0, utils_1.mapStepStatus)(!!step.error);
-        // Build metadata from step annotations
-        const metadata = new Map();
-        metadata.set("category", step.category);
-        step.annotations.forEach((annotation, index) => {
-            metadata.set(`annotation_${index}_type`, annotation.type);
-            if (annotation.description) {
-                metadata.set(`annotation_${index}_description`, annotation.description);
-            }
-        });
-        // Get parent step ID if this step has a parent
-        const parentStepId = step.parent
-            ? `${uniqueTestExecutionId}-${step.parent.title}-${step.parent.startTime.getTime()}`
-            : "";
-        // Build and send the StepEnd event
-        const request = new EventsNS.StepEndEventRequest({
-            step: new TestCaseEntities.StepRun({
-                id: uniqueStepId,
-                run_id: this.runId,
-                test_case_run_id: uniqueTestExecutionId,
-                title: step.title,
-                type: step.category,
-                start_time: (0, utils_1.createTimestamp)(step.startTime),
-                duration: (0, utils_1.createDuration)(step.duration),
-                status: stepStatus,
-                error: step.error ? step.error.message || "" : "",
-                errors: step.error ? [step.error.message || ""] : [],
-                location: step.location
-                    ? `${step.location.file}:${step.location.line}:${step.location.column}`
-                    : "",
-                metadata: metadata,
-                parent_step_id: parentStepId,
-                worker_index: result.workerIndex.toString(),
-            }),
-        });
-        // Fire-and-forget to avoid slowing tests
-        this.reportUnary("/testsystem.v1.observer.TestEventCollector/ReportStepEnd", request, this.grpcTimeout).catch((e) => this.logGrpcErrorOnce("Failed to report step end", e));
+        if (this.options.verbose) {
+            console.log(`Stanterprise Reporter: Step ended - ${step.title}`);
+            console.log(`  Duration: ${step.duration}ms`);
+        }
+        if (this.options.grpcEnabled) {
+            (0, handlers_1.handleOnStepEndEvent)(test, result, step, this.runId, this.grpcClient, this.options);
+        }
     }
     onTestEnd(test, result) {
-        const uniqueTestExecutionId = `${this.runId}-${test.id}`;
-        console.log(`Stanterprise Reporter: Test ended - ${test.title}`);
-        console.log(`  Status: ${result.status}`);
-        console.log(`  Duration: ${result.duration}ms`);
-        // Map Playwright test status to protobuf TestStatus
-        const testStatus = (0, utils_1.mapTestStatus)(result.status);
-        // Process attachments (screenshots, videos, etc.)
-        const attachments = (0, utils_1.processAttachments)(result);
-        // Extract error information if the test failed
-        const { errorMessage, stackTrace, errors } = (0, utils_1.extractErrorInfo)(result);
-        // Get test suite run ID from parent suite if available, ensuring suite is reported
-        const testSuiteRunId = test.parent ? this.getSuiteId(test.parent) : "";
-        // Build metadata from test annotations and result metadata
-        const metadata = new Map();
-        test.annotations.forEach((annotation, index) => {
-            metadata.set(`annotation_${index}_type`, annotation.type);
-            if (annotation.description) {
-                metadata.set(`annotation_${index}_description`, annotation.description);
-            }
-        });
-        result.annotations.forEach((annotation, index) => {
-            metadata.set(`result_annotation_${index}_type`, annotation.type);
-            if (annotation.description) {
-                metadata.set(`result_annotation_${index}_description`, annotation.description);
-            }
-        });
-        // Build and send the TestEnd event
-        const request = new EventsNS.TestEndEventRequest({
-            test_case: new TestCaseEntities.TestCaseRun({
-                id: test.id,
-                name: test.title,
-                run_id: this.runId,
-                test_suite_run_id: testSuiteRunId,
-                status: testStatus,
-                start_time: (0, utils_1.createTimestamp)(result.startTime),
-                attachments: attachments,
-                error_message: errorMessage,
-                stack_trace: stackTrace,
-                errors: errors,
-                metadata: metadata,
-                tags: test.tags,
-            }),
-        });
-        // Fire-and-forget to avoid slowing tests
-        this.reportUnary("/testsystem.v1.observer.TestEventCollector/ReportTestEnd", request, this.grpcTimeout).catch((e) => this.logGrpcErrorOnce("Failed to report test end", e));
+        if (this.options.verbose) {
+            console.log(`Stanterprise Reporter: Test ended - ${test.title}`);
+            console.log(`  Status: ${result.status}`);
+            console.log(`  Duration: ${result.duration}ms`);
+        }
+        if (this.options.grpcEnabled) {
+            (0, handlers_1.handleOnTestEndEvent)(test, result, this.runId, this.grpcClient, this.options);
+        }
     }
     onTestFail(test, result) {
-        const uniqueTestExecutionId = `${this.runId}-${test.id}`;
-        if (this.verbose) {
+        if (this.options.verbose) {
             console.log(`Stanterprise Reporter: Test failed - ${test.title}`);
         }
-        // Extract failure details
-        const { errorMessage: failureMessage, stackTrace } = (0, utils_1.extractErrorInfo)(result);
-        // Process attachments for failed tests
-        const attachments = (0, utils_1.processAttachments)(result);
-        // Build and send the TestFailure event
-        const request = new EventsNS.TestFailureEventRequest({
-            test_id: uniqueTestExecutionId,
-            failure_message: failureMessage,
-            stack_trace: stackTrace,
-            timestamp: (0, utils_1.createTimestampFromMs)(Date.now()),
-            attachments: attachments,
-        });
-        // Fire-and-forget to avoid slowing tests
-        this.reportUnary("/testsystem.v1.observer.TestEventCollector/ReportTestFailure", request, this.grpcTimeout).catch((e) => this.logGrpcErrorOnce("Failed to report test failure", e));
+        if (this.options.grpcEnabled) {
+            (0, handlers_1.handleOnTestFailEvent)(test, result, this.runId, this.grpcClient, this.options);
+        }
     }
     onError(error) {
         console.error("Stanterprise Reporter: An error occurred during the test run");
@@ -318,6 +127,9 @@ class StanterpriseReporter {
         if (error.stack) {
             console.error(`Stack trace: ${error.stack}`);
         }
+        if (this.options.grpcEnabled) {
+            (0, handlers_1.handleOnErrorEvent)(error, this.runId, this.grpcClient, this.options);
+        }
     }
     onStdErr(chunk, test, result) {
         console.error(`Stanterprise Reporter: Standard error output - ${chunk.toString()}`);
@@ -325,132 +137,5 @@ class StanterpriseReporter {
     onStdOut(chunk, test, result) {
         // console.log(`Stanterprise Reporter: Standard output - ${chunk.toString()}`);
     }
-    // Helper: Get suite ID for a suite, ensuring it's been reported
-    getSuiteId(suite) {
-        // Check if we've already reported this suite
-        if (this.reportedSuites.has(suite)) {
-            return this.reportedSuites.get(suite);
-        }
-        // Generate a unique suite ID based on suite hierarchy
-        const titlePath = suite.titlePath().join("/") || "root";
-        const suiteId = `${this.runId}-suite-${titlePath}`;
-        // Track that we've reported this suite
-        this.reportedSuites.set(suite, suiteId);
-        return suiteId;
-    }
-    // Helper: Report suite begin event
-    reportSuiteBegin(suite, suiteId) {
-        const id = suiteId || `${this.runId}-suite-${suite.title || "root"}`;
-        console.log(`Stanterprise Reporter: Suite started - ${suite.title || "root"}`);
-        console.log(`  Suite type: ${suite.type}`);
-        // Build metadata from suite location
-        const metadata = new Map();
-        metadata.set("suite_type", suite.type);
-        if (suite.location) {
-            metadata.set("location_file", suite.location.file);
-            metadata.set("location_line", suite.location.line.toString());
-            metadata.set("location_column", suite.location.column.toString());
-        }
-        // Build and send the SuiteBegin event
-        const request = new EventsNS.SuiteBeginEventRequest({
-            suite: new TestSuiteEntities.TestSuiteRun({
-                id: id,
-                name: suite.title || "root",
-                start_time: (0, utils_1.createTimestamp)(this.runStartTime),
-                metadata: metadata,
-            }),
-        });
-        // Fire-and-forget to avoid slowing tests
-        this.reportUnary("/testsystem.v1.observer.TestEventCollector/ReportSuiteBegin", request, this.grpcTimeout).catch((e) => this.logGrpcErrorOnce("Failed to report suite begin", e));
-    }
-    // Helper: Report suite end event
-    reportSuiteEnd(suite, result) {
-        const suiteId = `${this.runId}-suite-${suite.title || "root"}`;
-        const endTime = new Date();
-        const duration = endTime.getTime() - this.runStartTime.getTime();
-        console.log(`Stanterprise Reporter: Suite ended - ${suite.title || "root"}`);
-        console.log(`  Duration: ${duration}ms`);
-        // Map result status to protobuf TestStatus
-        const suiteStatus = this.mapSuiteStatus(result.status);
-        // Build metadata from suite location
-        const metadata = new Map();
-        metadata.set("suite_type", suite.type);
-        metadata.set("final_result", result.status);
-        if (suite.location) {
-            metadata.set("location_file", suite.location.file);
-            metadata.set("location_line", suite.location.line.toString());
-            metadata.set("location_column", suite.location.column.toString());
-        }
-        // Build and send the SuiteEnd event
-        const request = new EventsNS.SuiteEndEventRequest({
-            suite: new TestSuiteEntities.TestSuiteRun({
-                id: suiteId,
-                name: suite.title || "root",
-                start_time: (0, utils_1.createTimestamp)(this.runStartTime),
-                end_time: (0, utils_1.createTimestamp)(endTime),
-                duration: (0, utils_1.createDuration)(duration),
-                status: suiteStatus,
-                metadata: metadata,
-            }),
-        });
-        // Fire-and-forget to avoid slowing tests
-        this.reportUnary("/testsystem.v1.observer.TestEventCollector/ReportSuiteEnd", request, this.grpcTimeout).catch((e) => this.logGrpcErrorOnce("Failed to report suite end", e));
-    }
-    // Helper: Map FullResult status to protobuf TestStatus
-    mapSuiteStatus(status) {
-        switch (status) {
-            case "passed":
-                return TestStatus.PASSED;
-            case "failed":
-                return TestStatus.FAILED;
-            case "timedout":
-                return TestStatus.FAILED;
-            case "interrupted":
-                return TestStatus.BROKEN;
-            default:
-                return TestStatus.UNKNOWN;
-        }
-    }
-    // Helper: log first gRPC error once and disable further attempts
-    logGrpcErrorOnce(prefix, err) {
-        if (this.grpcFirstErrorLogged)
-            return;
-        this.grpcFirstErrorLogged = true;
-        const details = err instanceof Error ? `${err.message}` : String(err);
-        console.warn(`${prefix}. gRPC disabled for the remainder of the run. Address=${this.grpcAddress}. Details: ${details}`);
-        this.grpcEnabled = false;
-    }
-    // Helper: generic unary call using raw method path
-    async reportUnary(path, message, deadlineMs = 1000) {
-        if (!this.grpcEnabled || !this.grpcClient) {
-            return Buffer.alloc(0);
-        }
-        const reqSerialize = (arg) => {
-            const m = arg;
-            const bytes = m?.serializeBinary
-                ? m.serializeBinary()
-                : m?.serialize
-                    ? m.serialize()
-                    : new Uint8Array(0);
-            return Buffer.from(bytes);
-        };
-        const resDeserialize = (bytes) => bytes;
-        const metadata = new grpc.Metadata();
-        const callOptions = {
-            deadline: new Date(Date.now() + deadlineMs),
-        };
-        return new Promise((resolve, reject) => {
-            try {
-                this.grpcClient.makeUnaryRequest(path, reqSerialize, resDeserialize, message, metadata, callOptions, (err, response) => {
-                    if (err)
-                        return reject(err);
-                    resolve(response);
-                });
-            }
-            catch (e) {
-                reject(e);
-            }
-        });
-    }
 }
 exports.default = StanterpriseReporter;

package/dist/utils/idGenerators.d.ts

@@ -0,0 +1,20 @@
+import { Suite, TestCase, TestStep } from "@playwright/test/reporter";
+/**
+ * Generates a unique suite ID based on the suite's title path.
+ * @param suite The Playwright Suite object.
+ * @returns A unique string ID for the suite.
+ */
+export declare function generateSuiteId(suite: Suite): string;
+/**
+ * Generates a unique test ID based on the test case. Currently uses the test's existing ID.
+ * @param test The Playwright TestCase object.
+ * @returns A unique string ID for the test case.
+ */
+export declare function generateTestId(test: TestCase): string;
+/**
+ * Generates a unique step ID based on the step and its parent test case.
+ * @param step The Playwright TestStep object.
+ * @param test The Playwright TestCase object that the step belongs to.
+ * @returns A unique string ID for the step.
+ */
+export declare function generateStepId(step: TestStep, test: TestCase): string;

package/dist/utils/idGenerators.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSuiteId = generateSuiteId;
+exports.generateTestId = generateTestId;
+exports.generateStepId = generateStepId;
+const crypto_1 = __importDefault(require("crypto"));
+/**
+ * Generates a unique suite ID based on the suite's title path.
+ * @param suite The Playwright Suite object.
+ * @returns A unique string ID for the suite.
+ */
+function generateSuiteId(suite) {
+    return crypto_1.default
+        .createHash("sha256")
+        .update(suite.titlePath().join(":"))
+        .digest("hex");
+}
+/**
+ * Generates a unique test ID based on the test case. Currently uses the test's existing ID.
+ * @param test The Playwright TestCase object.
+ * @returns A unique string ID for the test case.
+ */
+function generateTestId(test) {
+    return test.id;
+}
+/**
+ * Generates a unique step ID based on the step and its parent test case.
+ * @param step The Playwright TestStep object.
+ * @param test The Playwright TestCase object that the step belongs to.
+ * @returns A unique string ID for the step.
+ */
+function generateStepId(step, test) {
+    return crypto_1.default
+        .createHash("sha256")
+        .update(`${test.id}:${step.titlePath().join(":")}`)
+        .digest("hex");
+}

package/dist/utils/index.d.ts

@@ -4,3 +4,4 @@
 export * from "./statusMapper";
 export * from "./attachmentProcessor";
 export * from "./timeHelpers";
+export * from "./idGenerators";

package/dist/utils/index.js

@@ -20,3 +20,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./statusMapper"), exports);
 __exportStar(require("./attachmentProcessor"), exports);
 __exportStar(require("./timeHelpers"), exports);
+__exportStar(require("./idGenerators"), exports);

package/dist/utils/optionsMapper.d.ts

@@ -0,0 +1,7 @@
+import { StanterpriseReporterOptions } from "../types";
+/**
+ * Define and map reporter options from provided options and environment variables. Apply defaults where necessary.
+ * @param providedOptions Options provided during reporter initialization
+ * @returns Mapped and completed StanterpriseReporterOptions
+ */
+export default function defineOptions(providedOptions: StanterpriseReporterOptions): StanterpriseReporterOptions;

package/dist/utils/optionsMapper.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = defineOptions;
+/**
+ * Define and map reporter options from provided options and environment variables. Apply defaults where necessary.
+ * @param providedOptions Options provided during reporter initialization
+ * @returns Mapped and completed StanterpriseReporterOptions
+ */
+function defineOptions(providedOptions) {
+    const result = {};
+    result.grpcAddress =
+        providedOptions.grpcAddress ||
+            process.env.STANTERPRISE_GRPC_ADDRESS ||
+            "localhost:50051";
+    result.grpcEnabled =
+        providedOptions.grpcEnabled ??
+            (process.env.STANTERPRISE_GRPC_ENABLED || "true").toLowerCase() !== "false";
+    result.grpcTimeout = providedOptions.grpcTimeout || 1000;
+    result.verbose = providedOptions.verbose || false;
+    return result;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stanterprise/playwright-reporter",
-  "version": "0.0.1",
+  "version": "0.0.6",
   "description": "Custom Playwright test reporter that sends test results to Stanterprise via gRPC",
   "homepage": "https://github.com/stanterprise/stanterprise-playwright-reporter#readme",
   "bugs": {
@@ -16,8 +16,7 @@
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
-    "dist/**/*",
-    "README.md"
+    "dist/**/*"
   ],
   "keywords": [
     "playwright",
@@ -54,6 +53,6 @@
     "@grpc/grpc-js": "^1.14.1",
     "@protobuf-ts/grpc-transport": "^2.11.1",
     "@protobuf-ts/grpcweb-transport": "^2.11.1",
-    "@stanterprise/protobuf": "^0.0.11"
+    "@stanterprise/protobuf": "^0.0.18"
   }
 }

package/dist/utils/suiteMapper.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/utils/suiteMapper.js

@@ -1,4 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const protobuf_1 = require("@stanterprise/protobuf");
-const SuiteType = protobuf_1.testSuite.v1.entities.SuiteType;