@playwright-orchestrator/pg 1.3.4 → 1.4.1

package/dist/pg-adapter.js

@@ -30,8 +30,8 @@ let PostgreSQLAdapter = class PostgreSQLAdapter extends BaseAdapter {
         this.testInfoHistoryTable = pg.escapeIdentifier(`${tableNamePrefix}_test_info_history`);
     }
     async getReportData(runId) {
-        const { rows: [{ config }], } = await this.pool.query({
-            text: `SELECT config FROM ${this.configTable} WHERE id = $1`,
+        const { rows: [{ config, shards }], } = await this.pool.query({
+            text: `SELECT config, shards FROM ${this.configTable} WHERE id = $1`,
             values: [runId],
         });
         if (!config)
@@ -43,6 +43,7 @@ let PostgreSQLAdapter = class PostgreSQLAdapter extends BaseAdapter {
         return {
             runId,
             config,
+            shards,
             tests: rows.map(({ file, projects, line, character, report }) => ({
                 averageDuration: report?.ema ?? 0,
                 duration: report?.duration ?? 0,

package/dist/pg-initializer.js

@@ -33,6 +33,7 @@ let PgInitializer = class PgInitializer {
                 updated TIMESTAMP NOT NULL DEFAULT NOW(),
                 config JSONB NOT NULL
             );
+            ALTER TABLE ${configTable} ADD COLUMN IF NOT EXISTS shards JSONB;
             CREATE TABLE IF NOT EXISTS ${testsTable} (
                 run_id UUID NOT NULL,
                 order_num INT NOT NULL,

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

@@ -1,15 +1,16 @@
-import type { ShardHandler } from '@playwright-orchestrator/core';
+import type { ShardHandler, TestRunContext } 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 runContext;
     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>;
+    constructor({ tableNamePrefix }: CreateArgs, pgPool: PgPool, runContext: TestRunContext);
+    getNextTest(_config: TestRunConfig): Promise<TestItem | undefined>;
+    getNextTestByProject(project: string): Promise<TestItem | undefined>;
     private claimNextTest;
-    startShard(runId: string): Promise<TestRunConfig>;
-    finishShard(runId: string): Promise<void>;
+    startShard(): Promise<TestRunConfig>;
+    finishShard(): Promise<void>;
 }

package/dist/pg-shard-handler.js

@@ -11,23 +11,27 @@ 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 { RunStatus, SYMBOLS, 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 {
+    runContext;
     configTable;
     testsTable;
     pool;
-    constructor({ tableNamePrefix }, pgPool) {
+    constructor({ tableNamePrefix }, pgPool, runContext) {
+        this.runContext = runContext;
         this.pool = pgPool.pool;
         this.configTable = pg.escapeIdentifier(`${tableNamePrefix}_test_runs`);
         this.testsTable = pg.escapeIdentifier(`${tableNamePrefix}_tests`);
     }
-    async getNextTest(runId, _config) {
+    async getNextTest(_config) {
+        const { runId } = this.runContext;
         return this.claimNextTest(runId);
     }
-    async getNextTestByProject(runId, project) {
+    async getNextTestByProject(project) {
+        const { runId } = this.runContext;
         return this.claimNextTest(runId, project);
     }
     async claimNextTest(runId, project) {
@@ -76,7 +80,8 @@ let PgShardHandler = class PgShardHandler {
             client.release();
         }
     }
-    async startShard(runId) {
+    async startShard() {
+        const { runId, shardId } = this.runContext;
         const client = await this.pool.connect();
         try {
             await client.query('BEGIN');
@@ -95,18 +100,27 @@ let PgShardHandler = class PgShardHandler {
                     WHERE run_id = $1 AND status = $2 AND updated <= $4;`,
                     values: [runId, TestStatus.Failed, TestStatus.Ready, updatedBefore],
                 });
-                result = await client.query({
+                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 *;`,
+                    WHERE id = $1;`,
                     values: [runId, RunStatus.Created],
                 });
             }
+            await client.query({
+                text: `UPDATE ${this.configTable}
+                SET shards = jsonb_set(
+                    shards,
+                    $2,
+                    jsonb_build_object('shardId', $3, 'started', (EXTRACT(EPOCH FROM NOW()) * 1000)::bigint)
+                )
+                WHERE id = $1 AND (shards->>$3 IS NULL);`,
+                values: [runId, `{${shardId}}`, shardId],
+            });
             await client.query('COMMIT');
             return result.rows[0].config;
         }
@@ -118,17 +132,20 @@ let PgShardHandler = class PgShardHandler {
             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],
-        });
+    async finishShard() {
+        const { runId, shardId } = this.runContext;
+        await this.pool.query(`UPDATE ${this.configTable}
+            SET status = $2,
+            updated = NOW(),
+            shards = jsonb_set(shards, $3, to_jsonb((EXTRACT(EPOCH FROM NOW()) * 1000)::bigint))
+            WHERE id = $1 AND shards #>> $3::text[] IS NULL;`, [runId, RunStatus.Finished, `{${shardId},finished}`]);
     }
 };
 PgShardHandler = __decorate([
     injectable(),
     __param(0, inject(PG_CONFIG)),
     __param(1, inject(PG_POOL)),
-    __metadata("design:paramtypes", [Object, PgPool])
+    __param(2, inject(SYMBOLS.RunContext)),
+    __metadata("design:paramtypes", [Object, PgPool, Object])
 ], PgShardHandler);
 export { PgShardHandler };

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

@@ -74,11 +74,21 @@ let PgTestRunCreator = class PgTestRunCreator extends BaseTestRunCreator {
         try {
             await client.query('BEGIN');
             await client.query({
-                text: `INSERT INTO ${this.configTable} (id, status, config) VALUES ($1, $2, $3)`,
+                text: `INSERT INTO ${this.configTable} (id, status, config, shards) 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'];
+                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) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@playwright-orchestrator/pg",
-  "version": "1.3.4",
+  "version": "1.4.1",
   "keywords": [],
   "author": "Rostyslav Kudrevatykh",
   "license": "Apache-2.0",
@@ -17,7 +17,7 @@
     "commander": "^13.0.0",
     "inversify": "^8.0.0-beta.0",
     "pg": "^8.13.1",
-    "@playwright-orchestrator/core": "1.3.4"
+    "@playwright-orchestrator/core": "1.4.1"
   },
   "devDependencies": {
     "@types/pg": "^8.11.0"