@sdods/db 0.2.0 → 0.2.1

package/dist/driver.d.ts

@@ -5,6 +5,15 @@ export interface DriverConfig {
     databaseUrl?: string;
 }
 export declare const DEFAULT_SQLITE_PATH = ".sdods/sdods.db";
+/**
+ * Nearest ancestor of `start` that looks like an SDODS workspace, or null.
+ *
+ * The default sqlite path is relative, and resolving it against the current directory meant every
+ * command opened a *different* database depending on where it was run from. `sdods serve` started
+ * inside a run's artifacts folder would silently create an empty database there and then reject
+ * every login, because the users live in the workspace database one or four levels up.
+ */
+export declare function findWorkspaceRoot(start?: string): string | null;
 /** Resolve the platform database driver from the environment (`DB_DRIVER`, `SQLITE_PATH`, `DATABASE_URL`). */
 export declare function resolveDriverConfig(env?: NodeJS.ProcessEnv): DriverConfig;
 //# sourceMappingURL=driver.d.ts.map

package/dist/driver.js

@@ -1,4 +1,29 @@
+import { existsSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
 export const DEFAULT_SQLITE_PATH = '.sdods/sdods.db';
+// Mirrors the markers ProjectRegistry.findRepoRoot looks for. Duplicated rather than imported
+// because @sdods/db must not depend on @sdods/core (core already depends on db).
+const WORKSPACE_MARKERS = ['sdods.workspace.yaml', 'sdods.config.ts', 'sdods.config.json'];
+/**
+ * Nearest ancestor of `start` that looks like an SDODS workspace, or null.
+ *
+ * The default sqlite path is relative, and resolving it against the current directory meant every
+ * command opened a *different* database depending on where it was run from. `sdods serve` started
+ * inside a run's artifacts folder would silently create an empty database there and then reject
+ * every login, because the users live in the workspace database one or four levels up.
+ */
+export function findWorkspaceRoot(start = process.cwd()) {
+    let dir = resolve(start);
+    for (let i = 0; i < 12; i++) {
+        if (WORKSPACE_MARKERS.some((m) => existsSync(join(dir, m))))
+            return dir;
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return null;
+}
 /** Resolve the platform database driver from the environment (`DB_DRIVER`, `SQLITE_PATH`, `DATABASE_URL`). */
 export function resolveDriverConfig(env = process.env) {
     const driver = (env.DB_DRIVER ?? 'sqlite').toLowerCase();
@@ -11,6 +36,15 @@ export function resolveDriverConfig(env = process.env) {
     if (driver !== 'sqlite') {
         throw new Error(`Unknown DB_DRIVER "${env.DB_DRIVER}". Use sqlite or postgres.`);
     }
-    return { driver: 'sqlite', sqlitePath: env.SQLITE_PATH ?? DEFAULT_SQLITE_PATH };
+    // An explicit SQLITE_PATH is taken at face value: the caller said where they want it. Only the
+    // default is anchored to the workspace, so `sdods serve` and `sdods users` agree on one database
+    // no matter which subdirectory they run from.
+    if (env.SQLITE_PATH)
+        return { driver: 'sqlite', sqlitePath: env.SQLITE_PATH };
+    const root = findWorkspaceRoot();
+    return {
+        driver: 'sqlite',
+        sqlitePath: root ? join(root, DEFAULT_SQLITE_PATH) : DEFAULT_SQLITE_PATH,
+    };
 }
 //# sourceMappingURL=driver.js.map

package/dist/ingest/cucumber-ingest.js

@@ -375,18 +375,6 @@ export class IngestSession {
                 const meta = json;
                 if (meta.dir)
                     a.dir = meta.dir;
-                // The runtime resolved the module from the project config (moduleForFeature), which is
-                // authoritative; the scenario row was inserted earlier with moduleFromUri(), a directory
-                // guess that is wrong whenever a module's `path` differs from its `name` (demo-shop's
-                // `posts-api` lives in features/api/, so the guess yields "api" and never joins to
-                // modules.name). Correct it now that the meta attachment has arrived.
-                if (meta.module) {
-                    await this.ctx.adb.db
-                        .updateTable('scenarios')
-                        .set({ module: meta.module })
-                        .where('id', '=', a.scenarioId)
-                        .execute();
-                }
             }
             else if (json) {
                 const stepIndex = parsed.stepIndex;

package/dist/repos/auth.d.ts

@@ -105,5 +105,6 @@ export declare function listApiTokens(db: Kysely<Database>, userId?: string): Pr
     revokedAt: string | null;
     createdAt: string | null;
 }[]>;
-export declare function revokeApiToken(db: Kysely<Database>, id: string): Promise<void>;
+/** True when a live token was revoked; false when the id is unknown or already revoked. */
+export declare function revokeApiToken(db: Kysely<Database>, id: string): Promise<boolean>;
 //# sourceMappingURL=auth.d.ts.map

package/dist/repos/auth.js

@@ -247,12 +247,14 @@ export async function listApiTokens(db, userId) {
         createdAt: readTs(r.created_at),
     }));
 }
+/** True when a live token was revoked; false when the id is unknown or already revoked. */
 export async function revokeApiToken(db, id) {
-    await db
+    const res = await db
         .updateTable('api_tokens')
         .set({ revoked_at: nowIso() })
         .where('id', '=', id)
         .where('revoked_at', 'is', null)
-        .execute();
+        .executeTakeFirst();
+    return Number(res?.numUpdatedRows ?? 0) > 0;
 }
 //# sourceMappingURL=auth.js.map

package/dist/repos/projects.d.ts

@@ -74,10 +74,10 @@ export declare function upsertEnvironment(db: Kysely<Database>, driver: Driver,
 }): Promise<string>;
 export declare function getEnvironment(db: Kysely<Database>, projectId: string, name: string): Promise<{
     id: string;
-    name: string;
-    config_json: Record<string, unknown>;
     created_at: string;
     updated_at: string;
+    name: string;
+    config_json: Record<string, unknown>;
     project_id: string;
     base_url: string | null;
     api_base_url: string | null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sdods/db",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "SDODS platform database: one schema on SQLite or Postgres, migrations, result ingest and insights.",
   "license": "Apache-2.0",
   "author": "SDODS <admin@sdods.com>",
@@ -23,7 +23,7 @@
     "node": ">=22"
   },
   "dependencies": {
-    "@sdods/contracts": "0.2.0",
+    "@sdods/contracts": "0.2.1",
     "better-sqlite3": "^13.0.3",
     "kysely": "^0.29.5",
     "pg": "^8.23.0",

package/dist/ingest/pw-json-ingest.d.ts

@@ -1,14 +0,0 @@
-import type { LocatorCounter } from './finalize.js';
-import { type IngestContext } from './types.js';
-export interface PwJsonCounts {
-    scenarios: number;
-    attempts: number;
-    steps: number;
-    artifacts: number;
-}
-/** Ingest a Playwright `json` reporter file (recorded layer / plain specs) into the same tables. */
-export declare function ingestPwJson(ctx: IngestContext, file: string, locatorCounters: Map<string, LocatorCounter>): Promise<PwJsonCounts & {
-    startedAt: string | null;
-    finishedAt: string | null;
-}>;
-//# sourceMappingURL=pw-json-ingest.d.ts.map

package/dist/ingest/pw-json-ingest.js

@@ -1,259 +0,0 @@
-import { existsSync, readFileSync } from 'node:fs';
-import { basename, dirname, isAbsolute, join, relative } from 'node:path';
-import { fingerprint as makeFingerprint, newId, parseRunnerProjectName } from '@sdods/contracts/ids';
-import { enc, nowIso } from '../col.js';
-import { artifactKindFor, parseAttachmentName, storeFile, targetFileFor } from './attachments.js';
-import { moduleFromUri, pwStatus, selectorFromError } from './types.js';
-/** Ingest a Playwright `json` reporter file (recorded layer / plain specs) into the same tables. */
-export async function ingestPwJson(ctx, file, locatorCounters) {
-    const report = JSON.parse(readFileSync(file, 'utf8'));
-    const counts = { scenarios: 0, attempts: 0, steps: 0, artifacts: 0 };
-    let startedAt = null;
-    let finishedAt = null;
-    const { db, driver } = ctx.adb;
-    const rootDir = report.config?.rootDir ?? dirname(file);
-    const walk = async (suite) => {
-        for (const s of suite.suites ?? [])
-            await walk(s);
-        for (const spec of suite.specs ?? []) {
-            for (const test of spec.tests ?? []) {
-                const pwProject = test.projectName ?? test.projectId ?? 'recorded';
-                const parts = parseRunnerProjectName(pwProject);
-                const slug = parts?.project ?? ctx.projectSlug;
-                const layer = parts?.layer ?? 'recorded';
-                const browser = parts?.browser ?? null;
-                const specFile = String(spec.file ?? suite.file ?? 'unknown.spec.ts').replace(/\\/g, '/');
-                const title = spec.title ?? test.title ?? 'untitled';
-                const fp = makeFingerprint({
-                    project: slug,
-                    featureUri: specFile,
-                    scenarioName: title,
-                    exampleIndex: null,
-                    layer,
-                });
-                const naturalKey = `${pwProject}:${test.id ?? `${specFile}:${spec.line ?? 0}`}`;
-                const tags = (spec.tags ?? test.tags ?? []).map((t) => t.startsWith('@') ? t : `@${t}`);
-                let scenarioId;
-                const existing = await db
-                    .selectFrom('scenarios')
-                    .select(['id'])
-                    .where('run_id', '=', ctx.runId)
-                    .where('natural_key', '=', naturalKey)
-                    .executeTakeFirst();
-                if (existing)
-                    scenarioId = existing.id;
-                else {
-                    scenarioId = newId();
-                    await db
-                        .insertInto('scenarios')
-                        .values({
-                        id: scenarioId,
-                        run_id: ctx.runId,
-                        project_id: ctx.projectId,
-                        natural_key: naturalKey,
-                        fingerprint: fp,
-                        source: 'pw-json',
-                        feature_uri: specFile,
-                        feature_name: suite.title ?? basename(specFile),
-                        scenario_name: title,
-                        module: moduleFromUri(specFile),
-                        examples_row: null,
-                        pw_project: pwProject,
-                        layer,
-                        browser,
-                        suite_tag: tags.find((t) => ['@smoke', '@regression', '@sanity'].includes(t)) ?? null,
-                        tags_json: enc.json(tags),
-                        jira_keys_json: enc.json(tags.filter((t) => t.startsWith('@jira:')).map((t) => t.slice(6))),
-                        status: 'unknown',
-                        attempts_count: 0,
-                        flaky: enc.bool(driver, false),
-                        duration_ms: null,
-                        error_message: null,
-                        error_stack: null,
-                        started_at: null,
-                        finished_at: null,
-                        created_at: nowIso(),
-                        updated_at: nowIso(),
-                    })
-                        .execute();
-                    counts.scenarios++;
-                }
-                for (const result of test.results ?? []) {
-                    const retry = Number(result.retry ?? 0);
-                    const tcsId = `${test.id ?? naturalKey}#${retry}`;
-                    const status = pwStatus(result.status);
-                    const started = result.startTime ? new Date(result.startTime).toISOString() : null;
-                    const finished = started && typeof result.duration === 'number'
-                        ? new Date(Date.parse(started) + result.duration).toISOString()
-                        : null;
-                    startedAt =
-                        !startedAt || (started && started < startedAt) ? (started ?? startedAt) : startedAt;
-                    finishedAt =
-                        !finishedAt || (finished && finished > finishedAt)
-                            ? (finished ?? finishedAt)
-                            : finishedAt;
-                    const errorMessage = result.error?.message ?? result.errors?.[0]?.message ?? null;
-                    const errorStack = result.error?.stack ?? result.errors?.[0]?.stack ?? null;
-                    if (status === 'failed' || status === 'timedOut') {
-                        const selector = selectorFromError(errorStack ?? errorMessage);
-                        if (selector) {
-                            const c = locatorCounters.get(selector) ?? { fails: 0, heals: 0, uses: 0 };
-                            c.fails++;
-                            c.uses++;
-                            locatorCounters.set(selector, c);
-                        }
-                    }
-                    let attemptId;
-                    const ex = await db
-                        .selectFrom('scenario_attempts')
-                        .select(['id'])
-                        .where('run_id', '=', ctx.runId)
-                        .where('test_case_started_id', '=', tcsId)
-                        .executeTakeFirst();
-                    const values = {
-                        attempt: retry,
-                        status,
-                        duration_ms: typeof result.duration === 'number' ? result.duration : null,
-                        error_message: errorMessage ? errorMessage.split('\n')[0].slice(0, 2000) : null,
-                        error_stack: errorStack,
-                        will_be_retried: enc.bool(driver, (status === 'failed' || status === 'timedOut') && retry < Number(test.retries ?? 0)),
-                        worker_index: typeof result.workerIndex === 'number' ? result.workerIndex : null,
-                        started_at: started,
-                        finished_at: finished,
-                    };
-                    if (ex) {
-                        attemptId = ex.id;
-                        await db
-                            .updateTable('scenario_attempts')
-                            .set(values)
-                            .where('id', '=', attemptId)
-                            .execute();
-                    }
-                    else {
-                        attemptId = newId();
-                        await db
-                            .insertInto('scenario_attempts')
-                            .values({
-                            id: attemptId,
-                            scenario_id: scenarioId,
-                            run_id: ctx.runId,
-                            test_case_started_id: tcsId,
-                            created_at: nowIso(),
-                            ...values,
-                        })
-                            .execute();
-                        counts.attempts++;
-                    }
-                    // steps (category test.step, top level)
-                    const steps = (result.steps ?? []).filter((s) => !s.category || s.category === 'test.step');
-                    let idx = 0;
-                    for (const st of steps) {
-                        const testStepId = `${tcsId}-step-${idx}`;
-                        const stepStatus = st.error ? 'failed' : 'passed';
-                        const sv = {
-                            step_index: idx,
-                            kind: 'step',
-                            hook_type: null,
-                            keyword: null,
-                            text: String(st.title ?? ''),
-                            argument_json: null,
-                            status: stepStatus,
-                            duration_ms: typeof st.duration === 'number' ? st.duration : null,
-                            error_message: st.error?.message
-                                ? String(st.error.message).split('\n')[0].slice(0, 2000)
-                                : null,
-                            error_stack: st.error?.stack ?? null,
-                            definition_location: st.location ? `${st.location.file}:${st.location.line}` : null,
-                            pickle_step_id: null,
-                            layer_hint: 'ui',
-                            started_at: null,
-                            finished_at: null,
-                        };
-                        const es = await db
-                            .selectFrom('steps')
-                            .select(['id'])
-                            .where('attempt_id', '=', attemptId)
-                            .where('test_step_id', '=', testStepId)
-                            .executeTakeFirst();
-                        if (es)
-                            await db.updateTable('steps').set(sv).where('id', '=', es.id).execute();
-                        else {
-                            await db
-                                .insertInto('steps')
-                                .values({
-                                id: newId(),
-                                attempt_id: attemptId,
-                                scenario_id: scenarioId,
-                                run_id: ctx.runId,
-                                test_step_id: testStepId,
-                                api_snapshot_json: null,
-                                perf_json: null,
-                                created_at: nowIso(),
-                                ...sv,
-                            })
-                                .execute();
-                            counts.steps++;
-                        }
-                        idx++;
-                    }
-                    // attachments
-                    const dir = join(ctx.runDir, slug, fp, `r${retry}`);
-                    for (const att of result.attachments ?? []) {
-                        const name = att.name ?? 'attachment';
-                        const mediaType = att.contentType ?? 'application/octet-stream';
-                        const parsed = parseAttachmentName(name);
-                        const filePath = att.path
-                            ? isAbsolute(att.path)
-                                ? att.path
-                                : join(rootDir, att.path)
-                            : undefined;
-                        const bytes = att.body ? Buffer.from(att.body, 'base64') : null;
-                        if (!bytes && !(filePath && existsSync(filePath)))
-                            continue;
-                        const stored = storeFile(ctx.artifactsRoot, dir, targetFileFor(parsed, name, mediaType), bytes, filePath);
-                        if (!stored)
-                            continue;
-                        const { kind, phase, stepIndex } = artifactKindFor(parsed, mediaType);
-                        const ea = await db
-                            .selectFrom('artifacts')
-                            .select(['id'])
-                            .where('rel_path', '=', stored.relPath)
-                            .executeTakeFirst();
-                        const av = {
-                            run_id: ctx.runId,
-                            scenario_id: scenarioId,
-                            attempt_id: attemptId,
-                            step_id: null,
-                            step_index: stepIndex,
-                            kind,
-                            phase,
-                            media_type: mediaType,
-                            file_name: name,
-                            size_bytes: stored.sizeBytes,
-                            sha256: stored.sha256,
-                            width: stored.width,
-                            height: stored.height,
-                            meta_json: enc.json({
-                                original: name,
-                                source: filePath ? relative(rootDir, filePath) : 'inline',
-                            }),
-                        };
-                        if (ea)
-                            await db.updateTable('artifacts').set(av).where('id', '=', ea.id).execute();
-                        else {
-                            await db
-                                .insertInto('artifacts')
-                                .values({ id: newId(), rel_path: stored.relPath, created_at: nowIso(), ...av })
-                                .execute();
-                            counts.artifacts++;
-                        }
-                    }
-                }
-            }
-        }
-    };
-    for (const s of report.suites ?? [])
-        await walk(s);
-    return { ...counts, startedAt, finishedAt };
-}
-//# sourceMappingURL=pw-json-ingest.js.map