@creative-introvert/tons-of-tests 2.1.0 → 3.0.0-rc.0

package/dist/cjs/internal/Test.repository.sqlite.js

@@ -3,398 +3,303 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-Object.defineProperty(exports, "TestRepository", {
+exports.makeTestRepository = exports.TestResultStorage = void 0;
+Object.defineProperty(exports, "tables", {
   enumerable: true,
   get: function () {
-    return _TestRepository.TestRepository;
+    return _testRepositoryMigrations.tables;
   }
 });
-exports.tables = exports.makeTestRepository = void 0;
-var SqlClient = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("effect/sql/SqlClient"));
 var _effect = /*#__PURE__*/require("effect");
-var _TestRepository = /*#__PURE__*/require("../Test.repository.js");
-var _TestRepositoryTypes = /*#__PURE__*/require("../Test.repository.types.js");
+var _sql = /*#__PURE__*/require("effect/sql");
+var _TestRun = /*#__PURE__*/require("../TestRun.js");
 var _RepositoryError = /*#__PURE__*/require("../RepositoryError.js");
 var _Classify = /*#__PURE__*/require("./Classify.js");
-var _Schema = /*#__PURE__*/require("./lib/Schema.js");
-var cache;
-function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var r, c, a = Object.defineProperty, n = { __proto__: null, default: e }; if (Object(e) !== e) return n; if (cache || "function" != typeof WeakMap || (cache = new WeakMap()), cache) { if (cache.has(e)) return cache.get(e); cache.set(e, n); } for (c in e) "default" !== c && {}.hasOwnProperty.call(e, c) && ((r = a && Object.getOwnPropertyDescriptor(e, c)) && (r.get || r.set) ? a(n, c, r) : n[c] = e[c]); return n; }
-const tables = exports.tables = {
-  testResults: 'test-results',
-  testRuns: 'test-runs',
-  testRunResults: 'test-run-results'
-};
-const TestResultWriteSchema = /*#__PURE__*/_effect.Schema.Struct({
+var _testRepositoryMigrations = /*#__PURE__*/require("./test-repository-migrations.js");
+var _testResultStats = /*#__PURE__*/require("./test-result-stats.js");
+var _TestSerialization = /*#__PURE__*/require("./Test.serialization.js");
+const TestResultStorage = exports.TestResultStorage = /*#__PURE__*/_effect.Schema.Struct({
   id: _effect.Schema.String,
   hashTestCase: _effect.Schema.String,
   key: _effect.Schema.String,
+  input: /*#__PURE__*/_effect.Schema.fromJsonString(_effect.Schema.Json),
+  result: /*#__PURE__*/_effect.Schema.fromJsonString(_effect.Schema.Json),
+  expected: /*#__PURE__*/_effect.Schema.fromJsonString(_effect.Schema.Json),
+  label: _Classify.LabelSchema
+});
+const StoredResult = /*#__PURE__*/_effect.Schema.Struct({
+  ...TestResultStorage.fields,
+  input: _effect.Schema.String,
+  result: _effect.Schema.String,
+  expected: _effect.Schema.String,
   ordering: _effect.Schema.Int,
   resultOrdering: _effect.Schema.Int,
-  input: /*#__PURE__*/_effect.Schema.fromJsonString(_effect.Schema.Unknown),
-  result: /*#__PURE__*/_effect.Schema.fromJsonString(_effect.Schema.Unknown),
-  expected: /*#__PURE__*/_effect.Schema.fromJsonString(_effect.Schema.Unknown),
-  label: _Classify.LabelSchema,
-  tags: /*#__PURE__*/(0, _Schema.split)(','),
+  tags: /*#__PURE__*/_effect.Schema.fromJsonString(/*#__PURE__*/_effect.Schema.Array(_effect.Schema.String)),
   timeMillis: _effect.Schema.Finite
 });
-const TestResultsSchema = /*#__PURE__*/_effect.Schema.Array(TestResultWriteSchema);
-const CountSchema = /*#__PURE__*/_effect.Schema.Tuple([_effect.Schema.Struct({
-  count: _effect.Schema.Int
-})]).pipe(/*#__PURE__*/_effect.Schema.decodeTo(_effect.Schema.Int, /*#__PURE__*/_effect.SchemaTransformation.transform({
-  decode: ([{
-    count
-  }]) => count,
-  encode: count => [{
-    count
-  }]
+const encodeResult = /*#__PURE__*/_effect.Schema.encodeEffect(StoredResult);
+const decodeRows = /*#__PURE__*/_effect.Schema.decodeUnknownEffect(/*#__PURE__*/_effect.Schema.Array(StoredResult));
+const decodeRuns = /*#__PURE__*/_effect.Schema.decodeUnknownEffect(/*#__PURE__*/_effect.Schema.Array(_TestRun.TestRun));
+const decodeListedRuns = /*#__PURE__*/_effect.Schema.decodeUnknownEffect(/*#__PURE__*/_effect.Schema.Array(/*#__PURE__*/_effect.Schema.Struct({
+  ..._TestRun.TestRun.fields,
+  isBaseline: /*#__PURE__*/_effect.Schema.Literals([0, 1])
+})));
+const decodeVariantBaselines = /*#__PURE__*/_effect.Schema.decodeUnknownEffect(/*#__PURE__*/_effect.Schema.Array(/*#__PURE__*/_effect.Schema.Struct({
+  variant: _effect.Schema.String,
+  id: /*#__PURE__*/_effect.Schema.NullOr(_TestRun.TestRun.fields.id),
+  name: /*#__PURE__*/_effect.Schema.NullOr(_TestRun.TestRun.fields.name),
+  state: /*#__PURE__*/_effect.Schema.NullOr(_TestRun.TestRun.fields.state)
+})));
+const decodeRunLimit = /*#__PURE__*/_effect.Schema.decodeUnknownEffect(/*#__PURE__*/_effect.Schema.Int.check(/*#__PURE__*/_effect.Schema.isBetween({
+  minimum: 1,
+  maximum: 100
 })));
-const TestRunsReadSchema = /*#__PURE__*/_effect.Schema.Array(_TestRepositoryTypes.TestRun);
-const TestRunResultsSchema = /*#__PURE__*/_effect.Schema.Array(/*#__PURE__*/_effect.Schema.Struct({
-  testRun: _effect.Schema.Int,
-  testResult: _effect.Schema.String,
-  ordering: _effect.Schema.Int,
-  resultOrdering: _effect.Schema.Int,
-  timeMillis: _effect.Schema.Finite
-}));
-const TableColumnsSchema = /*#__PURE__*/_effect.Schema.Array(/*#__PURE__*/_effect.Schema.Struct({
-  name: _effect.Schema.String
-}));
 const makeTestRepository = exports.makeTestRepository = /*#__PURE__*/_effect.Effect.gen(function* () {
-  const sql = yield* SqlClient.SqlClient;
+  const sql = yield* _sql.SqlClient.SqlClient;
   yield* sql`PRAGMA auto_vacuum = FULL;`;
-  yield* sql.withTransaction(_effect.Effect.gen(function* () {
-    yield* sql`
-        CREATE TABLE IF NOT EXISTS ${sql(tables.testRuns)}(
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            name TEXT NOT NULL,
-            hash TEXT
-        );
-    `;
-    yield* sql`CREATE INDEX IF NOT EXISTS idx_name_hash ON ${sql(tables.testRuns)}(name, hash)`;
-    // At most one "current" (hash IS NULL) row per suite name. Partial index
-    // so committed rows are unaffected.
-    yield* sql`
-        CREATE UNIQUE INDEX IF NOT EXISTS idx_current_per_name
-        ON ${sql(tables.testRuns)}(name)
-        WHERE hash IS NULL;
-    `;
-    yield* sql`
-        CREATE TABLE IF NOT EXISTS ${sql(tables.testResults)}(
-            id TEXT PRIMARY KEY,
-            hashTestCase TEXT NOT NULL,
-            key TEXT NOT NULL DEFAULT 'result',
-            ordering INTEGER NOT NULL,
-            resultOrdering INTEGER NOT NULL DEFAULT 0,
-            input TEXT,
-            result TEXT,
-            expected TEXT,
-            label TEXT NOT NULL,
-            tags TEXT NOT NULL,
-            timeMillis INTEGER NOT NULL
-        );
-    `;
-    yield* sql`
-        CREATE TABLE IF NOT EXISTS ${sql(tables.testRunResults)}(
-            testRun INTEGER NOT NULL,
-            testResult TEXT NOT NULL,
-            ordering INTEGER NOT NULL,
-            resultOrdering INTEGER NOT NULL,
-            timeMillis INTEGER NOT NULL,
-            FOREIGN KEY (testRun) REFERENCES ${sql(tables.testRuns)}(id),
-            FOREIGN KEY (testResult) REFERENCES ${sql(tables.testResults)}(id),
-            UNIQUE (testRun, testResult)
-        );
-    `;
-    const resultColumns = yield* _effect.Schema.decodeUnknownEffect(TableColumnsSchema)(yield* sql`PRAGMA table_info(${sql(tables.testResults)});`).pipe(_effect.Effect.mapError(_RepositoryError.RepositoryDecodeError.from('migrateTestResults')));
-    if (!resultColumns.some(column => column.name === 'key')) {
-      yield* sql`
-            ALTER TABLE ${sql(tables.testResults)}
-            ADD COLUMN key TEXT NOT NULL DEFAULT 'result';
-        `;
-    }
-    if (!resultColumns.some(column => column.name === 'resultOrdering')) {
-      yield* sql`
-            ALTER TABLE ${sql(tables.testResults)}
-            ADD COLUMN resultOrdering INTEGER NOT NULL DEFAULT 0;
-        `;
-    }
-    const runResultColumns = yield* _effect.Schema.decodeUnknownEffect(TableColumnsSchema)(yield* sql`PRAGMA table_info(${sql(tables.testRunResults)});`).pipe(_effect.Effect.mapError(_RepositoryError.RepositoryDecodeError.from('migrateTestRunResults')));
-    for (const column of ['ordering', 'resultOrdering', 'timeMillis']) {
-      if (runResultColumns.some(existing => existing.name === column)) {
-        continue;
-      }
-      yield* sql`
-            ALTER TABLE ${sql(tables.testRunResults)}
-            ADD COLUMN ${sql(column)} INTEGER NOT NULL DEFAULT 0;
-        `;
-      yield* sql`
-            UPDATE ${sql(tables.testRunResults)} AS runres
-            SET ${sql(column)} = (
-                SELECT ${sql(column)} FROM ${sql(tables.testResults)} res
-                WHERE res.id = runres.testResult
-            );
-        `;
-    }
-    // Lookup by the junction's `testResult` column: the existing
-    // UNIQUE(testRun, testResult) index is keyed on testRun first, so orphan
-    // cleanup (`... NOT IN (SELECT testResult ...)`) and stream joins
-    // (`res.id = runres.testResult`) would otherwise full-scan the junction.
-    yield* sql`CREATE INDEX IF NOT EXISTS idx_trr_testresult ON ${sql(tables.testRunResults)}(testResult)`;
-    yield* sql`CREATE INDEX IF NOT EXISTS idx_tr_hashtestcase ON ${sql(tables.testResults)}(hashTestCase)`;
-  }));
-  // With 11 result columns and 5 junction columns, batches of 50 rows stay below
-  // SQLite's lowest default limit of 999 bound values per statement.
-  const INSERT_BATCH_SIZE = 50;
-  const insertTestResults = (testResults, testRun) => sql.withTransaction(_effect.Effect.gen(function* () {
-    if (testResults.length === 0) return;
-    const encoded = yield* _effect.Effect.forEach(testResults, _ => _effect.Schema.encodeEffect(TestResultWriteSchema)(_).pipe(_effect.Effect.mapError(_RepositoryError.RepositoryDecodeError.from('insertTestResults'))));
-    for (let i = 0; i < encoded.length; i += INSERT_BATCH_SIZE) {
-      const chunk = encoded.slice(i, i + INSERT_BATCH_SIZE);
-      yield* sql`
-                        INSERT INTO ${sql(tables.testResults)}
-                        ${sql.insert(chunk)}
+  yield* _testRepositoryMigrations.migrate;
+  const getTestRun = _effect.Effect.fnUntraced(function* (id) {
+    return _effect.Array.head(yield* decodeRuns(yield* sql`SELECT * FROM ${sql(_testRepositoryMigrations.tables.testRuns)} WHERE id = ${id};`));
+  });
+  const insertTestResults = _effect.Effect.fnUntraced(function* (results, run, schemas) {
+    const codec = (0, _TestSerialization.makeResultCodec)(schemas, run.name);
+    // Each statement stays below SQLite's lowest default limit of 999 parameters.
+    for (let offset = 0; offset < Math.max(1, results.length); offset += 50) {
+      const encoded = yield* _effect.Effect.forEach(results.slice(offset, offset + 50), _effect.Effect.fnUntraced(function* (result) {
+        const encoded = yield* codec.encode(result);
+        return yield* encodeResult({
+          ...encoded,
+          input: (0, _TestSerialization.stringifyJson)(encoded.input),
+          result: (0, _TestSerialization.stringifyJson)(encoded.result),
+          expected: (0, _TestSerialization.stringifyJson)(encoded.expected)
+        });
+      }));
+      yield* sql.withTransaction(_effect.Effect.gen(function* () {
+        const saved = yield* getTestRun(run.id);
+        if (_effect.Option.isNone(saved)) {
+          return yield* new _RepositoryError.TestRunNotFound({
+            testRunId: run.id
+          });
+        }
+        if (saved.value.state !== 'Running') {
+          return yield* _effect.Effect.die(new Error('Only Running test runs accept result writes.'));
+        }
+        if (encoded.length === 0) return;
+        const content = encoded.map(result => ({
+          id: result.id,
+          hashTestCase: result.hashTestCase,
+          key: result.key,
+          input: result.input,
+          result: result.result,
+          expected: result.expected,
+          label: result.label
+        }));
+        yield* sql`
+                        INSERT INTO ${sql(_testRepositoryMigrations.tables.testResults)} ${sql.insert(content)}
                         ON CONFLICT(id) DO NOTHING;
-                    `.pipe(_effect.Effect.mapError(_RepositoryError.RepositoryWriteError.from('insertTestResults')));
-    }
-    // Junction rows reference the resolved testRun.id directly,
-    // so no correlated subquery.
-    const junction = encoded.map(_ => ({
-      testRun: testRun.id,
-      testResult: _.id,
-      ordering: _.ordering,
-      resultOrdering: _.resultOrdering,
-      timeMillis: _.timeMillis
-    }));
-    for (let i = 0; i < junction.length; i += INSERT_BATCH_SIZE) {
-      const chunk = junction.slice(i, i + INSERT_BATCH_SIZE);
-      yield* sql`
-                        INSERT INTO ${sql(tables.testRunResults)}
-                        ${sql.insert(chunk)}
+                    `;
+        const links = encoded.map(result => ({
+          testRun: run.id,
+          testResult: result.id,
+          ordering: result.ordering,
+          resultOrdering: result.resultOrdering,
+          timeMillis: result.timeMillis,
+          tags: result.tags
+        }));
+        yield* sql`
+                        INSERT INTO ${sql(_testRepositoryMigrations.tables.testRunResults)} ${sql.insert(links)}
                         ON CONFLICT(testRun, testResult) DO UPDATE SET
                             ordering = excluded.ordering,
                             resultOrdering = excluded.resultOrdering,
-                            timeMillis = excluded.timeMillis;
-                    `.pipe(_effect.Effect.mapError(_RepositoryError.RepositoryWriteError.from('insertTestResults')));
+                            timeMillis = excluded.timeMillis,
+                            tags = excluded.tags;
+                    `;
+      }));
     }
-  })).pipe(_effect.Effect.catchTag('SqlError', e => _effect.Effect.fail(_RepositoryError.RepositoryWriteError.from('insertTestResults')(e))));
-  const insertTestResult = (testResult, testRun) => insertTestResults([testResult], testRun);
-  const makeTestResultSchema = schemas => {
-    const input = schemas?.input ?? _effect.Schema.Unknown;
-    const result = schemas?.result ?? _effect.Schema.Unknown;
-    const expected = schemas?.expected ?? _effect.Schema.Unknown;
-    return _effect.Schema.Struct({
-      id: _effect.Schema.String,
-      hashTestCase: _effect.Schema.String,
-      key: _effect.Schema.String,
-      ordering: _effect.Schema.Int,
-      resultOrdering: _effect.Schema.Int,
-      input: _effect.Schema.fromJsonString(input),
-      result: _effect.Schema.fromJsonString(result),
-      expected: _effect.Schema.fromJsonString(expected),
-      label: _Classify.LabelSchema,
-      tags: (0, _Schema.split)(','),
-      timeMillis: _effect.Schema.Finite
-    });
-  };
-  const getTestResultsStream = (testRun, schemas) => {
-    const RowSchema = makeTestResultSchema(schemas);
-    const RowsSchema = _effect.Schema.Array(RowSchema);
-    // The SQLite driver returns rows in one batch. Decode that batch once
-    // before exposing it as a stream.
-    return _effect.Stream.unwrap(_effect.Effect.gen(function* () {
-      const rows = yield* sql`
-                    SELECT res.id, res.hashTestCase, res.key,
-                        runres.ordering, runres.resultOrdering,
-                        res.input, res.result, res.expected, res.label, res.tags,
-                        runres.timeMillis
-                    FROM ${sql(tables.testResults)} res
-                    JOIN ${sql(tables.testRunResults)} runres ON res.id = runres.testResult
-                    JOIN ${sql(tables.testRuns)} runs ON runs.id = runres.testRun
-                    WHERE runs.id = ${testRun.id}
-                    ORDER BY runres.ordering ASC, runres.resultOrdering ASC;
-                `.pipe(_effect.Effect.mapError(_RepositoryError.RepositoryQueryError.fromSql('getTestResultsStream')));
-      const decoded = yield* _effect.Schema.decodeUnknownEffect(RowsSchema)(rows).pipe(_effect.Effect.mapError(_RepositoryError.RepositoryDecodeError.from('getTestResultsStream')));
-      return _effect.Stream.fromIterable(decoded);
+  });
+  const getTestResultsStream = (run, schemas, matching) => {
+    if (matching !== undefined && matching.length > 50) {
+      return _effect.Stream.die(new Error('Match at most 50 case/key pairs per query.'));
+    }
+    const codec = (0, _TestSerialization.makeResultCodec)(schemas, run.name);
+    const filter = matching === undefined ? sql`1 = 1` : matching.length === 0 ? sql`1 = 0` : sql.or(matching.map(key => sql`res.hashTestCase = ${key.hashTestCase} AND res.key = ${key.key}`));
+    // Match case/key pairs first, so each batch avoids scanning the whole prior run.
+    // CROSS JOIN keeps SQLite from choosing the run-order index for that lookup.
+    const from = matching === undefined ? sql`${sql(_testRepositoryMigrations.tables.testRunResults)} runres
+                JOIN ${sql(_testRepositoryMigrations.tables.testResults)} res ON res.id = runres.testResult` : sql`${sql(_testRepositoryMigrations.tables.testResults)} res
+                CROSS JOIN ${sql(_testRepositoryMigrations.tables.testRunResults)} runres ON res.id = runres.testResult`;
+    // The driver cannot stream a query. Keyset pages keep decoded rows bounded.
+    return _effect.Stream.paginate(undefined, _effect.Effect.fnUntraced(function* (after) {
+      const rows = yield* decodeRows(yield* sql`
+                SELECT res.id, res.hashTestCase, res.key,
+                    runres.ordering, runres.resultOrdering, res.input, res.result,
+                    res.expected, res.label, runres.tags, runres.timeMillis
+                FROM ${from}
+                WHERE runres.testRun = ${run.id} AND ${filter}
+                    AND ${after === undefined ? sql`1 = 1` : sql`
+                        (runres.ordering, runres.resultOrdering, runres.testResult) >
+                        (${after.ordering}, ${after.resultOrdering}, ${after.id})
+                    `}
+                ORDER BY runres.ordering, runres.resultOrdering, runres.testResult
+                LIMIT 100;
+            `);
+      const last = rows[rows.length - 1];
+      const decoded = yield* _effect.Effect.forEach(rows, codec.decode);
+      return [decoded, rows.length < 100 ? _effect.Option.none() : _effect.Option.some({
+        ordering: last.ordering,
+        resultOrdering: last.resultOrdering,
+        id: last.id
+      })];
     }));
   };
-  const hasResults = _effect.Effect.fnUntraced(function* (testRun) {
-    const b = yield* sql`
-                SELECT COUNT(*) count FROM ${sql(tables.testRunResults)}
-                WHERE testRun = ${testRun.id};
-            `.pipe(_effect.Effect.mapError(_RepositoryError.RepositoryQueryError.fromSql('hasResults')));
-    const r = yield* _effect.Schema.decodeUnknownEffect(CountSchema)(b).pipe(_effect.Effect.mapError(_RepositoryError.RepositoryDecodeError.from('hasResults')));
-    return r > 0;
-  });
-  const getPreviousTestRun = _effect.Effect.fnUntraced(function* (name) {
-    const r = yield* sql`
-                SELECT * FROM ${sql(tables.testRuns)}
-                WHERE hash IS NOT NULL AND name = ${name}
-                ORDER BY id DESC
-                LIMIT 1;
-            `.pipe(_effect.Effect.mapError(_RepositoryError.RepositoryQueryError.fromSql('getPreviousTestRun')));
-    const p = yield* _effect.Schema.decodeUnknownEffect(TestRunsReadSchema)(r).pipe(_effect.Effect.mapError(_RepositoryError.RepositoryDecodeError.from('getPreviousTestRun')));
-    return _effect.Array.head(p);
-  });
-  const getAllTestRuns = _effect.Effect.gen(function* () {
-    const results = yield* sql`
-            SELECT * from ${sql(tables.testRuns)};
-        `.pipe(_effect.Effect.mapError(_RepositoryError.RepositoryQueryError.fromSql('getAllTestRuns')));
-    return yield* _effect.Schema.decodeUnknownEffect(TestRunsReadSchema)(results).pipe(_effect.Effect.mapError(_RepositoryError.RepositoryDecodeError.from('getAllTestRuns')));
-  });
-  const getAllTestRunResults = _effect.Effect.gen(function* () {
-    const results = yield* sql`
-            SELECT * from ${sql(tables.testRunResults)};
-        `.pipe(_effect.Effect.mapError(_RepositoryError.RepositoryQueryError.fromSql('getAllTestRunResults')));
-    return yield* _effect.Schema.decodeUnknownEffect(TestRunResultsSchema)(results).pipe(_effect.Effect.mapError(_RepositoryError.RepositoryDecodeError.from('getAllTestRunResults')));
-  });
-  const getAllTestResults = _effect.Effect.gen(function* () {
-    const results = yield* sql`
-            SELECT * from ${sql(tables.testResults)};
-        `.pipe(_effect.Effect.mapError(_RepositoryError.RepositoryQueryError.fromSql('getAllTestResults')));
-    return yield* _effect.Schema.decodeUnknownEffect(TestResultsSchema)(results).pipe(_effect.Effect.mapError(_RepositoryError.RepositoryDecodeError.from('getAllTestResults')));
+  const getLatestTestRun = _effect.Effect.fnUntraced(function* ({
+    name,
+    variant
+  }) {
+    return _effect.Array.head(yield* decodeRuns(yield* sql`
+                    SELECT * FROM ${sql(_testRepositoryMigrations.tables.testRuns)}
+                    WHERE name = ${name} AND variant = ${variant}
+                    ORDER BY id DESC LIMIT 1;
+                `));
   });
-  const getLastTestRunHash = _effect.Effect.fnUntraced(function* (name) {
-    const rows = yield* sql`
-            SELECT *
-            FROM ${sql(tables.testRuns)}
-            WHERE hash IS NOT NULL AND name = ${name}
-            ORDER BY id DESC
-            LIMIT 1;
-        `.pipe(_effect.Effect.mapError(_RepositoryError.RepositoryQueryError.fromSql('getLastTestRunHash')));
-    const runs = yield* _effect.Schema.decodeUnknownEffect(TestRunsReadSchema)(rows).pipe(_effect.Effect.mapError(_RepositoryError.RepositoryDecodeError.from('getLastTestRunHash')));
-    return _effect.Array.head(runs).pipe(_effect.Option.flatMap(run => _effect.Option.fromNullishOr(run.hash)));
+  const getBaselineTestRun = _effect.Effect.fnUntraced(function* ({
+    name,
+    variant
+  }) {
+    return _effect.Array.head(yield* decodeRuns(yield* sql`
+                    SELECT run.* FROM ${sql(_testRepositoryMigrations.tables.testBaselines)} baseline
+                    JOIN ${sql(_testRepositoryMigrations.tables.testRuns)} run ON run.id = baseline.testRun
+                    WHERE baseline.name = ${name} AND baseline.variant = ${variant};
+                `));
   });
-  const getOrCreateCurrentTestRun = name => sql.withTransaction(_effect.Effect.gen(function* () {
-    const currentRaw = yield* sql`
-                    SELECT *
-                    FROM ${sql(tables.testRuns)}
-                    WHERE hash IS NULL AND name = ${name}
-                    ORDER BY id DESC
-                    LIMIT 1;
-                `.pipe(_effect.Effect.mapError(_RepositoryError.RepositoryQueryError.fromSql('getOrCreateCurrentTestRun')));
-    const current = yield* _effect.Schema.decodeUnknownEffect(TestRunsReadSchema)(currentRaw).pipe(_effect.Effect.mapError(_RepositoryError.RepositoryDecodeError.from('getOrCreateCurrentTestRun')));
-    const existing = _effect.Array.head(current);
-    if (_effect.Option.isSome(existing)) {
-      return existing.value;
-    }
-    const insertedRaw = yield* sql`
-                    INSERT INTO ${sql(tables.testRuns)}
-                    ${sql.insert({
-      name
-    })}
-                    RETURNING *;
-                `.pipe(_effect.Effect.mapError(_RepositoryError.RepositoryWriteError.from('getOrCreateCurrentTestRun')));
-    const inserted = yield* _effect.Schema.decodeUnknownEffect(TestRunsReadSchema)(insertedRaw).pipe(_effect.Effect.mapError(_RepositoryError.RepositoryDecodeError.from('getOrCreateCurrentTestRun')));
+  const createTestRun = _effect.Effect.fnUntraced(function* (input) {
+    const inserted = yield* decodeRuns(yield* sql`
+                INSERT INTO ${sql(_testRepositoryMigrations.tables.testRuns)}
+                ${sql.insert({
+      ...input,
+      state: 'Running'
+    })} RETURNING *;
+            `);
     return yield* _effect.Effect.fromOption(_effect.Array.head(inserted)).pipe(_effect.Effect.mapError(() => new _RepositoryError.TestRunNotCreated({
-      testSuiteName: name
+      testSuiteName: input.name
     })));
-  })).pipe(_effect.Effect.catchTag('SqlError', e => _effect.Effect.fail(_RepositoryError.RepositoryQueryError.fromSql('getOrCreateCurrentTestRun')(e))));
-  const clearStale = ({
-    name,
-    keep = 1
-  }) => sql.withTransaction(_effect.Effect.gen(function* () {
-    const raw = yield* sql`
-                    SELECT *
-                    FROM ${sql(tables.testRuns)}
-                    WHERE hash IS NOT NULL AND name = ${name}
-                    ORDER BY id DESC
-                    LIMIT -1 OFFSET ${keep};
-                `.pipe(_effect.Effect.mapError(_RepositoryError.RepositoryQueryError.fromSql('clearStale')));
-    const staleTestRuns = yield* _effect.Schema.decodeUnknownEffect(TestRunsReadSchema)(raw).pipe(_effect.Effect.mapError(_RepositoryError.RepositoryDecodeError.from('clearStale')));
-    if (staleTestRuns.length === 0) {
-      return;
+  }, sql.withTransaction);
+  const finishTestRun = _effect.Effect.fnUntraced(function* (run, state) {
+    const updated = _effect.Array.head(yield* decodeRuns(yield* sql`
+                    UPDATE ${sql(_testRepositoryMigrations.tables.testRuns)} SET state = ${state}
+                    WHERE id = ${run.id} AND state = 'Running' RETURNING *;
+                `));
+    if (_effect.Option.isNone(updated)) {
+      return yield* new _RepositoryError.TestRunNotFound({
+        testRunId: run.id
+      });
     }
-    const ids = staleTestRuns.map(r => r.id);
-    yield* sql`
-                    DELETE FROM ${sql(tables.testRunResults)}
-                    WHERE testRun IN ${sql.in(ids)};
-                `.pipe(_effect.Effect.mapError(_RepositoryError.RepositoryWriteError.from('clearStale')));
-    yield* sql`
-                    DELETE FROM ${sql(tables.testRuns)}
-                    WHERE id IN ${sql.in(ids)};
-                `.pipe(_effect.Effect.mapError(_RepositoryError.RepositoryWriteError.from('clearStale')));
-    yield* sql`
-                    DELETE FROM ${sql(tables.testResults)}
-                    WHERE id NOT IN (
-                        SELECT DISTINCT testResult FROM ${sql(tables.testRunResults)}
-                    );
-                `.pipe(_effect.Effect.mapError(_RepositoryError.RepositoryWriteError.from('clearStale')));
-    yield* _effect.Console.log('Cleared stale test runs.');
-  })).pipe(_effect.Effect.catchTag('SqlError', e => _effect.Effect.fail(_RepositoryError.RepositoryWriteError.from('clearStale')(e))));
-  const clearUncommitedTestResults = ({
-    name
-  }) => sql.withTransaction(_effect.Effect.gen(function* () {
-    const currentRaw = yield* sql`
-                    SELECT *
-                    FROM ${sql(tables.testRuns)}
-                    WHERE hash IS NULL AND name = ${name}
-                    ORDER BY id DESC
-                    LIMIT 1;
-                `.pipe(_effect.Effect.mapError(_RepositoryError.RepositoryQueryError.fromSql('clearUncommitedTestResults')));
-    const current = yield* _effect.Schema.decodeUnknownEffect(TestRunsReadSchema)(currentRaw).pipe(_effect.Effect.mapError(_RepositoryError.RepositoryDecodeError.from('clearUncommitedTestResults')));
-    const currentTestRun = _effect.Array.head(current);
-    if (_effect.Option.isNone(currentTestRun)) {
-      return;
+  }, sql.withTransaction);
+  const withTestRun = (input, execute) => _effect.Effect.acquireUseRelease(createTestRun(input), run => _effect.Effect.suspend(() => execute(run)).pipe(_effect.Effect.map(value => ({
+    run,
+    value
+  }))), (run, exit) => finishTestRun(run, _effect.Exit.isSuccess(exit) ? 'Complete' : 'Failed')).pipe(_effect.Effect.map(({
+    run,
+    value
+  }) => ({
+    run: new _TestRun.TestRun({
+      id: run.id,
+      name: run.name,
+      variant: run.variant,
+      state: 'Complete'
+    }),
+    value
+  })));
+  const commitTestRun = _effect.Effect.fnUntraced(function* (id) {
+    const found = yield* getTestRun(id);
+    if (_effect.Option.isNone(found)) {
+      return yield* new _RepositoryError.TestRunNotFound({
+        testRunId: id
+      });
+    }
+    const run = found.value;
+    if (run.state !== 'Complete') {
+      return yield* new _RepositoryError.TestRunIncomplete({
+        testSuiteName: run.name,
+        testRunId: run.id,
+        variant: run.variant
+      });
     }
     yield* sql`
-                    DELETE FROM ${sql(tables.testRunResults)}
-                    WHERE testRun = ${currentTestRun.value.id};
-                `.pipe(_effect.Effect.mapError(_RepositoryError.RepositoryWriteError.from('clearUncommitedTestResults')));
-    yield* sql`
-                    DELETE FROM ${sql(tables.testResults)}
-                    WHERE id NOT IN (
-                        SELECT DISTINCT testResult FROM ${sql(tables.testRunResults)}
-                    );
-                `.pipe(_effect.Effect.mapError(_RepositoryError.RepositoryWriteError.from('clearUncommitedTestResults')));
-  })).pipe(_effect.Effect.catchTag('SqlError', e => _effect.Effect.fail(_RepositoryError.RepositoryWriteError.from('clearUncommitedTestResults')(e))));
-  const commitCurrentTestRun = _effect.Effect.fnUntraced(function* ({
+            INSERT INTO ${sql(_testRepositoryMigrations.tables.testBaselines)}
+            ${sql.insert({
+      name: run.name,
+      variant: run.variant,
+      testRun: run.id
+    })}
+            ON CONFLICT(name, variant) DO UPDATE SET testRun = excluded.testRun;
+        `;
+  }, sql.withTransaction);
+  const listTestRuns = _effect.Effect.fnUntraced(function* ({
     name,
-    hash
+    variant,
+    before,
+    limit
   }) {
-    const currentTestRunResults = yield* _effect.Schema.decodeUnknownEffect(CountSchema)(yield* sql`
-                    SELECT COUNT(*) count FROM ${sql(tables.testRunResults)}
-                    WHERE testRun = (
-                        SELECT id
-                        FROM ${sql(tables.testRuns)}
-                        WHERE hash IS NULL AND name = ${name}
-                    );
-                `.pipe(_effect.Effect.mapError(_RepositoryError.RepositoryQueryError.fromSql('commitCurrentTestRun')))).pipe(_effect.Effect.mapError(_RepositoryError.RepositoryDecodeError.from('commitCurrentTestRun')));
-    if (currentTestRunResults === 0) {
-      yield* _effect.Console.log('Current run has no test results, not commiting.');
-      return;
-    }
-    yield* sql`
-                UPDATE ${sql(tables.testRuns)}
-                SET hash = ${hash}
-                WHERE id = (
-                    SELECT id
-                    FROM ${sql(tables.testRuns)}
-                    WHERE hash IS NULL AND name = ${name}
-                );
-            `.pipe(_effect.Effect.mapError(_RepositoryError.RepositoryWriteError.from('commitCurrentTestRun')));
-    yield* sql`
-                INSERT INTO ${sql(tables.testRuns)}
-                ${sql.insert({
-      name
-    })};
-            `.pipe(_effect.Effect.mapError(_RepositoryError.RepositoryWriteError.from('commitCurrentTestRun')));
-    yield* _effect.Console.log('Commited test run.');
+    const parsedLimit = yield* decodeRunLimit(limit);
+    const runs = yield* decodeListedRuns(yield* sql`
+                SELECT run.*, EXISTS(
+                    SELECT 1 FROM ${sql(_testRepositoryMigrations.tables.testBaselines)} baseline
+                    WHERE baseline.name = run.name AND baseline.variant = run.variant
+                        AND baseline.testRun = run.id
+                ) AS isBaseline
+                FROM ${sql(_testRepositoryMigrations.tables.testRuns)} run
+                WHERE run.name = ${name}
+                    AND ${variant === undefined ? sql`1 = 1` : sql`run.variant = ${variant}`}
+                    AND ${before === undefined ? sql`1 = 1` : sql`run.id < ${before}`}
+                ORDER BY run.id DESC LIMIT ${parsedLimit};
+            `);
+    return runs.map(({
+      isBaseline,
+      ...run
+    }) => Object.assign(new _TestRun.TestRun(run), {
+      isBaseline: isBaseline === 1
+    }));
+  });
+  const listVariantBaselines = _effect.Effect.fnUntraced(function* (name) {
+    const variants = yield* decodeVariantBaselines(yield* sql`
+                SELECT variants.variant, run.id, run.name, run.state
+                FROM (
+                    SELECT DISTINCT variant FROM ${sql(_testRepositoryMigrations.tables.testRuns)}
+                    WHERE name = ${name}
+                ) variants
+                LEFT JOIN ${sql(_testRepositoryMigrations.tables.testBaselines)} baseline
+                    ON baseline.name = ${name} AND baseline.variant = variants.variant
+                LEFT JOIN ${sql(_testRepositoryMigrations.tables.testRuns)} run ON run.id = baseline.testRun
+                ORDER BY variants.variant;
+            `);
+    return variants.map(({
+      variant,
+      id,
+      name,
+      state
+    }) => ({
+      variant,
+      baseline: id === null || name === null || state === null ? _effect.Option.none() : _effect.Option.some(new _TestRun.TestRun({
+        id,
+        name,
+        variant,
+        state
+      }))
+    }));
   });
-  const service = {
-    clearStale,
-    clearUncommitedTestResults,
-    commitCurrentTestRun,
-    getAllTestResults,
-    getAllTestRuns,
-    getOrCreateCurrentTestRun,
-    getLastTestRunHash,
-    getPreviousTestRun,
+  return {
+    commitTestRun,
+    getTestRun,
+    getLatestTestRun,
+    getBaselineTestRun,
+    listTestRuns,
+    listVariantBaselines,
     getTestResultsStream,
-    hasResults,
-    insertTestResult,
-    insertTestResults,
-    getAllTestRunResults
+    withTestRun,
+    withStats: use => (0, _testResultStats.withStats)(use).pipe(_effect.Effect.provideService(_sql.SqlClient.SqlClient, sql)),
+    insertTestResult: (result, run, schemas) => insertTestResults([result], run, schemas),
+    insertTestResults
   };
-  return service;
 });
 //# sourceMappingURL=Test.repository.sqlite.js.map