remove connection job table

Author: brendan-kellam

packages/backend/src/connectionSyncWorkload.test.ts

@@ -6,8 +6,6 @@ import { beforeEach, describe, expect, test, vi } from "vitest";
 const mocks = vi.hoisted(() => ({
     connectionFindUniqueOrThrow: vi.fn(),
     connectionUpdate: vi.fn(),
-    connectionSyncJobUpsert: vi.fn(),
-    connectionSyncJobUpdate: vi.fn(),
     compileGithubConfig: vi.fn(),
     loadConfig: vi.fn(),
     syncSearchContexts: vi.fn(),
@@ -99,36 +97,18 @@ import {
 import { reportRepositoryDiscoveryIssue } from "./repositoryDiscoveryIssueContext.js";
 import { REPO_PERMISSION_SYNC_WHERE } from "./ee/permissionSyncEligibility.js";
 
-const transactionClient = {
-    connection: {
-        update: mocks.connectionUpdate,
-    },
-    connectionSyncJob: {
-        upsert: mocks.connectionSyncJobUpsert,
-    },
-};
-const transaction = vi.fn(
-    (callback: (tx: typeof transactionClient) => Promise<unknown>) =>
-        callback(transactionClient),
-);
-
 const db = {
     connection: {
         findUniqueOrThrow: mocks.connectionFindUniqueOrThrow,
         update: mocks.connectionUpdate,
     },
-    connectionSyncJob: {
-        upsert: mocks.connectionSyncJobUpsert,
-        update: mocks.connectionSyncJobUpdate,
-    },
     repo: {
         findMany: mocks.repoFindMany,
         upsert: mocks.repoUpsert,
     },
     repoToConnection: {
         deleteMany: mocks.repoToConnectionDeleteMany,
     },
-    $transaction: transaction,
 } as unknown as PrismaClient;
 
 const jobManager = {
@@ -172,10 +152,10 @@ describe("connectionWorkload", () => {
         mocks.syncSearchContexts.mockResolvedValue(undefined);
     });
 
-    test("declares database-backed lifecycle hooks", () => {
+    test("only records the latest job when the workload starts", () => {
         expect(connectionWorkload.onStarted).toBeTypeOf("function");
-        expect(connectionWorkload.onCompleted).toBeTypeOf("function");
-        expect(connectionWorkload.onTerminalFailure).toBeTypeOf("function");
+        expect(connectionWorkload.onCompleted).toBeUndefined();
+        expect(connectionWorkload.onTerminalFailure).toBeUndefined();
     });
 
     test("uses a distinct execution lock for each connection", () => {
@@ -204,26 +184,9 @@ describe("connectionWorkload", () => {
         expect(mocks.connectionFindUniqueOrThrow).not.toHaveBeenCalled();
     });
 
-    test("marks the connection sync job as in progress when started", async () => {
+    test("records the latest connection sync job ID when started", async () => {
         await connectionWorkload.onStarted?.(lifecycleContext);
 
-        expect(mocks.connectionSyncJobUpsert).toHaveBeenCalledWith({
-            where: {
-                id: "job-1",
-            },
-            update: {
-                status: "IN_PROGRESS",
-                completedAt: null,
-                errorMessage: null,
-                warningMessages: [],
-            },
-            create: {
-                id: "job-1",
-                connectionId: 42,
-                status: "IN_PROGRESS",
-                warningMessages: [],
-            },
-        });
         expect(mocks.connectionUpdate).toHaveBeenCalledWith({
             where: {
                 id: 42,
@@ -232,42 +195,6 @@ describe("connectionWorkload", () => {
                 latestSyncJobId: "job-1",
             },
         });
-        expect(transaction).toHaveBeenCalledOnce();
-    });
-
-    test("marks the connection sync job as completed", async () => {
-        await connectionWorkload.onCompleted?.(lifecycleContext, {
-            outcome: "SUCCESS",
-        });
-
-        expect(mocks.connectionSyncJobUpdate).toHaveBeenCalledWith({
-            where: {
-                id: "job-1",
-            },
-            data: {
-                status: "COMPLETED",
-                completedAt: expect.any(Date),
-                errorMessage: null,
-            },
-        });
-    });
-
-    test("marks the connection sync job as failed after terminal failure", async () => {
-        await connectionWorkload.onTerminalFailure?.(
-            lifecycleContext,
-            new Error("Connection credentials expired"),
-        );
-
-        expect(mocks.connectionSyncJobUpdate).toHaveBeenCalledWith({
-            where: {
-                id: "job-1",
-            },
-            data: {
-                status: "FAILED",
-                completedAt: expect.any(Date),
-                errorMessage: "Connection credentials expired",
-            },
-        });
     });
 
     test("orchestrates discovery, persistence, and repo work reconciliation", async () => {

packages/backend/src/connectionSyncWorkload.ts

@@ -1,5 +1,5 @@
 import * as Sentry from "@sentry/node";
-import { ConnectionSyncJobStatus, PrismaClient } from "@sourcebot/db";
+import { PrismaClient } from "@sourcebot/db";
 import { ConnectionConfig } from "@sourcebot/schemas/v3/index.type";
 import {
     CONNECTION_QUEUE,
@@ -152,55 +152,12 @@ export const createConnectionSyncWorkload = ({
             : { outcome: "PARTIAL_SUCCESS", reasons: issues };
     },
     onStarted: async ({ data: { connectionId }, jobId }) => {
-        await db.$transaction(async (tx) => {
-            await tx.connectionSyncJob.upsert({
-                where: {
-                    id: jobId,
-                },
-                update: {
-                    status: ConnectionSyncJobStatus.IN_PROGRESS,
-                    completedAt: null,
-                    errorMessage: null,
-                    warningMessages: [],
-                },
-                create: {
-                    id: jobId,
-                    connectionId,
-                    status: ConnectionSyncJobStatus.IN_PROGRESS,
-                    warningMessages: [],
-                },
-            });
-            await tx.connection.update({
-                where: {
-                    id: connectionId,
-                },
-                data: {
-                    latestSyncJobId: jobId,
-                },
-            });
-        });
-    },
-    onCompleted: async ({ jobId }) => {
-        await db.connectionSyncJob.update({
-            where: {
-                id: jobId,
-            },
-            data: {
-                status: ConnectionSyncJobStatus.COMPLETED,
-                completedAt: new Date(),
-                errorMessage: null,
-            },
-        });
-    },
-    onTerminalFailure: async ({ jobId }, error) => {
-        await db.connectionSyncJob.update({
+        await db.connection.update({
             where: {
-                id: jobId,
+                id: connectionId,
             },
             data: {
-                status: ConnectionSyncJobStatus.FAILED,
-                completedAt: new Date(),
-                errorMessage: error.message,
+                latestSyncJobId: jobId,
             },
         });
     },

packages/db/prisma/migrations/20260818193500_drop_connection_sync_job/migration.sql

@@ -0,0 +1,5 @@
+-- DropTable
+DROP TABLE "ConnectionSyncJob";
+
+-- DropEnum
+DROP TYPE "ConnectionSyncJobStatus";

packages/db/prisma/schema.prisma

@@ -134,7 +134,6 @@ model Connection {
   // The type of connection (e.g., github, gitlab, etc.)
   connectionType ConnectionType
 
-  syncJobs ConnectionSyncJob[]
   /// When the connection was last synced successfully.
   syncedAt           DateTime?
   latestSyncJobId    String? /// The most recently started connection sync job.
@@ -162,27 +161,6 @@ model Connection {
   @@unique([name, orgId])
 }
 
-enum ConnectionSyncJobStatus {
-  PENDING
-  IN_PROGRESS
-  COMPLETED
-  FAILED
-}
-
-model ConnectionSyncJob {
-  id          String                      @id @default(cuid())
-  status      ConnectionSyncJobStatus @default(PENDING)
-  createdAt   DateTime                    @default(now())
-  updatedAt   DateTime                    @updatedAt
-  completedAt DateTime?
-
-  warningMessages String[]
-  errorMessage String?
-
-  connection   Connection @relation(fields: [connectionId], references: [id], onDelete: Cascade)
-  connectionId Int
-}
-
 model RepoToConnection {
   addedAt DateTime @default(now())