@proofhound/core 0.1.6

package/dist/server/modules/canary-release/canary-release.repository.js

@@ -0,0 +1,673 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CanaryReleaseRepository = void 0;
+// Canary release compatibility repository: the source of truth is ph_releases.release_lines / release_line_events
+// See docs/specs/27-releases.md and docs/specs/06-database-schema.md
+const common_1 = require("@nestjs/common");
+const drizzle_orm_1 = require("drizzle-orm");
+const db_1 = require("@proofhound/db");
+const database_constants_1 = require("../../../shared/database/database.constants");
+const { annotations, annotationTasks, connectors, datasets, models, projects, prompts, promptVersions, promptVersionLabels, runResults, } = db_1.schema;
+let CanaryReleaseRepository = class CanaryReleaseRepository {
+    constructor(db) {
+        this.db = db;
+    }
+    async findProjectAccess(_actorUserId, projectId, _isSuperAdmin) {
+        const rows = await this.db
+            .select({ id: projects.id })
+            .from(projects)
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(projects.id, projectId), (0, drizzle_orm_1.isNull)(projects.deletedAt)))
+            .limit(1);
+        return rows[0] ?? null;
+    }
+    async listByProject(projectId) {
+        const rows = await this.db.execute((0, drizzle_orm_1.sql) `
+      ${canaryEventSelectSql()}
+      WHERE e.project_id = ${projectId}::uuid
+        AND e.lane_type = 'canary'
+        AND e.status <> 'archived'
+      ORDER BY e.created_at DESC
+    `);
+        return this.attachAnnotationTaskIds(unwrapRows(rows).map(mapCanaryEventRow));
+    }
+    async findByIdWithJoins(projectId, canaryId) {
+        const row = await this.findCanaryEventRow(projectId, canaryId);
+        if (!row)
+            return null;
+        const enriched = await this.attachAnnotationTaskIds([row]);
+        return enriched[0] ?? null;
+    }
+    async findById(canaryId) {
+        const row = await this.findCanaryEventRow(null, canaryId);
+        return row ?? null;
+    }
+    async findRunningByInputConnector(inputConnectorId) {
+        const rows = await this.db.execute((0, drizzle_orm_1.sql) `
+      ${canaryEventSelectSql()}
+      WHERE line.input_connector_id = ${inputConnectorId}::uuid
+        AND e.id = line.active_canary_event_id
+        AND e.lane_type = 'canary'
+        AND e.status IN ('running', 'stopped')
+      LIMIT 1
+    `);
+        const row = unwrapRows(rows)[0];
+        return row ? mapCanaryEventRow(row) : null;
+    }
+    async findRunningProductionByInputConnector(projectId, inputConnectorId) {
+        const rows = await this.db.execute((0, drizzle_orm_1.sql) `
+      SELECT
+        prod.id,
+        prod.project_id,
+        prod.prompt_id,
+        prod.prompt_version_id,
+        prod.input_connector_id,
+        prod.output_connector_ids,
+        prod.variable_mapping,
+        prod.filter_rules,
+        prod.external_id_field,
+        prod.submit_reason
+      FROM ph_releases.release_lines line
+      INNER JOIN ph_releases.release_line_events prod ON prod.id = line.current_production_event_id
+      WHERE line.project_id = ${projectId}::uuid
+        AND line.input_connector_id = ${inputConnectorId}::uuid
+        AND prod.lane_type = 'production'
+        AND prod.status = 'running'
+      LIMIT 1
+    `);
+        const row = unwrapRows(rows)[0];
+        return row
+            ? {
+                id: row['id'],
+                projectId: row['project_id'],
+                promptId: row['prompt_id'],
+                promptVersionId: row['prompt_version_id'],
+                inputConnectorId: row['input_connector_id'] ?? null,
+                outputConnectorIds: normalizeStringArray(row['output_connector_ids']),
+                variableMapping: row['variable_mapping'],
+                filterRules: row['filter_rules'],
+                externalIdField: row['external_id_field'] ?? null,
+                submitReason: row['submit_reason'] ?? '',
+            }
+            : null;
+    }
+    async findPromptVersionForProject(projectId, versionId) {
+        const rows = await this.db
+            .select({
+            id: promptVersions.id,
+            promptId: promptVersions.promptId,
+            promptName: prompts.name,
+            promptDefaultDatasetId: prompts.defaultDatasetId,
+            versionNumber: promptVersions.versionNumber,
+            body: promptVersions.body,
+            variables: promptVersions.variables,
+            outputSchema: promptVersions.outputSchema,
+            judgmentRules: promptVersions.judgmentRules,
+            promptLanguage: promptVersions.promptLanguage,
+            isFrozen: promptVersions.isFrozen,
+            createdBy: promptVersions.createdBy,
+            createdAt: promptVersions.createdAt,
+            frozenAt: promptVersions.frozenAt,
+        })
+            .from(promptVersions)
+            .innerJoin(prompts, (0, drizzle_orm_1.eq)(prompts.id, promptVersions.promptId))
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(prompts.projectId, projectId), (0, drizzle_orm_1.eq)(promptVersions.id, versionId), (0, drizzle_orm_1.isNull)(prompts.deletedAt)))
+            .limit(1);
+        return rows[0] ?? null;
+    }
+    async freezePromptVersionIfNeeded(promptVersionId) {
+        await this.db
+            .update(promptVersions)
+            .set({ isFrozen: true, frozenAt: (0, drizzle_orm_1.sql) `COALESCE(${promptVersions.frozenAt}, now())` })
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(promptVersions.id, promptVersionId), (0, drizzle_orm_1.eq)(promptVersions.isFrozen, false)));
+    }
+    async markPromptVersionGray(promptId, versionId, actorUserId) {
+        const now = new Date();
+        await this.db.transaction(async (tx) => {
+            await tx
+                .update(promptVersions)
+                .set({ isFrozen: true, frozenAt: (0, drizzle_orm_1.sql) `COALESCE(${promptVersions.frozenAt}, now())` })
+                .where((0, drizzle_orm_1.eq)(promptVersions.id, versionId));
+            await tx
+                .insert(promptVersionLabels)
+                .values({
+                promptId,
+                versionId,
+                label: 'gray',
+                labelType: 'system',
+                createdBy: actorUserId,
+                updatedAt: now,
+            })
+                .onConflictDoUpdate({
+                target: [promptVersionLabels.promptId, promptVersionLabels.label],
+                set: { versionId, labelType: 'system', updatedAt: now },
+            });
+        });
+    }
+    async findModelById(modelId) {
+        const rows = await this.db
+            .select({ id: models.id, name: models.name, providerType: models.providerType })
+            .from(models)
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(models.id, modelId), (0, drizzle_orm_1.isNull)(models.deletedAt)))
+            .limit(1);
+        return rows[0] ?? null;
+    }
+    async findConnectorForProject(projectId, connectorId) {
+        const rows = await this.db
+            .select({ id: connectors.id, name: connectors.name, type: connectors.type, direction: connectors.direction })
+            .from(connectors)
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(connectors.projectId, projectId), (0, drizzle_orm_1.eq)(connectors.id, connectorId), (0, drizzle_orm_1.isNull)(connectors.deletedAt)))
+            .limit(1);
+        return rows[0] ?? null;
+    }
+    async listConnectorsForProject(projectId, ids) {
+        if (ids.length === 0)
+            return [];
+        return this.db
+            .select({ id: connectors.id, name: connectors.name, type: connectors.type, direction: connectors.direction })
+            .from(connectors)
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(connectors.projectId, projectId), (0, drizzle_orm_1.inArray)(connectors.id, ids), (0, drizzle_orm_1.isNull)(connectors.deletedAt)));
+    }
+    async findDatasetForProject(projectId, datasetId) {
+        const rows = await this.db
+            .select({ id: datasets.id, name: datasets.name })
+            .from(datasets)
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(datasets.projectId, projectId), (0, drizzle_orm_1.eq)(datasets.id, datasetId), (0, drizzle_orm_1.isNull)(datasets.deletedAt)))
+            .limit(1);
+        return rows[0] ?? null;
+    }
+    async findCanaryAnnotationTaskId(canaryId) {
+        const rows = await this.db.execute((0, drizzle_orm_1.sql) `
+      SELECT t.id
+      FROM ph_releases.annotation_tasks t
+      WHERE t.scope = 'canary'
+        AND t.release_line_event_id = ${canaryId}::uuid
+      ORDER BY t.created_at DESC
+      LIMIT 1
+    `);
+        return unwrapRows(rows)[0]?.id ?? null;
+    }
+    async getAnnotationProgress(canaryId) {
+        const taskId = await this.findCanaryAnnotationTaskId(canaryId);
+        if (!taskId)
+            return { total: 0, claimed: 0, submitted: 0, correct: 0, wrong: 0 };
+        const rows = await this.db
+            .select({
+            total: (0, drizzle_orm_1.sql) `COUNT(*)::int`,
+            claimed: (0, drizzle_orm_1.sql) `COUNT(*) FILTER (
+          WHERE ${annotations.lockedBy} IS NOT NULL
+            AND ${annotations.submittedAt} IS NULL
+            AND ${annotations.lockHeartbeatAt} >= NOW() - INTERVAL '5 min'
+        )::int`,
+            submitted: (0, drizzle_orm_1.sql) `COUNT(*) FILTER (WHERE ${annotations.submittedAt} IS NOT NULL)::int`,
+            correct: (0, drizzle_orm_1.sql) `COUNT(*) FILTER (
+          WHERE ${annotations.submittedAt} IS NOT NULL
+            AND ${this.annotationCorrectnessSql()} IS TRUE
+        )::int`,
+            wrong: (0, drizzle_orm_1.sql) `COUNT(*) FILTER (
+          WHERE ${annotations.submittedAt} IS NOT NULL
+            AND ${this.annotationCorrectnessSql()} IS FALSE
+        )::int`,
+        })
+            .from(annotations)
+            .leftJoin(runResults, (0, drizzle_orm_1.eq)(runResults.id, annotations.runResultId))
+            .where((0, drizzle_orm_1.eq)(annotations.taskId, taskId));
+        return rows[0] ?? { total: 0, claimed: 0, submitted: 0, correct: 0, wrong: 0 };
+    }
+    async aggregateUsageByCanaryIds(canaryIds) {
+        if (canaryIds.length === 0)
+            return new Map();
+        const rows = await this.db.execute((0, drizzle_orm_1.sql) `
+      SELECT
+        rr.source_id AS canary_id,
+        COUNT(*)::int AS run_count,
+        COALESCE(SUM(COALESCE(rr.input_tokens, 0)), 0)::int AS input_tokens,
+        COALESCE(SUM(COALESCE(rr.output_tokens, 0)), 0)::int AS output_tokens,
+        COALESCE(SUM(COALESCE(rr.cost_estimate, 0)), 0)::numeric AS cost_estimate
+      FROM ph_runs.run_results rr
+      WHERE rr.source = 'release'
+        AND rr.source_id IN (${uuidList(canaryIds)})
+      GROUP BY rr.source_id
+    `);
+        const map = new Map();
+        for (const row of unwrapRows(rows)) {
+            const canaryId = row['canary_id'];
+            map.set(canaryId, {
+                canaryId,
+                runCount: Number(row['run_count'] ?? 0),
+                inputTokens: Number(row['input_tokens'] ?? 0),
+                outputTokens: Number(row['output_tokens'] ?? 0),
+                costEstimate: Number(row['cost_estimate'] ?? 0),
+            });
+        }
+        return map;
+    }
+    async aggregateQualityByCategory(canaryId) {
+        const rows = await this.db.execute((0, drizzle_orm_1.sql) `
+      SELECT
+        COALESCE(rr.decision_output, 'unknown') AS category,
+        COUNT(*)::int AS count,
+        COUNT(*) FILTER (WHERE a.submitted_at IS NOT NULL)::int AS submitted,
+        COUNT(*) FILTER (
+          WHERE a.submitted_at IS NOT NULL
+            AND COALESCE(
+              a.is_correct,
+              CASE
+                WHEN a.fields ? 'judgment'
+                  AND rr.decision_output IS NOT NULL
+                THEN (a.fields->>'judgment') = rr.decision_output
+                ELSE NULL
+              END
+            ) IS TRUE
+        )::int AS correct
+      FROM ph_runs.run_results rr
+      LEFT JOIN ph_runs.annotations a ON a.run_result_id = rr.id
+      WHERE rr.source = 'release'
+        AND rr.source_id = ${canaryId}::uuid
+      GROUP BY category
+      ORDER BY count DESC, category ASC
+    `);
+        return unwrapRows(rows).map((row) => ({
+            category: String(row['category'] ?? 'unknown'),
+            count: Number(row['count'] ?? 0),
+            submitted: Number(row['submitted'] ?? 0),
+            correct: Number(row['correct'] ?? 0),
+        }));
+    }
+    async listAnnotations(canaryId, filter) {
+        const taskId = await this.findCanaryAnnotationTaskId(canaryId);
+        if (!taskId)
+            return [];
+        const whereSql = drizzle_orm_1.sql.join(this.buildAnnotationFilters(taskId, filter.status), (0, drizzle_orm_1.sql) ` AND `);
+        const rows = await this.db.execute((0, drizzle_orm_1.sql) `
+      SELECT
+        a.id,
+        a.run_result_id,
+        a.run_result_created_at,
+        a.task_id,
+        ${this.annotationCorrectnessSqlForAliases()} AS is_correct,
+        a.fields,
+        a.notes,
+        a.locked_by,
+        a.locked_at,
+        a.lock_heartbeat_at,
+        a.submitted_at,
+        a.submitted_by,
+        a.created_at,
+        a.updated_at,
+        rr.external_id,
+        rr.input_variables,
+        rr.rendered_prompt,
+        rr.decision_output,
+        rr.raw_response,
+        rr.parsed_output,
+        rr.latency_ms,
+        rr.input_tokens,
+        rr.output_tokens
+      FROM ph_runs.annotations a
+      LEFT JOIN ph_runs.run_results rr ON rr.id = a.run_result_id
+      WHERE ${whereSql}
+      ORDER BY a.created_at DESC
+      LIMIT ${filter.limit}
+      OFFSET ${filter.offset}
+    `);
+        return unwrapRows(rows).map((row) => this.mapAnnotationRow(row));
+    }
+    async countAnnotations(canaryId, filter) {
+        const taskId = await this.findCanaryAnnotationTaskId(canaryId);
+        if (!taskId)
+            return 0;
+        const whereSql = drizzle_orm_1.sql.join(this.buildAnnotationFilters(taskId, filter.status), (0, drizzle_orm_1.sql) ` AND `);
+        const rows = await this.db.execute((0, drizzle_orm_1.sql) `
+      SELECT COUNT(*)::int AS total
+      FROM ph_runs.annotations a
+      WHERE ${whereSql}
+    `);
+        return Number(unwrapRows(rows)[0]?.['total'] ?? 0);
+    }
+    async claimAnnotations(canaryId, actorUserId, batchSize) {
+        const taskId = await this.findCanaryAnnotationTaskId(canaryId);
+        if (!taskId)
+            return [];
+        const result = await this.db.execute((0, drizzle_orm_1.sql) `
+      WITH claimed AS (
+        UPDATE ph_runs.annotations
+        SET locked_by = ${actorUserId}::uuid,
+            locked_at = NOW(),
+            lock_heartbeat_at = NOW(),
+            updated_at = NOW()
+        WHERE id IN (
+          SELECT id FROM ph_runs.annotations
+          WHERE task_id = ${taskId}::uuid
+            AND submitted_at IS NULL
+            AND (locked_by IS NULL OR lock_heartbeat_at < NOW() - INTERVAL '5 min')
+          ORDER BY created_at
+          FOR UPDATE SKIP LOCKED
+          LIMIT ${batchSize}
+        )
+        RETURNING *
+      )
+      SELECT
+        a.id,
+        a.run_result_id,
+        a.run_result_created_at,
+        a.task_id,
+        COALESCE(
+          a.is_correct,
+          CASE
+            WHEN a.submitted_at IS NOT NULL
+              AND a.fields ? 'judgment'
+              AND rr.decision_output IS NOT NULL
+            THEN (a.fields->>'judgment') = rr.decision_output
+            ELSE NULL
+          END
+        ) AS is_correct,
+        a.fields,
+        a.notes,
+        a.locked_by,
+        a.locked_at,
+        a.lock_heartbeat_at,
+        a.submitted_at,
+        a.submitted_by,
+        a.created_at,
+        a.updated_at,
+        rr.external_id,
+        rr.input_variables,
+        rr.rendered_prompt,
+        rr.decision_output,
+        rr.raw_response,
+        rr.parsed_output,
+        rr.latency_ms,
+        rr.input_tokens,
+        rr.output_tokens
+      FROM claimed a
+      LEFT JOIN ph_runs.run_results rr ON rr.id = a.run_result_id
+      ORDER BY a.created_at ASC;
+    `);
+        return unwrapRows(result).map((row) => this.mapAnnotationRow(row));
+    }
+    async submitAnnotation(annotationId, actorUserId, payload) {
+        const result = await this.db
+            .update(annotations)
+            .set({
+            isCorrect: payload.isCorrect,
+            notes: payload.notes,
+            fields: payload.fields,
+            submittedBy: actorUserId,
+            submittedAt: new Date(),
+            updatedAt: new Date(),
+        })
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(annotations.id, annotationId), (0, drizzle_orm_1.eq)(annotations.lockedBy, actorUserId), (0, drizzle_orm_1.isNull)(annotations.submittedAt)))
+            .returning();
+        return result[0] ?? null;
+    }
+    async releaseAnnotation(annotationId, actorUserId) {
+        const result = await this.db
+            .update(annotations)
+            .set({ lockedBy: null, lockedAt: null, lockHeartbeatAt: null, updatedAt: new Date() })
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(annotations.id, annotationId), (0, drizzle_orm_1.eq)(annotations.lockedBy, actorUserId), (0, drizzle_orm_1.isNull)(annotations.submittedAt)))
+            .returning();
+        return result[0] ?? null;
+    }
+    async findCanaryEventRow(projectId, canaryId) {
+        const projectFilter = projectId ? (0, drizzle_orm_1.sql) `AND e.project_id = ${projectId}::uuid` : (0, drizzle_orm_1.sql) ``;
+        const rows = await this.db.execute((0, drizzle_orm_1.sql) `
+      ${canaryEventSelectSql()}
+      WHERE e.lane_type = 'canary'
+        ${projectFilter}
+        AND e.id = ${canaryId}::uuid
+      LIMIT 1
+    `);
+        const row = unwrapRows(rows)[0];
+        return row ? mapCanaryEventRow(row) : null;
+    }
+    mapAnnotationRow(row) {
+        return {
+            id: row['id'],
+            runResultId: row['run_result_id'],
+            runResultCreatedAt: new Date(row['run_result_created_at']),
+            taskId: row['task_id'] ?? null,
+            isCorrect: row['is_correct'] ?? null,
+            fields: row['fields'] ?? {},
+            notes: row['notes'] ?? null,
+            lockedBy: row['locked_by'] ?? null,
+            lockedAt: row['locked_at'] ? new Date(row['locked_at']) : null,
+            lockHeartbeatAt: row['lock_heartbeat_at'] ? new Date(row['lock_heartbeat_at']) : null,
+            submittedAt: row['submitted_at'] ? new Date(row['submitted_at']) : null,
+            submittedBy: row['submitted_by'] ?? null,
+            createdAt: new Date(row['created_at']),
+            updatedAt: new Date(row['updated_at']),
+            externalId: row['external_id'] ?? null,
+            inputVariables: row['input_variables'],
+            renderedPrompt: row['rendered_prompt'],
+            decisionOutput: row['decision_output'] ?? null,
+            rawResponse: row['raw_response'] ?? null,
+            parsedOutput: row['parsed_output'],
+            latencyMs: row['latency_ms'] ?? null,
+            inputTokens: row['input_tokens'] ?? null,
+            outputTokens: row['output_tokens'] ?? null,
+        };
+    }
+    annotationCorrectnessSql() {
+        return (0, drizzle_orm_1.sql) `COALESCE(
+      ${annotations.isCorrect},
+      CASE
+        WHEN ${annotations.submittedAt} IS NOT NULL
+          AND ${annotations.fields} ? 'judgment'
+          AND ${runResults.decisionOutput} IS NOT NULL
+        THEN (${annotations.fields}->>'judgment') = ${runResults.decisionOutput}
+        ELSE NULL
+      END
+    )`;
+    }
+    annotationCorrectnessSqlForAliases() {
+        return (0, drizzle_orm_1.sql) `COALESCE(
+      a.is_correct,
+      CASE
+        WHEN a.submitted_at IS NOT NULL
+          AND a.fields ? 'judgment'
+          AND rr.decision_output IS NOT NULL
+        THEN (a.fields->>'judgment') = rr.decision_output
+        ELSE NULL
+      END
+    )`;
+    }
+    buildAnnotationFilters(taskId, status) {
+        const filters = [(0, drizzle_orm_1.sql) `a.task_id = ${taskId}::uuid`];
+        if (status === 'pending') {
+            filters.push((0, drizzle_orm_1.sql) `a.submitted_at IS NULL`, (0, drizzle_orm_1.sql) `(a.locked_by IS NULL OR a.lock_heartbeat_at < NOW() - INTERVAL '5 min')`);
+        }
+        else if (status === 'claimed') {
+            filters.push((0, drizzle_orm_1.sql) `a.locked_by IS NOT NULL`, (0, drizzle_orm_1.sql) `a.submitted_at IS NULL`, (0, drizzle_orm_1.sql) `a.lock_heartbeat_at >= NOW() - INTERVAL '5 min'`);
+        }
+        else if (status === 'submitted') {
+            filters.push((0, drizzle_orm_1.sql) `a.submitted_at IS NOT NULL`);
+        }
+        return filters;
+    }
+    async attachAnnotationTaskIds(rows) {
+        if (rows.length === 0)
+            return [];
+        const ids = rows.map((row) => row.id);
+        const tasks = await this.db
+            .select({ id: annotationTasks.id, releaseLineEventId: annotationTasks.releaseLineEventId })
+            .from(annotationTasks)
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.inArray)(annotationTasks.releaseLineEventId, ids), (0, drizzle_orm_1.eq)(annotationTasks.scope, 'canary')));
+        const map = new Map();
+        for (const task of tasks) {
+            if (task.releaseLineEventId)
+                map.set(task.releaseLineEventId, task.id);
+        }
+        return rows.map((row) => ({
+            ...row,
+            annotationTaskId: map.get(row.id) ?? ('annotationTaskId' in row ? row.annotationTaskId : null) ?? null,
+        }));
+    }
+};
+exports.CanaryReleaseRepository = CanaryReleaseRepository;
+exports.CanaryReleaseRepository = CanaryReleaseRepository = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(database_constants_1.DATABASE_CLIENT)),
+    __metadata("design:paramtypes", [Object])
+], CanaryReleaseRepository);
+function canaryEventSelectSql() {
+    return (0, drizzle_orm_1.sql) `
+    SELECT
+      e.id,
+      e.release_line_id,
+      e.project_id,
+      line.name,
+      line.description,
+      e.release_variant_id,
+      rv.variant_number AS release_variant_number,
+      e.prompt_id,
+      e.prompt_name,
+      e.prompt_version_id,
+      e.prompt_version_number,
+      e.model_id,
+      e.input_connector_id,
+      e.output_connector_ids,
+      e.status,
+      e.control_state,
+      e.control_state_payload,
+      e.traffic_ratio,
+      e.traffic_mode,
+      e.record_mode,
+      e.filter_rules,
+      e.variable_mapping,
+      e.output_mapping,
+      e.external_id_field,
+      e.run_config,
+      e.prompt_snapshot,
+      e.prompt_version_snapshot,
+      e.total_received,
+      e.total_processed,
+      e.total_filtered,
+      e.total_correct,
+      e.total_errors,
+      e.metrics,
+      e.started_at,
+      e.finished_at,
+      e.created_by,
+      e.created_at,
+      e.updated_at,
+      COALESCE(m.name, e.model_snapshot->>'name') AS model_name,
+      COALESCE(m.provider_type, e.model_snapshot->>'providerType', e.model_snapshot->>'provider') AS model_provider,
+      COALESCE(ic.name, e.input_connector_snapshot->>'name') AS input_connector_name,
+      COALESCE(ic.type, e.input_connector_snapshot->>'type') AS input_connector_type,
+      NULL::text AS target_dataset_name,
+      NULL::text AS created_by_name
+    FROM ph_releases.release_line_events e
+    INNER JOIN ph_releases.release_lines line ON line.id = e.release_line_id
+    LEFT JOIN ph_releases.release_variants rv ON rv.id = e.release_variant_id
+    LEFT JOIN ph_assets.models m ON m.id = e.model_id
+    LEFT JOIN ph_assets.connectors ic ON ic.id = e.input_connector_id
+  `;
+}
+function mapCanaryEventRow(row) {
+    const id = row['id'];
+    return {
+        id,
+        releaseLineId: row['release_line_id'],
+        projectId: row['project_id'],
+        name: row['name'] ?? null,
+        description: row['description'] ?? null,
+        promptVersionId: row['prompt_version_id'] ?? id,
+        modelId: row['model_id'] ?? id,
+        inputConnectorId: row['input_connector_id'] ?? id,
+        outputConnectorIds: normalizeStringArray(row['output_connector_ids']),
+        status: canaryStatusFromReleaseStatus(row['status']),
+        controlState: row['control_state'] ?? null,
+        controlStatePayload: row['control_state_payload'],
+        trafficRatio: String(row['traffic_ratio'] ?? '0'),
+        trafficMode: row['traffic_mode'] ?? 'split',
+        runMode: 'manual',
+        stopConditions: null,
+        recordMode: row['record_mode'] ?? 'all',
+        filterRules: row['filter_rules'] ?? null,
+        variableMapping: row['variable_mapping'] ?? [],
+        outputMapping: row['output_mapping'] ?? [],
+        externalIdField: row['external_id_field'] ?? 'id',
+        annotationSchema: [],
+        storageCategories: [],
+        targetDatasetId: null,
+        runConfig: row['run_config'] ?? {},
+        promptSnapshot: asRecord(row['prompt_snapshot']),
+        promptVersionSnapshot: asRecord(row['prompt_version_snapshot']),
+        totalReceived: Number(row['total_received'] ?? 0),
+        totalProcessed: Number(row['total_processed'] ?? 0),
+        totalFiltered: Number(row['total_filtered'] ?? 0),
+        totalCorrect: Number(row['total_correct'] ?? 0),
+        totalErrors: Number(row['total_errors'] ?? 0),
+        metrics: row['metrics'] ?? null,
+        startedAt: toDateOrNull(row['started_at']),
+        finishedAt: toDateOrNull(row['finished_at']),
+        createdBy: row['created_by'],
+        createdAt: toDateOrNull(row['created_at']) ?? new Date(0),
+        updatedAt: toDateOrNull(row['updated_at']) ?? new Date(0),
+        deletedAt: null,
+        promptId: row['prompt_id'] ?? null,
+        promptName: row['prompt_name'] ?? null,
+        promptVersionNumber: toNumberOrNull(row['prompt_version_number']),
+        modelName: row['model_name'] ?? null,
+        modelProvider: row['model_provider'] ?? null,
+        inputConnectorName: row['input_connector_name'] ?? null,
+        inputConnectorType: row['input_connector_type'] ?? null,
+        targetDatasetName: null,
+        createdByName: null,
+        annotationTaskId: null,
+        releaseVariantId: row['release_variant_id'] ?? null,
+        releaseVariantNumber: toNumberOrNull(row['release_variant_number']),
+    };
+}
+function canaryStatusFromReleaseStatus(status) {
+    if (status === 'archived')
+        return 'cancelled';
+    if (status === 'running' ||
+        status === 'stopped' ||
+        status === 'completed' ||
+        status === 'failed' ||
+        status === 'cancelled') {
+        return status;
+    }
+    return 'running';
+}
+function uuidList(ids) {
+    return drizzle_orm_1.sql.join(ids.map((id) => (0, drizzle_orm_1.sql) `${id}::uuid`), (0, drizzle_orm_1.sql) `, `);
+}
+function unwrapRows(result) {
+    if (Array.isArray(result))
+        return result;
+    if (result && typeof result === 'object' && 'rows' in result)
+        return result.rows ?? [];
+    return [];
+}
+function toDateOrNull(value) {
+    if (!value)
+        return null;
+    return value instanceof Date ? value : new Date(value);
+}
+function toNumberOrNull(value) {
+    if (value === null || value === undefined)
+        return null;
+    const n = typeof value === 'number' ? value : Number(value);
+    return Number.isFinite(n) ? n : null;
+}
+function normalizeStringArray(value) {
+    return Array.isArray(value) ? value.filter((item) => typeof item === 'string') : [];
+}
+function asRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+//# sourceMappingURL=canary-release.repository.js.map