@shipfox/api-projects 2.0.0

package/src/presentation/subscribers/on-source-commit-pushed.test.ts

@@ -0,0 +1,149 @@
+import {
+  INTEGRATION_SOURCE_COMMIT_PUSHED,
+  type IntegrationSourceCommitPushedEvent,
+  type SourcePushPayload,
+} from '@shipfox/api-integration-core-dto';
+import {PROJECT_SOURCE_COMMIT_OBSERVED} from '@shipfox/api-projects-dto';
+import type {DomainEvent} from '@shipfox/node-outbox';
+import {and, eq, sql} from 'drizzle-orm';
+import {db} from '#db/db.js';
+import {projectsOutbox} from '#db/schema/outbox.js';
+import {projectFactory} from '#test/index.js';
+import {createProjectsModule} from '../../index.js';
+import {onSourceCommitPushed} from './on-source-commit-pushed.js';
+
+function buildPush(overrides: Partial<SourcePushPayload> = {}): SourcePushPayload {
+  return {
+    externalRepositoryId: 'github:42',
+    ref: 'main',
+    headCommitSha: 'abc123',
+    defaultBranch: 'main',
+    isDefaultBranch: true,
+    ...overrides,
+  };
+}
+
+function buildEvent(
+  overrides: Partial<IntegrationSourceCommitPushedEvent> = {},
+  pushOverrides: Partial<SourcePushPayload> = {},
+  id = crypto.randomUUID(),
+): DomainEvent<IntegrationSourceCommitPushedEvent> {
+  return {
+    id,
+    type: INTEGRATION_SOURCE_COMMIT_PUSHED,
+    createdAt: new Date(),
+    payload: {
+      provider: 'github',
+      workspaceId: crypto.randomUUID(),
+      connectionId: crypto.randomUUID(),
+      deliveryId: crypto.randomUUID(),
+      receivedAt: new Date().toISOString(),
+      push: buildPush(pushOverrides),
+      ...overrides,
+    },
+  };
+}
+
+async function listCommitObservedEvents(externalRepositoryId: string) {
+  return await db()
+    .select()
+    .from(projectsOutbox)
+    .where(
+      and(
+        eq(projectsOutbox.eventType, PROJECT_SOURCE_COMMIT_OBSERVED),
+        sql`${projectsOutbox.payload}->>'externalRepositoryId' = ${externalRepositoryId}`,
+      ),
+    );
+}
+
+describe('onSourceCommitPushed', () => {
+  it('publishes a project source commit event for a default-branch push', async () => {
+    const sourceConnectionId = crypto.randomUUID();
+    const workspaceId = crypto.randomUUID();
+    const externalRepositoryId = `github:${crypto.randomUUID()}`;
+    const project = await projectFactory.create({
+      workspaceId,
+      sourceConnectionId,
+      sourceExternalRepositoryId: externalRepositoryId,
+    });
+    const event = buildEvent(
+      {workspaceId, connectionId: sourceConnectionId},
+      {externalRepositoryId},
+    );
+
+    await onSourceCommitPushed(event.payload, event);
+
+    const rows = await listCommitObservedEvents(externalRepositoryId);
+    expect(rows).toHaveLength(1);
+    expect(rows[0]?.payload).toMatchObject({
+      workspaceId,
+      projectId: project.id,
+      sourceConnectionId,
+      provider: 'github',
+      externalRepositoryId,
+      ref: 'main',
+      headCommitSha: 'abc123',
+    });
+  });
+
+  it('does not publish for a non-default branch push', async () => {
+    const sourceConnectionId = crypto.randomUUID();
+    const workspaceId = crypto.randomUUID();
+    const externalRepositoryId = `github:${crypto.randomUUID()}`;
+    await projectFactory.create({
+      workspaceId,
+      sourceConnectionId,
+      sourceExternalRepositoryId: externalRepositoryId,
+    });
+    const event = buildEvent(
+      {workspaceId, connectionId: sourceConnectionId},
+      {externalRepositoryId, ref: 'feature/x', isDefaultBranch: false},
+    );
+
+    await onSourceCommitPushed(event.payload, event);
+
+    const rows = await listCommitObservedEvents(externalRepositoryId);
+    expect(rows).toHaveLength(0);
+  });
+
+  it('does not publish when no project is bound to the pushed repository', async () => {
+    const externalRepositoryId = `github:${crypto.randomUUID()}`;
+    const event = buildEvent({}, {externalRepositoryId});
+
+    await onSourceCommitPushed(event.payload, event);
+
+    const rows = await listCommitObservedEvents(externalRepositoryId);
+    expect(rows).toHaveLength(0);
+  });
+
+  it('deduplicates the same source event for the same project', async () => {
+    const sourceConnectionId = crypto.randomUUID();
+    const workspaceId = crypto.randomUUID();
+    const externalRepositoryId = `github:${crypto.randomUUID()}`;
+    await projectFactory.create({
+      workspaceId,
+      sourceConnectionId,
+      sourceExternalRepositoryId: externalRepositoryId,
+    });
+    const event = buildEvent(
+      {workspaceId, connectionId: sourceConnectionId},
+      {externalRepositoryId},
+    );
+
+    await onSourceCommitPushed(event.payload, event);
+    await onSourceCommitPushed(event.payload, event);
+
+    const rows = await listCommitObservedEvents(externalRepositoryId);
+    expect(rows).toHaveLength(1);
+  });
+
+  // The source/event filter is the subscription itself, so this module should
+  // only receive the typed source-control event.
+  it('registers the projects module on INTEGRATION_SOURCE_COMMIT_PUSHED', () => {
+    const module = createProjectsModule({sourceControl: {} as never});
+
+    const events = module.subscribers?.map((subscriber) => subscriber.event);
+
+    expect(events).toContain(INTEGRATION_SOURCE_COMMIT_PUSHED);
+  });
+});

package/src/presentation/subscribers/on-source-commit-pushed.ts

@@ -0,0 +1,64 @@
+import type {IntegrationSourceCommitPushedEvent} from '@shipfox/api-integration-core-dto';
+import {PROJECT_SOURCE_COMMIT_OBSERVED} from '@shipfox/api-projects-dto';
+import {logger} from '@shipfox/node-opentelemetry';
+import {type DomainEvent, writeOutboxEvent} from '@shipfox/node-outbox';
+import {db} from '#db/db.js';
+import {recordIntegrationEventForProject} from '#db/integration-event-dedup.js';
+import {getProjectBySource} from '#db/projects.js';
+import {projectsOutbox} from '#db/schema/outbox.js';
+import {recordSourceCommitPushed, type SourceCommitPushedOutcome} from '#metrics/instance.js';
+
+export async function onSourceCommitPushed(
+  payload: IntegrationSourceCommitPushedEvent,
+  event: DomainEvent<IntegrationSourceCommitPushedEvent>,
+): Promise<void> {
+  const {provider, workspaceId, connectionId, push} = payload;
+
+  // Projects only track the default branch; other branches are someone else's policy.
+  if (!push.isDefaultBranch) {
+    recordSourceCommitPushed('non_default_branch');
+    return;
+  }
+
+  const project = await getProjectBySource({
+    workspaceId,
+    sourceConnectionId: connectionId,
+    sourceExternalRepositoryId: push.externalRepositoryId,
+  });
+  if (!project) {
+    logger().info(
+      {
+        eventId: event.id,
+        connectionId,
+        externalRepositoryId: push.externalRepositoryId,
+      },
+      'source commit pushed: no project bound to source, dropping',
+    );
+    recordSourceCommitPushed('unbound_source');
+    return;
+  }
+
+  const outcome = await db().transaction<SourceCommitPushedOutcome>(async (tx) => {
+    const {firstSeen} = await recordIntegrationEventForProject({
+      tx,
+      integrationEventId: event.id,
+      projectId: project.id,
+    });
+    if (!firstSeen) return 'duplicate';
+
+    await writeOutboxEvent(tx, projectsOutbox, {
+      type: PROJECT_SOURCE_COMMIT_OBSERVED,
+      payload: {
+        workspaceId: project.workspaceId,
+        projectId: project.id,
+        sourceConnectionId: project.sourceConnectionId,
+        provider,
+        externalRepositoryId: push.externalRepositoryId,
+        ref: push.ref,
+        headCommitSha: push.headCommitSha,
+      },
+    });
+    return 'observed';
+  });
+  recordSourceCommitPushed(outcome);
+}

package/src/temporal/activities/index.ts

@@ -0,0 +1,7 @@
+import {pruneIntegrationEventDedupActivity} from './prune-integration-event-dedup.js';
+
+export function createProjectsMaintenanceActivities() {
+  return {
+    pruneIntegrationEventDedupActivity,
+  };
+}

package/src/temporal/activities/prune-integration-event-dedup.test.ts

@@ -0,0 +1,50 @@
+import {randomUUID} from 'node:crypto';
+import {inArray} from 'drizzle-orm';
+import {db} from '#db/db.js';
+import {projectsIntegrationEventDedup} from '#db/schema/integration-event-dedup.js';
+import {pruneIntegrationEventDedupActivity} from './prune-integration-event-dedup.js';
+
+async function insertDedupRow(receivedAt: Date): Promise<{
+  integrationEventId: string;
+  projectId: string;
+}> {
+  const integrationEventId = randomUUID();
+  const projectId = randomUUID();
+  await db()
+    .insert(projectsIntegrationEventDedup)
+    .values({integrationEventId, projectId, receivedAt});
+  return {integrationEventId, projectId};
+}
+
+describe('pruneIntegrationEventDedupActivity', () => {
+  it('deletes rows older than the retention window and keeps recent ones', async () => {
+    const longAgo = new Date(Date.now() - 60 * 24 * 60 * 60 * 1000);
+    const yesterday = new Date(Date.now() - 24 * 60 * 60 * 1000);
+    const old = await insertDedupRow(longAgo);
+    const recent = await insertDedupRow(yesterday);
+
+    const result = await pruneIntegrationEventDedupActivity();
+
+    expect(result.deleted).toBe(1);
+    const remaining = await db()
+      .select()
+      .from(projectsIntegrationEventDedup)
+      .where(
+        inArray(projectsIntegrationEventDedup.integrationEventId, [
+          old.integrationEventId,
+          recent.integrationEventId,
+        ]),
+      );
+    expect(remaining.map((row) => row.integrationEventId)).toEqual([recent.integrationEventId]);
+    expect(remaining.map((row) => row.projectId)).toEqual([recent.projectId]);
+    expect(old.integrationEventId).not.toEqual(recent.integrationEventId);
+  });
+
+  it('returns zero deleted when nothing is past the retention window', async () => {
+    await insertDedupRow(new Date());
+
+    const result = await pruneIntegrationEventDedupActivity();
+
+    expect(result.deleted).toBe(0);
+  });
+});

package/src/temporal/activities/prune-integration-event-dedup.ts

@@ -0,0 +1,9 @@
+import {pruneIntegrationEventDedup} from '#db/integration-event-dedup.js';
+import {INTEGRATION_EVENT_DEDUP_RETENTION_DAYS} from '#temporal/constants.js';
+
+const MS_PER_DAY = 24 * 60 * 60 * 1000;
+
+export async function pruneIntegrationEventDedupActivity(): Promise<{deleted: number}> {
+  const olderThan = new Date(Date.now() - INTEGRATION_EVENT_DEDUP_RETENTION_DAYS * MS_PER_DAY);
+  return await pruneIntegrationEventDedup({olderThan});
+}

package/src/temporal/constants.ts

@@ -0,0 +1,3 @@
+export const PROJECTS_MAINTENANCE_TASK_QUEUE = 'projects-maintenance';
+
+export const INTEGRATION_EVENT_DEDUP_RETENTION_DAYS = 30;

package/src/temporal/workflows/index.ts

@@ -0,0 +1 @@
+export {pruneIntegrationEventDedupCron} from './prune-integration-event-dedup-cron.js';

package/src/temporal/workflows/prune-integration-event-dedup-cron.ts

@@ -0,0 +1,15 @@
+import {log, proxyActivities} from '@temporalio/workflow';
+import type {createProjectsMaintenanceActivities} from '../activities/index.js';
+
+const {pruneIntegrationEventDedupActivity} = proxyActivities<
+  ReturnType<typeof createProjectsMaintenanceActivities>
+>({
+  startToCloseTimeout: '5 minutes',
+});
+
+export async function pruneIntegrationEventDedupCron(): Promise<void> {
+  const {deleted} = await pruneIntegrationEventDedupActivity();
+  if (deleted > 0) {
+    log.info('Pruned projects integration event dedup rows', {deleted});
+  }
+}

package/test/env.ts

@@ -0,0 +1,14 @@
+process.env.POSTGRES_HOST ??= 'localhost';
+process.env.POSTGRES_PORT ??= '5432';
+process.env.POSTGRES_USERNAME ??= 'shipfox';
+process.env.POSTGRES_PASSWORD ??= 'password';
+process.env.POSTGRES_DATABASE = 'api_test';
+process.env.POSTGRES_MAX_CONNECTIONS ??= '5';
+process.env.TZ = 'UTC';
+process.env.GITHUB_APP_ID = '1';
+process.env.GITHUB_APP_PRIVATE_KEY = 'test-private-key';
+process.env.GITHUB_APP_CLIENT_ID = 'test-client-id';
+process.env.GITHUB_APP_CLIENT_SECRET = 'test-client-secret';
+process.env.GITHUB_APP_WEBHOOK_SECRET = 'test-webhook-secret';
+process.env.GITHUB_APP_SLUG = 'shipfox-test';
+process.env.GITHUB_INSTALL_STATE_SECRET = 'test-install-state-secret';

package/test/factories/project.ts

@@ -0,0 +1,24 @@
+import {Factory} from 'fishery';
+import type {Project} from '#core/entities/index.js';
+import {createProject} from '#db/index.js';
+
+export const projectFactory = Factory.define<Project>(({sequence, onCreate}) => {
+  onCreate(async (project) =>
+    createProject({
+      workspaceId: project.workspaceId,
+      sourceConnectionId: project.sourceConnectionId,
+      sourceExternalRepositoryId: project.sourceExternalRepositoryId,
+      name: project.name,
+    }),
+  );
+
+  return {
+    id: crypto.randomUUID(),
+    workspaceId: crypto.randomUUID(),
+    sourceConnectionId: crypto.randomUUID(),
+    sourceExternalRepositoryId: `repository-${sequence}`,
+    name: `Project ${sequence}`,
+    createdAt: new Date(),
+    updatedAt: new Date(),
+  };
+});

package/test/globalSetup.ts

@@ -0,0 +1,17 @@
+import './env.js';
+import {runMigrations} from '@shipfox/node-drizzle';
+import {closePostgresClient, createPostgresClient} from '@shipfox/node-postgres';
+import {sql} from 'drizzle-orm';
+import {closeDb, db, migrationsPath} from '#db/index.js';
+
+export async function setup() {
+  createPostgresClient();
+
+  await runMigrations(db(), migrationsPath, '__drizzle_migrations_projects');
+  await db().execute(sql`TRUNCATE projects_projects CASCADE`);
+  await db().execute(sql`TRUNCATE projects_outbox CASCADE`);
+  await db().execute(sql`TRUNCATE projects_integration_event_dedup CASCADE`);
+
+  closeDb();
+  await closePostgresClient();
+}

package/test/index.ts

@@ -0,0 +1 @@
+export {projectFactory} from './factories/project.js';

package/test/setup.ts

@@ -0,0 +1,17 @@
+import './env.js';
+import {closePostgresClient, createPostgresClient} from '@shipfox/node-postgres';
+import {afterAll, afterEach, beforeAll, vi} from '@shipfox/vitest/vi';
+import {closeDb} from '#db/index.js';
+
+beforeAll(() => {
+  createPostgresClient();
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+afterAll(async () => {
+  closeDb();
+  await closePostgresClient();
+});

package/tsconfig.build.json

@@ -0,0 +1,9 @@
+{
+  "extends": "@shipfox/ts-config/node",
+  "compilerOptions": {
+    "rootDir": "src",
+    "outDir": "dist"
+  },
+  "include": ["src"],
+  "exclude": ["**/*.test.tsx", "**/*.test.ts"]
+}