@sdods/db 0.11.2 → 0.12.0

package/dist/migrations/0010_run_params.d.ts

@@ -0,0 +1,11 @@
+import type { Kysely } from 'kysely';
+import type { Col } from '../col.js';
+/**
+ * The full selection a run was started with (feature, scenario, workers, headed, HAR mode…), so
+ * Rerun can replay it exactly. The existing columns only cover env/tags/layers/browsers, and
+ * `command` is an argv joined on spaces that cannot be split back once a scenario name has one.
+ * Nullable: runs started before this, and runs from the CLI, fall back to those columns.
+ */
+export declare function up(db: Kysely<any>, c: Col): Promise<void>;
+export declare function down(db: Kysely<any>, _c: Col): Promise<void>;
+//# sourceMappingURL=0010_run_params.d.ts.map

package/dist/migrations/0010_run_params.js

@@ -0,0 +1,13 @@
+/**
+ * The full selection a run was started with (feature, scenario, workers, headed, HAR mode…), so
+ * Rerun can replay it exactly. The existing columns only cover env/tags/layers/browsers, and
+ * `command` is an argv joined on spaces that cannot be split back once a scenario name has one.
+ * Nullable: runs started before this, and runs from the CLI, fall back to those columns.
+ */
+export async function up(db, c) {
+    await db.schema.alterTable('runs').addColumn('params_json', c.json).execute();
+}
+export async function down(db, _c) {
+    await db.schema.alterTable('runs').dropColumn('params_json').execute();
+}
+//# sourceMappingURL=0010_run_params.js.map

package/dist/migrations/0011_user_preferences.d.ts

@@ -0,0 +1,12 @@
+import type { Kysely } from 'kysely';
+import type { Col } from '../col.js';
+/**
+ * Per-user UI preferences, such as the last run selection for a project (`runForm:<ws>:<project>`).
+ *
+ * Server-side because browser storage is per origin, and the desktop app's origin is
+ * `http://127.0.0.1:<port>`: when its preferred port is taken it binds another, and everything
+ * the browser had stored is gone. It also carries a preference from the desktop app to the web UI.
+ */
+export declare function up(db: Kysely<any>, c: Col): Promise<void>;
+export declare function down(db: Kysely<any>, _c: Col): Promise<void>;
+//# sourceMappingURL=0011_user_preferences.d.ts.map

package/dist/migrations/0011_user_preferences.js

@@ -0,0 +1,18 @@
+import { dropTables, fk, index, stamps, table } from './helpers.js';
+/**
+ * Per-user UI preferences, such as the last run selection for a project (`runForm:<ws>:<project>`).
+ *
+ * Server-side because browser storage is per origin, and the desktop app's origin is
+ * `http://127.0.0.1:<port>`: when its preferred port is taken it binds another, and everything
+ * the browser had stored is gone. It also carries a preference from the desktop app to the web UI.
+ */
+export async function up(db, c) {
+    await stamps(fk(table(db, 'user_preferences', c), 'user_id', 'users', c)
+        .addColumn('key', 'text', (cb) => cb.notNull())
+        .addColumn('value_json', c.json, (cb) => cb.notNull()), c).execute();
+    await index(db, 'uq_user_preferences_user_key', 'user_preferences', ['user_id', 'key'], true);
+}
+export async function down(db, _c) {
+    await dropTables(db, ['user_preferences']);
+}
+//# sourceMappingURL=0011_user_preferences.js.map

package/dist/migrations/index.js

@@ -7,6 +7,8 @@ import * as m0006 from './0006_schedules.js';
 import * as m0007 from './0007_hierarchy.js';
 import * as m0008 from './0008_runner_naming.js';
 import * as m0009 from './0009_user_profile.js';
+import * as m0010 from './0010_run_params.js';
+import * as m0011 from './0011_user_preferences.js';
 /**
  * Static registry (bundler-friendly, no runtime file discovery). Order matters: Kysely sorts by key.
  */
@@ -20,5 +22,7 @@ export const MIGRATIONS = {
     '0007_hierarchy': m0007,
     '0008_runner_naming': m0008,
     '0009_user_profile': m0009,
+    '0010_run_params': m0010,
+    '0011_user_preferences': m0011,
 };
 //# sourceMappingURL=index.js.map

package/dist/repos/index.d.ts

@@ -5,4 +5,5 @@ export * from './test-data.js';
 export * from './auth.js';
 export * from './platform.js';
 export * from './hierarchy.js';
+export * from './preferences.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/repos/index.js

@@ -5,4 +5,5 @@ export * from './test-data.js';
 export * from './auth.js';
 export * from './platform.js';
 export * from './hierarchy.js';
+export * from './preferences.js';
 //# sourceMappingURL=index.js.map

package/dist/repos/preferences.d.ts

@@ -0,0 +1,12 @@
+import type { Kysely } from 'kysely';
+import type { Database } from '../schema.js';
+export interface UserPreference<T = unknown> {
+    key: string;
+    value: T;
+    updatedAt: string | null;
+}
+export declare function getUserPreference<T = unknown>(db: Kysely<Database>, userId: string, key: string): Promise<UserPreference<T> | null>;
+/** Insert or replace one preference; returns the stored row. */
+export declare function setUserPreference<T = unknown>(db: Kysely<Database>, userId: string, key: string, value: T): Promise<UserPreference<T>>;
+export declare function deleteUserPreference(db: Kysely<Database>, userId: string, key: string): Promise<void>;
+//# sourceMappingURL=preferences.d.ts.map

package/dist/repos/preferences.js

@@ -0,0 +1,56 @@
+import { enc, nowIso, readJson, readTs } from '../col.js';
+import { newId } from '../ids.js';
+export async function getUserPreference(db, userId, key) {
+    const row = await db
+        .selectFrom('user_preferences')
+        .select(['key', 'value_json', 'updated_at'])
+        .where('user_id', '=', userId)
+        .where('key', '=', key)
+        .executeTakeFirst();
+    if (!row)
+        return null;
+    return {
+        key: row.key,
+        value: readJson(row.value_json),
+        updatedAt: readTs(row.updated_at),
+    };
+}
+/** Insert or replace one preference; returns the stored row. */
+export async function setUserPreference(db, userId, key, value) {
+    const now = nowIso();
+    const existing = await db
+        .selectFrom('user_preferences')
+        .select('id')
+        .where('user_id', '=', userId)
+        .where('key', '=', key)
+        .executeTakeFirst();
+    if (existing) {
+        await db
+            .updateTable('user_preferences')
+            .set({ value_json: enc.json(value), updated_at: now })
+            .where('id', '=', existing.id)
+            .execute();
+    }
+    else {
+        await db
+            .insertInto('user_preferences')
+            .values({
+            id: newId(),
+            user_id: userId,
+            key,
+            value_json: enc.json(value),
+            created_at: now,
+            updated_at: now,
+        })
+            .execute();
+    }
+    return { key, value, updatedAt: now };
+}
+export async function deleteUserPreference(db, userId, key) {
+    await db
+        .deleteFrom('user_preferences')
+        .where('user_id', '=', userId)
+        .where('key', '=', key)
+        .execute();
+}
+//# sourceMappingURL=preferences.js.map

package/dist/repos/runs.d.ts

@@ -31,6 +31,8 @@ export interface RunUpsert {
     htmlReportRel?: string | null;
     exitCode?: number | null;
     errorText?: string | null;
+    /** The selection a server-started run was launched with, for Rerun. */
+    params?: Record<string, unknown>;
 }
 export declare function upsertRun(db: Kysely<Database>, _driver: Driver, r: RunUpsert): Promise<void>;
 export declare function getRun(db: Kysely<Database>, id: string): Promise<(RunRecord & {
@@ -51,6 +53,16 @@ export declare function mapRun(row: any): RunRecord & {
     projectId: string;
     totalsRaw: Record<string, unknown>;
 };
+/**
+ * What a run was started with, for Rerun: the stored selection when the server started it, else
+ * the parts the row always records. `null` when the run does not exist.
+ */
+export declare function getRunParams(db: Kysely<Database>, id: string): Promise<{
+    project: string;
+    params: Record<string, unknown>;
+} | null>;
+/** Names of the scenarios that failed in a run, deduplicated (a scenario can run per browser). */
+export declare function getFailedScenarioNames(db: Kysely<Database>, runId: string): Promise<string[]>;
 export declare function deleteRunChildren(db: Kysely<Database>, runId: string): Promise<void>;
 export declare function deleteRun(db: Kysely<Database>, runId: string): Promise<void>;
 /** Scenario tree for a run: scenarios with their attempts (no steps). */

package/dist/repos/runs.js

@@ -38,6 +38,7 @@ export async function upsertRun(db, _driver, r) {
         html_report_rel: r.htmlReportRel,
         exit_code: r.exitCode,
         error_text: r.errorText,
+        params_json: r.params ? enc.json(r.params) : undefined,
     });
     if (existing) {
         await db
@@ -124,6 +125,53 @@ export function mapRun(row) {
         errorText: row.error_text ?? undefined,
     };
 }
+/**
+ * What a run was started with, for Rerun: the stored selection when the server started it, else
+ * the parts the row always records. `null` when the run does not exist.
+ */
+export async function getRunParams(db, id) {
+    const row = await db
+        .selectFrom('runs')
+        .innerJoin('projects', 'projects.id', 'runs.project_id')
+        .select([
+        'projects.slug as project_slug',
+        'runs.params_json',
+        'runs.env_name',
+        'runs.process',
+        'runs.tags_expr',
+        'runs.layers_json',
+        'runs.browsers_json',
+    ])
+        .where('runs.id', '=', id)
+        .executeTakeFirst();
+    if (!row)
+        return null;
+    const stored = readJson(row.params_json);
+    if (stored)
+        return { project: row.project_slug, params: stored };
+    const layers = readJson(row.layers_json) ?? [];
+    const browsers = readJson(row.browsers_json) ?? [];
+    return {
+        project: row.project_slug,
+        params: stripUndefined({
+            env: row.env_name || undefined,
+            process: row.process ?? undefined,
+            tags: row.tags_expr ?? undefined,
+            layers: layers.length ? layers : undefined,
+            browsers: browsers.length ? browsers : undefined,
+        }),
+    };
+}
+/** Names of the scenarios that failed in a run, deduplicated (a scenario can run per browser). */
+export async function getFailedScenarioNames(db, runId) {
+    const rows = await db
+        .selectFrom('scenarios')
+        .select('scenario_name')
+        .where('run_id', '=', runId)
+        .where('status', 'in', ['failed', 'timedOut', 'interrupted'])
+        .execute();
+    return [...new Set(rows.map((r) => r.scenario_name))];
+}
 export async function deleteRunChildren(db, runId) {
     // FK cascades handle steps/attempts/artifacts/heal_events; delete explicitly for engines without FK enforcement.
     await db.deleteFrom('heal_events').where('run_id', '=', runId).execute();

package/dist/schema.d.ts

@@ -133,6 +133,8 @@ export interface RunsTable {
     html_report_rel: string | null;
     exit_code: number | null;
     error_text: string | null;
+    /** The StartRunInput a server-started run was launched with; null for CLI runs and older rows. */
+    params_json: Json<Record<string, unknown>> | null;
     created_at: Ts;
     updated_at: Ts;
 }
@@ -475,6 +477,14 @@ export interface AuditLogTable {
     ip: string | null;
     created_at: Ts;
 }
+export interface UserPreferencesTable {
+    id: string;
+    user_id: string;
+    key: string;
+    value_json: Json<unknown>;
+    created_at: Ts;
+    updated_at: Ts;
+}
 export interface Database {
     organizations: OrganizationsTable;
     workspaces: WorkspacesTable;
@@ -507,6 +517,7 @@ export interface Database {
     schedules: SchedulesTable;
     schedule_runs: ScheduleRunsTable;
     audit_log: AuditLogTable;
+    user_preferences: UserPreferencesTable;
 }
 /** Platform tables in foreign-key order (parents first). Used by export/import/switch/prune. */
 export declare const TABLES_IN_FK_ORDER: Array<keyof Database>;

package/dist/schema.js

@@ -4,6 +4,7 @@ export const TABLES_IN_FK_ORDER = [
     'users',
     'sessions',
     'api_tokens',
+    'user_preferences',
     'organizations',
     'workspaces',
     'org_members',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sdods/db",
-  "version": "0.11.2",
+  "version": "0.12.0",
   "description": "SDODS platform database: one schema on SQLite or Postgres, migrations, result ingest and insights.",
   "license": "Apache-2.0",
   "author": "SDODS <admin@sdods.com>",
@@ -17,13 +17,14 @@
     "access": "public"
   },
   "files": [
-    "dist"
+    "dist",
+    "NOTICE"
   ],
   "engines": {
     "node": ">=22"
   },
   "dependencies": {
-    "@sdods/contracts": "0.11.2",
+    "@sdods/contracts": "0.12.0",
     "better-sqlite3": "^13.0.3",
     "kysely": "^0.29.5",
     "pg": "^8.23.0",