@cat-factory/node-server 0.6.0 → 0.7.2

package/dist/repositories/drizzle.js

@@ -1,7 +1,7 @@
 import { LLM_WARNING_FINISH_REASONS } from '@cat-factory/kernel';
 import { blockInsertValues, blockPatchToColumns, rowToBlock, rowToExecution, executionToDetail, rowToPipeline, rowToWorkspace, } from '@cat-factory/server';
 import { and, desc, eq, gte, inArray, isNull, lt, or, sql } from 'drizzle-orm';
-import { accountInvitations, accounts, agentRuns, blocks, consensusSessions, emailConnections, llmCallMetrics, memberships, mergeThresholdPresets, repoBlueprints, pipelineScheduleRuns, pipelineSchedules, pipelines, requirementReviews, clarityReviews, services, tokenUsage, trackerSettings, userIdentities, users, workspaceFragmentDefaults, workspaceModelDefaults, workspaceServices, workspaces, } from '../db/schema.js';
+import { accountInvitations, accounts, agentRuns, blocks, consensusSessions, datadogConnections, emailConnections, llmCallMetrics, memberships, mergeThresholdPresets, releaseHealthConfigs, pipelineScheduleRuns, pipelineSchedules, pipelines, requirementReviews, clarityReviews, services, tokenUsage, trackerSettings, userIdentities, users, workspaceFragmentDefaults, workspaceModelDefaults, workspaceServices, workspaceSettings, workspaces, } from '../db/schema.js';
 // Drizzle/Postgres implementations of the core kernel repository ports. The
 // row<->domain mapping is the SAME shared mapping the Cloudflare D1 repos use
 // (@cat-factory/server), so behaviour matches across stores; this layer only owns
@@ -181,6 +181,9 @@ class DrizzlePipelineRepository {
             thresholds: pipeline.thresholds ? JSON.stringify(pipeline.thresholds) : null,
             enabled: pipeline.enabled ? JSON.stringify(pipeline.enabled) : null,
             consensus: pipeline.consensus ? JSON.stringify(pipeline.consensus) : null,
+            gating: pipeline.gating ? JSON.stringify(pipeline.gating) : null,
+            labels: pipeline.labels ? JSON.stringify(pipeline.labels) : null,
+            archived: pipeline.archived ? 1 : null,
             builtin: pipeline.builtin ? 1 : null,
         });
     }
@@ -196,6 +199,9 @@ class DrizzlePipelineRepository {
             thresholds: pipeline.thresholds ? JSON.stringify(pipeline.thresholds) : null,
             enabled: pipeline.enabled ? JSON.stringify(pipeline.enabled) : null,
             consensus: pipeline.consensus ? JSON.stringify(pipeline.consensus) : null,
+            gating: pipeline.gating ? JSON.stringify(pipeline.gating) : null,
+            labels: pipeline.labels ? JSON.stringify(pipeline.labels) : null,
+            archived: pipeline.archived ? 1 : null,
         })
             .where(and(eq(pipelines.workspace_id, workspaceId), eq(pipelines.id, pipeline.id)));
     }
@@ -1148,6 +1154,8 @@ class DrizzleTrackerSettingsRepository {
         return {
             tracker: row.tracker ?? null,
             jiraProjectKey: row.jira_project_key,
+            writebackCommentOnPrOpen: row.writeback_comment_on_pr_open === 1,
+            writebackResolveOnMerge: row.writeback_resolve_on_merge === 1,
             updatedAt: row.updated_at,
         };
     }
@@ -1158,6 +1166,8 @@ class DrizzleTrackerSettingsRepository {
             workspace_id: workspaceId,
             tracker: settings.tracker,
             jira_project_key: settings.jiraProjectKey,
+            writeback_comment_on_pr_open: settings.writebackCommentOnPrOpen ? 1 : 0,
+            writeback_resolve_on_merge: settings.writebackResolveOnMerge ? 1 : 0,
             updated_at: settings.updatedAt,
         })
             .onConflictDoUpdate({
@@ -1165,6 +1175,8 @@ class DrizzleTrackerSettingsRepository {
             set: {
                 tracker: settings.tracker,
                 jira_project_key: settings.jiraProjectKey,
+                writeback_comment_on_pr_open: settings.writebackCommentOnPrOpen ? 1 : 0,
+                writeback_resolve_on_merge: settings.writebackResolveOnMerge ? 1 : 0,
                 updated_at: settings.updatedAt,
             },
         });
@@ -1674,6 +1686,8 @@ function rowToMergePreset(row) {
         ciMaxAttempts: row.ci_max_attempts,
         maxRequirementIterations: row.max_requirement_iterations,
         maxRequirementConcernAllowed: row.max_requirement_concern_allowed,
+        releaseWatchWindowMinutes: row.release_watch_window_minutes,
+        releaseMaxAttempts: row.release_max_attempts,
         isDefault: row.is_default === 1,
         createdAt: row.created_at,
     };
@@ -1727,6 +1741,8 @@ export class DrizzleMergePresetRepository {
             ci_max_attempts: preset.ciMaxAttempts,
             max_requirement_iterations: preset.maxRequirementIterations,
             max_requirement_concern_allowed: preset.maxRequirementConcernAllowed,
+            release_watch_window_minutes: preset.releaseWatchWindowMinutes,
+            release_max_attempts: preset.releaseMaxAttempts,
             is_default: preset.isDefault ? 1 : 0,
             created_at: preset.createdAt,
         };
@@ -1753,6 +1769,8 @@ export class DrizzleMergePresetRepository {
                     ci_max_attempts: values.ci_max_attempts,
                     max_requirement_iterations: values.max_requirement_iterations,
                     max_requirement_concern_allowed: values.max_requirement_concern_allowed,
+                    release_watch_window_minutes: values.release_watch_window_minutes,
+                    release_max_attempts: values.release_max_attempts,
                     is_default: values.is_default,
                 },
             });
@@ -1764,81 +1782,192 @@ export class DrizzleMergePresetRepository {
             .where(and(eq(mergeThresholdPresets.workspace_id, workspaceId), eq(mergeThresholdPresets.id, id), eq(mergeThresholdPresets.is_default, 0)));
     }
 }
-function rowToBlueprintRecord(row) {
-    return {
-        id: row.id,
-        workspaceId: row.workspace_id,
-        repoOwner: row.repo_owner,
-        repoName: row.repo_name,
-        source: row.source,
-        service: JSON.parse(row.service_json),
-        createdAt: row.created_at,
-        updatedAt: row.updated_at,
-    };
+/**
+ * Per-workspace runtime settings over Postgres (the Drizzle mirror of the Worker's
+ * `D1WorkspaceSettingsRepository`, migration 0004). One row per workspace; the service
+ * lazily seeds the default, so an absent row reads as null. Per-type task limits are a
+ * JSON column.
+ */
+export class DrizzleWorkspaceSettingsRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async get(workspaceId) {
+        const rows = await this.db
+            .select()
+            .from(workspaceSettings)
+            .where(eq(workspaceSettings.workspace_id, workspaceId))
+            .limit(1);
+        const row = rows[0];
+        if (!row)
+            return null;
+        let perType = null;
+        if (row.task_limit_per_type) {
+            try {
+                perType = JSON.parse(row.task_limit_per_type);
+            }
+            catch {
+                perType = null;
+            }
+        }
+        return {
+            waitingEscalationMinutes: row.waiting_escalation_minutes,
+            taskLimitMode: row.task_limit_mode,
+            taskLimitShared: row.task_limit_shared,
+            taskLimitPerType: perType,
+        };
+    }
+    async upsert(workspaceId, settings) {
+        const values = {
+            workspace_id: workspaceId,
+            waiting_escalation_minutes: settings.waitingEscalationMinutes,
+            task_limit_mode: settings.taskLimitMode,
+            task_limit_shared: settings.taskLimitShared,
+            task_limit_per_type: settings.taskLimitPerType
+                ? JSON.stringify(settings.taskLimitPerType)
+                : null,
+        };
+        await this.db
+            .insert(workspaceSettings)
+            .values(values)
+            .onConflictDoUpdate({
+            target: [workspaceSettings.workspace_id],
+            set: {
+                waiting_escalation_minutes: values.waiting_escalation_minutes,
+                task_limit_mode: values.task_limit_mode,
+                task_limit_shared: values.task_limit_shared,
+                task_limit_per_type: values.task_limit_per_type,
+            },
+        });
+    }
 }
 /**
- * Repository blueprints over Postgres (the Drizzle mirror of the Worker's
- * `D1RepoBlueprintRepository`, migration 0011). One row per (workspace, repo):
- * `upsert` replaces the existing blueprint in place, keyed by the unique
- * `(workspace_id, repo_owner, repo_name)` index, so the row is always the single
- * current decomposition. The service → modules tree is persisted whole as JSON.
+ * A workspace's Datadog connection over Postgres (the Drizzle mirror of the Worker's
+ * `D1DatadogConnectionRepository`, migration 0003). One row per workspace; the keys are
+ * stored as sealed envelopes (encrypted by the caller).
  */
-export class DrizzleRepoBlueprintRepository {
+export class DrizzleDatadogConnectionRepository {
     db;
     constructor(db) {
         this.db = db;
     }
+    async get(workspaceId) {
+        const rows = await this.db
+            .select()
+            .from(datadogConnections)
+            .where(eq(datadogConnections.workspace_id, workspaceId))
+            .limit(1);
+        const row = rows[0];
+        if (!row)
+            return null;
+        return {
+            workspaceId: row.workspace_id,
+            site: row.site,
+            apiKey: row.api_key,
+            appKey: row.app_key,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+        };
+    }
     async upsert(record) {
         const values = {
-            id: record.id,
             workspace_id: record.workspaceId,
-            repo_owner: record.repoOwner,
-            repo_name: record.repoName,
-            source: record.source,
-            service_json: JSON.stringify(record.service),
+            site: record.site,
+            api_key: record.apiKey,
+            app_key: record.appKey,
             created_at: record.createdAt,
             updated_at: record.updatedAt,
         };
         await this.db
-            .insert(repoBlueprints)
+            .insert(datadogConnections)
             .values(values)
             .onConflictDoUpdate({
-            target: [repoBlueprints.workspace_id, repoBlueprints.repo_owner, repoBlueprints.repo_name],
+            target: datadogConnections.workspace_id,
             set: {
-                source: values.source,
-                service_json: values.service_json,
+                site: values.site,
+                api_key: values.api_key,
+                app_key: values.app_key,
                 updated_at: values.updated_at,
             },
         });
     }
-    async get(workspaceId, id) {
-        const rows = await this.db
-            .select()
-            .from(repoBlueprints)
-            .where(and(eq(repoBlueprints.workspace_id, workspaceId), eq(repoBlueprints.id, id)))
-            .limit(1);
-        return rows[0] ? rowToBlueprintRecord(rows[0]) : null;
+    async delete(workspaceId) {
+        await this.db.delete(datadogConnections).where(eq(datadogConnections.workspace_id, workspaceId));
+    }
+}
+function parseReleaseIds(json) {
+    try {
+        const parsed = JSON.parse(json);
+        return Array.isArray(parsed) ? parsed.map((x) => String(x)) : [];
+    }
+    catch {
+        return [];
+    }
+}
+function rowToReleaseHealthConfig(row) {
+    return {
+        workspaceId: row.workspace_id,
+        blockId: row.block_id,
+        monitorIds: parseReleaseIds(row.monitor_ids),
+        sloIds: parseReleaseIds(row.slo_ids),
+        envTag: row.env_tag,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+/**
+ * Per-block monitor/SLO mapping for the post-release-health gate over Postgres (the
+ * Drizzle mirror of the Worker's `D1ReleaseHealthConfigRepository`, migration 0003).
+ */
+export class DrizzleReleaseHealthConfigRepository {
+    db;
+    constructor(db) {
+        this.db = db;
     }
-    async getByRepo(workspaceId, repoOwner, repoName) {
+    async getByBlock(workspaceId, blockId) {
         const rows = await this.db
             .select()
-            .from(repoBlueprints)
-            .where(and(eq(repoBlueprints.workspace_id, workspaceId), eq(repoBlueprints.repo_owner, repoOwner), eq(repoBlueprints.repo_name, repoName)))
+            .from(releaseHealthConfigs)
+            .where(and(eq(releaseHealthConfigs.workspace_id, workspaceId), eq(releaseHealthConfigs.block_id, blockId)))
             .limit(1);
-        return rows[0] ? rowToBlueprintRecord(rows[0]) : null;
+        return rows[0] ? rowToReleaseHealthConfig(rows[0]) : null;
     }
     async listByWorkspace(workspaceId) {
         const rows = await this.db
             .select()
-            .from(repoBlueprints)
-            .where(eq(repoBlueprints.workspace_id, workspaceId))
-            .orderBy(desc(repoBlueprints.updated_at));
-        return rows.map(rowToBlueprintRecord);
+            .from(releaseHealthConfigs)
+            .where(eq(releaseHealthConfigs.workspace_id, workspaceId))
+            .orderBy(releaseHealthConfigs.block_id);
+        return rows.map(rowToReleaseHealthConfig);
     }
-    async delete(workspaceId, id) {
+    async upsert(record) {
+        const values = {
+            workspace_id: record.workspaceId,
+            block_id: record.blockId,
+            monitor_ids: JSON.stringify(record.monitorIds),
+            slo_ids: JSON.stringify(record.sloIds),
+            env_tag: record.envTag,
+            created_at: record.createdAt,
+            updated_at: record.updatedAt,
+        };
+        await this.db
+            .insert(releaseHealthConfigs)
+            .values(values)
+            .onConflictDoUpdate({
+            target: [releaseHealthConfigs.workspace_id, releaseHealthConfigs.block_id],
+            set: {
+                monitor_ids: values.monitor_ids,
+                slo_ids: values.slo_ids,
+                env_tag: values.env_tag,
+                updated_at: values.updated_at,
+            },
+        });
+    }
+    async delete(workspaceId, blockId) {
         await this.db
-            .delete(repoBlueprints)
-            .where(and(eq(repoBlueprints.workspace_id, workspaceId), eq(repoBlueprints.id, id)));
+            .delete(releaseHealthConfigs)
+            .where(and(eq(releaseHealthConfigs.workspace_id, workspaceId), eq(releaseHealthConfigs.block_id, blockId)));
     }
 }
 /** Build the Drizzle/Postgres-backed core repositories. */
@@ -1866,7 +1995,9 @@ export function createDrizzleRepositories(db, clock) {
         consensusSessionRepository: new DrizzleConsensusSessionRepository(db),
         clarityReviewRepository: new DrizzleClarityReviewRepository(db),
         mergePresetRepository: new DrizzleMergePresetRepository(db),
-        repoBlueprintRepository: new DrizzleRepoBlueprintRepository(db),
+        workspaceSettingsRepository: new DrizzleWorkspaceSettingsRepository(db),
+        datadogConnectionRepository: new DrizzleDatadogConnectionRepository(db),
+        releaseHealthConfigRepository: new DrizzleReleaseHealthConfigRepository(db),
     };
 }
 //# sourceMappingURL=drizzle.js.map