@sdods/db 0.2.0

package/dist/driver.d.ts

@@ -0,0 +1,10 @@
+export type Driver = 'sqlite' | 'postgres';
+export interface DriverConfig {
+    driver: Driver;
+    sqlitePath?: string;
+    databaseUrl?: string;
+}
+export declare const DEFAULT_SQLITE_PATH = ".sdods/sdods.db";
+/** 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

@@ -0,0 +1,16 @@
+export const DEFAULT_SQLITE_PATH = '.sdods/sdods.db';
+/** 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();
+    if (driver === 'postgres' || driver === 'postgresql' || driver === 'pg') {
+        if (!env.DATABASE_URL) {
+            throw new Error('DB_DRIVER=postgres requires DATABASE_URL (e.g. postgres://sdods:sdods@localhost:5432/sdods)');
+        }
+        return { driver: 'postgres', databaseUrl: env.DATABASE_URL };
+    }
+    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 };
+}
+//# sourceMappingURL=driver.js.map

package/dist/ids.d.ts

@@ -0,0 +1,2 @@
+export { newId, uuidv7, fingerprint, parseRunnerProjectName, runnerProjectName, } from '@sdods/contracts/ids';
+//# sourceMappingURL=ids.d.ts.map

package/dist/ids.js

@@ -0,0 +1,2 @@
+export { newId, uuidv7, fingerprint, parseRunnerProjectName, runnerProjectName, } from '@sdods/contracts/ids';
+//# sourceMappingURL=ids.js.map

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+export * from './driver.js';
+export * from './create-db.js';
+export * from './col.js';
+export * from './ids.js';
+export * from './schema.js';
+export * from './migrate.js';
+export * from './repos/index.js';
+export * from './ingest/index.js';
+export * from './switch/index.js';
+export * from './insights.js';
+export * from './test-data.js';
+export * from './scopes.js';
+import { type SdodsDb } from './create-db.js';
+import { type DriverConfig } from './driver.js';
+/** Open + migrate in one call (what `sdods serve` and `sdods run --ingest` do on boot). */
+export declare function openDb(cfg?: DriverConfig): Promise<SdodsDb>;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,22 @@
+export * from './driver.js';
+export * from './create-db.js';
+export * from './col.js';
+export * from './ids.js';
+export * from './schema.js';
+export * from './migrate.js';
+export * from './repos/index.js';
+export * from './ingest/index.js';
+export * from './switch/index.js';
+export * from './insights.js';
+export * from './test-data.js';
+export * from './scopes.js';
+import { createDb } from './create-db.js';
+import { resolveDriverConfig } from './driver.js';
+import { migrateToLatest } from './migrate.js';
+/** Open + migrate in one call (what `sdods serve` and `sdods run --ingest` do on boot). */
+export async function openDb(cfg = resolveDriverConfig()) {
+    const adb = createDb(cfg);
+    await migrateToLatest(adb);
+    return adb;
+}
+//# sourceMappingURL=index.js.map

package/dist/ingest/attachments.d.ts

@@ -0,0 +1,40 @@
+import { basename } from 'node:path';
+import { parseAttachmentName, type ParsedAttachment } from '@sdods/contracts/names';
+export interface StoredFile {
+    relPath: string;
+    absPath: string;
+    sizeBytes: number;
+    sha256: string;
+    width: number | null;
+    height: number | null;
+}
+export interface AttachmentInput {
+    fileName: string;
+    mediaType: string;
+    body?: string;
+    contentEncoding?: 'IDENTITY' | 'BASE64';
+    /** absolute or run-relative path when the reporter kept the file external */
+    url?: string;
+}
+/** Decode an attachment body to bytes (base64 or identity). */
+export declare function attachmentBytes(a: AttachmentInput): Buffer | null;
+/** Text body as string (JSON attachments are IDENTITY-encoded by playwright-bdd). */
+export declare function attachmentText(a: AttachmentInput): string | null;
+export declare function safeName(name: string): string;
+/** Target file name inside the scenario attempt dir for a parsed SDODS attachment. */
+export declare function targetFileFor(parsed: ParsedAttachment, original: string, mediaType: string): string;
+export declare function extFor(mediaType: string): string;
+/** Write bytes to `<dir>/<file>` unless an identical file already exists there; returns metadata. */
+export declare function storeFile(artifactsRoot: string, dir: string, file: string, bytes: Buffer | null, sourcePath?: string): StoredFile | null;
+/** Read width/height from a PNG IHDR chunk. */
+export declare function pngDimensions(buf: Buffer): {
+    width: number;
+    height: number;
+} | null;
+export declare function artifactKindFor(parsed: ParsedAttachment, mediaType: string): {
+    kind: string;
+    phase: string | null;
+    stepIndex: number | null;
+};
+export { parseAttachmentName, basename };
+//# sourceMappingURL=attachments.d.ts.map

package/dist/ingest/attachments.js

@@ -0,0 +1,154 @@
+import { createHash } from 'node:crypto';
+import { copyFileSync, existsSync, mkdirSync, readFileSync, statSync, writeFileSync, } from 'node:fs';
+import { basename, dirname, join, relative } from 'node:path';
+import { parseAttachmentName, scenarioFiles } from '@sdods/contracts/names';
+/** Decode an attachment body to bytes (base64 or identity). */
+export function attachmentBytes(a) {
+    if (a.url && existsSync(a.url))
+        return readFileSync(a.url);
+    if (a.body === undefined)
+        return null;
+    return a.contentEncoding === 'BASE64'
+        ? Buffer.from(a.body, 'base64')
+        : Buffer.from(a.body, 'utf8');
+}
+/** Text body as string (JSON attachments are IDENTITY-encoded by playwright-bdd). */
+export function attachmentText(a) {
+    const bytes = attachmentBytes(a);
+    return bytes ? bytes.toString('utf8') : null;
+}
+export function safeName(name) {
+    return name.replace(/[^A-Za-z0-9._-]+/g, '_').replace(/^_+/, '') || 'attachment';
+}
+/** Target file name inside the scenario attempt dir for a parsed SDODS attachment. */
+export function targetFileFor(parsed, original, mediaType) {
+    switch (parsed.kind) {
+        case 'shot-scenario':
+            return scenarioFiles.scenarioShot(parsed.phase);
+        case 'shot-step':
+            return scenarioFiles.stepShot(parsed.stepIndex, parsed.phase);
+        case 'visual':
+            return `visual/${String(parsed.stepIndex).padStart(2, '0')}-${safeName(parsed.name)}${extFor(mediaType)}`;
+        case 'api':
+            return scenarioFiles.apiJson(parsed.stepIndex, parsed.callIndex, parsed.part);
+        case 'perf':
+            return scenarioFiles.perfJson(parsed.stepIndex);
+        case 'a11y':
+            return scenarioFiles.a11yJson(parsed.stepIndex);
+        case 'heal':
+            return `heal/${String(parsed.stepIndex).padStart(2, '0')}-${parsed.n}.json`;
+        case 'cleanup-errors':
+            return 'cleanup-errors.json';
+        case 'meta':
+            return scenarioFiles.meta;
+        case 'visual-baseline':
+            return `visual/${safeName(parsed.name)}-${parsed.phase}.png`;
+        case 'runner-builtin':
+            return parsed.name === 'trace'
+                ? 'trace.zip'
+                : parsed.name === 'video'
+                    ? `video${extFor(mediaType) || '.webm'}`
+                    : 'failure-pw.png';
+        default:
+            return `attachments/${safeName(original)}${extFor(mediaType)}`;
+    }
+}
+export function extFor(mediaType) {
+    if (!mediaType)
+        return '';
+    if (mediaType.includes('png'))
+        return '.png';
+    if (mediaType.includes('jpeg') || mediaType.includes('jpg'))
+        return '.jpg';
+    if (mediaType.includes('webm'))
+        return '.webm';
+    if (mediaType.includes('zip'))
+        return '.zip';
+    if (mediaType.includes('json'))
+        return '.json';
+    if (mediaType.includes('html'))
+        return '.html';
+    if (mediaType.startsWith('text/'))
+        return '.txt';
+    return '';
+}
+/** Write bytes to `<dir>/<file>` unless an identical file already exists there; returns metadata. */
+export function storeFile(artifactsRoot, dir, file, bytes, sourcePath) {
+    const abs = join(dir, file);
+    mkdirSync(dirname(abs), { recursive: true });
+    if (!existsSync(abs)) {
+        if (bytes)
+            writeFileSync(abs, bytes);
+        else if (sourcePath && existsSync(sourcePath))
+            copyFileSync(sourcePath, abs);
+        else
+            return null;
+    }
+    const data = readFileSync(abs);
+    const dims = pngDimensions(data);
+    return {
+        relPath: relative(artifactsRoot, abs).replace(/\\/g, '/'),
+        absPath: abs,
+        sizeBytes: statSync(abs).size,
+        sha256: createHash('sha256').update(data).digest('hex'),
+        width: dims?.width ?? null,
+        height: dims?.height ?? null,
+    };
+}
+/** Read width/height from a PNG IHDR chunk. */
+export function pngDimensions(buf) {
+    if (buf.length < 24)
+        return null;
+    if (buf.readUInt32BE(0) !== 0x89504e47)
+        return null;
+    return { width: buf.readUInt32BE(16), height: buf.readUInt32BE(20) };
+}
+export function artifactKindFor(parsed, mediaType) {
+    switch (parsed.kind) {
+        case 'shot-scenario':
+            return {
+                kind: 'screenshot',
+                phase: parsed.phase === 'start'
+                    ? 'scenario-start'
+                    : parsed.phase === 'end'
+                        ? 'scenario-end'
+                        : 'failure',
+                stepIndex: null,
+            };
+        case 'shot-step':
+            return { kind: 'screenshot', phase: parsed.phase, stepIndex: parsed.stepIndex };
+        case 'visual':
+            return { kind: 'visual', phase: 'actual', stepIndex: parsed.stepIndex };
+        case 'visual-baseline':
+            return { kind: 'visual', phase: parsed.phase, stepIndex: null };
+        case 'runner-builtin':
+            return {
+                kind: parsed.name === 'screenshot' ? 'screenshot' : parsed.name,
+                phase: parsed.name === 'screenshot' ? 'failure' : null,
+                stepIndex: null,
+            };
+        case 'api':
+        case 'heal':
+        case 'perf':
+        case 'a11y':
+        case 'cleanup-errors':
+        case 'meta':
+            return {
+                kind: 'attachment',
+                phase: null,
+                stepIndex: 'stepIndex' in parsed ? parsed.stepIndex : null,
+            };
+        default:
+            return {
+                kind: mediaType.startsWith('image/')
+                    ? 'screenshot'
+                    : mediaType.includes('zip')
+                        ? 'trace'
+                        : 'attachment',
+                phase: null,
+                stepIndex: null,
+            };
+    }
+}
+export { parseAttachmentName, basename };
+//# sourceMappingURL=attachments.js.map

package/dist/ingest/cucumber-ingest.d.ts

@@ -0,0 +1,40 @@
+import type { LocatorCounter } from './finalize.js';
+import { MessageIndex } from './message-index.js';
+import type { Envelope } from './parse-ndjson.js';
+import { type IngestContext } from './types.js';
+export interface CucumberIngestCounts {
+    scenarios: number;
+    attempts: number;
+    steps: number;
+    artifacts: number;
+    healEvents: number;
+}
+/**
+ * State machine over cucumber message envelopes. Static messages are indexed; dynamic ones are
+ * upserted immediately with natural keys so re-ingest converges.
+ */
+export declare class IngestSession {
+    private readonly ctx;
+    readonly idx: MessageIndex;
+    readonly locatorCounters: Map<string, LocatorCounter>;
+    readonly counts: CucumberIngestCounts;
+    runStartedAt: string | null;
+    runFinishedAt: string | null;
+    private readonly attempts;
+    private readonly pendingStepStart;
+    private readonly seenScenarios;
+    private readonly pendingTestCases;
+    constructor(ctx: IngestContext);
+    consume(env: Envelope): Promise<void>;
+    private onAttemptStarted;
+    private onStepFinished;
+    private readonly pendingPayloads;
+    /** Apply a structured (JSON) attachment to its step row / heal table. */
+    private applyStructured;
+    private onAttachment;
+    private onAttemptFinished;
+    private stepRowByIndex;
+}
+export declare function layerFromTags(tags: string[]): 'ui' | 'api' | 'hybrid' | null;
+export declare function suiteFromTags(tags: string[]): string | null;
+//# sourceMappingURL=cucumber-ingest.d.ts.map