@shipfox/api-projects 2.0.0

package/dist/db/db.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"db.d.ts","sourceRoot":"","sources":["../../src/db/db.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,KAAK,cAAc,EAAC,MAAM,uBAAuB,CAAC;AAMnE,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAIlB,CAAC;AAIF,wBAAgB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAGjB;AAED,wBAAgB,OAAO,IAAI,IAAI,CAE9B"}

package/dist/db/db.js

@@ -0,0 +1,22 @@
+import { drizzle } from '@shipfox/node-drizzle';
+import { pgClient } from '@shipfox/node-postgres';
+import { projectsIntegrationEventDedup } from './schema/integration-event-dedup.js';
+import { projectsOutbox } from './schema/outbox.js';
+import { projects } from './schema/projects.js';
+export const schema = {
+    projects,
+    projectsOutbox,
+    projectsIntegrationEventDedup
+};
+let _db;
+export function db() {
+    if (!_db) _db = drizzle(pgClient(), {
+        schema
+    });
+    return _db;
+}
+export function closeDb() {
+    _db = undefined;
+}
+
+//# sourceMappingURL=db.js.map

package/dist/db/db.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/db/db.ts"],"sourcesContent":["import {drizzle, type NodePgDatabase} from '@shipfox/node-drizzle';\nimport {pgClient} from '@shipfox/node-postgres';\nimport {projectsIntegrationEventDedup} from './schema/integration-event-dedup.js';\nimport {projectsOutbox} from './schema/outbox.js';\nimport {projects} from './schema/projects.js';\n\nexport const schema = {\n  projects,\n  projectsOutbox,\n  projectsIntegrationEventDedup,\n};\n\nlet _db: NodePgDatabase<typeof schema> | undefined;\n\nexport function db() {\n  if (!_db) _db = drizzle(pgClient(), {schema});\n  return _db;\n}\n\nexport function closeDb(): void {\n  _db = undefined;\n}\n"],"names":["drizzle","pgClient","projectsIntegrationEventDedup","projectsOutbox","projects","schema","_db","db","closeDb","undefined"],"mappings":"AAAA,SAAQA,OAAO,QAA4B,wBAAwB;AACnE,SAAQC,QAAQ,QAAO,yBAAyB;AAChD,SAAQC,6BAA6B,QAAO,sCAAsC;AAClF,SAAQC,cAAc,QAAO,qBAAqB;AAClD,SAAQC,QAAQ,QAAO,uBAAuB;AAE9C,OAAO,MAAMC,SAAS;IACpBD;IACAD;IACAD;AACF,EAAE;AAEF,IAAII;AAEJ,OAAO,SAASC;IACd,IAAI,CAACD,KAAKA,MAAMN,QAAQC,YAAY;QAACI;IAAM;IAC3C,OAAOC;AACT;AAEA,OAAO,SAASE;IACdF,MAAMG;AACR"}

package/dist/db/index.d.ts

@@ -0,0 +1,8 @@
+export { closeDb, db, schema } from './db.js';
+export { pruneIntegrationEventDedup, recordIntegrationEventForProject, } from './integration-event-dedup.js';
+export type { CreateProjectParams, GetProjectBySourceParams, ListProjectsParams, ListProjectsResult, } from './projects.js';
+export { createProject, getProjectById, getProjectBySource, getProjectCount, listProjects, requireProjectForWorkspace, } from './projects.js';
+export { projectsIntegrationEventDedup } from './schema/integration-event-dedup.js';
+export { projectsOutbox } from './schema/outbox.js';
+export declare const migrationsPath: string;
+//# sourceMappingURL=index.d.ts.map

package/dist/db/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/db/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAC,OAAO,EAAE,EAAE,EAAE,MAAM,EAAC,MAAM,SAAS,CAAC;AAC5C,OAAO,EACL,0BAA0B,EAC1B,gCAAgC,GACjC,MAAM,8BAA8B,CAAC;AACtC,YAAY,EACV,mBAAmB,EACnB,wBAAwB,EACxB,kBAAkB,EAClB,kBAAkB,GACnB,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,aAAa,EACb,cAAc,EACd,kBAAkB,EAClB,eAAe,EACf,YAAY,EACZ,0BAA0B,GAC3B,MAAM,eAAe,CAAC;AACvB,OAAO,EAAC,6BAA6B,EAAC,MAAM,qCAAqC,CAAC;AAClF,OAAO,EAAC,cAAc,EAAC,MAAM,oBAAoB,CAAC;AAElD,eAAO,MAAM,cAAc,QAAoE,CAAC"}

package/dist/db/index.js

@@ -0,0 +1,10 @@
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+export { closeDb, db, schema } from './db.js';
+export { pruneIntegrationEventDedup, recordIntegrationEventForProject } from './integration-event-dedup.js';
+export { createProject, getProjectById, getProjectBySource, getProjectCount, listProjects, requireProjectForWorkspace } from './projects.js';
+export { projectsIntegrationEventDedup } from './schema/integration-event-dedup.js';
+export { projectsOutbox } from './schema/outbox.js';
+export const migrationsPath = resolve(dirname(fileURLToPath(import.meta.url)), '../../drizzle');
+
+//# sourceMappingURL=index.js.map

package/dist/db/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/db/index.ts"],"sourcesContent":["import {dirname, resolve} from 'node:path';\nimport {fileURLToPath} from 'node:url';\n\nexport {closeDb, db, schema} from './db.js';\nexport {\n  pruneIntegrationEventDedup,\n  recordIntegrationEventForProject,\n} from './integration-event-dedup.js';\nexport type {\n  CreateProjectParams,\n  GetProjectBySourceParams,\n  ListProjectsParams,\n  ListProjectsResult,\n} from './projects.js';\nexport {\n  createProject,\n  getProjectById,\n  getProjectBySource,\n  getProjectCount,\n  listProjects,\n  requireProjectForWorkspace,\n} from './projects.js';\nexport {projectsIntegrationEventDedup} from './schema/integration-event-dedup.js';\nexport {projectsOutbox} from './schema/outbox.js';\n\nexport const migrationsPath = resolve(dirname(fileURLToPath(import.meta.url)), '../../drizzle');\n"],"names":["dirname","resolve","fileURLToPath","closeDb","db","schema","pruneIntegrationEventDedup","recordIntegrationEventForProject","createProject","getProjectById","getProjectBySource","getProjectCount","listProjects","requireProjectForWorkspace","projectsIntegrationEventDedup","projectsOutbox","migrationsPath","url"],"mappings":"AAAA,SAAQA,OAAO,EAAEC,OAAO,QAAO,YAAY;AAC3C,SAAQC,aAAa,QAAO,WAAW;AAEvC,SAAQC,OAAO,EAAEC,EAAE,EAAEC,MAAM,QAAO,UAAU;AAC5C,SACEC,0BAA0B,EAC1BC,gCAAgC,QAC3B,+BAA+B;AAOtC,SACEC,aAAa,EACbC,cAAc,EACdC,kBAAkB,EAClBC,eAAe,EACfC,YAAY,EACZC,0BAA0B,QACrB,gBAAgB;AACvB,SAAQC,6BAA6B,QAAO,sCAAsC;AAClF,SAAQC,cAAc,QAAO,qBAAqB;AAElD,OAAO,MAAMC,iBAAiBf,QAAQD,QAAQE,cAAc,YAAYe,GAAG,IAAI,iBAAiB"}

package/dist/db/integration-event-dedup.d.ts

@@ -0,0 +1,17 @@
+type DrizzleTxLike = any;
+export interface RecordIntegrationEventForProjectParams {
+    tx: DrizzleTxLike;
+    integrationEventId: string;
+    projectId: string;
+}
+export declare function recordIntegrationEventForProject(params: RecordIntegrationEventForProjectParams): Promise<{
+    firstSeen: boolean;
+}>;
+export interface PruneIntegrationEventDedupParams {
+    olderThan: Date;
+}
+export declare function pruneIntegrationEventDedup(params: PruneIntegrationEventDedupParams): Promise<{
+    deleted: number;
+}>;
+export {};
+//# sourceMappingURL=integration-event-dedup.d.ts.map

package/dist/db/integration-event-dedup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"integration-event-dedup.d.ts","sourceRoot":"","sources":["../../src/db/integration-event-dedup.ts"],"names":[],"mappings":"AAKA,KAAK,aAAa,GAAG,GAAG,CAAC;AAEzB,MAAM,WAAW,sCAAsC;IACrD,EAAE,EAAE,aAAa,CAAC;IAClB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,wBAAsB,gCAAgC,CACpD,MAAM,EAAE,sCAAsC,GAC7C,OAAO,CAAC;IAAC,SAAS,EAAE,OAAO,CAAA;CAAC,CAAC,CAgB/B;AAED,MAAM,WAAW,gCAAgC;IAC/C,SAAS,EAAE,IAAI,CAAC;CACjB;AAED,wBAAsB,0BAA0B,CAC9C,MAAM,EAAE,gCAAgC,GACvC,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAC,CAAC,CAK5B"}

package/dist/db/integration-event-dedup.js

@@ -0,0 +1,27 @@
+import { lt } from 'drizzle-orm';
+import { db } from './db.js';
+import { projectsIntegrationEventDedup } from './schema/integration-event-dedup.js';
+export async function recordIntegrationEventForProject(params) {
+    const inserted = await params.tx.insert(projectsIntegrationEventDedup).values({
+        integrationEventId: params.integrationEventId,
+        projectId: params.projectId
+    }).onConflictDoNothing({
+        target: [
+            projectsIntegrationEventDedup.integrationEventId,
+            projectsIntegrationEventDedup.projectId
+        ]
+    }).returning({
+        projectId: projectsIntegrationEventDedup.projectId
+    });
+    return {
+        firstSeen: inserted.length > 0
+    };
+}
+export async function pruneIntegrationEventDedup(params) {
+    const result = await db().delete(projectsIntegrationEventDedup).where(lt(projectsIntegrationEventDedup.receivedAt, params.olderThan));
+    return {
+        deleted: result.rowCount ?? 0
+    };
+}
+
+//# sourceMappingURL=integration-event-dedup.js.map

package/dist/db/integration-event-dedup.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/db/integration-event-dedup.ts"],"sourcesContent":["import {lt} from 'drizzle-orm';\nimport {db} from './db.js';\nimport {projectsIntegrationEventDedup} from './schema/integration-event-dedup.js';\n\n// biome-ignore lint/suspicious/noExplicitAny: cross-module drizzle tx without a portable exported type\ntype DrizzleTxLike = any;\n\nexport interface RecordIntegrationEventForProjectParams {\n  tx: DrizzleTxLike;\n  integrationEventId: string;\n  projectId: string;\n}\n\nexport async function recordIntegrationEventForProject(\n  params: RecordIntegrationEventForProjectParams,\n): Promise<{firstSeen: boolean}> {\n  const inserted = await params.tx\n    .insert(projectsIntegrationEventDedup)\n    .values({\n      integrationEventId: params.integrationEventId,\n      projectId: params.projectId,\n    })\n    .onConflictDoNothing({\n      target: [\n        projectsIntegrationEventDedup.integrationEventId,\n        projectsIntegrationEventDedup.projectId,\n      ],\n    })\n    .returning({projectId: projectsIntegrationEventDedup.projectId});\n\n  return {firstSeen: inserted.length > 0};\n}\n\nexport interface PruneIntegrationEventDedupParams {\n  olderThan: Date;\n}\n\nexport async function pruneIntegrationEventDedup(\n  params: PruneIntegrationEventDedupParams,\n): Promise<{deleted: number}> {\n  const result = await db()\n    .delete(projectsIntegrationEventDedup)\n    .where(lt(projectsIntegrationEventDedup.receivedAt, params.olderThan));\n  return {deleted: result.rowCount ?? 0};\n}\n"],"names":["lt","db","projectsIntegrationEventDedup","recordIntegrationEventForProject","params","inserted","tx","insert","values","integrationEventId","projectId","onConflictDoNothing","target","returning","firstSeen","length","pruneIntegrationEventDedup","result","delete","where","receivedAt","olderThan","deleted","rowCount"],"mappings":"AAAA,SAAQA,EAAE,QAAO,cAAc;AAC/B,SAAQC,EAAE,QAAO,UAAU;AAC3B,SAAQC,6BAA6B,QAAO,sCAAsC;AAWlF,OAAO,eAAeC,iCACpBC,MAA8C;IAE9C,MAAMC,WAAW,MAAMD,OAAOE,EAAE,CAC7BC,MAAM,CAACL,+BACPM,MAAM,CAAC;QACNC,oBAAoBL,OAAOK,kBAAkB;QAC7CC,WAAWN,OAAOM,SAAS;IAC7B,GACCC,mBAAmB,CAAC;QACnBC,QAAQ;YACNV,8BAA8BO,kBAAkB;YAChDP,8BAA8BQ,SAAS;SACxC;IACH,GACCG,SAAS,CAAC;QAACH,WAAWR,8BAA8BQ,SAAS;IAAA;IAEhE,OAAO;QAACI,WAAWT,SAASU,MAAM,GAAG;IAAC;AACxC;AAMA,OAAO,eAAeC,2BACpBZ,MAAwC;IAExC,MAAMa,SAAS,MAAMhB,KAClBiB,MAAM,CAAChB,+BACPiB,KAAK,CAACnB,GAAGE,8BAA8BkB,UAAU,EAAEhB,OAAOiB,SAAS;IACtE,OAAO;QAACC,SAASL,OAAOM,QAAQ,IAAI;IAAC;AACvC"}

package/dist/db/projects.d.ts

@@ -0,0 +1,36 @@
+import type { Project } from '#core/entities/project.js';
+export interface CreateProjectParams {
+    workspaceId: string;
+    sourceConnectionId: string;
+    sourceExternalRepositoryId: string;
+    name: string;
+}
+export interface ProjectCursor {
+    createdAt: Date;
+    id: string;
+}
+export interface ListProjectsParams {
+    workspaceId: string;
+    limit: number;
+    cursor?: ProjectCursor | undefined;
+    search?: string | undefined;
+}
+export interface ListProjectsResult {
+    projects: Project[];
+    nextCursor: ProjectCursor | null;
+}
+export declare function createProject(params: CreateProjectParams): Promise<Project>;
+export declare function getProjectById(id: string): Promise<Project | undefined>;
+export interface GetProjectBySourceParams {
+    workspaceId: string;
+    sourceConnectionId: string;
+    sourceExternalRepositoryId: string;
+}
+export declare function getProjectBySource(params: GetProjectBySourceParams): Promise<Project | undefined>;
+export declare function requireProjectForWorkspace(params: {
+    projectId: string;
+    workspaceId: string;
+}): Promise<Project>;
+export declare function listProjects(params: ListProjectsParams): Promise<ListProjectsResult>;
+export declare function getProjectCount(): Promise<number>;
+//# sourceMappingURL=projects.d.ts.map

package/dist/db/projects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"projects.d.ts","sourceRoot":"","sources":["../../src/db/projects.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,2BAA2B,CAAC;AAMvD,MAAM,WAAW,mBAAmB;IAClC,WAAW,EAAE,MAAM,CAAC;IACpB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,0BAA0B,EAAE,MAAM,CAAC;IACnC,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,aAAa;IAC5B,SAAS,EAAE,IAAI,CAAC;IAChB,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,MAAM,WAAW,kBAAkB;IACjC,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;IACnC,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC7B;AAMD,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,UAAU,EAAE,aAAa,GAAG,IAAI,CAAC;CAClC;AAUD,wBAAsB,aAAa,CAAC,MAAM,EAAE,mBAAmB,GAAG,OAAO,CAAC,OAAO,CAAC,CAwCjF;AAED,wBAAsB,cAAc,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,GAAG,SAAS,CAAC,CAM7E;AAED,MAAM,WAAW,wBAAwB;IACvC,WAAW,EAAE,MAAM,CAAC;IACpB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,0BAA0B,EAAE,MAAM,CAAC;CACpC;AAED,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,wBAAwB,GAC/B,OAAO,CAAC,OAAO,GAAG,SAAS,CAAC,CAgB9B;AAED,wBAAsB,0BAA0B,CAAC,MAAM,EAAE;IACvD,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;CACrB,GAAG,OAAO,CAAC,OAAO,CAAC,CAKnB;AAED,wBAAsB,YAAY,CAAC,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAuB1F;AAED,wBAAsB,eAAe,IAAI,OAAO,CAAC,MAAM,CAAC,CAGvD"}

package/dist/db/projects.js

@@ -0,0 +1,84 @@
+import { and, count, desc, eq, ilike, lt, or } from 'drizzle-orm';
+import { ProjectAlreadyExistsError, ProjectNotFoundError } from '#core/errors.js';
+import { recordProjectCreated } from '#metrics/instance.js';
+import { db } from './db.js';
+import { projects, toProject } from './schema/projects.js';
+function escapeIlikePattern(value) {
+    return value.replace(/[\\%_]/g, (char)=>`\\${char}`);
+}
+function cursorWhere(params) {
+    if (!params.cursor) return undefined;
+    return or(lt(projects.createdAt, params.cursor.createdAt), and(eq(projects.createdAt, params.cursor.createdAt), lt(projects.id, params.cursor.id)));
+}
+export async function createProject(params) {
+    const project = await db().transaction(async (tx)=>{
+        const [projectRow] = await tx.insert(projects).values({
+            workspaceId: params.workspaceId,
+            sourceConnectionId: params.sourceConnectionId,
+            sourceExternalRepositoryId: params.sourceExternalRepositoryId,
+            name: params.name
+        }).onConflictDoNothing({
+            target: [
+                projects.sourceConnectionId,
+                projects.sourceExternalRepositoryId
+            ]
+        }).returning();
+        if (!projectRow) {
+            const [conflict] = await tx.select().from(projects).where(and(eq(projects.sourceConnectionId, params.sourceConnectionId), eq(projects.sourceExternalRepositoryId, params.sourceExternalRepositoryId))).limit(1);
+            if (conflict) {
+                throw new ProjectAlreadyExistsError(conflict.id, params.sourceConnectionId, params.sourceExternalRepositoryId);
+            }
+            throw new Error('Insert returned no rows');
+        }
+        return toProject(projectRow);
+    });
+    recordProjectCreated();
+    return project;
+}
+export async function getProjectById(id) {
+    const rows = await db().select().from(projects).where(eq(projects.id, id)).limit(1);
+    const row = rows[0];
+    if (!row) return undefined;
+    return toProject(row);
+}
+export async function getProjectBySource(params) {
+    const rows = await db().select().from(projects).where(and(eq(projects.workspaceId, params.workspaceId), eq(projects.sourceConnectionId, params.sourceConnectionId), eq(projects.sourceExternalRepositoryId, params.sourceExternalRepositoryId))).limit(1);
+    const row = rows[0];
+    if (!row) return undefined;
+    return toProject(row);
+}
+export async function requireProjectForWorkspace(params) {
+    const project = await getProjectById(params.projectId);
+    if (!project) throw new ProjectNotFoundError(params.projectId);
+    if (project.workspaceId !== params.workspaceId) throw new ProjectNotFoundError(params.projectId);
+    return project;
+}
+export async function listProjects(params) {
+    const conditions = [
+        eq(projects.workspaceId, params.workspaceId)
+    ];
+    const cursorCondition = cursorWhere(params);
+    if (cursorCondition) conditions.push(cursorCondition);
+    if (params.search) {
+        conditions.push(ilike(projects.name, `%${escapeIlikePattern(params.search)}%`));
+    }
+    const rows = await db().select().from(projects).where(and(...conditions)).orderBy(desc(projects.createdAt), desc(projects.id)).limit(params.limit + 1);
+    const hasMore = rows.length > params.limit;
+    const pageRows = hasMore ? rows.slice(0, params.limit) : rows;
+    const last = pageRows.at(-1);
+    return {
+        projects: pageRows.map(toProject),
+        nextCursor: hasMore && last ? {
+            createdAt: last.createdAt,
+            id: last.id
+        } : null
+    };
+}
+export async function getProjectCount() {
+    const [row] = await db().select({
+        value: count()
+    }).from(projects);
+    return row?.value ?? 0;
+}
+
+//# sourceMappingURL=projects.js.map

package/dist/db/projects.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/db/projects.ts"],"sourcesContent":["import {and, count, desc, eq, ilike, lt, or, type SQL} from 'drizzle-orm';\nimport type {Project} from '#core/entities/project.js';\nimport {ProjectAlreadyExistsError, ProjectNotFoundError} from '#core/errors.js';\nimport {recordProjectCreated} from '#metrics/instance.js';\nimport {db} from './db.js';\nimport {projects, toProject} from './schema/projects.js';\n\nexport interface CreateProjectParams {\n  workspaceId: string;\n  sourceConnectionId: string;\n  sourceExternalRepositoryId: string;\n  name: string;\n}\n\nexport interface ProjectCursor {\n  createdAt: Date;\n  id: string;\n}\n\nexport interface ListProjectsParams {\n  workspaceId: string;\n  limit: number;\n  cursor?: ProjectCursor | undefined;\n  search?: string | undefined;\n}\n\nfunction escapeIlikePattern(value: string): string {\n  return value.replace(/[\\\\%_]/g, (char) => `\\\\${char}`);\n}\n\nexport interface ListProjectsResult {\n  projects: Project[];\n  nextCursor: ProjectCursor | null;\n}\n\nfunction cursorWhere(params: ListProjectsParams): SQL | undefined {\n  if (!params.cursor) return undefined;\n  return or(\n    lt(projects.createdAt, params.cursor.createdAt),\n    and(eq(projects.createdAt, params.cursor.createdAt), lt(projects.id, params.cursor.id)),\n  );\n}\n\nexport async function createProject(params: CreateProjectParams): Promise<Project> {\n  const project = await db().transaction(async (tx) => {\n    const [projectRow] = await tx\n      .insert(projects)\n      .values({\n        workspaceId: params.workspaceId,\n        sourceConnectionId: params.sourceConnectionId,\n        sourceExternalRepositoryId: params.sourceExternalRepositoryId,\n        name: params.name,\n      })\n      .onConflictDoNothing({\n        target: [projects.sourceConnectionId, projects.sourceExternalRepositoryId],\n      })\n      .returning();\n\n    if (!projectRow) {\n      const [conflict] = await tx\n        .select()\n        .from(projects)\n        .where(\n          and(\n            eq(projects.sourceConnectionId, params.sourceConnectionId),\n            eq(projects.sourceExternalRepositoryId, params.sourceExternalRepositoryId),\n          ),\n        )\n        .limit(1);\n      if (conflict) {\n        throw new ProjectAlreadyExistsError(\n          conflict.id,\n          params.sourceConnectionId,\n          params.sourceExternalRepositoryId,\n        );\n      }\n      throw new Error('Insert returned no rows');\n    }\n\n    return toProject(projectRow);\n  });\n  recordProjectCreated();\n  return project;\n}\n\nexport async function getProjectById(id: string): Promise<Project | undefined> {\n  const rows = await db().select().from(projects).where(eq(projects.id, id)).limit(1);\n\n  const row = rows[0];\n  if (!row) return undefined;\n  return toProject(row);\n}\n\nexport interface GetProjectBySourceParams {\n  workspaceId: string;\n  sourceConnectionId: string;\n  sourceExternalRepositoryId: string;\n}\n\nexport async function getProjectBySource(\n  params: GetProjectBySourceParams,\n): Promise<Project | undefined> {\n  const rows = await db()\n    .select()\n    .from(projects)\n    .where(\n      and(\n        eq(projects.workspaceId, params.workspaceId),\n        eq(projects.sourceConnectionId, params.sourceConnectionId),\n        eq(projects.sourceExternalRepositoryId, params.sourceExternalRepositoryId),\n      ),\n    )\n    .limit(1);\n\n  const row = rows[0];\n  if (!row) return undefined;\n  return toProject(row);\n}\n\nexport async function requireProjectForWorkspace(params: {\n  projectId: string;\n  workspaceId: string;\n}): Promise<Project> {\n  const project = await getProjectById(params.projectId);\n  if (!project) throw new ProjectNotFoundError(params.projectId);\n  if (project.workspaceId !== params.workspaceId) throw new ProjectNotFoundError(params.projectId);\n  return project;\n}\n\nexport async function listProjects(params: ListProjectsParams): Promise<ListProjectsResult> {\n  const conditions = [eq(projects.workspaceId, params.workspaceId)];\n  const cursorCondition = cursorWhere(params);\n  if (cursorCondition) conditions.push(cursorCondition);\n  if (params.search) {\n    conditions.push(ilike(projects.name, `%${escapeIlikePattern(params.search)}%`));\n  }\n\n  const rows = await db()\n    .select()\n    .from(projects)\n    .where(and(...conditions))\n    .orderBy(desc(projects.createdAt), desc(projects.id))\n    .limit(params.limit + 1);\n\n  const hasMore = rows.length > params.limit;\n  const pageRows = hasMore ? rows.slice(0, params.limit) : rows;\n  const last = pageRows.at(-1);\n\n  return {\n    projects: pageRows.map(toProject),\n    nextCursor: hasMore && last ? {createdAt: last.createdAt, id: last.id} : null,\n  };\n}\n\nexport async function getProjectCount(): Promise<number> {\n  const [row] = await db().select({value: count()}).from(projects);\n  return row?.value ?? 0;\n}\n"],"names":["and","count","desc","eq","ilike","lt","or","ProjectAlreadyExistsError","ProjectNotFoundError","recordProjectCreated","db","projects","toProject","escapeIlikePattern","value","replace","char","cursorWhere","params","cursor","undefined","createdAt","id","createProject","project","transaction","tx","projectRow","insert","values","workspaceId","sourceConnectionId","sourceExternalRepositoryId","name","onConflictDoNothing","target","returning","conflict","select","from","where","limit","Error","getProjectById","rows","row","getProjectBySource","requireProjectForWorkspace","projectId","listProjects","conditions","cursorCondition","push","search","orderBy","hasMore","length","pageRows","slice","last","at","map","nextCursor","getProjectCount"],"mappings":"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"}

package/dist/db/schema/common.d.ts

@@ -0,0 +1,2 @@
+export declare const pgTable: import("drizzle-orm/pg-core").PgTableFn<undefined>;
+//# sourceMappingURL=common.d.ts.map

package/dist/db/schema/common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../../src/db/schema/common.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,OAAO,oDAA+C,CAAC"}

package/dist/db/schema/common.js

@@ -0,0 +1,4 @@
+import { pgTableCreator } from 'drizzle-orm/pg-core';
+export const pgTable = pgTableCreator((name)=>`projects_${name}`);
+
+//# sourceMappingURL=common.js.map

package/dist/db/schema/common.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/db/schema/common.ts"],"sourcesContent":["import {pgTableCreator} from 'drizzle-orm/pg-core';\n\nexport const pgTable = pgTableCreator((name) => `projects_${name}`);\n"],"names":["pgTableCreator","pgTable","name"],"mappings":"AAAA,SAAQA,cAAc,QAAO,sBAAsB;AAEnD,OAAO,MAAMC,UAAUD,eAAe,CAACE,OAAS,CAAC,SAAS,EAAEA,MAAM,EAAE"}

package/dist/db/schema/integration-event-dedup.d.ts

@@ -0,0 +1,59 @@
+export declare const projectsIntegrationEventDedup: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "integration_event_dedup";
+    schema: undefined;
+    columns: {
+        integrationEventId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "integration_event_id";
+            tableName: "integration_event_dedup";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        projectId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "project_id";
+            tableName: "integration_event_dedup";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        receivedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "received_at";
+            tableName: "integration_event_dedup";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+//# sourceMappingURL=integration-event-dedup.d.ts.map

package/dist/db/schema/integration-event-dedup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"integration-event-dedup.d.ts","sourceRoot":"","sources":["../../../src/db/schema/integration-event-dedup.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAWzC,CAAC"}

package/dist/db/schema/integration-event-dedup.js

@@ -0,0 +1,19 @@
+import { index, primaryKey, timestamp, uuid } from 'drizzle-orm/pg-core';
+import { pgTable } from './common.js';
+export const projectsIntegrationEventDedup = pgTable('integration_event_dedup', {
+    integrationEventId: uuid('integration_event_id').notNull(),
+    projectId: uuid('project_id').notNull(),
+    receivedAt: timestamp('received_at', {
+        withTimezone: true
+    }).notNull().defaultNow()
+}, (table)=>[
+        primaryKey({
+            columns: [
+                table.integrationEventId,
+                table.projectId
+            ]
+        }),
+        index('projects_integration_event_dedup_received_at_idx').on(table.receivedAt)
+    ]);
+
+//# sourceMappingURL=integration-event-dedup.js.map

package/dist/db/schema/integration-event-dedup.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/db/schema/integration-event-dedup.ts"],"sourcesContent":["import {index, primaryKey, timestamp, uuid} from 'drizzle-orm/pg-core';\nimport {pgTable} from './common.js';\n\nexport const projectsIntegrationEventDedup = pgTable(\n  'integration_event_dedup',\n  {\n    integrationEventId: uuid('integration_event_id').notNull(),\n    projectId: uuid('project_id').notNull(),\n    receivedAt: timestamp('received_at', {withTimezone: true}).notNull().defaultNow(),\n  },\n  (table) => [\n    primaryKey({columns: [table.integrationEventId, table.projectId]}),\n    index('projects_integration_event_dedup_received_at_idx').on(table.receivedAt),\n  ],\n);\n"],"names":["index","primaryKey","timestamp","uuid","pgTable","projectsIntegrationEventDedup","integrationEventId","notNull","projectId","receivedAt","withTimezone","defaultNow","table","columns","on"],"mappings":"AAAA,SAAQA,KAAK,EAAEC,UAAU,EAAEC,SAAS,EAAEC,IAAI,QAAO,sBAAsB;AACvE,SAAQC,OAAO,QAAO,cAAc;AAEpC,OAAO,MAAMC,gCAAgCD,QAC3C,2BACA;IACEE,oBAAoBH,KAAK,wBAAwBI,OAAO;IACxDC,WAAWL,KAAK,cAAcI,OAAO;IACrCE,YAAYP,UAAU,eAAe;QAACQ,cAAc;IAAI,GAAGH,OAAO,GAAGI,UAAU;AACjF,GACA,CAACC,QAAU;QACTX,WAAW;YAACY,SAAS;gBAACD,MAAMN,kBAAkB;gBAAEM,MAAMJ,SAAS;aAAC;QAAA;QAChER,MAAM,oDAAoDc,EAAE,CAACF,MAAMH,UAAU;KAC9E,EACD"}

package/dist/db/schema/outbox.d.ts

@@ -0,0 +1,195 @@
+export declare const projectsOutbox: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "outbox";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "outbox";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        eventType: import("drizzle-orm/pg-core").PgColumn<{
+            name: "event_type";
+            tableName: "outbox";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        orderingKey: import("drizzle-orm/pg-core").PgColumn<{
+            name: "ordering_key";
+            tableName: "outbox";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        payload: import("drizzle-orm/pg-core").PgColumn<{
+            name: "payload";
+            tableName: "outbox";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "outbox";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        dispatchedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "dispatched_at";
+            tableName: "outbox";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        dispatchAttempts: import("drizzle-orm/pg-core").PgColumn<{
+            name: "dispatch_attempts";
+            tableName: "outbox";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        nextDispatchAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "next_dispatch_at";
+            tableName: "outbox";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        lastDispatchError: import("drizzle-orm/pg-core").PgColumn<{
+            name: "last_dispatch_error";
+            tableName: "outbox";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        lastDispatchFailedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "last_dispatch_failed_at";
+            tableName: "outbox";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        deadLetteredAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "dead_lettered_at";
+            tableName: "outbox";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+//# sourceMappingURL=outbox.d.ts.map

package/dist/db/schema/outbox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"outbox.d.ts","sourceRoot":"","sources":["../../../src/db/schema/outbox.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAA6B,CAAC"}

package/dist/db/schema/outbox.js

@@ -0,0 +1,5 @@
+import { createOutboxTable } from '@shipfox/node-outbox';
+import { pgTable } from './common.js';
+export const projectsOutbox = createOutboxTable(pgTable);
+
+//# sourceMappingURL=outbox.js.map

package/dist/db/schema/outbox.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/db/schema/outbox.ts"],"sourcesContent":["import {createOutboxTable} from '@shipfox/node-outbox';\nimport {pgTable} from './common.js';\n\nexport const projectsOutbox = createOutboxTable(pgTable);\n"],"names":["createOutboxTable","pgTable","projectsOutbox"],"mappings":"AAAA,SAAQA,iBAAiB,QAAO,uBAAuB;AACvD,SAAQC,OAAO,QAAO,cAAc;AAEpC,OAAO,MAAMC,iBAAiBF,kBAAkBC,SAAS"}