@proofhound/core 0.1.6

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

@@ -0,0 +1,834 @@
+"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.ReleaseLineRepository = void 0;
+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 { annotationTasks, connectors, models, projects, releaseLineEvents, releaseLines, releaseVariants } = db_1.schema;
+let ReleaseLineRepository = class ReleaseLineRepository {
+    constructor(db) {
+        this.db = db;
+    }
+    async findProjectAccess(projectId) {
+        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 list(projectId) {
+        const lines = await this.db
+            .select()
+            .from(releaseLines)
+            .where((0, drizzle_orm_1.eq)(releaseLines.projectId, projectId))
+            .orderBy((0, drizzle_orm_1.desc)(releaseLines.updatedAt));
+        return this.hydrateLines(lines);
+    }
+    async findById(projectId, releaseLineId) {
+        const rows = await this.db
+            .select()
+            .from(releaseLines)
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(releaseLines.projectId, projectId), (0, drizzle_orm_1.eq)(releaseLines.id, releaseLineId)))
+            .limit(1);
+        const line = rows[0];
+        if (!line)
+            return null;
+        const hydrated = await this.hydrateLines([line]);
+        return hydrated[0] ?? null;
+    }
+    async findByName(projectId, name) {
+        const rows = await this.db
+            .select({ id: releaseLines.id, name: releaseLines.name })
+            .from(releaseLines)
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(releaseLines.projectId, projectId), (0, drizzle_orm_1.eq)(releaseLines.name, name)))
+            .limit(1);
+        return rows[0] ?? null;
+    }
+    async findByIdentity(projectId, identity) {
+        const rows = await this.db
+            .select({ id: releaseLines.id, name: releaseLines.name })
+            .from(releaseLines)
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(releaseLines.projectId, projectId), releaseLineIdentityCondition(identity)))
+            .limit(1);
+        return rows[0] ?? null;
+    }
+    async listEvents(projectId, releaseLineId) {
+        const rows = await this.db
+            .select()
+            .from(releaseLineEvents)
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(releaseLineEvents.projectId, projectId), (0, drizzle_orm_1.eq)(releaseLineEvents.releaseLineId, releaseLineId)))
+            .orderBy((0, drizzle_orm_1.desc)(releaseLineEvents.createdAt));
+        return this.hydrateEvents(rows);
+    }
+    async record(snapshot) {
+        const releaseLineId = await this.db.transaction(async (tx) => {
+            const now = snapshot.updatedAt ?? new Date();
+            const existingLegacyEvent = await this.findExistingLegacyEvent(tx, snapshot);
+            if (existingLegacyEvent)
+                return existingLegacyEvent.releaseLineId;
+            const line = await this.findOrCreateLine(tx, snapshot, now);
+            let supersedesEventId = snapshot.supersedesEventId ?? null;
+            if (snapshot.laneType === 'production' && snapshot.status === 'running') {
+                const previousRunning = await tx
+                    .select({ id: releaseLineEvents.id })
+                    .from(releaseLineEvents)
+                    .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(releaseLineEvents.releaseLineId, line.id), (0, drizzle_orm_1.eq)(releaseLineEvents.laneType, 'production'), (0, drizzle_orm_1.eq)(releaseLineEvents.status, 'running')))
+                    .limit(1);
+                supersedesEventId = supersedesEventId ?? previousRunning[0]?.id ?? null;
+                await tx
+                    .update(releaseLineEvents)
+                    .set({
+                    status: 'stopped',
+                    terminalReason: snapshot.operation === 'rollback' ? 'rolled_back' : 'replaced',
+                    finishedAt: now,
+                    updatedAt: now,
+                })
+                    .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(releaseLineEvents.releaseLineId, line.id), (0, drizzle_orm_1.eq)(releaseLineEvents.laneType, 'production'), (0, drizzle_orm_1.eq)(releaseLineEvents.status, 'running')));
+            }
+            if (snapshot.laneType === 'production' && snapshot.operation === 'force_stop') {
+                await tx
+                    .update(releaseLineEvents)
+                    .set({
+                    status: 'stopped',
+                    terminalReason: 'force_stopped',
+                    finishedAt: now,
+                    controlState: null,
+                    controlStatePayload: null,
+                    updatedAt: now,
+                })
+                    .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(releaseLineEvents.releaseLineId, line.id), (0, drizzle_orm_1.eq)(releaseLineEvents.laneType, 'production'), (0, drizzle_orm_1.eq)(releaseLineEvents.status, 'running')));
+                await tx
+                    .update(releaseLineEvents)
+                    .set({
+                    status: 'cancelled',
+                    terminalReason: 'cancelled',
+                    finishedAt: now,
+                    controlState: null,
+                    controlStatePayload: null,
+                    updatedAt: now,
+                })
+                    .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(releaseLineEvents.releaseLineId, line.id), (0, drizzle_orm_1.eq)(releaseLineEvents.laneType, 'canary'), (0, drizzle_orm_1.sql) `${releaseLineEvents.status} IN ('running', 'stopped')`));
+            }
+            if (snapshot.laneType === 'canary') {
+                await tx
+                    .update(releaseLineEvents)
+                    .set({ status: 'completed', terminalReason: 'replaced', finishedAt: now, updatedAt: now })
+                    .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(releaseLineEvents.releaseLineId, line.id), (0, drizzle_orm_1.eq)(releaseLineEvents.laneType, 'canary'), (0, drizzle_orm_1.sql) `${releaseLineEvents.status} IN ('running', 'stopped')`));
+            }
+            const releaseVariant = await this.findOrCreateVariant(tx, line.id, snapshot, now);
+            const eventValues = await this.buildEventInsert(snapshot, line.id, supersedesEventId, releaseVariant?.id ?? null, now);
+            const inserted = await tx.insert(releaseLineEvents).values(eventValues).returning();
+            const event = inserted[0];
+            if (!event)
+                throw new Error('release_line_events insert returned no row');
+            await this.updateLinePointers(tx, line.id, event, now);
+            return line.id;
+        });
+        const result = await this.findById(snapshot.projectId, releaseLineId);
+        if (!result)
+            throw new Error('release_lines row disappeared after event insert');
+        return result;
+    }
+    async updateActiveCanaryTrafficRatio(projectId, releaseLineId, trafficRatio, actorUserId) {
+        const line = await this.findById(projectId, releaseLineId);
+        const canary = line?.activeCanaryEvent;
+        if (!line || !canary || (canary.status !== 'running' && canary.status !== 'stopped'))
+            return null;
+        if (canary.status === 'running' && canary.trafficMode === 'split' && trafficRatio >= 1) {
+            const promoted = await this.record(resetRuntimeStats({
+                ...eventDtoToSnapshot(line, canary),
+                laneType: 'production',
+                operation: 'promote_canary',
+                status: 'running',
+                terminalReason: null,
+                sourceEventId: canary.id,
+                trafficMode: null,
+                trafficRatio: null,
+                submitReason: promotionSubmitReason(line),
+                createdBy: actorUserId,
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                legacySource: null,
+                legacySourceId: null,
+            }));
+            await this.completeCanaryEvent(canary.id, 'promoted');
+            return this.findById(projectId, promoted.id);
+        }
+        await this.record(resetRuntimeStats({
+            ...eventDtoToSnapshot(line, canary),
+            operation: 'traffic_updated',
+            status: canary.status,
+            trafficRatio,
+            submitReason: `traffic ${Math.round(trafficRatio * 100)}%`,
+            createdBy: actorUserId,
+            createdAt: new Date(),
+            updatedAt: new Date(),
+            legacySource: null,
+            legacySourceId: null,
+        }));
+        return this.findById(projectId, releaseLineId);
+    }
+    async updateActiveLaneRunConfig(projectId, releaseLineId, input, actorUserId) {
+        const line = await this.findById(projectId, releaseLineId);
+        if (!line)
+            return null;
+        const event = input.laneType === 'production' ? line.currentProductionEvent : line.activeCanaryEvent;
+        if (!event)
+            return null;
+        if (event.status !== 'running' && event.status !== 'stopped')
+            return null;
+        const now = new Date();
+        const nextModel = input.modelId && input.modelId !== event.modelId
+            ? await this.findModelSnapshotForProject(projectId, input.modelId)
+            : null;
+        if (input.modelId && input.modelId !== event.modelId && (!nextModel || !nextModel.isActive))
+            return null;
+        const updated = await this.record(resetRuntimeStats({
+            ...eventDtoToSnapshot(line, event),
+            operation: 'config_changed',
+            terminalReason: null,
+            supersedesEventId: event.id,
+            modelId: nextModel?.id ?? event.modelId,
+            modelName: nextModel?.name ?? event.modelName,
+            modelProvider: nextModel?.providerType ?? event.modelProvider,
+            runConfig: input.runConfig,
+            submitReason: nextModel && input.laneType === 'production'
+                ? '正式发布模型与运行配置变更'
+                : nextModel
+                    ? '灰度发布模型与运行配置变更'
+                    : input.laneType === 'production'
+                        ? '正式发布运行配置变更'
+                        : '灰度发布运行配置变更',
+            createdBy: actorUserId,
+            createdAt: now,
+            updatedAt: now,
+            legacySource: null,
+            legacySourceId: null,
+        }));
+        return this.findById(projectId, updated.id);
+    }
+    async findModelSnapshotForProject(projectId, modelId) {
+        const rows = await this.db
+            .select({
+            id: models.id,
+            name: models.name,
+            providerType: models.providerType,
+            isActive: models.isActive,
+        })
+            .from(models)
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(models.projectId, projectId), (0, drizzle_orm_1.eq)(models.id, modelId), (0, drizzle_orm_1.isNull)(models.deletedAt)))
+            .limit(1);
+        return rows[0] ?? null;
+    }
+    async completeCanaryEvent(eventId, terminalReason) {
+        await this.db.transaction(async (tx) => {
+            const now = new Date();
+            const updated = await tx
+                .update(releaseLineEvents)
+                .set({
+                status: 'completed',
+                terminalReason,
+                finishedAt: now,
+                controlState: null,
+                controlStatePayload: null,
+                updatedAt: now,
+            })
+                .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(releaseLineEvents.id, eventId), (0, drizzle_orm_1.eq)(releaseLineEvents.laneType, 'canary')))
+                .returning();
+            const event = updated[0];
+            if (event)
+                await this.updateLinePointers(tx, event.releaseLineId, event, now);
+        });
+    }
+    async hydrateLines(lines) {
+        if (lines.length === 0)
+            return [];
+        const eventIds = new Set();
+        for (const line of lines) {
+            if (line.currentProductionEventId)
+                eventIds.add(line.currentProductionEventId);
+            if (line.activeCanaryEventId)
+                eventIds.add(line.activeCanaryEventId);
+        }
+        const latestRows = await this.db
+            .select()
+            .from(releaseLineEvents)
+            .where((0, drizzle_orm_1.inArray)(releaseLineEvents.releaseLineId, lines.map((line) => line.id)))
+            .orderBy((0, drizzle_orm_1.desc)(releaseLineEvents.createdAt));
+        const explicitEvents = eventIds.size > 0
+            ? await this.db
+                .select()
+                .from(releaseLineEvents)
+                .where((0, drizzle_orm_1.inArray)(releaseLineEvents.id, Array.from(eventIds)))
+            : [];
+        const variantRows = await this.db
+            .select()
+            .from(releaseVariants)
+            .where((0, drizzle_orm_1.inArray)(releaseVariants.releaseLineId, lines.map((line) => line.id)))
+            .orderBy(releaseVariants.variantNumber);
+        const hydratedEvents = await this.hydrateEvents([...latestRows, ...explicitEvents]);
+        const eventById = new Map(hydratedEvents.map((event) => [event.id, event]));
+        const latestByLine = new Map();
+        for (const event of hydratedEvents) {
+            if (!latestByLine.has(event.releaseLineId))
+                latestByLine.set(event.releaseLineId, event);
+        }
+        const variantsByLine = new Map();
+        for (const variant of variantRows) {
+            const list = variantsByLine.get(variant.releaseLineId) ?? [];
+            list.push(toReleaseVariantDto(variant));
+            variantsByLine.set(variant.releaseLineId, list);
+        }
+        return lines.map((line) => {
+            const currentProductionEvent = line.currentProductionEventId
+                ? (eventById.get(line.currentProductionEventId) ?? null)
+                : null;
+            const activeCanaryEvent = line.activeCanaryEventId ? (eventById.get(line.activeCanaryEventId) ?? null) : null;
+            return {
+                id: line.id,
+                projectId: line.projectId,
+                name: line.name,
+                description: line.description,
+                promptId: line.promptId,
+                promptName: line.promptName,
+                promptSnapshot: asRecord(line.promptSnapshot),
+                inputConnectorId: line.inputConnectorId,
+                inputConnectorName: line.inputConnectorName,
+                inputConnectorType: line.inputConnectorType,
+                inputConnectorSnapshot: asRecord(line.inputConnectorSnapshot),
+                status: line.status,
+                currentProductionEventId: line.currentProductionEventId,
+                activeCanaryEventId: line.activeCanaryEventId,
+                currentProductionEvent,
+                activeCanaryEvent,
+                variants: variantsByLine.get(line.id) ?? [],
+                outputConnectors: mergeOutputConnectors(currentProductionEvent, activeCanaryEvent),
+                latestEvent: latestByLine.get(line.id) ?? null,
+                createdBy: line.createdBy,
+                createdAt: line.createdAt.toISOString(),
+                updatedAt: line.updatedAt.toISOString(),
+                archivedAt: line.archivedAt ? line.archivedAt.toISOString() : null,
+            };
+        });
+    }
+    async hydrateEvents(rows) {
+        if (rows.length === 0)
+            return [];
+        const outputIds = new Set();
+        const sourceEventIds = new Set();
+        const eventIds = new Set();
+        const variantIds = new Set();
+        for (const row of rows) {
+            eventIds.add(row.id);
+            for (const id of row.outputConnectorIds ?? [])
+                outputIds.add(id);
+            if (row.sourceEventId)
+                sourceEventIds.add(row.sourceEventId);
+            if (row.releaseVariantId)
+                variantIds.add(row.releaseVariantId);
+        }
+        const outputMap = new Map();
+        if (outputIds.size > 0) {
+            const outputRows = await this.db
+                .select({ id: connectors.id, name: connectors.name, type: connectors.type })
+                .from(connectors)
+                .where((0, drizzle_orm_1.inArray)(connectors.id, Array.from(outputIds)));
+            for (const output of outputRows)
+                outputMap.set(output.id, output);
+        }
+        const sourceEventMap = new Map();
+        if (sourceEventIds.size > 0) {
+            const sourceRows = await this.db
+                .select({
+                id: releaseLineEvents.id,
+                legacySource: releaseLineEvents.legacySource,
+                legacySourceId: releaseLineEvents.legacySourceId,
+            })
+                .from(releaseLineEvents)
+                .where((0, drizzle_orm_1.inArray)(releaseLineEvents.id, Array.from(sourceEventIds)));
+            for (const source of sourceRows) {
+                sourceEventMap.set(source.id, {
+                    legacySource: source.legacySource,
+                    legacySourceId: source.legacySourceId,
+                });
+            }
+        }
+        const variantMap = new Map();
+        if (variantIds.size > 0) {
+            const variantRows = await this.db
+                .select()
+                .from(releaseVariants)
+                .where((0, drizzle_orm_1.inArray)(releaseVariants.id, Array.from(variantIds)));
+            for (const variant of variantRows)
+                variantMap.set(variant.id, variant);
+        }
+        const annotationTaskMap = new Map();
+        if (eventIds.size > 0) {
+            const taskRows = await this.db
+                .select({ id: annotationTasks.id, releaseLineEventId: annotationTasks.releaseLineEventId })
+                .from(annotationTasks)
+                .where((0, drizzle_orm_1.inArray)(annotationTasks.releaseLineEventId, Array.from(eventIds)));
+            for (const task of taskRows) {
+                if (task.releaseLineEventId && !annotationTaskMap.has(task.releaseLineEventId)) {
+                    annotationTaskMap.set(task.releaseLineEventId, task.id);
+                }
+            }
+        }
+        return rows.map((row) => {
+            const variant = row.releaseVariantId ? (variantMap.get(row.releaseVariantId) ?? null) : null;
+            const outputSnapshots = asArrayOfRecords(row.outputConnectorSnapshots);
+            const outputConnectors = (row.outputConnectorIds ?? []).map((id) => {
+                const fromJoin = outputMap.get(id);
+                if (fromJoin)
+                    return fromJoin;
+                const fromSnapshot = outputSnapshots.find((snapshot) => snapshot['id'] === id);
+                return {
+                    id,
+                    name: typeof fromSnapshot?.['name'] === 'string' ? fromSnapshot['name'] : id,
+                    type: typeof fromSnapshot?.['type'] === 'string' ? fromSnapshot['type'] : 'connector',
+                };
+            });
+            const promptVersionNumber = row.promptVersionNumber ?? numberFromSnapshot(row.promptVersionSnapshot, 'versionNumber');
+            return {
+                id: row.id,
+                projectId: row.projectId,
+                releaseLineId: row.releaseLineId,
+                releaseVariantId: row.releaseVariantId,
+                releaseVariantNumber: variant?.variantNumber ?? null,
+                releaseVariantLabel: variant ? formatReleaseVariantLabel(variant.variantNumber) : null,
+                annotationTaskId: annotationTaskMap.get(row.id) ?? null,
+                laneType: row.laneType,
+                operation: row.operation,
+                status: row.status,
+                terminalReason: row.terminalReason,
+                sourceEventId: row.sourceEventId,
+                sourceLegacySource: row.sourceEventId ? (sourceEventMap.get(row.sourceEventId)?.legacySource ?? null) : null,
+                sourceLegacyId: row.sourceEventId ? (sourceEventMap.get(row.sourceEventId)?.legacySourceId ?? null) : null,
+                supersedesEventId: row.supersedesEventId,
+                rollbackTargetEventId: row.rollbackTargetEventId,
+                legacySource: row.legacySource,
+                legacySourceId: row.legacySourceId,
+                promptId: row.promptId,
+                promptName: row.promptName,
+                promptVersionId: row.promptVersionId,
+                promptVersionNumber,
+                promptVersionLabel: promptVersionNumber ? `v${promptVersionNumber}` : null,
+                promptSnapshot: asRecord(row.promptSnapshot),
+                promptVersionSnapshot: asRecord(row.promptVersionSnapshot),
+                modelId: row.modelId,
+                modelName: stringFromSnapshot(row.modelSnapshot, 'name'),
+                modelProvider: stringFromSnapshot(row.modelSnapshot, 'providerType') ?? stringFromSnapshot(row.modelSnapshot, 'provider'),
+                modelSnapshot: asRecord(row.modelSnapshot),
+                inputConnectorId: row.inputConnectorId,
+                inputConnectorName: stringFromSnapshot(row.inputConnectorSnapshot, 'name'),
+                inputConnectorType: stringFromSnapshot(row.inputConnectorSnapshot, 'type'),
+                inputConnectorSnapshot: asRecord(row.inputConnectorSnapshot),
+                outputConnectorIds: row.outputConnectorIds ?? [],
+                outputConnectors,
+                outputConnectorSnapshots: outputSnapshots,
+                trafficMode: row.trafficMode,
+                trafficRatio: row.trafficRatio === null ? null : Number(row.trafficRatio),
+                runConfig: asRecord(row.runConfig),
+                variableMapping: row.variableMapping,
+                outputMapping: row.outputMapping,
+                filterRules: row.filterRules,
+                recordMode: row.recordMode,
+                externalIdField: row.externalIdField,
+                retentionDays: row.retentionDays,
+                sourceExperimentId: row.sourceExperimentId,
+                submitReason: row.submitReason,
+                metrics: row.metrics ? asRecord(row.metrics) : null,
+                totalReceived: row.totalReceived,
+                totalProcessed: row.totalProcessed,
+                totalFiltered: row.totalFiltered,
+                totalCorrect: row.totalCorrect,
+                totalErrors: row.totalErrors,
+                controlState: row.controlState,
+                controlStatePayload: row.controlStatePayload ? asRecord(row.controlStatePayload) : null,
+                startedAt: row.startedAt ? row.startedAt.toISOString() : null,
+                finishedAt: row.finishedAt ? row.finishedAt.toISOString() : null,
+                createdBy: row.createdBy,
+                createdAt: row.createdAt.toISOString(),
+                updatedAt: row.updatedAt.toISOString(),
+            };
+        });
+    }
+    async findOrCreateLine(tx, snapshot, now) {
+        const existing = await tx
+            .select()
+            .from(releaseLines)
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(releaseLines.projectId, snapshot.projectId), releaseLineIdentityCondition(snapshot)))
+            .limit(1);
+        const found = existing[0];
+        if (found) {
+            const updates = await tx
+                .update(releaseLines)
+                .set({
+                promptName: snapshot.promptName,
+                promptSnapshot: snapshot.promptSnapshot,
+                inputConnectorName: snapshot.inputConnectorName,
+                inputConnectorType: snapshot.inputConnectorType,
+                inputConnectorSnapshot: connectorSnapshot(snapshot.inputConnectorId, snapshot.inputConnectorName, snapshot.inputConnectorType),
+                updatedAt: now,
+            })
+                .where((0, drizzle_orm_1.eq)(releaseLines.id, found.id))
+                .returning();
+            return updates[0] ?? found;
+        }
+        const inserted = await tx
+            .insert(releaseLines)
+            .values({
+            projectId: snapshot.projectId,
+            name: snapshot.lineName,
+            description: snapshot.lineDescription ?? null,
+            promptId: snapshot.promptId ?? undefined,
+            promptName: snapshot.promptName,
+            promptSnapshot: snapshot.promptSnapshot,
+            inputConnectorId: snapshot.inputConnectorId ?? undefined,
+            inputConnectorName: snapshot.inputConnectorName,
+            inputConnectorType: snapshot.inputConnectorType,
+            inputConnectorSnapshot: connectorSnapshot(snapshot.inputConnectorId, snapshot.inputConnectorName, snapshot.inputConnectorType),
+            status: snapshot.laneType === 'production' ? 'production' : 'canary',
+            createdBy: snapshot.createdBy,
+            createdAt: snapshot.createdAt ?? now,
+            updatedAt: now,
+        })
+            .returning();
+        const line = inserted[0];
+        if (!line)
+            throw new Error('release_lines insert returned no row');
+        return line;
+    }
+    async findOrCreateVariant(tx, releaseLineId, snapshot, now) {
+        if (!snapshot.promptVersionId || !snapshot.modelId)
+            return null;
+        const existing = await tx
+            .select()
+            .from(releaseVariants)
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(releaseVariants.releaseLineId, releaseLineId), (0, drizzle_orm_1.eq)(releaseVariants.promptVersionId, snapshot.promptVersionId), (0, drizzle_orm_1.eq)(releaseVariants.modelId, snapshot.modelId)))
+            .limit(1);
+        const found = existing[0];
+        if (found) {
+            const updated = await tx
+                .update(releaseVariants)
+                .set({
+                promptName: snapshot.promptName,
+                promptVersionNumber: snapshot.promptVersionNumber ?? null,
+                promptSnapshot: snapshot.promptSnapshot,
+                promptVersionSnapshot: snapshot.promptVersionSnapshot,
+                modelSnapshot: modelSnapshot(snapshot.modelId, snapshot.modelName, snapshot.modelProvider),
+                updatedAt: now,
+            })
+                .where((0, drizzle_orm_1.eq)(releaseVariants.id, found.id))
+                .returning();
+            return updated[0] ?? found;
+        }
+        const maxRows = await tx
+            .select({ maxVariantNumber: (0, drizzle_orm_1.sql) `MAX(${releaseVariants.variantNumber})::int` })
+            .from(releaseVariants)
+            .where((0, drizzle_orm_1.eq)(releaseVariants.releaseLineId, releaseLineId));
+        const variantNumber = Number(maxRows[0]?.maxVariantNumber ?? 0) + 1;
+        const inserted = await tx
+            .insert(releaseVariants)
+            .values({
+            projectId: snapshot.projectId,
+            releaseLineId,
+            variantNumber,
+            promptId: snapshot.promptId ?? null,
+            promptName: snapshot.promptName,
+            promptVersionId: snapshot.promptVersionId,
+            promptVersionNumber: snapshot.promptVersionNumber ?? null,
+            promptSnapshot: snapshot.promptSnapshot,
+            promptVersionSnapshot: snapshot.promptVersionSnapshot,
+            modelId: snapshot.modelId,
+            modelSnapshot: modelSnapshot(snapshot.modelId, snapshot.modelName, snapshot.modelProvider),
+            createdBy: snapshot.createdBy,
+            createdAt: snapshot.createdAt ?? now,
+            updatedAt: now,
+        })
+            .returning();
+        return inserted[0] ?? null;
+    }
+    async findExistingLegacyEvent(tx, snapshot) {
+        if (!snapshot.legacySource || !snapshot.legacySourceId)
+            return null;
+        const rows = await tx
+            .select({ releaseLineId: releaseLineEvents.releaseLineId })
+            .from(releaseLineEvents)
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(releaseLineEvents.projectId, snapshot.projectId), (0, drizzle_orm_1.eq)(releaseLineEvents.legacySource, snapshot.legacySource), (0, drizzle_orm_1.eq)(releaseLineEvents.legacySourceId, snapshot.legacySourceId)))
+            .limit(1);
+        return rows[0] ?? null;
+    }
+    async buildEventInsert(snapshot, releaseLineId, supersedesEventId, releaseVariantId, now) {
+        const outputSnapshots = await this.loadOutputConnectorSnapshots(snapshot.outputConnectorIds);
+        return {
+            projectId: snapshot.projectId,
+            releaseLineId,
+            laneType: snapshot.laneType,
+            operation: snapshot.operation,
+            status: snapshot.status,
+            terminalReason: snapshot.terminalReason ?? null,
+            sourceEventId: snapshot.sourceEventId ?? null,
+            supersedesEventId,
+            rollbackTargetEventId: snapshot.rollbackTargetEventId ?? null,
+            legacySource: snapshot.legacySource ?? null,
+            legacySourceId: snapshot.legacySourceId ?? null,
+            releaseVariantId,
+            promptId: snapshot.promptId ?? null,
+            promptName: snapshot.promptName,
+            promptVersionId: snapshot.promptVersionId ?? null,
+            promptVersionNumber: snapshot.promptVersionNumber ?? null,
+            promptSnapshot: snapshot.promptSnapshot,
+            promptVersionSnapshot: snapshot.promptVersionSnapshot,
+            modelId: snapshot.modelId ?? null,
+            modelSnapshot: modelSnapshot(snapshot.modelId, snapshot.modelName, snapshot.modelProvider),
+            inputConnectorId: snapshot.inputConnectorId ?? null,
+            inputConnectorSnapshot: connectorSnapshot(snapshot.inputConnectorId, snapshot.inputConnectorName, snapshot.inputConnectorType),
+            outputConnectorIds: snapshot.outputConnectorIds,
+            outputConnectorSnapshots: outputSnapshots,
+            trafficMode: snapshot.trafficMode ?? null,
+            trafficRatio: snapshot.trafficRatio === null || snapshot.trafficRatio === undefined ? null : String(snapshot.trafficRatio),
+            runConfig: asRecord(snapshot.runConfig),
+            variableMapping: snapshot.variableMapping,
+            outputMapping: (snapshot.outputMapping ?? []),
+            filterRules: snapshot.filterRules,
+            recordMode: snapshot.recordMode,
+            externalIdField: snapshot.externalIdField ?? null,
+            retentionDays: snapshot.retentionDays ?? null,
+            sourceExperimentId: snapshot.sourceExperimentId ?? null,
+            submitReason: snapshot.submitReason ?? '',
+            metrics: snapshot.metrics,
+            totalReceived: snapshot.totalReceived ?? 0,
+            totalProcessed: snapshot.totalProcessed ?? 0,
+            totalFiltered: snapshot.totalFiltered ?? 0,
+            totalCorrect: snapshot.totalCorrect ?? 0,
+            totalErrors: snapshot.totalErrors ?? 0,
+            controlState: snapshot.controlState ?? null,
+            controlStatePayload: snapshot.controlStatePayload,
+            startedAt: snapshot.startedAt ?? null,
+            finishedAt: snapshot.finishedAt ?? null,
+            createdBy: snapshot.createdBy,
+            createdAt: snapshot.createdAt ?? now,
+            updatedAt: now,
+        };
+    }
+    async updateLinePointers(tx, releaseLineId, event, now) {
+        const productionRows = await tx
+            .select({ id: releaseLineEvents.id })
+            .from(releaseLineEvents)
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(releaseLineEvents.releaseLineId, releaseLineId), (0, drizzle_orm_1.eq)(releaseLineEvents.laneType, 'production'), (0, drizzle_orm_1.eq)(releaseLineEvents.status, 'running')))
+            .orderBy((0, drizzle_orm_1.desc)(releaseLineEvents.createdAt))
+            .limit(1);
+        const canaryRows = await tx
+            .select({ id: releaseLineEvents.id })
+            .from(releaseLineEvents)
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(releaseLineEvents.releaseLineId, releaseLineId), (0, drizzle_orm_1.eq)(releaseLineEvents.laneType, 'canary'), (0, drizzle_orm_1.sql) `${releaseLineEvents.status} IN ('running', 'stopped')`))
+            .orderBy((0, drizzle_orm_1.desc)(releaseLineEvents.createdAt))
+            .limit(1);
+        const currentProductionEventId = productionRows[0]?.id ?? null;
+        const activeCanaryEventId = canaryRows[0]?.id ?? null;
+        const status = lineStatus(currentProductionEventId, activeCanaryEventId);
+        await tx
+            .update(releaseLines)
+            .set({
+            currentProductionEventId,
+            activeCanaryEventId,
+            status,
+            updatedAt: now,
+            archivedAt: status === 'archived' ? now : null,
+        })
+            .where((0, drizzle_orm_1.eq)(releaseLines.id, releaseLineId));
+    }
+    async loadOutputConnectorSnapshots(outputConnectorIds) {
+        if (outputConnectorIds.length === 0)
+            return [];
+        const rows = await this.db
+            .select({ id: connectors.id, name: connectors.name, type: connectors.type })
+            .from(connectors)
+            .where((0, drizzle_orm_1.inArray)(connectors.id, outputConnectorIds));
+        const map = new Map(rows.map((row) => [row.id, row]));
+        return outputConnectorIds.map((id) => map.get(id) ?? { id, name: id, type: 'connector' });
+    }
+};
+exports.ReleaseLineRepository = ReleaseLineRepository;
+exports.ReleaseLineRepository = ReleaseLineRepository = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(database_constants_1.DATABASE_CLIENT)),
+    __metadata("design:paramtypes", [Object])
+], ReleaseLineRepository);
+function lineStatus(currentProductionEventId, activeCanaryEventId) {
+    if (currentProductionEventId && activeCanaryEventId)
+        return 'production_with_canary';
+    if (currentProductionEventId)
+        return 'production';
+    if (activeCanaryEventId)
+        return 'canary';
+    return 'stopped';
+}
+function asRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+function asArrayOfRecords(value) {
+    return Array.isArray(value)
+        ? value.filter((item) => Boolean(item) && typeof item === 'object' && !Array.isArray(item))
+        : [];
+}
+function stringFromSnapshot(snapshot, key) {
+    const value = asRecord(snapshot)[key];
+    return typeof value === 'string' ? value : null;
+}
+function numberFromSnapshot(snapshot, key) {
+    const value = asRecord(snapshot)[key];
+    if (typeof value === 'number' && Number.isFinite(value))
+        return value;
+    if (typeof value === 'string') {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed))
+            return parsed;
+    }
+    return null;
+}
+function connectorSnapshot(id, name, type) {
+    return { id, name, type };
+}
+function modelSnapshot(id, name, providerType) {
+    return { id, name, providerType };
+}
+function formatReleaseVariantLabel(variantNumber) {
+    return `#${variantNumber}`;
+}
+function toReleaseVariantDto(variant) {
+    const promptVersionNumber = variant.promptVersionNumber ?? numberFromSnapshot(variant.promptVersionSnapshot, 'versionNumber');
+    return {
+        id: variant.id,
+        projectId: variant.projectId,
+        releaseLineId: variant.releaseLineId,
+        variantNumber: variant.variantNumber,
+        label: formatReleaseVariantLabel(variant.variantNumber),
+        promptId: variant.promptId,
+        promptName: variant.promptName,
+        promptVersionId: variant.promptVersionId,
+        promptVersionNumber,
+        promptVersionLabel: promptVersionNumber ? `v${promptVersionNumber}` : null,
+        promptSnapshot: asRecord(variant.promptSnapshot),
+        promptVersionSnapshot: asRecord(variant.promptVersionSnapshot),
+        modelId: variant.modelId,
+        modelName: stringFromSnapshot(variant.modelSnapshot, 'name'),
+        modelProvider: stringFromSnapshot(variant.modelSnapshot, 'providerType') ?? stringFromSnapshot(variant.modelSnapshot, 'provider'),
+        modelSnapshot: asRecord(variant.modelSnapshot),
+        createdBy: variant.createdBy,
+        createdAt: variant.createdAt.toISOString(),
+        updatedAt: variant.updatedAt.toISOString(),
+    };
+}
+function mergeOutputConnectors(production, canary) {
+    const map = new Map();
+    for (const connector of production?.outputConnectors ?? [])
+        map.set(connector.id, connector);
+    for (const connector of canary?.outputConnectors ?? [])
+        map.set(connector.id, connector);
+    return [...map.values()];
+}
+function eventDtoToSnapshot(line, event) {
+    return {
+        projectId: event.projectId,
+        lineName: line.name,
+        lineDescription: line.description,
+        promptId: event.promptId,
+        promptName: event.promptName,
+        promptSnapshot: event.promptSnapshot,
+        promptVersionId: event.promptVersionId,
+        promptVersionNumber: event.promptVersionNumber,
+        promptVersionSnapshot: event.promptVersionSnapshot,
+        modelId: event.modelId,
+        modelName: event.modelName,
+        modelProvider: event.modelProvider,
+        inputConnectorId: event.inputConnectorId,
+        inputConnectorName: event.inputConnectorName,
+        inputConnectorType: event.inputConnectorType,
+        outputConnectorIds: event.outputConnectorIds,
+        laneType: event.laneType,
+        operation: event.operation,
+        status: event.status,
+        terminalReason: event.terminalReason,
+        sourceEventId: event.sourceEventId,
+        supersedesEventId: event.supersedesEventId,
+        rollbackTargetEventId: event.rollbackTargetEventId,
+        trafficMode: event.trafficMode,
+        trafficRatio: event.trafficRatio,
+        runConfig: event.runConfig,
+        variableMapping: event.variableMapping,
+        outputMapping: event.outputMapping,
+        filterRules: event.filterRules,
+        recordMode: event.recordMode,
+        externalIdField: event.externalIdField,
+        retentionDays: event.retentionDays,
+        sourceExperimentId: event.sourceExperimentId,
+        submitReason: event.submitReason,
+        metrics: event.metrics,
+        totalReceived: event.totalReceived,
+        totalProcessed: event.totalProcessed,
+        totalFiltered: event.totalFiltered,
+        totalCorrect: event.totalCorrect,
+        totalErrors: event.totalErrors,
+        controlState: event.controlState,
+        controlStatePayload: event.controlStatePayload,
+        startedAt: event.startedAt ? new Date(event.startedAt) : null,
+        finishedAt: event.finishedAt ? new Date(event.finishedAt) : null,
+        createdBy: event.createdBy,
+    };
+}
+function promotionSubmitReason(line) {
+    const currentProductionReason = normalizePromotionSubmitReason(line.currentProductionEvent?.submitReason);
+    if (currentProductionReason)
+        return currentProductionReason;
+    const lineName = line.name.trim();
+    const lineDescription = line.description?.trim();
+    return lineDescription ? `${lineName}\n${lineDescription}` : lineName;
+}
+function normalizePromotionSubmitReason(value) {
+    const trimmed = value?.trim();
+    if (!trimmed)
+        return '';
+    const normalized = stripLegacyCanaryPromotionPrefix(trimmed);
+    return isGenericPromotionSubmitReason(normalized) ? '' : normalized;
+}
+function stripLegacyCanaryPromotionPrefix(value) {
+    return value.replace(/^灰度候选\s*100%\s*接管[：:]\s*/u, '').trim();
+}
+function isGenericPromotionSubmitReason(value) {
+    return value.split('\n')[0]?.trim().toLowerCase() === 'promote canary 100%';
+}
+function resetRuntimeStats(snapshot) {
+    return {
+        ...snapshot,
+        metrics: null,
+        totalReceived: 0,
+        totalProcessed: 0,
+        totalFiltered: 0,
+        totalCorrect: 0,
+        totalErrors: 0,
+    };
+}
+function releaseLineIdentityCondition(identity) {
+    if (identity.inputConnectorId)
+        return (0, drizzle_orm_1.eq)(releaseLines.inputConnectorId, identity.inputConnectorId);
+    if (identity.promptId)
+        return (0, drizzle_orm_1.and)((0, drizzle_orm_1.isNull)(releaseLines.inputConnectorId), (0, drizzle_orm_1.eq)(releaseLines.promptId, identity.promptId));
+    return (0, drizzle_orm_1.isNull)(releaseLines.inputConnectorId);
+}
+//# sourceMappingURL=release-line.repository.js.map