@sdods/db 0.2.0

package/dist/repos/platform.js

@@ -0,0 +1,429 @@
+import { enc, nowIso, readBool, readJson, readTs } from '../col.js';
+import { newId } from '../ids.js';
+// ── integrations ──────────────────────────────────────────────────────────
+export async function upsertIntegration(db, driver, input) {
+    const existing = await db
+        .selectFrom('integrations')
+        .select(['id'])
+        .where('project_id', '=', input.projectId)
+        .where('provider', '=', input.provider)
+        .executeTakeFirst();
+    const values = {
+        config_json: enc.json(input.config),
+        secret_env_json: enc.json(input.secretEnv ?? {}),
+        enabled: enc.bool(driver, input.enabled ?? false),
+        updated_at: nowIso(),
+    };
+    if (existing) {
+        await db.updateTable('integrations').set(values).where('id', '=', existing.id).execute();
+        return existing.id;
+    }
+    const id = newId();
+    await db
+        .insertInto('integrations')
+        .values({
+        id,
+        project_id: input.projectId,
+        provider: input.provider,
+        last_sync_at: null,
+        created_at: nowIso(),
+        ...values,
+    })
+        .execute();
+    return id;
+}
+export async function listIntegrations(db, projectId) {
+    const rows = await db
+        .selectFrom('integrations')
+        .selectAll()
+        .where('project_id', '=', projectId)
+        .orderBy('provider')
+        .execute();
+    return rows.map((r) => ({
+        id: r.id,
+        provider: r.provider,
+        config: readJson(r.config_json) ?? {},
+        secretEnv: readJson(r.secret_env_json) ?? {},
+        enabled: readBool(r.enabled),
+        lastSyncAt: readTs(r.last_sync_at),
+    }));
+}
+// ── issue links ───────────────────────────────────────────────────────────
+export async function upsertIssueLink(db, input) {
+    const existing = await db
+        .selectFrom('issue_links')
+        .select(['id'])
+        .where('project_id', '=', input.projectId)
+        .where('provider', '=', input.provider)
+        .where('fingerprint', '=', input.fingerprint)
+        .where('external_key', '=', input.externalKey)
+        .executeTakeFirst();
+    const values = {
+        integration_id: input.integrationId ?? null,
+        scenario_name: input.scenarioName ?? null,
+        external_url: input.externalUrl ?? null,
+        status: input.status ?? 'unknown',
+        source: input.source ?? 'auto',
+        last_run_id: input.lastRunId ?? null,
+        last_synced_at: nowIso(),
+        updated_at: nowIso(),
+    };
+    if (existing) {
+        await db.updateTable('issue_links').set(values).where('id', '=', existing.id).execute();
+        return existing.id;
+    }
+    const id = newId();
+    await db
+        .insertInto('issue_links')
+        .values({
+        id,
+        project_id: input.projectId,
+        provider: input.provider,
+        fingerprint: input.fingerprint,
+        external_key: input.externalKey,
+        created_at: nowIso(),
+        ...values,
+    })
+        .execute();
+    return id;
+}
+export async function findOpenIssueLink(db, projectId, provider, fingerprint) {
+    const row = await db
+        .selectFrom('issue_links')
+        .selectAll()
+        .where('project_id', '=', projectId)
+        .where('provider', '=', provider)
+        .where('fingerprint', '=', fingerprint)
+        .where('status', '=', 'open')
+        .executeTakeFirst();
+    return row ? mapIssueLink(row) : null;
+}
+export async function listIssueLinks(db, opts) {
+    let q = db.selectFrom('issue_links').selectAll().orderBy('updated_at', 'desc');
+    if (opts.projectId)
+        q = q.where('project_id', '=', opts.projectId);
+    if (opts.fingerprint)
+        q = q.where('fingerprint', '=', opts.fingerprint);
+    if (opts.provider)
+        q = q.where('provider', '=', opts.provider);
+    return (await q.execute()).map(mapIssueLink);
+}
+export async function setIssueLinkStatus(db, id, status) {
+    await db
+        .updateTable('issue_links')
+        .set({ status, last_synced_at: nowIso(), updated_at: nowIso() })
+        .where('id', '=', id)
+        .execute();
+}
+function mapIssueLink(r) {
+    return {
+        id: r.id,
+        projectId: r.project_id,
+        integrationId: r.integration_id,
+        provider: r.provider,
+        fingerprint: r.fingerprint,
+        scenarioName: r.scenario_name,
+        externalKey: r.external_key,
+        externalUrl: r.external_url,
+        status: r.status,
+        source: r.source,
+        lastRunId: r.last_run_id,
+        lastSyncedAt: readTs(r.last_synced_at),
+    };
+}
+// ── proposals ─────────────────────────────────────────────────────────────
+export async function upsertProposal(db, input) {
+    const existing = await db
+        .selectFrom('proposals')
+        .select(['id'])
+        .where('id', '=', input.id)
+        .executeTakeFirst();
+    const values = {
+        role: input.role,
+        status: input.status ?? 'pending',
+        summary: input.summary ?? null,
+        manifest_json: enc.json(input.manifest),
+        cost_usd: input.costUsd ?? null,
+        model: input.model ?? null,
+    };
+    if (existing) {
+        await db.updateTable('proposals').set(values).where('id', '=', input.id).execute();
+        return;
+    }
+    await db
+        .insertInto('proposals')
+        .values({
+        id: input.id,
+        project_id: input.projectId,
+        created_by: input.createdBy ?? null,
+        reviewed_by: null,
+        created_at: nowIso(),
+        reviewed_at: null,
+        ...values,
+    })
+        .execute();
+}
+export async function reviewProposal(db, id, status, reviewedBy) {
+    await db
+        .updateTable('proposals')
+        .set({ status, reviewed_by: reviewedBy ?? null, reviewed_at: nowIso() })
+        .where('id', '=', id)
+        .execute();
+}
+export async function listProposals(db, opts = {}) {
+    let q = db
+        .selectFrom('proposals')
+        .selectAll()
+        .orderBy('created_at', 'desc')
+        .limit(opts.limit ?? 100);
+    if (opts.projectId)
+        q = q.where('project_id', '=', opts.projectId);
+    if (opts.status)
+        q = q.where('status', '=', opts.status);
+    return (await q.execute()).map((p) => ({
+        id: p.id,
+        projectId: p.project_id,
+        role: p.role,
+        status: p.status,
+        summary: p.summary,
+        manifest: readJson(p.manifest_json) ?? {},
+        costUsd: p.cost_usd,
+        model: p.model,
+        createdBy: p.created_by,
+        reviewedBy: p.reviewed_by,
+        createdAt: readTs(p.created_at),
+        reviewedAt: readTs(p.reviewed_at),
+    }));
+}
+// ── agent jobs ────────────────────────────────────────────────────────────
+export async function createAgentJob(db, input) {
+    const id = newId();
+    await db
+        .insertInto('agent_jobs')
+        .values({
+        id,
+        project_id: input.projectId,
+        kind: input.kind,
+        goal: input.goal ?? null,
+        status: 'queued',
+        input_json: enc.json(input.input ?? {}),
+        output_json: null,
+        diff_text: null,
+        log_rel: null,
+        provider: input.provider ?? null,
+        model: input.model ?? null,
+        tokens_in: null,
+        tokens_out: null,
+        cost_usd: null,
+        turns: null,
+        proposal_id: null,
+        started_by: input.startedBy ?? null,
+        reviewed_by: null,
+        started_at: null,
+        finished_at: null,
+        reviewed_at: null,
+        error: null,
+        created_at: nowIso(),
+    })
+        .execute();
+    return id;
+}
+export async function updateAgentJob(db, id, patch) {
+    await db
+        .updateTable('agent_jobs')
+        .set({
+        ...(patch.status !== undefined ? { status: patch.status } : {}),
+        ...(patch.output !== undefined ? { output_json: enc.json(patch.output) } : {}),
+        ...(patch.diffText !== undefined ? { diff_text: patch.diffText } : {}),
+        ...(patch.logRel !== undefined ? { log_rel: patch.logRel } : {}),
+        ...(patch.tokensIn !== undefined ? { tokens_in: patch.tokensIn } : {}),
+        ...(patch.tokensOut !== undefined ? { tokens_out: patch.tokensOut } : {}),
+        ...(patch.costUsd !== undefined ? { cost_usd: patch.costUsd } : {}),
+        ...(patch.turns !== undefined ? { turns: patch.turns } : {}),
+        ...(patch.proposalId !== undefined ? { proposal_id: patch.proposalId } : {}),
+        ...(patch.startedAt !== undefined ? { started_at: patch.startedAt } : {}),
+        ...(patch.finishedAt !== undefined ? { finished_at: patch.finishedAt } : {}),
+        ...(patch.error !== undefined ? { error: patch.error } : {}),
+        ...(patch.reviewedBy !== undefined ? { reviewed_by: patch.reviewedBy } : {}),
+        ...(patch.reviewedAt !== undefined ? { reviewed_at: patch.reviewedAt } : {}),
+    })
+        .where('id', '=', id)
+        .execute();
+}
+export async function getAgentJob(db, id) {
+    const j = await db.selectFrom('agent_jobs').selectAll().where('id', '=', id).executeTakeFirst();
+    return j ? mapAgentJob(j) : null;
+}
+export async function listAgentJobs(db, opts = {}) {
+    let q = db
+        .selectFrom('agent_jobs')
+        .selectAll()
+        .orderBy('created_at', 'desc')
+        .limit(opts.limit ?? 50);
+    if (opts.projectId)
+        q = q.where('project_id', '=', opts.projectId);
+    if (opts.status)
+        q = q.where('status', '=', opts.status);
+    return (await q.execute()).map(mapAgentJob);
+}
+function mapAgentJob(j) {
+    return {
+        id: j.id,
+        projectId: j.project_id,
+        kind: j.kind,
+        goal: j.goal,
+        status: j.status,
+        input: readJson(j.input_json) ?? {},
+        output: readJson(j.output_json),
+        diffText: j.diff_text,
+        logRel: j.log_rel,
+        provider: j.provider,
+        model: j.model,
+        tokensIn: j.tokens_in,
+        tokensOut: j.tokens_out,
+        costUsd: j.cost_usd,
+        turns: j.turns,
+        proposalId: j.proposal_id,
+        startedBy: j.started_by,
+        startedAt: readTs(j.started_at),
+        finishedAt: readTs(j.finished_at),
+        error: j.error,
+        createdAt: readTs(j.created_at),
+    };
+}
+export async function upsertSchedule(db, driver, s) {
+    const existing = await db
+        .selectFrom('schedules')
+        .select(['id'])
+        .where('project_id', '=', s.projectId)
+        .where('name', '=', s.name)
+        .executeTakeFirst();
+    const values = {
+        environment_id: s.environmentId ?? null,
+        cron_expr: s.cronExpr,
+        timezone: s.timezone ?? 'UTC',
+        run_input_json: enc.json(s.runInput),
+        overlap_policy: s.overlapPolicy ?? 'skip',
+        jitter_seconds: s.jitterSeconds ?? 0,
+        catch_up: enc.bool(driver, s.catchUp ?? false),
+        enabled: enc.bool(driver, s.enabled ?? true),
+        notify_json: enc.json(s.notify ?? []),
+        retention_runs: s.retentionRuns ?? null,
+        next_run_at: s.nextRunAt ?? null,
+        updated_at: nowIso(),
+    };
+    if (existing) {
+        await db.updateTable('schedules').set(values).where('id', '=', existing.id).execute();
+        return existing.id;
+    }
+    const id = newId();
+    await db
+        .insertInto('schedules')
+        .values({
+        id,
+        project_id: s.projectId,
+        name: s.name,
+        last_run_id: null,
+        last_status: null,
+        created_by: s.createdBy ?? null,
+        created_at: nowIso(),
+        ...values,
+    })
+        .execute();
+    return id;
+}
+export async function listSchedules(db, projectId) {
+    let q = db.selectFrom('schedules').selectAll().orderBy('name');
+    if (projectId)
+        q = q.where('project_id', '=', projectId);
+    return (await q.execute()).map((s) => ({
+        id: s.id,
+        projectId: s.project_id,
+        environmentId: s.environment_id,
+        name: s.name,
+        cronExpr: s.cron_expr,
+        timezone: s.timezone,
+        runInput: readJson(s.run_input_json) ?? {},
+        overlapPolicy: s.overlap_policy,
+        jitterSeconds: s.jitter_seconds,
+        catchUp: readBool(s.catch_up),
+        enabled: readBool(s.enabled),
+        notify: readJson(s.notify_json) ?? [],
+        retentionRuns: s.retention_runs,
+        nextRunAt: readTs(s.next_run_at),
+        lastRunId: s.last_run_id,
+        lastStatus: s.last_status,
+    }));
+}
+export async function updateScheduleState(db, id, patch, driver) {
+    await db
+        .updateTable('schedules')
+        .set({
+        ...(patch.nextRunAt !== undefined ? { next_run_at: patch.nextRunAt } : {}),
+        ...(patch.lastRunId !== undefined ? { last_run_id: patch.lastRunId } : {}),
+        ...(patch.lastStatus !== undefined ? { last_status: patch.lastStatus } : {}),
+        ...(patch.enabled !== undefined
+            ? { enabled: enc.bool(driver, patch.enabled) }
+            : {}),
+        updated_at: nowIso(),
+    })
+        .where('id', '=', id)
+        .execute();
+}
+export async function deleteSchedule(db, id) {
+    await db.deleteFrom('schedules').where('id', '=', id).execute();
+}
+export async function recordScheduleRun(db, input) {
+    await db
+        .insertInto('schedule_runs')
+        .values({
+        id: newId(),
+        schedule_id: input.scheduleId,
+        run_id: input.runId ?? null,
+        fired_at: nowIso(),
+        status: input.status,
+        note: input.note ?? null,
+    })
+        .execute();
+}
+export async function listScheduleRuns(db, scheduleId, limit = 50) {
+    return db
+        .selectFrom('schedule_runs')
+        .selectAll()
+        .where('schedule_id', '=', scheduleId)
+        .orderBy('fired_at', 'desc')
+        .limit(limit)
+        .execute();
+}
+// ── audit ─────────────────────────────────────────────────────────────────
+export async function audit(db, input) {
+    await db
+        .insertInto('audit_log')
+        .values({
+        id: newId(),
+        actor_user_id: input.actorUserId ?? null,
+        actor_type: input.actorType ?? 'system',
+        action: input.action,
+        target_type: input.targetType ?? null,
+        target_id: input.targetId ?? null,
+        details_json: input.details ? enc.json(input.details) : null,
+        ip: input.ip ?? null,
+        created_at: nowIso(),
+    })
+        .execute();
+}
+export async function listAudit(db, opts = {}) {
+    let q = db
+        .selectFrom('audit_log')
+        .selectAll()
+        .orderBy('created_at', 'desc')
+        .limit(opts.limit ?? 100);
+    if (opts.before)
+        q = q.where('created_at', '<', opts.before);
+    return (await q.execute()).map((a) => ({
+        ...a,
+        details: readJson(a.details_json),
+        createdAt: readTs(a.created_at),
+    }));
+}
+//# sourceMappingURL=platform.js.map

package/dist/repos/projects.d.ts

@@ -0,0 +1,87 @@
+import type { Kysely } from 'kysely';
+import type { Driver } from '../driver.js';
+import type { Database } from '../schema.js';
+export interface ProjectUpsert {
+    slug: string;
+    name: string;
+    workspaceId?: string | null;
+    description?: string | null;
+    rootPath?: string | null;
+    config: Record<string, unknown>;
+    layers: string[];
+    browsers: string[];
+    tagsPolicy?: Record<string, unknown>;
+    screenshotPolicy?: Record<string, unknown>;
+}
+export declare function configHash(config: unknown): string;
+/** Insert or update a project by slug; returns its id. */
+export declare function upsertProject(db: Kysely<Database>, driver: Driver, p: ProjectUpsert): Promise<string>;
+/** Ensure a minimal project row exists (used by ingest when the registry is unavailable). */
+export declare function ensureProject(db: Kysely<Database>, driver: Driver, slug: string, name?: string): Promise<string>;
+export declare function getProjectBySlug(db: Kysely<Database>, slug: string): Promise<{
+    id: string;
+    workspaceId: string | null;
+    slug: string;
+    name: string;
+    description: string | null;
+    rootPath: string | null;
+    config: Record<string, unknown>;
+    configHash: string | null;
+    layers: string[];
+    browsers: string[];
+    archived: boolean;
+    createdAt: string;
+    updatedAt: string;
+} | null>;
+export declare function listProjects(db: Kysely<Database>): Promise<{
+    id: string;
+    workspaceId: string | null;
+    slug: string;
+    name: string;
+    description: string | null;
+    rootPath: string | null;
+    config: Record<string, unknown>;
+    configHash: string | null;
+    layers: string[];
+    browsers: string[];
+    archived: boolean;
+    createdAt: string;
+    updatedAt: string;
+}[]>;
+export declare function mapProject(row: any): {
+    id: string;
+    workspaceId: string | null;
+    slug: string;
+    name: string;
+    description: string | null;
+    rootPath: string | null;
+    config: Record<string, unknown>;
+    configHash: string | null;
+    layers: string[];
+    browsers: string[];
+    archived: boolean;
+    createdAt: string;
+    updatedAt: string;
+};
+export declare function upsertEnvironment(db: Kysely<Database>, driver: Driver, input: {
+    projectId: string;
+    name: string;
+    baseUrl?: string | null;
+    apiBaseUrl?: string | null;
+    config?: Record<string, unknown>;
+    secretKeys?: string[];
+    isDefault?: boolean;
+}): 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;
+    project_id: string;
+    base_url: string | null;
+    api_base_url: string | null;
+    secret_keys_json: string[];
+    is_default: number | boolean;
+} | undefined>;
+//# sourceMappingURL=projects.d.ts.map

package/dist/repos/projects.js

@@ -0,0 +1,118 @@
+import { createHash } from 'node:crypto';
+import { enc, nowIso, readBool, readJson } from '../col.js';
+import { newId } from '../ids.js';
+export function configHash(config) {
+    return createHash('sha256').update(JSON.stringify(config)).digest('hex').slice(0, 16);
+}
+/** Insert or update a project by slug; returns its id. */
+export async function upsertProject(db, driver, p) {
+    const existing = await db
+        .selectFrom('projects')
+        .select(['id'])
+        .where('slug', '=', p.slug)
+        .executeTakeFirst();
+    const values = {
+        name: p.name,
+        workspace_id: p.workspaceId ?? null,
+        description: p.description ?? null,
+        root_path: p.rootPath ?? null,
+        config_json: enc.json(p.config),
+        config_hash: configHash(p.config),
+        layers_json: enc.json(p.layers),
+        browsers_json: enc.json(p.browsers),
+        tags_policy_json: enc.json(p.tagsPolicy ?? {}),
+        screenshot_policy_json: enc.json(p.screenshotPolicy ?? {}),
+        updated_at: nowIso(),
+    };
+    if (existing) {
+        await db.updateTable('projects').set(values).where('id', '=', existing.id).execute();
+        return existing.id;
+    }
+    const id = newId();
+    await db
+        .insertInto('projects')
+        .values({
+        id,
+        slug: p.slug,
+        archived: enc.bool(driver, false),
+        created_at: nowIso(),
+        ...values,
+    })
+        .execute();
+    return id;
+}
+/** Ensure a minimal project row exists (used by ingest when the registry is unavailable). */
+export async function ensureProject(db, driver, slug, name = slug) {
+    const existing = await db
+        .selectFrom('projects')
+        .select(['id'])
+        .where('slug', '=', slug)
+        .executeTakeFirst();
+    if (existing)
+        return existing.id;
+    return upsertProject(db, driver, { slug, name, config: {}, layers: [], browsers: [] });
+}
+export async function getProjectBySlug(db, slug) {
+    const row = await db
+        .selectFrom('projects')
+        .selectAll()
+        .where('slug', '=', slug)
+        .executeTakeFirst();
+    return row ? mapProject(row) : null;
+}
+export async function listProjects(db) {
+    const rows = await db.selectFrom('projects').selectAll().orderBy('slug').execute();
+    return rows.map(mapProject);
+}
+export function mapProject(row) {
+    return {
+        id: row.id,
+        workspaceId: (row.workspace_id ?? null),
+        slug: row.slug,
+        name: row.name,
+        description: row.description,
+        rootPath: row.root_path,
+        config: readJson(row.config_json) ?? {},
+        configHash: row.config_hash,
+        layers: readJson(row.layers_json) ?? [],
+        browsers: readJson(row.browsers_json) ?? [],
+        archived: readBool(row.archived),
+        createdAt: String(row.created_at),
+        updatedAt: String(row.updated_at),
+    };
+}
+export async function upsertEnvironment(db, driver, input) {
+    const existing = await db
+        .selectFrom('environments')
+        .select(['id'])
+        .where('project_id', '=', input.projectId)
+        .where('name', '=', input.name)
+        .executeTakeFirst();
+    const values = {
+        base_url: input.baseUrl ?? null,
+        api_base_url: input.apiBaseUrl ?? null,
+        config_json: enc.json(input.config ?? {}),
+        secret_keys_json: enc.json(input.secretKeys ?? []),
+        is_default: enc.bool(driver, input.isDefault ?? false),
+        updated_at: nowIso(),
+    };
+    if (existing) {
+        await db.updateTable('environments').set(values).where('id', '=', existing.id).execute();
+        return existing.id;
+    }
+    const id = newId();
+    await db
+        .insertInto('environments')
+        .values({ id, project_id: input.projectId, name: input.name, created_at: nowIso(), ...values })
+        .execute();
+    return id;
+}
+export async function getEnvironment(db, projectId, name) {
+    return db
+        .selectFrom('environments')
+        .selectAll()
+        .where('project_id', '=', projectId)
+        .where('name', '=', name)
+        .executeTakeFirst();
+}
+//# sourceMappingURL=projects.js.map