squally-reporter 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Squally <squally.dev@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,82 @@
+# squally-reporter
+
+Playwright reporter that sends test results to your Squally dashboard.
+
+Learn more at [squally-app.vercel.app](https://squally-app.vercel.app).
+
+## Requirements
+
+- Node.js >= 22.19.0 (required by the `undici` dependency)
+- `@playwright/test` >= 1.30.0
+
+## Install
+
+```bash
+npm install squally-reporter
+```
+
+## Config
+
+Set two env vars (e.g. in CI secrets or `.env`):
+
+```bash
+SQUALLY_API_URL=https://squally-app.vercel.app
+SQUALLY_API_KEY=your-project-api-key
+```
+
+Find your API key on your project's Settings page in the Squally dashboard.
+
+Then add the reporter to `playwright.config.ts`:
+
+```ts
+import { defineConfig } from "@playwright/test";
+
+export default defineConfig({
+  reporter: [
+    ["list"],
+    ["squally-reporter"],
+  ],
+});
+```
+
+Alternatively, pass config explicitly instead of using env vars:
+
+```ts
+reporter: [
+  ["squally-reporter", { apiUrl: "https://squally-app.vercel.app", apiKey: "..." }],
+],
+```
+
+That's it - run your tests as usual (`npx playwright test`) and results will
+be sent to Squally after the run finishes.
+
+## Tested revision (optional)
+
+If your test-automation code lives in the same repo as the application it
+tests, Squally can already tell which commit was tested from the CI
+provider's own commit env vars. If they're **separate repos** (e.g. a
+dedicated E2E-test repo pointed at a deployed app), set one of the following
+so Squally knows which application state was actually tested:
+
+```bash
+# Same repo as the application under test - Squally will trust this CI
+# job's own commit (GITHUB_SHA / CI_COMMIT_SHA) as the tested revision.
+SAME_REPO_AS_APP=true
+
+# Separate repos - pass the tested revision explicitly (a commit SHA, tag,
+# or branch name/ref).
+TESTED_REVISION=v1.2.0
+```
+
+Neither variable is required - without them, test results are still sent
+and stored exactly as before.
+
+## Support
+
+Found a bug or have a question? Please open an issue on
+[GitHub Issues](https://github.com/squallydev-admin/squally-reporter/issues) -
+that's the primary way to report problems or ask questions.
+
+## License
+
+MIT - see [LICENSE](./LICENSE).

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+import type { FullConfig, FullResult, Reporter, Suite, TestCase, TestResult } from "@playwright/test/reporter";
+interface SquallyReporterOptions {
+    apiUrl?: string;
+    apiKey?: string;
+}
+export default class SquallyReporter implements Reporter {
+    private apiUrl;
+    private apiKey;
+    private startedAt;
+    private results;
+    constructor(options?: SquallyReporterOptions);
+    onBegin(_config: FullConfig, _suite: Suite): void;
+    onTestEnd(test: TestCase, result: TestResult): void;
+    onEnd(result: FullResult): Promise<void>;
+}
+export {};

package/dist/index.js

@@ -0,0 +1,182 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_child_process_1 = require("node:child_process");
+const node_path_1 = __importDefault(require("node:path"));
+const undici_1 = require("undici");
+// Maps Playwright's more granular statuses down to the three
+// statuses Squally stores (passed | failed | skipped).
+// "timedOut" and "interrupted" both count as failures for reporting purposes.
+function mapStatus(status) {
+    if (status === "passed")
+        return "passed";
+    if (status === "skipped")
+        return "skipped";
+    return "failed";
+}
+// CI systems expose branch/commit via env vars - checking the common ones
+// first avoids shelling out to git, which may not have full history in CI.
+function detectCiProvider() {
+    if (process.env.GITHUB_ACTIONS)
+        return "github-actions";
+    if (process.env.GITLAB_CI)
+        return "gitlab-ci";
+    if (process.env.CIRCLECI)
+        return "circleci";
+    if (process.env.CI)
+        return "unknown-ci";
+    return null;
+}
+function detectBranch() {
+    if (process.env.GITHUB_REF_NAME)
+        return process.env.GITHUB_REF_NAME;
+    if (process.env.CI_COMMIT_BRANCH)
+        return process.env.CI_COMMIT_BRANCH;
+    try {
+        return (0, node_child_process_1.execSync)("git rev-parse --abbrev-ref HEAD").toString().trim();
+    }
+    catch {
+        return null;
+    }
+}
+function detectCommitSha() {
+    if (process.env.GITHUB_SHA)
+        return process.env.GITHUB_SHA;
+    if (process.env.CI_COMMIT_SHA)
+        return process.env.CI_COMMIT_SHA;
+    try {
+        return (0, node_child_process_1.execSync)("git rev-parse HEAD").toString().trim();
+    }
+    catch {
+        return null;
+    }
+}
+// --- Flakiness Engine v2 (Phase A): tested application revision ---
+//
+// commitSha above is the test-automation repo's own commit. For teams whose
+// test suite lives in a separate repo from the application it tests, that's
+// not the same thing as "what application state did this run actually
+// test" - testedRevision fills that gap.
+// Applied to every resolved revision value before it's sent, regardless of
+// which pattern below produced it.
+function normalizeRevision(raw) {
+    let value = raw.toLowerCase();
+    if (value.startsWith("refs/heads/")) {
+        value = value.slice("refs/heads/".length);
+    }
+    if (/^v\d/.test(value)) {
+        value = value.slice(1);
+    }
+    return value;
+}
+// Fallback chain:
+// 1. ci_native - only trusted when the caller has explicitly confirmed (via
+//    SAME_REPO_AS_APP) that this CI job's own commit *is* the application
+//    commit, i.e. test-automation and application share one repo.
+// 2. passed_param - the caller passes the tested revision directly, for the
+//    separate-repos case where nothing in this job's own env describes the
+//    application under test.
+// Neither found: returns null, no error thrown - existing users without
+// these new env vars must keep working exactly as before.
+function resolveTestedRevision() {
+    if (process.env.SAME_REPO_AS_APP === "true") {
+        const revision = process.env.GITHUB_SHA ?? process.env.CI_COMMIT_SHA;
+        if (revision) {
+            return { revision: normalizeRevision(revision), source: "ci_native" };
+        }
+    }
+    if (process.env.TESTED_REVISION) {
+        return { revision: normalizeRevision(process.env.TESTED_REVISION), source: "passed_param" };
+    }
+    return null;
+}
+// Resolved independently of resolveTestedRevision()'s outcome - e.g. a repo
+// using TESTED_REVISION (pattern 2, separate repos) can still be running
+// under GitHub Actions/GitLab CI and have this available.
+function detectEventType() {
+    if (process.env.GITHUB_EVENT_NAME)
+        return process.env.GITHUB_EVENT_NAME;
+    if (process.env.CI_PIPELINE_SOURCE)
+        return process.env.CI_PIPELINE_SOURCE;
+    return null;
+}
+class SquallyReporter {
+    constructor(options = {}) {
+        this.startedAt = new Date();
+        this.results = [];
+        const apiUrl = options.apiUrl ?? process.env.SQUALLY_API_URL;
+        const apiKey = options.apiKey ?? process.env.SQUALLY_API_KEY;
+        if (!apiUrl || !apiKey) {
+            throw new Error("[squally-reporter] Missing config: set SQUALLY_API_URL and " +
+                "SQUALLY_API_KEY as env vars, or pass apiUrl/apiKey in playwright.config.ts");
+        }
+        this.apiUrl = apiUrl.replace(/\/$/, ""); // strip trailing slash if present
+        this.apiKey = apiKey;
+    }
+    onBegin(_config, _suite) {
+        this.startedAt = new Date();
+    }
+    onTestEnd(test, result) {
+        const error = result.errors[0];
+        this.results.push({
+            testName: test.titlePath().slice(1).join(" > "),
+            filePath: node_path_1.default.relative(process.cwd(), test.location.file),
+            status: mapStatus(result.status),
+            durationMs: result.duration,
+            retryCount: result.retry,
+            errorMessage: error?.message ?? null,
+            errorStack: error?.stack ?? null,
+        });
+    }
+    async onEnd(result) {
+        const resolvedRevision = resolveTestedRevision();
+        const payload = {
+            branch: detectBranch(),
+            commitSha: detectCommitSha(),
+            ciProvider: detectCiProvider(),
+            status: result.status === "passed" ? "passed" : "failed",
+            startedAt: this.startedAt.toISOString(),
+            finishedAt: new Date().toISOString(),
+            testResults: this.results,
+            testedRevision: resolvedRevision?.revision ?? null,
+            revisionSource: resolvedRevision?.source ?? null,
+            eventType: detectEventType(),
+        };
+        // Node's global fetch() pools connections through a shared, long-lived
+        // keep-alive dispatcher by default. In a short-lived CLI process like
+        // this reporter, that pooled socket can still be mid-teardown when
+        // Playwright exits the process, which crashes with a libuv assertion on
+        // Windows ("UV_HANDLE_CLOSING", src/win/async.c). Using our own Agent
+        // for this one request and closing it explicitly guarantees no open
+        // handle is left behind by the time onEnd() resolves. Importing fetch
+        // from undici too (not Node's global one) avoids a possible instanceof
+        // mismatch between Node's internal bundled undici and this installed
+        // copy when passing our Agent as the dispatcher.
+        const dispatcher = new undici_1.Agent({ keepAliveTimeout: 1, keepAliveMaxTimeout: 1 });
+        try {
+            const response = await (0, undici_1.fetch)(`${this.apiUrl}/api/ingest`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${this.apiKey}`,
+                },
+                body: JSON.stringify(payload),
+                dispatcher,
+            });
+            if (!response.ok) {
+                // Never throw here - a failing reporter upload should not fail the
+                // whole CI run just because the dashboard was unreachable.
+                console.error(`[squally-reporter] Ingest failed: ${response.status} ${response.statusText}`);
+            }
+        }
+        catch (err) {
+            console.error("[squally-reporter] Failed to reach Squally API:", err);
+        }
+        finally {
+            await dispatcher.close();
+        }
+    }
+}
+exports.default = SquallyReporter;

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "squally-reporter",
+  "version": "0.1.0",
+  "description": "Playwright reporter that sends test results to your Squally dashboard.",
+  "author": "Squally <squally.dev@gmail.com>",
+  "keywords": [
+    "playwright",
+    "playwright-reporter",
+    "flaky-tests",
+    "test-results",
+    "ci"
+  ],
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=22.19.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "prepare": "npm run build"
+  },
+  "peerDependencies": {
+    "@playwright/test": ">=1.30.0"
+  },
+  "devDependencies": {
+    "@playwright/test": "^1.48.0",
+    "@types/node": "^20.14.0",
+    "typescript": "^5.6.0"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "undici": "^8.10.0"
+  }
+}