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

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

@@ -1,330 +1,294 @@
-import * as SqlClient from 'effect/sql/SqlClient';
-import { Array as A, Console, Effect, Option, Schema, SchemaTransformation, Stream } from 'effect';
-import { TestRepository } from '../Test.repository.js';
-import { TestRun } from '../Test.repository.types.js';
-export { TestRepository };
-import { RepositoryDecodeError, RepositoryQueryError, RepositoryWriteError, TestRunNotCreated } from '../RepositoryError.js';
+import { Array as A, Effect, Exit, Option, Schema, Stream } from 'effect';
+import { SqlClient } from 'effect/sql';
+import { TestRun } from '../TestRun.js';
+import { TestRunNotCreated, TestRunIncomplete, TestRunNotFound } from '../RepositoryError.js';
 import { LabelSchema } from './Classify.js';
-import { split } from './lib/Schema.js';
-export const tables = {
-  testResults: 'test-results',
-  testRuns: 'test-runs',
-  testRunResults: 'test-run-results'
-};
-const TestResultWriteSchema = /*#__PURE__*/Schema.Struct({
+import { migrate, tables } from './test-repository-migrations.js';
+import { withStats } from './test-result-stats.js';
+import { makeResultCodec, stringifyJson } from './Test.serialization.js';
+export { tables } from './test-repository-migrations.js';
+export const TestResultStorage = /*#__PURE__*/Schema.Struct({
   id: Schema.String,
   hashTestCase: Schema.String,
+  key: Schema.String,
+  input: /*#__PURE__*/Schema.fromJsonString(Schema.Json),
+  result: /*#__PURE__*/Schema.fromJsonString(Schema.Json),
+  expected: /*#__PURE__*/Schema.fromJsonString(Schema.Json),
+  label: LabelSchema
+});
+const StoredResult = /*#__PURE__*/Schema.Struct({
+  ...TestResultStorage.fields,
+  input: Schema.String,
+  result: Schema.String,
+  expected: Schema.String,
   ordering: Schema.Int,
-  input: /*#__PURE__*/Schema.fromJsonString(Schema.Unknown),
-  result: /*#__PURE__*/Schema.fromJsonString(Schema.Unknown),
-  expected: /*#__PURE__*/Schema.fromJsonString(Schema.Unknown),
-  label: LabelSchema,
-  tags: /*#__PURE__*/split(','),
+  resultOrdering: Schema.Int,
+  tags: /*#__PURE__*/Schema.fromJsonString(/*#__PURE__*/Schema.Array(Schema.String)),
   timeMillis: Schema.Finite
 });
-const TestResultsSchema = /*#__PURE__*/Schema.Array(TestResultWriteSchema);
-const CountSchema = /*#__PURE__*/Schema.Tuple([Schema.Struct({
-  count: Schema.Int
-})]).pipe(/*#__PURE__*/Schema.decodeTo(Schema.Int, /*#__PURE__*/SchemaTransformation.transform({
-  decode: ([{
-    count
-  }]) => count,
-  encode: count => [{
-    count
-  }]
+const encodeResult = /*#__PURE__*/Schema.encodeEffect(StoredResult);
+const decodeRows = /*#__PURE__*/Schema.decodeUnknownEffect(/*#__PURE__*/Schema.Array(StoredResult));
+const decodeRuns = /*#__PURE__*/Schema.decodeUnknownEffect(/*#__PURE__*/Schema.Array(TestRun));
+const decodeListedRuns = /*#__PURE__*/Schema.decodeUnknownEffect(/*#__PURE__*/Schema.Array(/*#__PURE__*/Schema.Struct({
+  ...TestRun.fields,
+  isBaseline: /*#__PURE__*/Schema.Literals([0, 1])
+})));
+const decodeVariantBaselines = /*#__PURE__*/Schema.decodeUnknownEffect(/*#__PURE__*/Schema.Array(/*#__PURE__*/Schema.Struct({
+  variant: Schema.String,
+  id: /*#__PURE__*/Schema.NullOr(TestRun.fields.id),
+  name: /*#__PURE__*/Schema.NullOr(TestRun.fields.name),
+  state: /*#__PURE__*/Schema.NullOr(TestRun.fields.state)
+})));
+const decodeRunLimit = /*#__PURE__*/Schema.decodeUnknownEffect(/*#__PURE__*/Schema.Int.check(/*#__PURE__*/Schema.isBetween({
+  minimum: 1,
+  maximum: 100
 })));
-const TestRunsReadSchema = /*#__PURE__*/Schema.Array(TestRun);
-const TestRunResultsSchema = /*#__PURE__*/Schema.Array(/*#__PURE__*/Schema.Struct({
-  testRun: Schema.Int,
-  testResult: Schema.String
-}));
 export const makeTestRepository = /*#__PURE__*/Effect.gen(function* () {
   const sql = yield* SqlClient.SqlClient;
   yield* sql`PRAGMA auto_vacuum = FULL;`;
-  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,
-            ordering INTEGER NOT NULL,
-            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,
-            FOREIGN KEY (testRun) REFERENCES ${sql(tables.testRuns)}(id),
-            FOREIGN KEY (testResult) REFERENCES ${sql(tables.testResults)}(id),
-            UNIQUE (testRun, 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)`;
-  // SQLite's default SQLITE_MAX_VARIABLE_NUMBER is 999; testResults has 9
-  // columns and junction rows 2, so 50 rows stays well under the limit.
-  const INSERT_BATCH_SIZE = 50;
-  const insertTestResults = (testResults, testRun) => sql.withTransaction(Effect.gen(function* () {
-    if (testResults.length === 0) return;
-    const encoded = yield* Effect.forEach(testResults, _ => Schema.encodeEffect(TestResultWriteSchema)(_).pipe(Effect.mapError(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* migrate;
+  const getTestRun = Effect.fnUntraced(function* (id) {
+    return A.head(yield* decodeRuns(yield* sql`SELECT * FROM ${sql(tables.testRuns)} WHERE id = ${id};`));
+  });
+  const insertTestResults = Effect.fnUntraced(function* (results, run, schemas) {
+    const codec = 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.forEach(results.slice(offset, offset + 50), Effect.fnUntraced(function* (result) {
+        const encoded = yield* codec.encode(result);
+        return yield* encodeResult({
+          ...encoded,
+          input: stringifyJson(encoded.input),
+          result: stringifyJson(encoded.result),
+          expected: stringifyJson(encoded.expected)
+        });
+      }));
+      yield* sql.withTransaction(Effect.gen(function* () {
+        const saved = yield* getTestRun(run.id);
+        if (Option.isNone(saved)) {
+          return yield* new TestRunNotFound({
+            testRunId: run.id
+          });
+        }
+        if (saved.value.state !== 'Running') {
+          return yield* 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(tables.testResults)} ${sql.insert(content)}
                         ON CONFLICT(id) DO NOTHING;
-                    `.pipe(Effect.mapError(RepositoryWriteError.from('insertTestResults')));
+                    `;
+        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(tables.testRunResults)} ${sql.insert(links)}
+                        ON CONFLICT(testRun, testResult) DO UPDATE SET
+                            ordering = excluded.ordering,
+                            resultOrdering = excluded.resultOrdering,
+                            timeMillis = excluded.timeMillis,
+                            tags = excluded.tags;
+                    `;
+      }));
     }
-    // Junction rows reference the resolved testRun.id directly,
-    // so no correlated subquery.
-    const junction = encoded.map(_ => ({
-      testRun: testRun.id,
-      testResult: _.id
-    }));
-    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)}
-                        ON CONFLICT(testRun, testResult) DO NOTHING;
-                    `.pipe(Effect.mapError(RepositoryWriteError.from('insertTestResults')));
+  });
+  const getTestResultsStream = (run, schemas, matching) => {
+    if (matching !== undefined && matching.length > 50) {
+      return Stream.die(new Error('Match at most 50 case/key pairs per query.'));
     }
-  })).pipe(Effect.catchTag('SqlError', e => Effect.fail(RepositoryWriteError.from('insertTestResults')(e))));
-  const insertTestResult = (testResult, testRun) => insertTestResults([testResult], testRun);
-  const makeTestResultSchema = schemas => {
-    const input = schemas?.input ?? Schema.Unknown;
-    const result = schemas?.result ?? Schema.Unknown;
-    const expected = schemas?.expected ?? Schema.Unknown;
-    return Schema.Struct({
-      id: Schema.String,
-      hashTestCase: Schema.String,
-      ordering: Schema.Int,
-      input: Schema.fromJsonString(input),
-      result: Schema.fromJsonString(result),
-      expected: Schema.fromJsonString(expected),
-      label: LabelSchema,
-      tags: split(','),
-      timeMillis: Schema.Finite
-    });
-  };
-  const getTestResultsStream = (testRun, schemas) => {
-    const RowSchema = makeTestResultSchema(schemas);
-    const RowsSchema = Schema.Array(RowSchema);
-    // The SQLite driver returns rows in one batch. Decode that batch once
-    // before exposing it as a stream.
-    return Stream.unwrap(Effect.gen(function* () {
-      const rows = yield* sql`
-                    SELECT res.* 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 ordering ASC;
-                `.pipe(Effect.mapError(RepositoryQueryError.fromSql('getTestResultsStream')));
-      const decoded = yield* Schema.decodeUnknownEffect(RowsSchema)(rows).pipe(Effect.mapError(RepositoryDecodeError.from('getTestResultsStream')));
-      return Stream.fromIterable(decoded);
+    const codec = 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(tables.testRunResults)} runres
+                JOIN ${sql(tables.testResults)} res ON res.id = runres.testResult` : sql`${sql(tables.testResults)} res
+                CROSS JOIN ${sql(tables.testRunResults)} runres ON res.id = runres.testResult`;
+    // The driver cannot stream a query. Keyset pages keep decoded rows bounded.
+    return Stream.paginate(undefined, 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.forEach(rows, codec.decode);
+      return [decoded, rows.length < 100 ? Option.none() : Option.some({
+        ordering: last.ordering,
+        resultOrdering: last.resultOrdering,
+        id: last.id
+      })];
     }));
   };
-  const hasResults = Effect.fnUntraced(function* (testRun) {
-    const b = yield* sql`
-                SELECT COUNT(*) count FROM ${sql(tables.testRunResults)}
-                WHERE testRun = ${testRun.id};
-            `.pipe(Effect.mapError(RepositoryQueryError.fromSql('hasResults')));
-    const r = yield* Schema.decodeUnknownEffect(CountSchema)(b).pipe(Effect.mapError(RepositoryDecodeError.from('hasResults')));
-    return r > 0;
-  });
-  const getPreviousTestRun = 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.mapError(RepositoryQueryError.fromSql('getPreviousTestRun')));
-    const p = yield* Schema.decodeUnknownEffect(TestRunsReadSchema)(r).pipe(Effect.mapError(RepositoryDecodeError.from('getPreviousTestRun')));
-    return A.head(p);
-  });
-  const getAllTestRuns = Effect.gen(function* () {
-    const results = yield* sql`
-            SELECT * from ${sql(tables.testRuns)};
-        `.pipe(Effect.mapError(RepositoryQueryError.fromSql('getAllTestRuns')));
-    return yield* Schema.decodeUnknownEffect(TestRunsReadSchema)(results).pipe(Effect.mapError(RepositoryDecodeError.from('getAllTestRuns')));
-  });
-  const getAllTestRunResults = Effect.gen(function* () {
-    const results = yield* sql`
-            SELECT * from ${sql(tables.testRunResults)};
-        `.pipe(Effect.mapError(RepositoryQueryError.fromSql('getAllTestRunResults')));
-    return yield* Schema.decodeUnknownEffect(TestRunResultsSchema)(results).pipe(Effect.mapError(RepositoryDecodeError.from('getAllTestRunResults')));
-  });
-  const getAllTestResults = Effect.gen(function* () {
-    const results = yield* sql`
-            SELECT * from ${sql(tables.testResults)};
-        `.pipe(Effect.mapError(RepositoryQueryError.fromSql('getAllTestResults')));
-    return yield* Schema.decodeUnknownEffect(TestResultsSchema)(results).pipe(Effect.mapError(RepositoryDecodeError.from('getAllTestResults')));
+  const getLatestTestRun = Effect.fnUntraced(function* ({
+    name,
+    variant
+  }) {
+    return A.head(yield* decodeRuns(yield* sql`
+                    SELECT * FROM ${sql(tables.testRuns)}
+                    WHERE name = ${name} AND variant = ${variant}
+                    ORDER BY id DESC LIMIT 1;
+                `));
   });
-  const getLastTestRunHash = 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.mapError(RepositoryQueryError.fromSql('getLastTestRunHash')));
-    const runs = yield* Schema.decodeUnknownEffect(TestRunsReadSchema)(rows).pipe(Effect.mapError(RepositoryDecodeError.from('getLastTestRunHash')));
-    return A.head(runs).pipe(Option.flatMap(run => Option.fromNullishOr(run.hash)));
+  const getBaselineTestRun = Effect.fnUntraced(function* ({
+    name,
+    variant
+  }) {
+    return A.head(yield* decodeRuns(yield* sql`
+                    SELECT run.* FROM ${sql(tables.testBaselines)} baseline
+                    JOIN ${sql(tables.testRuns)} run ON run.id = baseline.testRun
+                    WHERE baseline.name = ${name} AND baseline.variant = ${variant};
+                `));
   });
-  const getOrCreateCurrentTestRun = name => sql.withTransaction(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.mapError(RepositoryQueryError.fromSql('getOrCreateCurrentTestRun')));
-    const current = yield* Schema.decodeUnknownEffect(TestRunsReadSchema)(currentRaw).pipe(Effect.mapError(RepositoryDecodeError.from('getOrCreateCurrentTestRun')));
-    const existing = A.head(current);
-    if (Option.isSome(existing)) {
-      return existing.value;
-    }
-    const insertedRaw = yield* sql`
-                    INSERT INTO ${sql(tables.testRuns)}
-                    ${sql.insert({
-      name
-    })}
-                    RETURNING *;
-                `.pipe(Effect.mapError(RepositoryWriteError.from('getOrCreateCurrentTestRun')));
-    const inserted = yield* Schema.decodeUnknownEffect(TestRunsReadSchema)(insertedRaw).pipe(Effect.mapError(RepositoryDecodeError.from('getOrCreateCurrentTestRun')));
+  const createTestRun = Effect.fnUntraced(function* (input) {
+    const inserted = yield* decodeRuns(yield* sql`
+                INSERT INTO ${sql(tables.testRuns)}
+                ${sql.insert({
+      ...input,
+      state: 'Running'
+    })} RETURNING *;
+            `);
     return yield* Effect.fromOption(A.head(inserted)).pipe(Effect.mapError(() => new TestRunNotCreated({
-      testSuiteName: name
+      testSuiteName: input.name
     })));
-  })).pipe(Effect.catchTag('SqlError', e => Effect.fail(RepositoryQueryError.fromSql('getOrCreateCurrentTestRun')(e))));
-  const clearStale = ({
-    name,
-    keep = 1
-  }) => sql.withTransaction(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.mapError(RepositoryQueryError.fromSql('clearStale')));
-    const staleTestRuns = yield* Schema.decodeUnknownEffect(TestRunsReadSchema)(raw).pipe(Effect.mapError(RepositoryDecodeError.from('clearStale')));
-    if (staleTestRuns.length === 0) {
-      return;
+  }, sql.withTransaction);
+  const finishTestRun = Effect.fnUntraced(function* (run, state) {
+    const updated = A.head(yield* decodeRuns(yield* sql`
+                    UPDATE ${sql(tables.testRuns)} SET state = ${state}
+                    WHERE id = ${run.id} AND state = 'Running' RETURNING *;
+                `));
+    if (Option.isNone(updated)) {
+      return yield* new 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.mapError(RepositoryWriteError.from('clearStale')));
-    yield* sql`
-                    DELETE FROM ${sql(tables.testRuns)}
-                    WHERE id IN ${sql.in(ids)};
-                `.pipe(Effect.mapError(RepositoryWriteError.from('clearStale')));
-    yield* sql`
-                    DELETE FROM ${sql(tables.testResults)}
-                    WHERE id NOT IN (
-                        SELECT DISTINCT testResult FROM ${sql(tables.testRunResults)}
-                    );
-                `.pipe(Effect.mapError(RepositoryWriteError.from('clearStale')));
-    yield* Console.log('Cleared stale test runs.');
-  })).pipe(Effect.catchTag('SqlError', e => Effect.fail(RepositoryWriteError.from('clearStale')(e))));
-  const clearUncommitedTestResults = ({
-    name
-  }) => sql.withTransaction(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.mapError(RepositoryQueryError.fromSql('clearUncommitedTestResults')));
-    const current = yield* Schema.decodeUnknownEffect(TestRunsReadSchema)(currentRaw).pipe(Effect.mapError(RepositoryDecodeError.from('clearUncommitedTestResults')));
-    const currentTestRun = A.head(current);
-    if (Option.isNone(currentTestRun)) {
-      return;
+  }, sql.withTransaction);
+  const withTestRun = (input, execute) => Effect.acquireUseRelease(createTestRun(input), run => Effect.suspend(() => execute(run)).pipe(Effect.map(value => ({
+    run,
+    value
+  }))), (run, exit) => finishTestRun(run, Exit.isSuccess(exit) ? 'Complete' : 'Failed')).pipe(Effect.map(({
+    run,
+    value
+  }) => ({
+    run: new TestRun({
+      id: run.id,
+      name: run.name,
+      variant: run.variant,
+      state: 'Complete'
+    }),
+    value
+  })));
+  const commitTestRun = Effect.fnUntraced(function* (id) {
+    const found = yield* getTestRun(id);
+    if (Option.isNone(found)) {
+      return yield* new TestRunNotFound({
+        testRunId: id
+      });
+    }
+    const run = found.value;
+    if (run.state !== 'Complete') {
+      return yield* new TestRunIncomplete({
+        testSuiteName: run.name,
+        testRunId: run.id,
+        variant: run.variant
+      });
     }
     yield* sql`
-                    DELETE FROM ${sql(tables.testRunResults)}
-                    WHERE testRun = ${currentTestRun.value.id};
-                `.pipe(Effect.mapError(RepositoryWriteError.from('clearUncommitedTestResults')));
-    yield* sql`
-                    DELETE FROM ${sql(tables.testResults)}
-                    WHERE id NOT IN (
-                        SELECT DISTINCT testResult FROM ${sql(tables.testRunResults)}
-                    );
-                `.pipe(Effect.mapError(RepositoryWriteError.from('clearUncommitedTestResults')));
-  })).pipe(Effect.catchTag('SqlError', e => Effect.fail(RepositoryWriteError.from('clearUncommitedTestResults')(e))));
-  const commitCurrentTestRun = Effect.fnUntraced(function* ({
+            INSERT INTO ${sql(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.fnUntraced(function* ({
     name,
-    hash
+    variant,
+    before,
+    limit
   }) {
-    const currentTestRunResults = yield* 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.mapError(RepositoryQueryError.fromSql('commitCurrentTestRun')))).pipe(Effect.mapError(RepositoryDecodeError.from('commitCurrentTestRun')));
-    if (currentTestRunResults === 0) {
-      yield* 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.mapError(RepositoryWriteError.from('commitCurrentTestRun')));
-    yield* sql`
-                INSERT INTO ${sql(tables.testRuns)}
-                ${sql.insert({
-      name
-    })};
-            `.pipe(Effect.mapError(RepositoryWriteError.from('commitCurrentTestRun')));
-    yield* Console.log('Commited test run.');
+    const parsedLimit = yield* decodeRunLimit(limit);
+    const runs = yield* decodeListedRuns(yield* sql`
+                SELECT run.*, EXISTS(
+                    SELECT 1 FROM ${sql(tables.testBaselines)} baseline
+                    WHERE baseline.name = run.name AND baseline.variant = run.variant
+                        AND baseline.testRun = run.id
+                ) AS isBaseline
+                FROM ${sql(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(run), {
+      isBaseline: isBaseline === 1
+    }));
+  });
+  const listVariantBaselines = 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(tables.testRuns)}
+                    WHERE name = ${name}
+                ) variants
+                LEFT JOIN ${sql(tables.testBaselines)} baseline
+                    ON baseline.name = ${name} AND baseline.variant = variants.variant
+                LEFT JOIN ${sql(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 ? Option.none() : Option.some(new 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 => withStats(use).pipe(Effect.provideService(SqlClient.SqlClient, sql)),
+    insertTestResult: (result, run, schemas) => insertTestResults([result], run, schemas),
+    insertTestResults
   };
-  return service;
 });
 //# sourceMappingURL=Test.repository.sqlite.js.map