@playwright-orchestrator/pg 1.2.0 → 1.3.0

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { Command } from '@commander-js/extra-typings';
-import { CreateArgs } from './create-args.js';
-import { PostgreSQLAdapter } from './postgresql-adapter.js';
-export declare function factory(args: CreateArgs): Promise<PostgreSQLAdapter>;
+import { Container } from 'inversify';
+import type { CreateArgs } from './create-args.js';
+export declare function register(container: Container, options: CreateArgs): Promise<void>;
 export declare function createOptions(command: Command): void;
 export declare const description = "PostgreSQL storage adapter";

package/dist/index.js

@@ -1,17 +1,28 @@
 import { Option } from '@commander-js/extra-typings';
+import { SYMBOLS } from '@playwright-orchestrator/core';
 import { PostgreSQLAdapter } from './postgresql-adapter.js';
+import { PgShardHandler } from './pg-shard-handler.js';
+import { PgInitializer } from './pg-initializer.js';
+import { PgTestRunCreator } from './pg-test-run-creator.js';
+import { PgPool } from './pg-pool.js';
 import { readFile } from 'node:fs/promises';
-export async function factory(args) {
-    if (args.sslCa) {
-        args.sslCa = await readFile(args.sslCa);
+import { PG_CONFIG, PG_POOL } from './symbols.js';
+export async function register(container, options) {
+    if (options.sslCa) {
+        options.sslCa = await readFile(options.sslCa);
     }
-    if (args.sslCert) {
-        args.sslCert = await readFile(args.sslCert);
+    if (options.sslCert) {
+        options.sslCert = await readFile(options.sslCert);
     }
-    if (args.sslKey) {
-        args.sslKey = await readFile(args.sslKey);
+    if (options.sslKey) {
+        options.sslKey = await readFile(options.sslKey);
     }
-    return new PostgreSQLAdapter(args);
+    container.bind(PG_CONFIG).toConstantValue(options);
+    container.bind(PG_POOL).to(PgPool).inSingletonScope();
+    container.bind(SYMBOLS.Adapter).to(PostgreSQLAdapter).inSingletonScope();
+    container.bind(SYMBOLS.ShardHandler).to(PgShardHandler).inSingletonScope();
+    container.bind(SYMBOLS.Initializer).to(PgInitializer).inSingletonScope();
+    container.bind(SYMBOLS.TestRunCreator).to(PgTestRunCreator).inSingletonScope();
 }
 export function createOptions(command) {
     command

package/dist/pg-initializer.d.ts

@@ -0,0 +1,9 @@
+import type { Initializer } from '@playwright-orchestrator/core';
+import type { CreateArgs } from './create-args.js';
+import { PgPool } from './pg-pool.js';
+export declare class PgInitializer implements Initializer {
+    private readonly config;
+    private readonly pgPool;
+    constructor(config: CreateArgs, pgPool: PgPool);
+    initialize(): Promise<void>;
+}

package/dist/pg-initializer.js

@@ -0,0 +1,97 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { injectable, inject } from 'inversify';
+import { PgPool } from './pg-pool.js';
+import pg from 'pg';
+import { PG_CONFIG, PG_POOL } from './symbols.js';
+let PgInitializer = class PgInitializer {
+    config;
+    pgPool;
+    constructor(config, pgPool) {
+        this.config = config;
+        this.pgPool = pgPool;
+    }
+    async initialize() {
+        const { tableNamePrefix } = this.config;
+        const configTable = pg.escapeIdentifier(`${tableNamePrefix}_test_runs`);
+        const testsTable = pg.escapeIdentifier(`${tableNamePrefix}_tests`);
+        const testInfoTable = pg.escapeIdentifier(`${tableNamePrefix}_test_info`);
+        const testInfoHistoryTable = pg.escapeIdentifier(`${tableNamePrefix}_test_info_history`);
+        await this.pgPool.pool.query(`CREATE TABLE IF NOT EXISTS ${configTable} (
+                id UUID PRIMARY KEY,
+                status INT NOT NULL,
+                updated TIMESTAMP NOT NULL DEFAULT NOW(),
+                config JSONB NOT NULL
+            );
+            CREATE TABLE IF NOT EXISTS ${testsTable} (
+                run_id UUID NOT NULL,
+                order_num INT NOT NULL,
+                status INT NOT NULL DEFAULT 0,
+                test_id TEXT NOT NULL,
+                file TEXT NOT NULL,
+                line INT NOT NULL,
+                character INT NOT NULL,
+                projects JSONB NOT NULL,
+                timeout INT NOT NULL,
+                ema FLOAT NOT NULL,
+                updated TIMESTAMP NOT NULL DEFAULT NOW(),
+                report JSONB,
+                children JSONB,
+                PRIMARY KEY (run_id, order_num),
+                FOREIGN KEY (run_id) REFERENCES ${configTable}(id)
+            );
+            ALTER TABLE ${testsTable} ADD COLUMN IF NOT EXISTS children JSONB;
+            ALTER TABLE ${testsTable} ADD COLUMN IF NOT EXISTS ema FLOAT NOT NULL DEFAULT 0;
+            ALTER TABLE ${testsTable} ALTER COLUMN ema DROP DEFAULT;
+            ALTER TABLE ${testsTable} ADD COLUMN IF NOT EXISTS test_id TEXT NOT NULL DEFAULT '';
+            ALTER TABLE ${testsTable} ALTER COLUMN test_id DROP DEFAULT;
+            DO $$
+            BEGIN
+            IF NOT EXISTS (
+                SELECT 1
+                FROM information_schema.columns
+                WHERE table_name = ${pg.escapeLiteral(`${tableNamePrefix}_tests`)} AND column_name = 'projects'
+            ) THEN
+                ALTER TABLE ${testsTable} ADD COLUMN projects JSONB NOT NULL DEFAULT '[]';
+                UPDATE ${testsTable} SET projects = jsonb_build_array(project) WHERE project IS NOT NULL;
+                ALTER TABLE ${testsTable} DROP COLUMN IF EXISTS project;
+                ALTER TABLE ${testsTable} ALTER COLUMN projects DROP DEFAULT;
+            END IF;
+            END $$;
+            UPDATE ${testsTable} SET projects = '[]' WHERE projects IS NULL;
+            CREATE INDEX IF NOT EXISTS status_idx ON ${testsTable}(status);
+            CREATE TABLE IF NOT EXISTS ${testInfoTable} (
+                id SERIAL PRIMARY KEY,
+                name TEXT NOT NULL,
+                ema FLOAT NOT NULL DEFAULT 0,
+                created TIMESTAMP NOT NULL DEFAULT NOW()
+            );
+            CREATE INDEX IF NOT EXISTS name_idx ON ${testInfoTable} USING HASH (name);
+            CREATE TABLE IF NOT EXISTS ${testInfoHistoryTable} (
+                id SERIAL PRIMARY KEY,
+                duration FLOAT NOT NULL,
+                status INT NOT NULL,
+                updated TIMESTAMP NOT NULL DEFAULT NOW(),
+                test_info_id INT NOT NULL,
+                FOREIGN KEY (test_info_id) REFERENCES ${testInfoTable}(id)
+            );
+            CREATE INDEX IF NOT EXISTS test_info_id_idx ON ${testInfoHistoryTable}(test_info_id);`);
+    }
+};
+PgInitializer = __decorate([
+    injectable(),
+    __param(0, inject(PG_CONFIG)),
+    __param(1, inject(PG_POOL)),
+    __metadata("design:paramtypes", [Object, PgPool])
+], PgInitializer);
+export { PgInitializer };

package/dist/pg-pool.d.ts

@@ -0,0 +1,7 @@
+import type { CreateArgs } from './create-args.js';
+import pg from 'pg';
+export declare class PgPool {
+    readonly pool: pg.Pool;
+    constructor({ connectionString, sslCa, sslCert, sslKey }: CreateArgs);
+    dispose(): Promise<void>;
+}

package/dist/pg-pool.js

@@ -0,0 +1,46 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { injectable, inject, preDestroy } from 'inversify';
+import pg from 'pg';
+import { PG_CONFIG } from './symbols.js';
+let PgPool = class PgPool {
+    pool;
+    constructor({ connectionString, sslCa, sslCert, sslKey }) {
+        const config = { connectionString };
+        config.ssl = sslCa || sslCert || sslKey ? {} : undefined;
+        if (sslCa)
+            config.ssl.ca = sslCa;
+        if (sslCert && sslKey) {
+            config.ssl.cert = sslCert;
+            config.ssl.key = sslKey;
+        }
+        this.pool = new pg.Pool(config);
+    }
+    async dispose() {
+        if (this.pool.ending)
+            return;
+        await this.pool.end();
+    }
+};
+__decorate([
+    preDestroy(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], PgPool.prototype, "dispose", null);
+PgPool = __decorate([
+    injectable(),
+    __param(0, inject(PG_CONFIG)),
+    __metadata("design:paramtypes", [Object])
+], PgPool);
+export { PgPool };

package/dist/pg-shard-handler.d.ts

@@ -0,0 +1,15 @@
+import type { ShardHandler } from '@playwright-orchestrator/core';
+import type { TestItem, TestRunConfig } from '@playwright-orchestrator/core';
+import type { CreateArgs } from './create-args.js';
+import { PgPool } from './pg-pool.js';
+export declare class PgShardHandler implements ShardHandler {
+    private readonly configTable;
+    private readonly testsTable;
+    private readonly pool;
+    constructor({ tableNamePrefix }: CreateArgs, pgPool: PgPool);
+    getNextTest(runId: string, _config: TestRunConfig): Promise<TestItem | undefined>;
+    getNextTestByProject(runId: string, project: string): Promise<TestItem | undefined>;
+    private claimNextTest;
+    startShard(runId: string): Promise<TestRunConfig>;
+    finishShard(runId: string): Promise<void>;
+}

package/dist/pg-shard-handler.js

@@ -0,0 +1,134 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { injectable, inject } from 'inversify';
+import { RunStatus, TestStatus } from '@playwright-orchestrator/core';
+import { PgPool } from './pg-pool.js';
+import pg from 'pg';
+import { PG_CONFIG, PG_POOL } from './symbols.js';
+let PgShardHandler = class PgShardHandler {
+    configTable;
+    testsTable;
+    pool;
+    constructor({ tableNamePrefix }, pgPool) {
+        this.pool = pgPool.pool;
+        this.configTable = pg.escapeIdentifier(`${tableNamePrefix}_test_runs`);
+        this.testsTable = pg.escapeIdentifier(`${tableNamePrefix}_tests`);
+    }
+    async getNextTest(runId, _config) {
+        return this.claimNextTest(runId);
+    }
+    async getNextTestByProject(runId, project) {
+        return this.claimNextTest(runId, project);
+    }
+    async claimNextTest(runId, project) {
+        const projectFilter = project ? `AND projects @> to_jsonb(ARRAY[$4]::text[])` : '';
+        const values = project
+            ? [runId, TestStatus.Ready, TestStatus.Ongoing, project]
+            : [runId, TestStatus.Ready, TestStatus.Ongoing];
+        const client = await this.pool.connect();
+        try {
+            await client.query('BEGIN');
+            const result = await client.query({
+                text: `WITH next_test AS (
+                    SELECT order_num FROM ${this.testsTable}
+                    WHERE run_id = $1 AND status = $2 ${projectFilter}
+                    ORDER BY order_num
+                    LIMIT 1
+                    FOR UPDATE SKIP LOCKED
+                )
+                UPDATE ${this.testsTable} t
+                SET status = $3, updated = NOW()
+                FROM next_test
+                WHERE t.run_id = $1 AND t.order_num = next_test.order_num
+                RETURNING *`,
+                values,
+            });
+            await client.query('COMMIT');
+            if (result.rowCount === 0)
+                return undefined;
+            const { file, line, character, projects, timeout, ema, order_num, children, test_id } = result.rows[0];
+            return {
+                file,
+                position: `${line}:${character}`,
+                projects,
+                timeout,
+                ema,
+                order: order_num,
+                children,
+                testId: test_id,
+            };
+        }
+        catch (e) {
+            await client.query('ROLLBACK');
+            throw e;
+        }
+        finally {
+            client.release();
+        }
+    }
+    async startShard(runId) {
+        const client = await this.pool.connect();
+        try {
+            await client.query('BEGIN');
+            let result = await client.query({
+                text: `SELECT * FROM ${this.configTable} WHERE id = $1 FOR UPDATE`,
+                values: [runId],
+            });
+            if (result.rowCount === 0) {
+                throw new Error(`Run ${runId} not found`);
+            }
+            const { updated: updatedBefore, status: statusBefore } = result.rows[0];
+            if (statusBefore === RunStatus.Created || statusBefore === RunStatus.Finished) {
+                await client.query({
+                    text: `UPDATE ${this.testsTable}
+                    SET updated = NOW(), status = $3
+                    WHERE run_id = $1 AND status = $2 AND updated <= $4;`,
+                    values: [runId, TestStatus.Failed, TestStatus.Ready, updatedBefore],
+                });
+                result = await client.query({
+                    text: `UPDATE ${this.configTable}
+                    SET status = (CASE
+                        WHEN status = $2 THEN ${RunStatus.Run}
+                        ELSE ${RunStatus.RepeatRun}
+                    END),
+                    updated = NOW()
+                    WHERE id = $1
+                    RETURNING *;`,
+                    values: [runId, RunStatus.Created],
+                });
+            }
+            await client.query('COMMIT');
+            return result.rows[0].config;
+        }
+        catch (e) {
+            await client.query('ROLLBACK');
+            throw e;
+        }
+        finally {
+            client.release();
+        }
+    }
+    async finishShard(runId) {
+        await this.pool.query({
+            text: `UPDATE ${this.configTable} SET status = $1, updated = NOW() WHERE id = $2`,
+            values: [RunStatus.Finished, runId],
+        });
+    }
+};
+PgShardHandler = __decorate([
+    injectable(),
+    __param(0, inject(PG_CONFIG)),
+    __param(1, inject(PG_POOL)),
+    __metadata("design:paramtypes", [Object, PgPool])
+], PgShardHandler);
+export { PgShardHandler };

package/dist/pg-test-run-creator.d.ts

@@ -0,0 +1,14 @@
+import { BaseTestRunCreator } from '@playwright-orchestrator/core';
+import type { TestItem, TestRun, TestSortItem } from '@playwright-orchestrator/core';
+import type { CreateArgs } from './create-args.js';
+import { PgPool } from './pg-pool.js';
+export declare class PgTestRunCreator extends BaseTestRunCreator {
+    private readonly configTable;
+    private readonly testsTable;
+    private readonly testInfoTable;
+    private readonly testInfoHistoryTable;
+    private readonly pool;
+    constructor({ tableNamePrefix }: CreateArgs, pgPool: PgPool);
+    loadTestInfos(tests: TestItem[]): Promise<Map<string, TestSortItem>>;
+    saveRunData(runId: string, run: TestRun, tests: TestItem[]): Promise<void>;
+}

package/dist/pg-test-run-creator.js

@@ -0,0 +1,127 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { injectable, inject, injectFromBase } from 'inversify';
+import { BaseTestRunCreator, RunStatus, TestStatus } from '@playwright-orchestrator/core';
+import { PgPool } from './pg-pool.js';
+import pg from 'pg';
+import { PG_CONFIG, PG_POOL } from './symbols.js';
+let PgTestRunCreator = class PgTestRunCreator extends BaseTestRunCreator {
+    configTable;
+    testsTable;
+    testInfoTable;
+    testInfoHistoryTable;
+    pool;
+    constructor({ tableNamePrefix }, pgPool) {
+        super();
+        this.pool = pgPool.pool;
+        this.configTable = pg.escapeIdentifier(`${tableNamePrefix}_test_runs`);
+        this.testsTable = pg.escapeIdentifier(`${tableNamePrefix}_tests`);
+        this.testInfoTable = pg.escapeIdentifier(`${tableNamePrefix}_test_info`);
+        this.testInfoHistoryTable = pg.escapeIdentifier(`${tableNamePrefix}_test_info_history`);
+    }
+    async loadTestInfos(tests) {
+        const results = await this.pool.query({
+            text: `
+            WITH test_names AS (
+                SELECT UNNEST($1::TEXT[]) AS name
+            ),
+            existing_tests AS (
+                SELECT id, name, ema, created FROM ${this.testInfoTable}
+                WHERE name IN (SELECT name FROM test_names)
+            ),
+            inserted_tests AS (
+                INSERT INTO ${this.testInfoTable} (name)
+                SELECT name FROM test_names
+                WHERE NOT EXISTS (
+                    SELECT 1 FROM ${this.testInfoTable} WHERE name = test_names.name
+                )
+                RETURNING id, name, ema, created
+            ),
+            combined_tests AS (
+                SELECT * FROM existing_tests
+                UNION ALL
+                SELECT * FROM inserted_tests
+            )
+            SELECT
+                t.id,
+                t.name,
+                t.ema,
+                t.created,
+                COUNT(CASE WHEN h.status = ${TestStatus.Failed} THEN 1 END) as fails
+            FROM combined_tests t
+            LEFT JOIN ${this.testInfoHistoryTable} h ON h.test_info_id = t.id
+            GROUP BY t.id, t.name, t.ema, t.created`,
+            values: [tests.map((t) => t.testId)],
+        });
+        const testInfo = new Map();
+        for (const { name, ema, fails } of results.rows) {
+            testInfo.set(name, { ema, fails: +fails });
+        }
+        return testInfo;
+    }
+    async saveRunData(runId, run, tests) {
+        const client = await this.pool.connect();
+        try {
+            await client.query('BEGIN');
+            await client.query({
+                text: `INSERT INTO ${this.configTable} (id, status, config) VALUES ($1, $2, $3)`,
+                values: [runId, RunStatus.Created, JSON.stringify(run.config)],
+            });
+            if (tests.length > 0) {
+                const fields = ['order_num', 'file', 'line', 'character', 'projects', 'timeout', 'ema', 'children', 'test_id'];
+                await client.query({
+                    text: `INSERT INTO ${this.testsTable} (run_id, ${fields.join(', ')}) VALUES ${tests
+                        .map((_, i) => {
+                        const len = fields.length;
+                        const values = fields.map((_, j) => `$${i * len + j + 2}`).join(', ');
+                        return `($1, ${values})`;
+                    })
+                        .join(', ')}`,
+                    values: [
+                        runId,
+                        ...tests.flatMap(({ position, order, file, projects, timeout, ema, children, testId }) => {
+                            const [line, character] = position.split(':');
+                            return [
+                                order,
+                                file,
+                                line,
+                                character,
+                                JSON.stringify(projects),
+                                timeout,
+                                ema,
+                                children != null ? JSON.stringify(children) : null,
+                                testId,
+                            ];
+                        }),
+                    ],
+                });
+            }
+            await client.query('COMMIT');
+        }
+        catch (e) {
+            await client.query('ROLLBACK');
+            throw e;
+        }
+        finally {
+            client.release();
+        }
+    }
+};
+PgTestRunCreator = __decorate([
+    injectable(),
+    injectFromBase({ extendProperties: true, extendConstructorArguments: false }),
+    __param(0, inject(PG_CONFIG)),
+    __param(1, inject(PG_POOL)),
+    __metadata("design:paramtypes", [Object, PgPool])
+], PgTestRunCreator);
+export { PgTestRunCreator };

package/dist/postgresql-adapter.d.ts

@@ -1,23 +1,15 @@
-import { TestItem, Adapter, TestRunConfig, ResultTestParams, SaveTestRunParams } from '@playwright-orchestrator/core';
-import { CreateArgs } from './create-args.js';
-import { TestRunReport } from '../../core/dist/types/reporter.js';
-export declare class PostgreSQLAdapter extends Adapter {
+import { BaseAdapter, TestRunReport, SaveTestResultParams } from '@playwright-orchestrator/core';
+import type { CreateArgs } from './create-args.js';
+import { PgPool } from './pg-pool.js';
+export declare class PostgreSQLAdapter extends BaseAdapter {
     private readonly configTable;
     private readonly testsTable;
     private readonly testInfoTable;
     private readonly testInfoHistoryTable;
     private readonly pool;
-    constructor({ connectionString, tableNamePrefix, sslCa, sslCert, sslKey }: CreateArgs);
-    getNextTest(runId: string, config: TestRunConfig): Promise<TestItem | undefined>;
-    finishTest(params: ResultTestParams): Promise<void>;
-    failTest(params: ResultTestParams): Promise<void>;
-    saveTestRun({ runId, args, historyWindow, testRun }: SaveTestRunParams): Promise<void>;
-    initialize(): Promise<void>;
-    startShard(runId: string): Promise<TestRunConfig>;
-    finishShard(runId: string): Promise<void>;
-    dispose(): Promise<void>;
+    constructor({ tableNamePrefix }: CreateArgs, pgPool: PgPool);
     getReportData(runId: string): Promise<TestRunReport>;
-    private updateTestWithResults;
-    private loadTestInfos;
+    getTestEma(testId: string): Promise<number>;
+    saveTestResult({ runId, test, item, historyWindow, newEma }: SaveTestResultParams): Promise<void>;
     private mapConfig;
 }

package/dist/postgresql-adapter.js

@@ -1,196 +1,34 @@
-import { Adapter, RunStatus, TestStatus, } from '@playwright-orchestrator/core';
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { BaseAdapter, TestStatus, } from '@playwright-orchestrator/core';
+import { injectable, inject } from 'inversify';
+import { PgPool } from './pg-pool.js';
 import pg from 'pg';
-export class PostgreSQLAdapter extends Adapter {
+import { PG_CONFIG, PG_POOL } from './symbols.js';
+let PostgreSQLAdapter = class PostgreSQLAdapter extends BaseAdapter {
     configTable;
     testsTable;
     testInfoTable;
     testInfoHistoryTable;
     pool;
-    constructor({ connectionString, tableNamePrefix, sslCa, sslCert, sslKey }) {
+    constructor({ tableNamePrefix }, pgPool) {
         super();
-        const config = { connectionString };
-        config.ssl = sslCa || sslCert || sslKey ? {} : undefined;
-        if (sslCa) {
-            config.ssl.ca = sslCa;
-        }
-        if (sslCert && sslKey) {
-            config.ssl.cert = sslCert;
-            config.ssl.key = sslKey;
-        }
-        this.pool = new pg.Pool(config);
+        this.pool = pgPool.pool;
         this.configTable = pg.escapeIdentifier(`${tableNamePrefix}_test_runs`);
         this.testsTable = pg.escapeIdentifier(`${tableNamePrefix}_tests`);
         this.testInfoTable = pg.escapeIdentifier(`${tableNamePrefix}_test_info`);
         this.testInfoHistoryTable = pg.escapeIdentifier(`${tableNamePrefix}_test_info_history`);
     }
-    async getNextTest(runId, config) {
-        const client = await this.pool.connect();
-        try {
-            await client.query('BEGIN');
-            const result = await client.query({
-                text: `WITH next_test AS (
-                    SELECT order_num FROM ${this.testsTable}
-                    WHERE run_id = $1 AND status = $2
-                    ORDER BY order_num
-                    LIMIT 1
-                    FOR UPDATE SKIP LOCKED
-                )
-                UPDATE ${this.testsTable} t
-                SET status = $3, updated = NOW()
-                FROM next_test
-                WHERE t.run_id = $1 AND t.order_num = next_test.order_num
-                RETURNING *`,
-                values: [runId, TestStatus.Ready, TestStatus.Ongoing],
-            });
-            await client.query('COMMIT');
-            if (result.rowCount === 0)
-                return undefined;
-            const { file, line, character, project, timeout, order_num } = result.rows[0];
-            return { file, position: `${line}:${character}`, project, timeout, order: order_num };
-        }
-        catch (e) {
-            await this.pool.query('ROLLBACK');
-        }
-        finally {
-            client.release();
-        }
-    }
-    async finishTest(params) {
-        await this.updateTestWithResults(TestStatus.Passed, params);
-    }
-    async failTest(params) {
-        await this.updateTestWithResults(TestStatus.Failed, params);
-    }
-    async saveTestRun({ runId, args, historyWindow, testRun }) {
-        let tests = this.transformTestRunToItems(testRun.testRun);
-        const testInfos = await this.loadTestInfos(tests);
-        tests = this.sortTests(tests, testInfos, { historyWindow });
-        await this.pool.query({
-            text: `INSERT INTO ${this.configTable} (id, status, config) VALUES ($1, $2, $3)`,
-            values: [runId, RunStatus.Created, JSON.stringify({ ...testRun.config, args, historyWindow })],
-        });
-        const fields = ['order_num', 'file', 'line', 'character', 'project', 'timeout'];
-        await this.pool.query({
-            text: `INSERT INTO ${this.testsTable} (run_id, ${fields.join(', ')}) VALUES ${tests
-                .map((_, i) => {
-                const len = fields.length;
-                const values = fields.map((_, j) => `$${i * len + j + 2}`).join(', ');
-                return `($1, ${values})`;
-            })
-                .join(', ')}`,
-            values: [
-                runId,
-                ...tests.flatMap(({ position, order, file, project, timeout }) => {
-                    const [line, character] = position.split(':');
-                    return [order, file, line, character, project, timeout];
-                }),
-            ],
-        });
-    }
-    async initialize() {
-        await this.pool.query(`CREATE TABLE IF NOT EXISTS ${this.configTable} (
-                id UUID PRIMARY KEY,
-                status INT NOT NULL,
-                updated TIMESTAMP NOT NULL DEFAULT NOW(),
-                config JSONB NOT NULL
-            );
-            CREATE TABLE IF NOT EXISTS ${this.testsTable} (
-                run_id UUID NOT NULL,
-                order_num INT NOT NULL,
-                status INT NOT NULL DEFAULT 0,
-                file TEXT NOT NULL,
-                line INT NOT NULL,
-                character INT NOT NULL,
-                project TEXT NOT NULL,
-                timeout INT NOT NULL,
-                updated TIMESTAMP NOT NULL DEFAULT NOW(),
-                report JSONB,
-                PRIMARY KEY (run_id, order_num),
-                FOREIGN KEY (run_id) REFERENCES ${this.configTable}(id)
-            );
-            CREATE INDEX IF NOT EXISTS status_idx ON ${this.testsTable}(status);
-            CREATE TABLE IF NOT EXISTS ${this.testInfoTable} (
-                id SERIAL PRIMARY KEY,
-                name TEXT NOT NULL,
-                ema FLOAT NOT NULL DEFAULT 0,
-                created TIMESTAMP NOT NULL DEFAULT NOW()
-            );
-            CREATE INDEX IF NOT EXISTS name_idx ON ${this.testInfoTable} USING HASH (name);
-            CREATE TABLE IF NOT EXISTS ${this.testInfoHistoryTable} (
-                id SERIAL PRIMARY KEY,
-                duration FLOAT NOT NULL,
-                status INT NOT NULL,
-                updated TIMESTAMP NOT NULL DEFAULT NOW(),
-                test_info_id INT NOT NULL,
-                FOREIGN KEY (test_info_id) REFERENCES ${this.testInfoTable}(id)
-            );
-            CREATE INDEX IF NOT EXISTS test_info_id_idx ON ${this.testInfoHistoryTable}(test_info_id);`);
-    }
-    async startShard(runId) {
-        const client = await this.pool.connect();
-        try {
-            await client.query('BEGIN');
-            let result = await client.query({
-                text: `
-                    SELECT *
-                    FROM ${this.configTable}
-                    WHERE id = $1
-                    FOR UPDATE`,
-                values: [runId],
-            });
-            if (result.rowCount === 0) {
-                throw new Error(`Run ${runId} not found`);
-            }
-            const { updated: updatedBefore, status: statusBefore } = result.rows[0];
-            if (statusBefore === RunStatus.Created || statusBefore === RunStatus.Finished) {
-                await client.query({
-                    text: `
-                    UPDATE ${this.testsTable}
-                    SET updated = NOW(), status = $3
-                    WHERE run_id = $1 AND status = $2 AND updated <= $4;`,
-                    values: [runId, TestStatus.Failed, TestStatus.Ready, updatedBefore],
-                });
-                // using str interpolation for case statement to avoid casting ints to strings
-                result = await client.query({
-                    text: `
-                    UPDATE ${this.configTable}
-                    SET status = (CASE
-                        WHEN status = $2 THEN ${RunStatus.Run}
-                        ELSE ${RunStatus.RepeatRun}
-                    END),
-                    updated = NOW()
-                    WHERE id = $1
-                    RETURNING *;`,
-                    values: [runId, RunStatus.Created],
-                });
-            }
-            await client.query('COMMIT');
-            return this.mapConfig(result.rows[0]);
-        }
-        catch (e) {
-            await client.query('ROLLBACK');
-            throw e;
-        }
-        finally {
-            client.release();
-        }
-    }
-    async finishShard(runId) {
-        // set 'updated' field to current time as test run exhausted all tests
-        // update 'updated' field until last shard set correct finish time
-        await this.pool.query({
-            text: `UPDATE ${this.configTable}
-            SET status = $1,
-            updated = NOW()
-            WHERE id = $2`,
-            values: [RunStatus.Finished, runId],
-        });
-    }
-    async dispose() {
-        if (this.pool.ending)
-            return;
-        await this.pool.end();
-    }
     async getReportData(runId) {
         const { rows: [dbConfig], } = await this.pool.query({
             text: `SELECT * FROM ${this.configTable} WHERE id = $1`,
@@ -205,117 +43,87 @@ export class PostgreSQLAdapter extends Adapter {
         return {
             runId,
             config: this.mapConfig(dbConfig),
-            tests: rows.map(({ file, project, line, character, report }) => ({
-                averageDuration: 0,
+            tests: rows.map(({ file, projects, line, character, report }) => ({
+                averageDuration: report?.ema ?? 0,
                 duration: report?.duration ?? 0,
                 status: report?.status ?? TestStatus.Ready,
                 fails: report?.fails ?? 0,
                 file,
                 position: `${line}:${character}`,
-                project,
+                projects,
                 title: report?.title,
                 lastSuccessfulRunTimestamp: report?.lastSuccessfulRun,
             })),
         };
     }
-    async updateTestWithResults(status, { runId, test, config, testResult }) {
-        const testId = this.getTestId({ ...test, ...testResult });
+    async getTestEma(testId) {
         const { rows: [testInfo], } = await this.pool.query({
-            text: `SELECT 
-                id, 
-                ema,
-                (
-                    SELECT COUNT(*) FROM ${this.testInfoHistoryTable} 
-                    WHERE status = ${TestStatus.Failed} AND test_info_id = info.id
-                ) AS fails,
-                (
-                    SELECT updated FROM ${this.testInfoHistoryTable} 
-                    WHERE status = ${TestStatus.Passed} AND test_info_id = info.id 
-                    ORDER BY updated DESC LIMIT 1
-                ) AS last_successful_run
-            FROM ${this.testInfoTable} info
-            WHERE name = $1`,
+            text: `SELECT ema FROM ${this.testInfoTable} WHERE name = $1`,
             values: [testId],
         });
-        const report = {
-            title: testResult.title,
-            status,
-            duration: testResult.duration,
-            ema: testInfo.ema,
-            fails: +testInfo.fails,
-            lastSuccessfulRun: testInfo.last_successful_run?.getTime?.(),
-        };
-        const newEma = this.calculateEMA(testResult.duration, testInfo.ema, config.historyWindow);
-        await this.pool.query({
-            text: `UPDATE ${this.testsTable}
-            SET 
-                status = $1,
-                updated = NOW(),
-                report = $2 
-            WHERE run_id = $3 AND order_num = $4;`,
-            values: [status, report, runId, test.order],
-        });
-        await this.pool.query({
-            text: `UPDATE ${this.testInfoTable} SET ema = $1 WHERE id = $2;`,
-            values: [newEma, testInfo.id],
-        });
-        await this.pool.query({
-            text: `INSERT INTO ${this.testInfoHistoryTable} (status, duration, updated, test_info_id)
-            VALUES ($1, $2, NOW(), $3);`,
-            values: [status, testResult.duration, testInfo.id],
-        });
-        await this.pool.query({
-            text: `DELETE FROM ${this.testInfoHistoryTable}
-            WHERE id IN (
-                SELECT id 
-                FROM ${this.testInfoHistoryTable}
-                WHERE test_info_id = $1
-                ORDER BY updated
-                LIMIT 10
-                OFFSET 10
-            )`,
-            values: [testInfo.id],
-        });
+        return testInfo?.ema ?? 0;
     }
-    async loadTestInfos(tests) {
-        const results = await this.pool.query({
-            text: `
-            WITH test_names AS (
-                SELECT UNNEST($1::TEXT[]) AS name
-            ),
-            existing_tests AS (
-                SELECT id, name, ema, created FROM ${this.testInfoTable}
-                WHERE name IN (SELECT name FROM test_names)
-            ),
-            inserted_tests AS (
-                INSERT INTO ${this.testInfoTable} (name)
-                SELECT name FROM test_names
-                WHERE NOT EXISTS (
-                    SELECT 1 FROM ${this.testInfoTable} WHERE name = test_names.name
-                )
-                RETURNING id, name, ema, created
-            ),
-            combined_tests AS (
-                SELECT * FROM existing_tests
-                UNION ALL
-                SELECT * FROM inserted_tests
-            )
-            SELECT 
-                t.id,
-                t.name,
-                t.ema,
-                t.created,
-                COUNT(CASE WHEN h.status = ${TestStatus.Failed} THEN 1 END) as fails
-            FROM combined_tests t
-            LEFT JOIN ${this.testInfoHistoryTable} h ON h.test_info_id = t.id
-            GROUP BY t.id, t.name, t.ema, t.created`,
-            values: [tests.map((t) => t.testId)],
-        });
-        const testInfo = new Map();
-        for (const { name, ema, fails } of results.rows) {
-            testInfo.set(name, { ema, fails: +fails });
+    async saveTestResult({ runId, test, item, historyWindow, newEma }) {
+        const client = await this.pool.connect();
+        try {
+            await client.query('BEGIN');
+            const { rows: [{ id }], } = await client.query({
+                text: `UPDATE ${this.testInfoTable} SET ema = $1 WHERE name = $2 RETURNING id`,
+                values: [newEma, test.testId],
+            });
+            await client.query({
+                text: `INSERT INTO ${this.testInfoHistoryTable} (status, duration, updated, test_info_id) VALUES ($1, $2, NOW(), $3)`,
+                values: [item.status, item.duration, id],
+            });
+            await client.query({
+                text: `DELETE FROM ${this.testInfoHistoryTable}
+                WHERE id IN (
+                    SELECT id
+                    FROM ${this.testInfoHistoryTable}
+                    WHERE test_info_id = $1
+                    ORDER BY updated
+                    LIMIT GREATEST(0, (SELECT COUNT(*) FROM ${this.testInfoHistoryTable} WHERE test_info_id = $1) - $2)
+                )`,
+                values: [id, historyWindow],
+            });
+            const { rows } = await client.query({
+                text: `SELECT status, duration, EXTRACT(EPOCH FROM updated) * 1000 AS updated
+                       FROM ${this.testInfoHistoryTable} WHERE test_info_id = $1 ORDER BY updated`,
+                values: [id],
+            });
+            const history = rows.map(({ status, duration, updated }) => ({
+                status: +status,
+                duration,
+                updated: +updated,
+            }));
+            const report = this.buildReport(test, item, newEma, history);
+            await client.query({
+                text: `UPDATE ${this.testsTable}
+                SET status = $1, updated = NOW(), report = $2
+                WHERE run_id = $3 AND order_num = $4`,
+                values: [
+                    report.status,
+                    {
+                        title: report.title,
+                        status: report.status,
+                        duration: report.duration,
+                        ema: report.averageDuration,
+                        fails: report.fails,
+                        lastSuccessfulRun: report.lastSuccessfulRunTimestamp,
+                    },
+                    runId,
+                    test.order,
+                ],
+            });
+            await client.query('COMMIT');
+        }
+        catch (e) {
+            await client.query('ROLLBACK');
+            throw e;
+        }
+        finally {
+            client.release();
         }
-        return testInfo;
     }
     mapConfig(dbConfig) {
         return {
@@ -324,4 +132,11 @@ export class PostgreSQLAdapter extends Adapter {
             status: dbConfig.status,
         };
     }
-}
+};
+PostgreSQLAdapter = __decorate([
+    injectable(),
+    __param(0, inject(PG_CONFIG)),
+    __param(1, inject(PG_POOL)),
+    __metadata("design:paramtypes", [Object, PgPool])
+], PostgreSQLAdapter);
+export { PostgreSQLAdapter };

package/dist/symbols.d.ts

@@ -0,0 +1,2 @@
+export declare const PG_CONFIG: unique symbol;
+export declare const PG_POOL: unique symbol;

package/dist/symbols.js

@@ -0,0 +1,2 @@
+export const PG_CONFIG = Symbol.for('PgConfig');
+export const PG_POOL = Symbol.for('PgPool');

package/package.json

@@ -1,34 +1,33 @@
 {
-    "name": "@playwright-orchestrator/pg",
-    "version": "1.2.0",
-    "keywords": [],
-    "author": "Rostyslav Kudrevatykh",
-    "license": "Apache-2.0",
-    "description": "Playwright orchestrator PostgreSQL plugin",
-    "repository": {
-        "type": "git",
-        "url": "git+https://github.com/rostmanrk/playwright-orchestrator.git"
-    },
-    "files": [
-        "dist"
-    ],
-    "dependencies": {
-        "@commander-js/extra-typings": "^13.0.0",
-        "@playwright-orchestrator/core": "^1.1.0",
-        "commander": "^13.0.0",
-        "pg": "^8.13.1"
-    },
-    "devDependencies": {
-        "@types/pg": "^8.11.0"
-    },
-    "main": "dist/index.js",
-    "type": "module",
-    "exports": {
-        ".": {
-            "default": "./dist/index.js"
-        }
-    },
-    "scripts": {
-        "prepare": "cp ../../LICENSE.md ./"
+  "name": "@playwright-orchestrator/pg",
+  "version": "1.3.0",
+  "keywords": [],
+  "author": "Rostyslav Kudrevatykh",
+  "license": "Apache-2.0",
+  "description": "Playwright orchestrator PostgreSQL plugin",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rostmanrk/playwright-orchestrator.git"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@commander-js/extra-typings": "^13.0.0",
+    "commander": "^13.0.0",
+    "inversify": "^8.0.0-beta.0",
+    "pg": "^8.13.1",
+    "@playwright-orchestrator/core": "1.3.0"
+  },
+  "devDependencies": {
+    "@types/pg": "^8.11.0"
+  },
+  "main": "dist/index.js",
+  "type": "module",
+  "exports": {
+    ".": {
+      "default": "./dist/index.js"
     }
-}
+  },
+  "scripts": {}
+}