@sdods/db 0.2.0

package/dist/repos/runs.d.ts

@@ -0,0 +1,306 @@
+import type { Kysely } from 'kysely';
+import type { RunRecord } from '@sdods/contracts/types';
+import type { Driver } from '../driver.js';
+import type { Database } from '../schema.js';
+export interface RunUpsert {
+    id: string;
+    projectId: string;
+    workspaceId?: string | null;
+    environmentId?: string | null;
+    envName: string;
+    process?: string | null;
+    trigger?: string;
+    status?: string;
+    suiteTag?: string | null;
+    tagsExpr?: string | null;
+    layers?: string[];
+    browsers?: string[];
+    shardTotal?: number | null;
+    gitSha?: string | null;
+    gitBranch?: string | null;
+    ciProvider?: string | null;
+    ciRunId?: string | null;
+    ciUrl?: string | null;
+    startedBy?: string | null;
+    command?: string | null;
+    startedAt?: string | null;
+    finishedAt?: string | null;
+    durationMs?: number | null;
+    totals?: Record<string, unknown>;
+    artifactsDir?: string | null;
+    htmlReportRel?: string | null;
+    exitCode?: number | null;
+    errorText?: string | null;
+}
+export declare function upsertRun(db: Kysely<Database>, _driver: Driver, r: RunUpsert): Promise<void>;
+export declare function getRun(db: Kysely<Database>, id: string): Promise<(RunRecord & {
+    projectId: string;
+    totalsRaw: Record<string, unknown>;
+}) | null>;
+export declare function listRuns(db: Kysely<Database>, opts?: {
+    projectSlug?: string;
+    status?: string;
+    env?: string;
+    limit?: number;
+    before?: string;
+}): Promise<(RunRecord & {
+    projectId: string;
+    totalsRaw: Record<string, unknown>;
+})[]>;
+export declare function mapRun(row: any): RunRecord & {
+    projectId: string;
+    totalsRaw: Record<string, unknown>;
+};
+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). */
+export declare function getRunScenarios(db: Kysely<Database>, runId: string): Promise<{
+    attempts: any[];
+    id: any;
+    runId: any;
+    projectId: any;
+    naturalKey: any;
+    fingerprint: any;
+    source: any;
+    featureUri: any;
+    featureName: any;
+    scenarioName: any;
+    module: any;
+    exampleIndex: any;
+    runnerProject: any;
+    layer: any;
+    browser: any;
+    suiteTag: any;
+    tags: string[];
+    jiraKeys: string[];
+    status: any;
+    attemptsCount: any;
+    flaky: boolean;
+    durationMs: any;
+    errorMessage: any;
+    errorStack: any;
+    startedAt: string | null;
+    finishedAt: string | null;
+}[]>;
+/** One scenario with steps and artifacts grouped by attempt. */
+export declare function getScenarioDetail(db: Kysely<Database>, scenarioId: string): Promise<{
+    attempts: {
+        steps: {
+            id: any;
+            attemptId: any;
+            scenarioId: any;
+            runId: any;
+            stepIndex: any;
+            kind: any;
+            hookType: any;
+            keyword: any;
+            text: any;
+            argument: unknown;
+            status: any;
+            durationMs: any;
+            errorMessage: any;
+            errorStack: any;
+            definitionLocation: any;
+            layerHint: any;
+            apiSnapshot: unknown;
+            perf: unknown;
+            startedAt: string | null;
+            finishedAt: string | null;
+        }[];
+        artifacts: {
+            id: any;
+            runId: any;
+            scenarioId: any;
+            attemptId: any;
+            stepId: any;
+            stepIndex: any;
+            kind: any;
+            phase: any;
+            mediaType: any;
+            fileName: any;
+            relPath: any;
+            sizeBytes: any;
+            sha256: any;
+            width: any;
+            height: any;
+            meta: Record<string, unknown> | null;
+        }[];
+        heals: {
+            id: any;
+            projectId: any;
+            runId: any;
+            scenarioId: any;
+            attemptId: any;
+            stepId: any;
+            pageUrl: any;
+            originalSelector: any;
+            context: Record<string, unknown>;
+            strategyUsed: any;
+            healedSelector: any;
+            candidates: unknown[];
+            succeeded: boolean;
+            durationMs: any;
+            source: any;
+            accepted: boolean | null;
+            createdAt: string | null;
+        }[];
+        id: any;
+        scenarioId: any;
+        attempt: any;
+        testCaseStartedId: any;
+        status: any;
+        durationMs: any;
+        errorMessage: any;
+        errorStack: any;
+        willBeRetried: boolean;
+        workerIndex: any;
+        startedAt: string | null;
+        finishedAt: string | null;
+    }[];
+    id: any;
+    runId: any;
+    projectId: any;
+    naturalKey: any;
+    fingerprint: any;
+    source: any;
+    featureUri: any;
+    featureName: any;
+    scenarioName: any;
+    module: any;
+    exampleIndex: any;
+    runnerProject: any;
+    layer: any;
+    browser: any;
+    suiteTag: any;
+    tags: string[];
+    jiraKeys: string[];
+    status: any;
+    attemptsCount: any;
+    flaky: boolean;
+    durationMs: any;
+    errorMessage: any;
+    errorStack: any;
+    startedAt: string | null;
+    finishedAt: string | null;
+} | null>;
+export declare function mapScenario(s: any): {
+    id: any;
+    runId: any;
+    projectId: any;
+    naturalKey: any;
+    fingerprint: any;
+    source: any;
+    featureUri: any;
+    featureName: any;
+    scenarioName: any;
+    module: any;
+    exampleIndex: any;
+    runnerProject: any;
+    layer: any;
+    browser: any;
+    suiteTag: any;
+    tags: string[];
+    jiraKeys: string[];
+    status: any;
+    attemptsCount: any;
+    flaky: boolean;
+    durationMs: any;
+    errorMessage: any;
+    errorStack: any;
+    startedAt: string | null;
+    finishedAt: string | null;
+};
+export declare function mapAttempt(a: any): {
+    id: any;
+    scenarioId: any;
+    attempt: any;
+    testCaseStartedId: any;
+    status: any;
+    durationMs: any;
+    errorMessage: any;
+    errorStack: any;
+    willBeRetried: boolean;
+    workerIndex: any;
+    startedAt: string | null;
+    finishedAt: string | null;
+};
+export declare function mapStep(s: any): {
+    id: any;
+    attemptId: any;
+    scenarioId: any;
+    runId: any;
+    stepIndex: any;
+    kind: any;
+    hookType: any;
+    keyword: any;
+    text: any;
+    argument: unknown;
+    status: any;
+    durationMs: any;
+    errorMessage: any;
+    errorStack: any;
+    definitionLocation: any;
+    layerHint: any;
+    apiSnapshot: unknown;
+    perf: unknown;
+    startedAt: string | null;
+    finishedAt: string | null;
+};
+export declare function mapArtifact(a: any): {
+    id: any;
+    runId: any;
+    scenarioId: any;
+    attemptId: any;
+    stepId: any;
+    stepIndex: any;
+    kind: any;
+    phase: any;
+    mediaType: any;
+    fileName: any;
+    relPath: any;
+    sizeBytes: any;
+    sha256: any;
+    width: any;
+    height: any;
+    meta: Record<string, unknown> | null;
+};
+export declare function mapHeal(h: any): {
+    id: any;
+    projectId: any;
+    runId: any;
+    scenarioId: any;
+    attemptId: any;
+    stepId: any;
+    pageUrl: any;
+    originalSelector: any;
+    context: Record<string, unknown>;
+    strategyUsed: any;
+    healedSelector: any;
+    candidates: unknown[];
+    succeeded: boolean;
+    durationMs: any;
+    source: any;
+    accepted: boolean | null;
+    createdAt: string | null;
+};
+export declare function getArtifact(db: Kysely<Database>, id: string): Promise<{
+    id: any;
+    runId: any;
+    scenarioId: any;
+    attemptId: any;
+    stepId: any;
+    stepIndex: any;
+    kind: any;
+    phase: any;
+    mediaType: any;
+    fileName: any;
+    relPath: any;
+    sizeBytes: any;
+    sha256: any;
+    width: any;
+    height: any;
+    meta: Record<string, unknown> | null;
+} | null>;
+export declare function newArtifactId(): string;
+export declare function stripUndefined<T extends Record<string, unknown>>(obj: T): Partial<T>;
+//# sourceMappingURL=runs.d.ts.map

package/dist/repos/runs.js

@@ -0,0 +1,321 @@
+import { enc, nowIso, readBool, readJson, readTs } from '../col.js';
+import { newId } from '../ids.js';
+export async function upsertRun(db, _driver, r) {
+    const existing = await db
+        .selectFrom('runs')
+        .select(['id', 'totals_json'])
+        .where('id', '=', r.id)
+        .executeTakeFirst();
+    const base = {
+        project_id: r.projectId,
+        environment_id: r.environmentId ?? null,
+        env_name: r.envName,
+        updated_at: nowIso(),
+    };
+    const optional = stripUndefined({
+        workspace_id: r.workspaceId,
+        process: r.process,
+        trigger: r.trigger,
+        status: r.status,
+        suite_tag: r.suiteTag,
+        tags_expr: r.tagsExpr,
+        layers_json: r.layers ? enc.json(r.layers) : undefined,
+        browsers_json: r.browsers ? enc.json(r.browsers) : undefined,
+        shard_total: r.shardTotal,
+        git_sha: r.gitSha,
+        git_branch: r.gitBranch,
+        ci_provider: r.ciProvider,
+        ci_run_id: r.ciRunId,
+        ci_url: r.ciUrl,
+        started_by: r.startedBy,
+        command: r.command,
+        started_at: r.startedAt,
+        finished_at: r.finishedAt,
+        duration_ms: r.durationMs,
+        totals_json: r.totals ? enc.json(r.totals) : undefined,
+        artifacts_dir: r.artifactsDir,
+        html_report_rel: r.htmlReportRel,
+        exit_code: r.exitCode,
+        error_text: r.errorText,
+    });
+    if (existing) {
+        await db
+            .updateTable('runs')
+            .set({ ...base, ...optional })
+            .where('id', '=', r.id)
+            .execute();
+        return;
+    }
+    await db
+        .insertInto('runs')
+        .values({
+        id: r.id,
+        created_at: nowIso(),
+        trigger: r.trigger ?? 'cli',
+        status: r.status ?? 'queued',
+        layers_json: enc.json(r.layers ?? []),
+        browsers_json: enc.json(r.browsers ?? []),
+        shards_ingested: 0,
+        totals_json: enc.json(r.totals ?? {}),
+        ...base,
+        ...optional,
+    })
+        .execute();
+}
+export async function getRun(db, id) {
+    const row = await db
+        .selectFrom('runs')
+        .innerJoin('projects', 'projects.id', 'runs.project_id')
+        .selectAll('runs')
+        .select('projects.slug as project_slug')
+        .where('runs.id', '=', id)
+        .executeTakeFirst();
+    return row ? mapRun(row) : null;
+}
+export async function listRuns(db, opts = {}) {
+    let q = db
+        .selectFrom('runs')
+        .innerJoin('projects', 'projects.id', 'runs.project_id')
+        .selectAll('runs')
+        .select('projects.slug as project_slug')
+        .orderBy('runs.created_at', 'desc')
+        .limit(opts.limit ?? 50);
+    if (opts.projectSlug)
+        q = q.where('projects.slug', '=', opts.projectSlug);
+    if (opts.status)
+        q = q.where('runs.status', '=', opts.status);
+    if (opts.env)
+        q = q.where('runs.env_name', '=', opts.env);
+    if (opts.before)
+        q = q.where('runs.created_at', '<', opts.before);
+    const rows = await q.execute();
+    return rows.map(mapRun);
+}
+export function mapRun(row) {
+    const totalsRaw = readJson(row.totals_json) ?? {};
+    const totals = totalsRaw.total !== undefined ? totalsRaw : undefined;
+    return {
+        id: row.id,
+        projectId: row.project_id,
+        projectSlug: row.project_slug,
+        workspaceId: row.workspace_id ?? null,
+        process: row.process ?? undefined,
+        env: row.env_name,
+        trigger: row.trigger,
+        status: row.status,
+        suiteTag: row.suite_tag ?? undefined,
+        tagsExpr: row.tags_expr ?? undefined,
+        layers: readJson(row.layers_json) ?? [],
+        browsers: readJson(row.browsers_json) ?? [],
+        gitSha: row.git_sha ?? undefined,
+        gitBranch: row.git_branch ?? undefined,
+        ciProvider: row.ci_provider ?? undefined,
+        ciRunId: row.ci_run_id ?? undefined,
+        ciUrl: row.ci_url ?? undefined,
+        startedAt: readTs(row.started_at) ?? undefined,
+        finishedAt: readTs(row.finished_at) ?? undefined,
+        durationMs: row.duration_ms ?? undefined,
+        totals,
+        totalsRaw,
+        artifactsDir: row.artifacts_dir ?? undefined,
+        exitCode: row.exit_code ?? undefined,
+        errorText: row.error_text ?? undefined,
+    };
+}
+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();
+    await db.deleteFrom('artifacts').where('run_id', '=', runId).execute();
+    await db.deleteFrom('steps').where('run_id', '=', runId).execute();
+    await db.deleteFrom('scenario_attempts').where('run_id', '=', runId).execute();
+    await db.deleteFrom('scenarios').where('run_id', '=', runId).execute();
+}
+export async function deleteRun(db, runId) {
+    await deleteRunChildren(db, runId);
+    await db.deleteFrom('runs').where('id', '=', runId).execute();
+}
+/** Scenario tree for a run: scenarios with their attempts (no steps). */
+export async function getRunScenarios(db, runId) {
+    const scenarios = await db
+        .selectFrom('scenarios')
+        .selectAll()
+        .where('run_id', '=', runId)
+        .orderBy('feature_uri')
+        .orderBy('scenario_name')
+        .execute();
+    const attempts = await db
+        .selectFrom('scenario_attempts')
+        .selectAll()
+        .where('run_id', '=', runId)
+        .orderBy('attempt')
+        .execute();
+    const byScenario = new Map();
+    for (const a of attempts) {
+        const list = byScenario.get(a.scenario_id) ?? [];
+        list.push(mapAttempt(a));
+        byScenario.set(a.scenario_id, list);
+    }
+    return scenarios.map((s) => ({ ...mapScenario(s), attempts: byScenario.get(s.id) ?? [] }));
+}
+/** One scenario with steps and artifacts grouped by attempt. */
+export async function getScenarioDetail(db, scenarioId) {
+    const scenario = await db
+        .selectFrom('scenarios')
+        .selectAll()
+        .where('id', '=', scenarioId)
+        .executeTakeFirst();
+    if (!scenario)
+        return null;
+    const attempts = await db
+        .selectFrom('scenario_attempts')
+        .selectAll()
+        .where('scenario_id', '=', scenarioId)
+        .orderBy('attempt')
+        .execute();
+    const steps = await db
+        .selectFrom('steps')
+        .selectAll()
+        .where('scenario_id', '=', scenarioId)
+        .orderBy('step_index')
+        .execute();
+    const artifacts = await db
+        .selectFrom('artifacts')
+        .selectAll()
+        .where('scenario_id', '=', scenarioId)
+        .execute();
+    const heals = await db
+        .selectFrom('heal_events')
+        .selectAll()
+        .where('scenario_id', '=', scenarioId)
+        .execute();
+    return {
+        ...mapScenario(scenario),
+        attempts: attempts.map((a) => ({
+            ...mapAttempt(a),
+            steps: steps.filter((s) => s.attempt_id === a.id).map(mapStep),
+            artifacts: artifacts.filter((x) => x.attempt_id === a.id).map(mapArtifact),
+            heals: heals.filter((h) => h.attempt_id === a.id).map(mapHeal),
+        })),
+    };
+}
+export function mapScenario(s) {
+    return {
+        id: s.id,
+        runId: s.run_id,
+        projectId: s.project_id,
+        naturalKey: s.natural_key,
+        fingerprint: s.fingerprint,
+        source: s.source,
+        featureUri: s.feature_uri,
+        featureName: s.feature_name,
+        scenarioName: s.scenario_name,
+        module: s.module ?? null,
+        exampleIndex: s.examples_row,
+        runnerProject: s.runner_project,
+        layer: s.layer,
+        browser: s.browser,
+        suiteTag: s.suite_tag,
+        tags: readJson(s.tags_json) ?? [],
+        jiraKeys: readJson(s.jira_keys_json) ?? [],
+        status: s.status,
+        attemptsCount: s.attempts_count,
+        flaky: readBool(s.flaky),
+        durationMs: s.duration_ms,
+        errorMessage: s.error_message,
+        errorStack: s.error_stack,
+        startedAt: readTs(s.started_at),
+        finishedAt: readTs(s.finished_at),
+    };
+}
+export function mapAttempt(a) {
+    return {
+        id: a.id,
+        scenarioId: a.scenario_id,
+        attempt: a.attempt,
+        testCaseStartedId: a.test_case_started_id,
+        status: a.status,
+        durationMs: a.duration_ms,
+        errorMessage: a.error_message,
+        errorStack: a.error_stack,
+        willBeRetried: readBool(a.will_be_retried),
+        workerIndex: a.worker_index,
+        startedAt: readTs(a.started_at),
+        finishedAt: readTs(a.finished_at),
+    };
+}
+export function mapStep(s) {
+    return {
+        id: s.id,
+        attemptId: s.attempt_id,
+        scenarioId: s.scenario_id,
+        runId: s.run_id,
+        stepIndex: s.step_index,
+        kind: s.kind,
+        hookType: s.hook_type,
+        keyword: s.keyword,
+        text: s.text,
+        argument: readJson(s.argument_json),
+        status: s.status,
+        durationMs: s.duration_ms,
+        errorMessage: s.error_message,
+        errorStack: s.error_stack,
+        definitionLocation: s.definition_location,
+        layerHint: s.layer_hint,
+        apiSnapshot: readJson(s.api_snapshot_json),
+        perf: readJson(s.perf_json),
+        startedAt: readTs(s.started_at),
+        finishedAt: readTs(s.finished_at),
+    };
+}
+export function mapArtifact(a) {
+    return {
+        id: a.id,
+        runId: a.run_id,
+        scenarioId: a.scenario_id,
+        attemptId: a.attempt_id,
+        stepId: a.step_id,
+        stepIndex: a.step_index,
+        kind: a.kind,
+        phase: a.phase,
+        mediaType: a.media_type,
+        fileName: a.file_name,
+        relPath: a.rel_path,
+        sizeBytes: a.size_bytes,
+        sha256: a.sha256,
+        width: a.width,
+        height: a.height,
+        meta: readJson(a.meta_json),
+    };
+}
+export function mapHeal(h) {
+    return {
+        id: h.id,
+        projectId: h.project_id,
+        runId: h.run_id,
+        scenarioId: h.scenario_id,
+        attemptId: h.attempt_id,
+        stepId: h.step_id,
+        pageUrl: h.page_url,
+        originalSelector: h.original_selector,
+        context: readJson(h.context_json) ?? {},
+        strategyUsed: h.strategy_used,
+        healedSelector: h.healed_selector,
+        candidates: readJson(h.candidates_json) ?? [],
+        succeeded: readBool(h.succeeded),
+        durationMs: h.duration_ms,
+        source: h.source,
+        accepted: h.accepted == null ? null : readBool(h.accepted),
+        createdAt: readTs(h.created_at),
+    };
+}
+export async function getArtifact(db, id) {
+    const row = await db.selectFrom('artifacts').selectAll().where('id', '=', id).executeTakeFirst();
+    return row ? mapArtifact(row) : null;
+}
+export function newArtifactId() {
+    return newId();
+}
+export function stripUndefined(obj) {
+    return Object.fromEntries(Object.entries(obj).filter(([, v]) => v !== undefined));
+}
+//# sourceMappingURL=runs.js.map

package/dist/repos/test-data.d.ts

@@ -0,0 +1,84 @@
+import type { Kysely } from 'kysely';
+import type { Driver } from '../driver.js';
+import type { Database } from '../schema.js';
+type Row = Record<string, unknown>;
+export declare function upsertDataset(db: Kysely<Database>, _driver: Driver, input: {
+    projectId: string;
+    envKey?: string;
+    name: string;
+    kind: string;
+    storage?: 'db' | 'file';
+    sourcePath?: string | null;
+    rows?: Row[];
+    createdBy?: string | null;
+}): Promise<{
+    id: string;
+    rowCount: number;
+}>;
+export declare function listDatasets(db: Kysely<Database>, projectId: string): Promise<{
+    id: string;
+    envKey: string;
+    name: string;
+    kind: string;
+    storage: string;
+    sourcePath: string | null;
+    columns: string[];
+    rowCount: number;
+    contentHash: string | null;
+    updatedAt: string | null;
+}[]>;
+export declare function getDatasetRows(db: Kysely<Database>, datasetId: string, opts?: {
+    offset?: number;
+    limit?: number;
+}): Promise<{
+    index: number;
+    data: Row;
+}[]>;
+/** Resolve a dataset for an env: exact env first, then `*`. */
+export declare function loadDatasetRows(db: Kysely<Database>, projectId: string, name: string, env: string): Promise<Row[] | null>;
+export declare function upsertPoolUser(db: Kysely<Database>, driver: Driver, input: {
+    projectId: string;
+    environmentId?: string | null;
+    envName: string;
+    poolName?: string;
+    username: string;
+    secretRef?: string | null;
+    role?: string;
+    storageStateRel?: string | null;
+    attributes?: Record<string, unknown>;
+    enabled?: boolean;
+}): Promise<string>;
+/**
+ * Lease one enabled user of `role` that has no active lease. Single conditional insert per candidate;
+ * on both dialects the unique-ish check is enforced by re-reading after insert.
+ */
+export declare function leasePoolUser(db: Kysely<Database>, input: {
+    projectId: string;
+    envName: string;
+    poolName?: string;
+    role: string;
+    holder: string;
+    runId?: string;
+    workerIndex?: number;
+    ttlMs: number;
+}): Promise<{
+    leaseId: string;
+    userId: string;
+    username: string;
+    secretRef: string | null;
+    role: string;
+    attributes: Record<string, unknown>;
+} | null>;
+export declare function releaseLease(db: Kysely<Database>, leaseId: string): Promise<void>;
+export declare function releaseLeasesByHolder(db: Kysely<Database>, holder: string): Promise<number>;
+export declare function poolStatus(db: Kysely<Database>, projectId: string, envName: string): Promise<{
+    id: string;
+    username: string;
+    role: string;
+    enabled: boolean;
+    leased: boolean;
+    holder: string | null;
+    expiresAt: string | null;
+}[]>;
+export {};
+//# sourceMappingURL=test-data.d.ts.map