@sdods/db 0.2.0

package/dist/repos/hierarchy.js

@@ -0,0 +1,465 @@
+import { effectiveWorkspaceRole, } from '@sdods/contracts/scopes';
+import { enc, nowIso, readBool, readJson, readTs } from '../col.js';
+import { newId } from '../ids.js';
+import { upsertProject } from './projects.js';
+// ── organizations / workspaces ────────────────────────────────────────────
+export async function upsertOrganization(db, input) {
+    const existing = await db
+        .selectFrom('organizations')
+        .select(['id'])
+        .where('slug', '=', input.slug)
+        .executeTakeFirst();
+    const values = {
+        name: input.name,
+        description: input.description ?? null,
+        url: input.url ?? null,
+        updated_at: nowIso(),
+    };
+    if (existing) {
+        await db.updateTable('organizations').set(values).where('id', '=', existing.id).execute();
+        return existing.id;
+    }
+    const id = newId();
+    await db
+        .insertInto('organizations')
+        .values({ id, slug: input.slug, created_at: nowIso(), ...values })
+        .execute();
+    return id;
+}
+export async function upsertWorkspace(db, input) {
+    const existing = await db
+        .selectFrom('workspaces')
+        .select(['id'])
+        .where('organization_id', '=', input.organizationId)
+        .where('slug', '=', input.slug)
+        .executeTakeFirst();
+    const values = { name: input.name, description: input.description ?? null, updated_at: nowIso() };
+    if (existing) {
+        await db.updateTable('workspaces').set(values).where('id', '=', existing.id).execute();
+        return existing.id;
+    }
+    const id = newId();
+    await db
+        .insertInto('workspaces')
+        .values({
+        id,
+        organization_id: input.organizationId,
+        slug: input.slug,
+        created_at: nowIso(),
+        ...values,
+    })
+        .execute();
+    return id;
+}
+export async function listOrganizations(db) {
+    const rows = await db.selectFrom('organizations').selectAll().orderBy('slug').execute();
+    return rows.map((o) => ({
+        id: o.id,
+        slug: o.slug,
+        name: o.name,
+        description: o.description,
+        url: o.url,
+        createdAt: readTs(o.created_at),
+    }));
+}
+export async function listWorkspaces(db, organizationId) {
+    let q = db
+        .selectFrom('workspaces')
+        .innerJoin('organizations', 'organizations.id', 'workspaces.organization_id')
+        .selectAll('workspaces')
+        .select('organizations.slug as org_slug')
+        .orderBy('workspaces.slug');
+    if (organizationId)
+        q = q.where('workspaces.organization_id', '=', organizationId);
+    const rows = await q.execute();
+    return rows.map(mapWorkspace);
+}
+export async function getWorkspaceBySlug(db, orgSlug, slug) {
+    const row = await db
+        .selectFrom('workspaces')
+        .innerJoin('organizations', 'organizations.id', 'workspaces.organization_id')
+        .selectAll('workspaces')
+        .select('organizations.slug as org_slug')
+        .where('organizations.slug', '=', orgSlug)
+        .where('workspaces.slug', '=', slug)
+        .executeTakeFirst();
+    return row ? mapWorkspace(row) : null;
+}
+function mapWorkspace(w) {
+    return {
+        id: w.id,
+        organizationId: w.organization_id,
+        organizationSlug: w.org_slug,
+        slug: w.slug,
+        name: w.name,
+        description: w.description,
+        createdAt: readTs(w.created_at),
+    };
+}
+// ── memberships ───────────────────────────────────────────────────────────
+export async function addOrgMember(db, organizationId, userId, role) {
+    const existing = await db
+        .selectFrom('org_members')
+        .select(['id'])
+        .where('organization_id', '=', organizationId)
+        .where('user_id', '=', userId)
+        .executeTakeFirst();
+    if (existing) {
+        await db.updateTable('org_members').set({ role }).where('id', '=', existing.id).execute();
+        return;
+    }
+    await db
+        .insertInto('org_members')
+        .values({
+        id: newId(),
+        organization_id: organizationId,
+        user_id: userId,
+        role,
+        created_at: nowIso(),
+    })
+        .execute();
+}
+export async function removeOrgMember(db, organizationId, userId) {
+    await db
+        .deleteFrom('org_members')
+        .where('organization_id', '=', organizationId)
+        .where('user_id', '=', userId)
+        .execute();
+}
+export async function addWorkspaceMember(db, workspaceId, userId, role) {
+    const existing = await db
+        .selectFrom('workspace_members')
+        .select(['id'])
+        .where('workspace_id', '=', workspaceId)
+        .where('user_id', '=', userId)
+        .executeTakeFirst();
+    if (existing) {
+        await db.updateTable('workspace_members').set({ role }).where('id', '=', existing.id).execute();
+        return;
+    }
+    await db
+        .insertInto('workspace_members')
+        .values({ id: newId(), workspace_id: workspaceId, user_id: userId, role, created_at: nowIso() })
+        .execute();
+}
+export async function removeWorkspaceMember(db, workspaceId, userId) {
+    await db
+        .deleteFrom('workspace_members')
+        .where('workspace_id', '=', workspaceId)
+        .where('user_id', '=', userId)
+        .execute();
+}
+/** `setRole` for either level. */
+export async function setRole(db, target) {
+    if ('organizationId' in target)
+        return addOrgMember(db, target.organizationId, target.userId, target.role);
+    return addWorkspaceMember(db, target.workspaceId, target.userId, target.role);
+}
+export async function listOrgMembers(db, organizationId) {
+    const rows = await db
+        .selectFrom('org_members')
+        .innerJoin('users', 'users.id', 'org_members.user_id')
+        .select([
+        'org_members.id as id',
+        'org_members.user_id as user_id',
+        'users.username as username',
+        'org_members.role as role',
+        'org_members.created_at as created_at',
+    ])
+        .where('org_members.organization_id', '=', organizationId)
+        .orderBy('users.username')
+        .execute();
+    return rows.map((r) => ({
+        id: r.id,
+        userId: r.user_id,
+        username: r.username,
+        role: r.role,
+        createdAt: readTs(r.created_at),
+    }));
+}
+export async function listWorkspaceMembers(db, workspaceId) {
+    const rows = await db
+        .selectFrom('workspace_members')
+        .innerJoin('users', 'users.id', 'workspace_members.user_id')
+        .select([
+        'workspace_members.id as id',
+        'workspace_members.user_id as user_id',
+        'users.username as username',
+        'workspace_members.role as role',
+        'workspace_members.created_at as created_at',
+    ])
+        .where('workspace_members.workspace_id', '=', workspaceId)
+        .orderBy('users.username')
+        .execute();
+    return rows.map((r) => ({
+        id: r.id,
+        userId: r.user_id,
+        username: r.username,
+        role: r.role,
+        createdAt: readTs(r.created_at),
+    }));
+}
+export async function listUserOrgs(db, userId) {
+    const rows = await db
+        .selectFrom('org_members')
+        .innerJoin('organizations', 'organizations.id', 'org_members.organization_id')
+        .select([
+        'organizations.id as id',
+        'organizations.slug as slug',
+        'organizations.name as name',
+        'org_members.role as role',
+    ])
+        .where('org_members.user_id', '=', userId)
+        .orderBy('organizations.slug')
+        .execute();
+    return rows.map((r) => ({ id: r.id, slug: r.slug, name: r.name, role: r.role }));
+}
+/**
+ * Every workspace the user can see with the effective role (max of explicit workspace role and the
+ * role implied by org membership; platform admins see everything as admin).
+ */
+export async function listUserWorkspaces(db, userId, platformRole) {
+    const orgRoles = new Map();
+    for (const o of await listUserOrgs(db, userId))
+        orgRoles.set(o.id, o.role);
+    const wsRoles = new Map();
+    const memberships = await db
+        .selectFrom('workspace_members')
+        .select(['workspace_id', 'role'])
+        .where('user_id', '=', userId)
+        .execute();
+    for (const m of memberships)
+        wsRoles.set(m.workspace_id, m.role);
+    const all = await listWorkspaces(db);
+    const out = [];
+    for (const w of all) {
+        const role = effectiveWorkspaceRole({
+            platformRole,
+            orgRole: orgRoles.get(w.organizationId),
+            workspaceRole: wsRoles.get(w.id),
+        });
+        if (role)
+            out.push({ ...w, role });
+    }
+    return out;
+}
+export async function effectiveRoleForWorkspace(db, userId, workspaceId, platformRole) {
+    const ws = await db
+        .selectFrom('workspaces')
+        .select(['organization_id'])
+        .where('id', '=', workspaceId)
+        .executeTakeFirst();
+    if (!ws)
+        return null;
+    const org = await db
+        .selectFrom('org_members')
+        .select(['role'])
+        .where('organization_id', '=', ws.organization_id)
+        .where('user_id', '=', userId)
+        .executeTakeFirst();
+    const m = await db
+        .selectFrom('workspace_members')
+        .select(['role'])
+        .where('workspace_id', '=', workspaceId)
+        .where('user_id', '=', userId)
+        .executeTakeFirst();
+    return effectiveWorkspaceRole({
+        platformRole,
+        orgRole: org?.role,
+        workspaceRole: m?.role,
+    });
+}
+/** Grant `owner` on every organization that has no owner yet (admin bootstrap). */
+export async function bootstrapOwner(db, userId) {
+    const orgs = await db.selectFrom('organizations').select(['id', 'slug']).execute();
+    const granted = [];
+    for (const o of orgs) {
+        const owner = await db
+            .selectFrom('org_members')
+            .select(['id'])
+            .where('organization_id', '=', o.id)
+            .where('role', '=', 'owner')
+            .executeTakeFirst();
+        if (owner)
+            continue;
+        await addOrgMember(db, o.id, userId, 'owner');
+        granted.push(o.slug);
+    }
+    return granted;
+}
+// ── modules / processes ───────────────────────────────────────────────────
+export async function upsertModule(db, projectId, m) {
+    const existing = await db
+        .selectFrom('modules')
+        .select(['id'])
+        .where('project_id', '=', projectId)
+        .where('name', '=', m.name)
+        .executeTakeFirst();
+    const values = {
+        title: m.title ?? null,
+        description: m.description ?? null,
+        path: m.path ?? m.name,
+        layers_json: enc.json(m.layers ?? []),
+        testing_types_json: enc.json(m.testingTypes ?? []),
+        tags_json: enc.json(m.tags ?? []),
+        owner: m.owner ?? null,
+        jira_component: m.jiraComponent ?? null,
+        routes_json: enc.json(m.routes ?? []),
+        endpoints_json: enc.json(m.endpoints ?? []),
+        updated_at: nowIso(),
+    };
+    if (existing) {
+        await db.updateTable('modules').set(values).where('id', '=', existing.id).execute();
+        return existing.id;
+    }
+    const id = newId();
+    await db
+        .insertInto('modules')
+        .values({ id, project_id: projectId, name: m.name, created_at: nowIso(), ...values })
+        .execute();
+    return id;
+}
+export async function listModules(db, projectId) {
+    const rows = await db
+        .selectFrom('modules')
+        .selectAll()
+        .where('project_id', '=', projectId)
+        .orderBy('name')
+        .execute();
+    return rows.map((r) => ({
+        id: r.id,
+        name: r.name,
+        title: r.title,
+        description: r.description,
+        path: r.path,
+        layers: readJson(r.layers_json) ?? [],
+        testingTypes: readJson(r.testing_types_json) ?? [],
+        tags: readJson(r.tags_json) ?? [],
+        owner: r.owner,
+        jiraComponent: r.jira_component,
+        routes: readJson(r.routes_json) ?? [],
+        endpoints: readJson(r.endpoints_json) ?? [],
+    }));
+}
+export async function upsertProcess(db, driver, scope, p) {
+    let q = db.selectFrom('processes').select(['id']).where('name', '=', p.name);
+    q = scope.projectId
+        ? q.where('project_id', '=', scope.projectId)
+        : q.where('project_id', 'is', null).where('workspace_id', '=', scope.workspaceId ?? null);
+    const existing = await q.executeTakeFirst();
+    const { name: _n, title, description, trigger, ...config } = p;
+    const values = {
+        title: title ?? null,
+        description: description ?? null,
+        trigger: trigger ?? 'manual',
+        config_json: enc.json(config),
+        enabled: enc.bool(driver, true),
+        updated_at: nowIso(),
+    };
+    if (existing) {
+        await db.updateTable('processes').set(values).where('id', '=', existing.id).execute();
+        return existing.id;
+    }
+    const id = newId();
+    await db
+        .insertInto('processes')
+        .values({
+        id,
+        project_id: scope.projectId ?? null,
+        workspace_id: scope.workspaceId ?? null,
+        name: p.name,
+        last_run_id: null,
+        last_status: null,
+        created_at: nowIso(),
+        ...values,
+    })
+        .execute();
+    return id;
+}
+export async function listProcesses(db, scope = {}) {
+    let q = db.selectFrom('processes').selectAll().orderBy('name');
+    if (scope.projectId)
+        q = q.where('project_id', '=', scope.projectId);
+    if (scope.workspaceId)
+        q = q.where('workspace_id', '=', scope.workspaceId);
+    const rows = await q.execute();
+    return rows.map((r) => ({
+        id: r.id,
+        projectId: r.project_id,
+        workspaceId: r.workspace_id,
+        name: r.name,
+        title: r.title,
+        description: r.description,
+        trigger: r.trigger,
+        config: readJson(r.config_json) ?? {},
+        enabled: readBool(r.enabled),
+        lastRunId: r.last_run_id,
+        lastStatus: r.last_status,
+    }));
+}
+export async function updateProcessState(db, id, patch) {
+    await db
+        .updateTable('processes')
+        .set({
+        last_run_id: patch.lastRunId ?? null,
+        last_status: patch.lastStatus ?? null,
+        updated_at: nowIso(),
+    })
+        .where('id', '=', id)
+        .execute();
+}
+/** Upsert organization → workspaces → projects → modules/processes from the yaml files. */
+export async function syncHierarchy(db, driver, input) {
+    const result = {
+        organizationId: null,
+        workspaces: {},
+        projects: {},
+        modules: 0,
+        processes: 0,
+    };
+    const wf = input.workspaceFile ?? null;
+    let defaultWorkspaceId = null;
+    if (wf) {
+        result.organizationId = await upsertOrganization(db, wf.organization);
+        for (const ws of wf.workspaces) {
+            const id = await upsertWorkspace(db, {
+                organizationId: result.organizationId,
+                slug: ws.slug,
+                name: ws.name,
+                description: ws.description ?? null,
+            });
+            result.workspaces[ws.slug] = id;
+            for (const p of wf.defaults.processes) {
+                await upsertProcess(db, driver, { workspaceId: id }, p);
+                result.processes++;
+            }
+        }
+        defaultWorkspaceId = result.workspaces[wf.defaultWorkspace] ?? null;
+    }
+    for (const { config, root } of input.projects) {
+        const workspaceId = (config.workspace && result.workspaces[config.workspace]) || defaultWorkspaceId;
+        const projectId = await upsertProject(db, driver, {
+            slug: config.slug,
+            name: config.name,
+            workspaceId,
+            description: config.description ?? null,
+            rootPath: root ?? null,
+            config: config,
+            layers: config.layers,
+            browsers: config.browsers,
+            tagsPolicy: config.tags,
+            screenshotPolicy: config.screenshots,
+        });
+        result.projects[config.slug] = projectId;
+        for (const m of config.modules ?? []) {
+            await upsertModule(db, projectId, m);
+            result.modules++;
+        }
+        for (const p of config.processes ?? []) {
+            await upsertProcess(db, driver, { projectId }, p);
+            result.processes++;
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=hierarchy.js.map

package/dist/repos/improvement.d.ts

@@ -0,0 +1,84 @@
+import type { Kysely } from 'kysely';
+import type { HealEvent } from '@sdods/contracts/types';
+import type { Driver } from '../driver.js';
+import type { Database } from '../schema.js';
+export declare function insertHealEvent(db: Kysely<Database>, driver: Driver, input: {
+    projectId: string;
+    runId: string;
+    scenarioId?: string | null;
+    attemptId?: string | null;
+    stepId?: string | null;
+    event: HealEvent;
+    source?: 'runtime' | 'agent';
+}): Promise<string>;
+export interface LocatorDelta {
+    selector: string;
+    pageHint?: string | null;
+    fails?: number;
+    heals?: number;
+    uses?: number;
+    lastStrategy?: string | null;
+    suggestedSelector?: string | null;
+    at?: string;
+}
+/** Increment counters for one selector (upsert on project_id + selector). */
+export declare function bumpLocatorStats(db: Kysely<Database>, projectId: string, d: LocatorDelta): Promise<void>;
+export declare function listLocatorStats(db: Kysely<Database>, projectId: string, limit?: number): Promise<{
+    id: string;
+    selector: string;
+    pageHint: string | null;
+    failCount: number;
+    healCount: number;
+    useCount: number;
+    lastFailedAt: string | null;
+    lastHealedAt: string | null;
+    lastStrategy: string | null;
+    suggestedSelector: string | null;
+}[]>;
+export declare function listHealEvents(db: Kysely<Database>, opts: {
+    projectId?: string;
+    runId?: string;
+    limit?: number;
+}): Promise<{
+    id: string;
+    runId: string;
+    scenarioId: string | null;
+    pageUrl: string | null;
+    originalSelector: string;
+    context: Record<string, unknown>;
+    strategyUsed: string | null;
+    healedSelector: string | null;
+    candidates: unknown[];
+    succeeded: boolean;
+    durationMs: number | null;
+    createdAt: string | null;
+}[]>;
+/**
+ * Recompute flaky stats for one (project, fingerprint, runner_project) over the last `window` runs.
+ */
+export declare function recomputeFlakyStats(db: Kysely<Database>, driver: Driver, input: {
+    projectId: string;
+    fingerprint: string;
+    runnerProject: string;
+    window?: number;
+}): Promise<void>;
+export declare function listFlakyStats(db: Kysely<Database>, projectId: string, limit?: number): Promise<{
+    id: string;
+    fingerprint: string;
+    runnerProject: string;
+    featureUri: string | null;
+    scenarioName: string | null;
+    windowSize: number;
+    runsCount: number;
+    passCount: number;
+    failCount: number;
+    flakyCount: number;
+    flakyRate: number;
+    failStreak: number;
+    lastStatus: string | null;
+    lastRunId: string | null;
+    lastFailedAt: string | null;
+    quarantined: boolean;
+}[]>;
+export declare function setQuarantine(db: Kysely<Database>, driver: Driver, id: string, quarantined: boolean): Promise<void>;
+//# sourceMappingURL=improvement.d.ts.map