@shipfox/api-integration-gitea 2.0.0

package/dist/db/connections.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/db/connections.ts"],"sourcesContent":["import {eq} from 'drizzle-orm';\nimport {GiteaOrgAlreadyLinkedError} from '#core/errors.js';\nimport {db} from './db.js';\nimport {giteaConnections, toGiteaConnection} from './schema/connections.js';\n\nexport interface GiteaConnection {\n  id: string;\n  connectionId: string;\n  org: string;\n  createdAt: Date;\n  updatedAt: Date;\n}\n\nexport interface UpsertGiteaConnectionParams {\n  connectionId: string;\n  org: string;\n}\n\ntype GiteaDb = ReturnType<typeof db>;\ntype GiteaTx = Parameters<Parameters<GiteaDb['transaction']>[0]>[0];\n\nexport async function upsertGiteaConnection(\n  params: UpsertGiteaConnectionParams,\n  options: {tx?: unknown} = {},\n): Promise<GiteaConnection> {\n  const executor = (options.tx ?? db()) as GiteaDb | GiteaTx;\n  const now = new Date();\n  const [row] = await executor\n    .insert(giteaConnections)\n    .values({\n      connectionId: params.connectionId,\n      org: params.org,\n    })\n    .onConflictDoUpdate({\n      target: giteaConnections.org,\n      // TOCTOU guard: only (re)point this org at the connection that already\n      // owns it. A concurrent connect of the same org to a different workspace\n      // inserts its own connection row, so its connectionId differs here; the\n      // predicate is false, Postgres updates nothing, and the empty RETURNING\n      // below rolls the losing transaction back instead of silently repointing\n      // the org (cross-tenant connection takeover).\n      setWhere: eq(giteaConnections.connectionId, params.connectionId),\n      set: {\n        connectionId: params.connectionId,\n        updatedAt: now,\n      },\n    })\n    .returning();\n\n  if (!row) throw new GiteaOrgAlreadyLinkedError(params.org);\n  return toGiteaConnection(row);\n}\n\nexport async function getGiteaConnectionByOrg(\n  org: string,\n  options: {tx?: unknown} = {},\n): Promise<GiteaConnection | undefined> {\n  const executor = (options.tx ?? db()) as GiteaDb | GiteaTx;\n  const rows = await executor\n    .select()\n    .from(giteaConnections)\n    .where(eq(giteaConnections.org, org))\n    .limit(1);\n  const row = rows[0];\n  if (!row) return undefined;\n  return toGiteaConnection(row);\n}\n\nexport async function getGiteaConnectionByConnectionId(\n  connectionId: string,\n): Promise<GiteaConnection | undefined> {\n  const rows = await db()\n    .select()\n    .from(giteaConnections)\n    .where(eq(giteaConnections.connectionId, connectionId))\n    .limit(1);\n  const row = rows[0];\n  if (!row) return undefined;\n  return toGiteaConnection(row);\n}\n"],"names":["eq","GiteaOrgAlreadyLinkedError","db","giteaConnections","toGiteaConnection","upsertGiteaConnection","params","options","executor","tx","now","Date","row","insert","values","connectionId","org","onConflictDoUpdate","target","setWhere","set","updatedAt","returning","getGiteaConnectionByOrg","rows","select","from","where","limit","undefined","getGiteaConnectionByConnectionId"],"mappings":"AAAA,SAAQA,EAAE,QAAO,cAAc;AAC/B,SAAQC,0BAA0B,QAAO,kBAAkB;AAC3D,SAAQC,EAAE,QAAO,UAAU;AAC3B,SAAQC,gBAAgB,EAAEC,iBAAiB,QAAO,0BAA0B;AAkB5E,OAAO,eAAeC,sBACpBC,MAAmC,EACnCC,UAA0B,CAAC,CAAC;IAE5B,MAAMC,WAAYD,QAAQE,EAAE,IAAIP;IAChC,MAAMQ,MAAM,IAAIC;IAChB,MAAM,CAACC,IAAI,GAAG,MAAMJ,SACjBK,MAAM,CAACV,kBACPW,MAAM,CAAC;QACNC,cAAcT,OAAOS,YAAY;QACjCC,KAAKV,OAAOU,GAAG;IACjB,GACCC,kBAAkB,CAAC;QAClBC,QAAQf,iBAAiBa,GAAG;QAC5B,uEAAuE;QACvE,yEAAyE;QACzE,wEAAwE;QACxE,wEAAwE;QACxE,yEAAyE;QACzE,8CAA8C;QAC9CG,UAAUnB,GAAGG,iBAAiBY,YAAY,EAAET,OAAOS,YAAY;QAC/DK,KAAK;YACHL,cAAcT,OAAOS,YAAY;YACjCM,WAAWX;QACb;IACF,GACCY,SAAS;IAEZ,IAAI,CAACV,KAAK,MAAM,IAAIX,2BAA2BK,OAAOU,GAAG;IACzD,OAAOZ,kBAAkBQ;AAC3B;AAEA,OAAO,eAAeW,wBACpBP,GAAW,EACXT,UAA0B,CAAC,CAAC;IAE5B,MAAMC,WAAYD,QAAQE,EAAE,IAAIP;IAChC,MAAMsB,OAAO,MAAMhB,SAChBiB,MAAM,GACNC,IAAI,CAACvB,kBACLwB,KAAK,CAAC3B,GAAGG,iBAAiBa,GAAG,EAAEA,MAC/BY,KAAK,CAAC;IACT,MAAMhB,MAAMY,IAAI,CAAC,EAAE;IACnB,IAAI,CAACZ,KAAK,OAAOiB;IACjB,OAAOzB,kBAAkBQ;AAC3B;AAEA,OAAO,eAAekB,iCACpBf,YAAoB;IAEpB,MAAMS,OAAO,MAAMtB,KAChBuB,MAAM,GACNC,IAAI,CAACvB,kBACLwB,KAAK,CAAC3B,GAAGG,iBAAiBY,YAAY,EAAEA,eACxCa,KAAK,CAAC;IACT,MAAMhB,MAAMY,IAAI,CAAC,EAAE;IACnB,IAAI,CAACZ,KAAK,OAAOiB;IACjB,OAAOzB,kBAAkBQ;AAC3B"}

package/dist/db/db.d.ts

@@ -0,0 +1,191 @@
+import { type NodePgDatabase } from '@shipfox/node-drizzle';
+export declare const schema: {
+    giteaConnections: import("drizzle-orm/pg-core").PgTableWithColumns<{
+        name: "connections";
+        schema: undefined;
+        columns: {
+            id: import("drizzle-orm/pg-core").PgColumn<{
+                name: "id";
+                tableName: "connections";
+                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;
+            }, {}, {}>;
+            connectionId: import("drizzle-orm/pg-core").PgColumn<{
+                name: "connection_id";
+                tableName: "connections";
+                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;
+            }, {}, {}>;
+            org: import("drizzle-orm/pg-core").PgColumn<{
+                name: "org";
+                tableName: "connections";
+                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;
+            }, {}, {}>;
+            createdAt: import("drizzle-orm/pg-core").PgColumn<{
+                name: "created_at";
+                tableName: "connections";
+                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;
+            }, {}, {}>;
+            updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+                name: "updated_at";
+                tableName: "connections";
+                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";
+    }>;
+};
+export declare function db(): NodePgDatabase<{
+    giteaConnections: import("drizzle-orm/pg-core").PgTableWithColumns<{
+        name: "connections";
+        schema: undefined;
+        columns: {
+            id: import("drizzle-orm/pg-core").PgColumn<{
+                name: "id";
+                tableName: "connections";
+                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;
+            }, {}, {}>;
+            connectionId: import("drizzle-orm/pg-core").PgColumn<{
+                name: "connection_id";
+                tableName: "connections";
+                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;
+            }, {}, {}>;
+            org: import("drizzle-orm/pg-core").PgColumn<{
+                name: "org";
+                tableName: "connections";
+                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;
+            }, {}, {}>;
+            createdAt: import("drizzle-orm/pg-core").PgColumn<{
+                name: "created_at";
+                tableName: "connections";
+                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;
+            }, {}, {}>;
+            updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+                name: "updated_at";
+                tableName: "connections";
+                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";
+    }>;
+}>;
+export declare function closeDb(): void;
+//# sourceMappingURL=db.d.ts.map

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;AAInE,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAElB,CAAC;AAIF,wBAAgB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAGjB;AAED,wBAAgB,OAAO,IAAI,IAAI,CAE9B"}

package/dist/db/db.js

@@ -0,0 +1,18 @@
+import { drizzle } from '@shipfox/node-drizzle';
+import { pgClient } from '@shipfox/node-postgres';
+import { giteaConnections } from './schema/connections.js';
+export const schema = {
+    giteaConnections
+};
+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 {giteaConnections} from './schema/connections.js';\n\nexport const schema = {\n  giteaConnections,\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","giteaConnections","schema","_db","db","closeDb","undefined"],"mappings":"AAAA,SAAQA,OAAO,QAA4B,wBAAwB;AACnE,SAAQC,QAAQ,QAAO,yBAAyB;AAChD,SAAQC,gBAAgB,QAAO,0BAA0B;AAEzD,OAAO,MAAMC,SAAS;IACpBD;AACF,EAAE;AAEF,IAAIE;AAEJ,OAAO,SAASC;IACd,IAAI,CAACD,KAAKA,MAAMJ,QAAQC,YAAY;QAACE;IAAM;IAC3C,OAAOC;AACT;AAEA,OAAO,SAASE;IACdF,MAAMG;AACR"}

package/dist/db/migrations.d.ts

@@ -0,0 +1,2 @@
+export declare const migrationsPath: string;
+//# sourceMappingURL=migrations.d.ts.map

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

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

package/dist/db/migrations.js

@@ -0,0 +1,5 @@
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+export const migrationsPath = resolve(dirname(fileURLToPath(import.meta.url)), '../../drizzle');
+
+//# sourceMappingURL=migrations.js.map

package/dist/db/migrations.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/db/migrations.ts"],"sourcesContent":["import {dirname, resolve} from 'node:path';\nimport {fileURLToPath} from 'node:url';\n\nexport const migrationsPath = resolve(dirname(fileURLToPath(import.meta.url)), '../../drizzle');\n"],"names":["dirname","resolve","fileURLToPath","migrationsPath","url"],"mappings":"AAAA,SAAQA,OAAO,EAAEC,OAAO,QAAO,YAAY;AAC3C,SAAQC,aAAa,QAAO,WAAW;AAEvC,OAAO,MAAMC,iBAAiBF,QAAQD,QAAQE,cAAc,YAAYE,GAAG,IAAI,iBAAiB"}

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,oDAAyD,CAAC"}

package/dist/db/schema/common.js

@@ -0,0 +1,4 @@
+import { pgTableCreator } from 'drizzle-orm/pg-core';
+export const pgTable = pgTableCreator((name)=>`integrations_gitea_${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) => `integrations_gitea_${name}`);\n"],"names":["pgTableCreator","pgTable","name"],"mappings":"AAAA,SAAQA,cAAc,QAAO,sBAAsB;AAEnD,OAAO,MAAMC,UAAUD,eAAe,CAACE,OAAS,CAAC,mBAAmB,EAAEA,MAAM,EAAE"}

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

@@ -0,0 +1,97 @@
+import type { GiteaConnection } from '#db/connections.js';
+export declare const giteaConnections: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "connections";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "connections";
+            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;
+        }, {}, {}>;
+        connectionId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "connection_id";
+            tableName: "connections";
+            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;
+        }, {}, {}>;
+        org: import("drizzle-orm/pg-core").PgColumn<{
+            name: "org";
+            tableName: "connections";
+            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;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "connections";
+            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;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "connections";
+            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";
+}>;
+export type GiteaConnectionDb = typeof giteaConnections.$inferSelect;
+export type GiteaConnectionCreateDb = typeof giteaConnections.$inferInsert;
+export declare function toGiteaConnection(row: GiteaConnectionDb): GiteaConnection;
+//# sourceMappingURL=connections.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"connections.d.ts","sourceRoot":"","sources":["../../../src/db/schema/connections.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,oBAAoB,CAAC;AAGxD,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAa5B,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG,OAAO,gBAAgB,CAAC,YAAY,CAAC;AACrE,MAAM,MAAM,uBAAuB,GAAG,OAAO,gBAAgB,CAAC,YAAY,CAAC;AAE3E,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,iBAAiB,GAAG,eAAe,CAQzE"}

package/dist/db/schema/connections.js

@@ -0,0 +1,28 @@
+import { uuidv7PrimaryKey } from '@shipfox/node-drizzle';
+import { text, timestamp, uniqueIndex, uuid } from 'drizzle-orm/pg-core';
+import { pgTable } from './common.js';
+export const giteaConnections = pgTable('connections', {
+    id: uuidv7PrimaryKey(),
+    connectionId: uuid('connection_id').notNull(),
+    org: text('org').notNull(),
+    createdAt: timestamp('created_at', {
+        withTimezone: true
+    }).notNull().defaultNow(),
+    updatedAt: timestamp('updated_at', {
+        withTimezone: true
+    }).notNull().defaultNow()
+}, (table)=>[
+        uniqueIndex('integrations_gitea_connections_connection_unique').on(table.connectionId),
+        uniqueIndex('integrations_gitea_connections_org_unique').on(table.org)
+    ]);
+export function toGiteaConnection(row) {
+    return {
+        id: row.id,
+        connectionId: row.connectionId,
+        org: row.org,
+        createdAt: row.createdAt,
+        updatedAt: row.updatedAt
+    };
+}
+
+//# sourceMappingURL=connections.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/db/schema/connections.ts"],"sourcesContent":["import {uuidv7PrimaryKey} from '@shipfox/node-drizzle';\nimport {text, timestamp, uniqueIndex, uuid} from 'drizzle-orm/pg-core';\nimport type {GiteaConnection} from '#db/connections.js';\nimport {pgTable} from './common.js';\n\nexport const giteaConnections = pgTable(\n  'connections',\n  {\n    id: uuidv7PrimaryKey(),\n    connectionId: uuid('connection_id').notNull(),\n    org: text('org').notNull(),\n    createdAt: timestamp('created_at', {withTimezone: true}).notNull().defaultNow(),\n    updatedAt: timestamp('updated_at', {withTimezone: true}).notNull().defaultNow(),\n  },\n  (table) => [\n    uniqueIndex('integrations_gitea_connections_connection_unique').on(table.connectionId),\n    uniqueIndex('integrations_gitea_connections_org_unique').on(table.org),\n  ],\n);\n\nexport type GiteaConnectionDb = typeof giteaConnections.$inferSelect;\nexport type GiteaConnectionCreateDb = typeof giteaConnections.$inferInsert;\n\nexport function toGiteaConnection(row: GiteaConnectionDb): GiteaConnection {\n  return {\n    id: row.id,\n    connectionId: row.connectionId,\n    org: row.org,\n    createdAt: row.createdAt,\n    updatedAt: row.updatedAt,\n  };\n}\n"],"names":["uuidv7PrimaryKey","text","timestamp","uniqueIndex","uuid","pgTable","giteaConnections","id","connectionId","notNull","org","createdAt","withTimezone","defaultNow","updatedAt","table","on","toGiteaConnection","row"],"mappings":"AAAA,SAAQA,gBAAgB,QAAO,wBAAwB;AACvD,SAAQC,IAAI,EAAEC,SAAS,EAAEC,WAAW,EAAEC,IAAI,QAAO,sBAAsB;AAEvE,SAAQC,OAAO,QAAO,cAAc;AAEpC,OAAO,MAAMC,mBAAmBD,QAC9B,eACA;IACEE,IAAIP;IACJQ,cAAcJ,KAAK,iBAAiBK,OAAO;IAC3CC,KAAKT,KAAK,OAAOQ,OAAO;IACxBE,WAAWT,UAAU,cAAc;QAACU,cAAc;IAAI,GAAGH,OAAO,GAAGI,UAAU;IAC7EC,WAAWZ,UAAU,cAAc;QAACU,cAAc;IAAI,GAAGH,OAAO,GAAGI,UAAU;AAC/E,GACA,CAACE,QAAU;QACTZ,YAAY,oDAAoDa,EAAE,CAACD,MAAMP,YAAY;QACrFL,YAAY,6CAA6Ca,EAAE,CAACD,MAAML,GAAG;KACtE,EACD;AAKF,OAAO,SAASO,kBAAkBC,GAAsB;IACtD,OAAO;QACLX,IAAIW,IAAIX,EAAE;QACVC,cAAcU,IAAIV,YAAY;QAC9BE,KAAKQ,IAAIR,GAAG;QACZC,WAAWO,IAAIP,SAAS;QACxBG,WAAWI,IAAIJ,SAAS;IAC1B;AACF"}

package/dist/index.d.ts

@@ -0,0 +1,39 @@
+import type { GetIntegrationConnectionByIdFn, IntegrationConnection, PublishSourcePushFn, RecordDeliveryOnlyFn } from '@shipfox/api-integration-core-dto';
+import type { NodePgDatabase } from 'drizzle-orm/node-postgres';
+import { type GiteaApiClient } from '#api/client.js';
+import type { ConnectGiteaConnectionInput } from '#core/connect.js';
+import { GiteaSourceControlProvider } from '#core/source-control.js';
+import { closeDb, db } from '#db/db.js';
+import { migrationsPath } from '#db/migrations.js';
+export type { GiteaApiClient, GiteaFileContent, GiteaRepository, GiteaRepositoryPage, GiteaTree, GiteaTreeBlob, } from '#api/client.js';
+export { createGiteaApiClient } from '#api/client.js';
+export type { ConnectGiteaConnectionInput } from '#core/connect.js';
+export { handleGiteaConnect } from '#core/connect.js';
+export { GiteaIntegrationProviderError, GiteaOrgAlreadyLinkedError, GiteaOrganizationNotFoundError, } from '#core/errors.js';
+export { GiteaSourceControlProvider } from '#core/source-control.js';
+export type { GiteaConnection, UpsertGiteaConnectionParams } from '#db/connections.js';
+export { getGiteaConnectionByConnectionId, getGiteaConnectionByOrg, upsertGiteaConnection, } from '#db/connections.js';
+export { closeDb, db, migrationsPath };
+export interface CreateGiteaIntegrationProviderOptions {
+    gitea?: GiteaApiClient | undefined;
+    getExistingGiteaConnection: (input: {
+        org: string;
+    }) => Promise<IntegrationConnection<'gitea'> | undefined>;
+    connectGiteaConnection: (input: ConnectGiteaConnectionInput) => Promise<IntegrationConnection<'gitea'>>;
+    coreDb: () => NodePgDatabase<Record<string, unknown>>;
+    publishSourcePush: PublishSourcePushFn;
+    recordDeliveryOnly: RecordDeliveryOnlyFn;
+    getIntegrationConnectionById: GetIntegrationConnectionByIdFn;
+}
+export declare function createGiteaIntegrationProvider(options: CreateGiteaIntegrationProviderOptions): {
+    provider: string;
+    displayName: string;
+    adapters: {
+        source_control: GiteaSourceControlProvider;
+    };
+    connectionExternalUrl(connection: {
+        externalAccountId: string;
+    }): Promise<string | undefined>;
+    routes: import("@shipfox/node-fastify").RouteGroup[];
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,8BAA8B,EAC9B,qBAAqB,EACrB,mBAAmB,EACnB,oBAAoB,EACrB,MAAM,mCAAmC,CAAC;AAE3C,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,2BAA2B,CAAC;AAC9D,OAAO,EAAuB,KAAK,cAAc,EAAC,MAAM,gBAAgB,CAAC;AACzE,OAAO,KAAK,EAAC,2BAA2B,EAAC,MAAM,kBAAkB,CAAC;AAElE,OAAO,EAAC,0BAA0B,EAAC,MAAM,yBAAyB,CAAC;AACnE,OAAO,EAAC,OAAO,EAAE,EAAE,EAAC,MAAM,WAAW,CAAC;AACtC,OAAO,EAAC,cAAc,EAAC,MAAM,mBAAmB,CAAC;AAIjD,YAAY,EACV,cAAc,EACd,gBAAgB,EAChB,eAAe,EACf,mBAAmB,EACnB,SAAS,EACT,aAAa,GACd,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAC,oBAAoB,EAAC,MAAM,gBAAgB,CAAC;AACpD,YAAY,EAAC,2BAA2B,EAAC,MAAM,kBAAkB,CAAC;AAClE,OAAO,EAAC,kBAAkB,EAAC,MAAM,kBAAkB,CAAC;AACpD,OAAO,EACL,6BAA6B,EAC7B,0BAA0B,EAC1B,8BAA8B,GAC/B,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAC,0BAA0B,EAAC,MAAM,yBAAyB,CAAC;AACnE,YAAY,EAAC,eAAe,EAAE,2BAA2B,EAAC,MAAM,oBAAoB,CAAC;AACrF,OAAO,EACL,gCAAgC,EAChC,uBAAuB,EACvB,qBAAqB,GACtB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAC,OAAO,EAAE,EAAE,EAAE,cAAc,EAAC,CAAC;AAErC,MAAM,WAAW,qCAAqC;IACpD,KAAK,CAAC,EAAE,cAAc,GAAG,SAAS,CAAC;IACnC,0BAA0B,EAAE,CAAC,KAAK,EAAE;QAClC,GAAG,EAAE,MAAM,CAAC;KACb,KAAK,OAAO,CAAC,qBAAqB,CAAC,OAAO,CAAC,GAAG,SAAS,CAAC,CAAC;IAC1D,sBAAsB,EAAE,CACtB,KAAK,EAAE,2BAA2B,KAC/B,OAAO,CAAC,qBAAqB,CAAC,OAAO,CAAC,CAAC,CAAC;IAC7C,MAAM,EAAE,MAAM,cAAc,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACtD,iBAAiB,EAAE,mBAAmB,CAAC;IACvC,kBAAkB,EAAE,oBAAoB,CAAC;IACzC,4BAA4B,EAAE,8BAA8B,CAAC;CAC9D;AAED,wBAAgB,8BAA8B,CAAC,OAAO,EAAE,qCAAqC;;;;;;sCASvD;QAAC,iBAAiB,EAAE,MAAM,CAAA;KAAC,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC;;EAiB9F"}

package/dist/index.js

@@ -0,0 +1,42 @@
+import { giteaProviderKind } from '@shipfox/api-integration-gitea-dto';
+import { createGiteaApiClient } from '#api/client.js';
+import { giteaConnectionExternalUrl } from '#core/connection-url.js';
+import { GiteaSourceControlProvider } from '#core/source-control.js';
+import { closeDb, db } from '#db/db.js';
+import { migrationsPath } from '#db/migrations.js';
+import { createGiteaConnectionRoutes } from '#presentation/routes/connections.js';
+import { createGiteaWebhookRoutes } from '#presentation/routes/webhooks.js';
+export { createGiteaApiClient } from '#api/client.js';
+export { handleGiteaConnect } from '#core/connect.js';
+export { GiteaIntegrationProviderError, GiteaOrgAlreadyLinkedError, GiteaOrganizationNotFoundError } from '#core/errors.js';
+export { GiteaSourceControlProvider } from '#core/source-control.js';
+export { getGiteaConnectionByConnectionId, getGiteaConnectionByOrg, upsertGiteaConnection } from '#db/connections.js';
+export { closeDb, db, migrationsPath };
+export function createGiteaIntegrationProvider(options) {
+    const gitea = options.gitea ?? createGiteaApiClient();
+    return {
+        provider: giteaProviderKind,
+        displayName: 'Gitea',
+        adapters: {
+            source_control: new GiteaSourceControlProvider(gitea)
+        },
+        connectionExternalUrl (connection) {
+            return Promise.resolve(giteaConnectionExternalUrl(connection.externalAccountId));
+        },
+        routes: [
+            createGiteaConnectionRoutes({
+                gitea,
+                getExistingGiteaConnection: options.getExistingGiteaConnection,
+                connectGiteaConnection: options.connectGiteaConnection
+            }),
+            createGiteaWebhookRoutes({
+                coreDb: options.coreDb,
+                publishSourcePush: options.publishSourcePush,
+                recordDeliveryOnly: options.recordDeliveryOnly,
+                getIntegrationConnectionById: options.getIntegrationConnectionById
+            })
+        ]
+    };
+}
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import type {\n  GetIntegrationConnectionByIdFn,\n  IntegrationConnection,\n  PublishSourcePushFn,\n  RecordDeliveryOnlyFn,\n} from '@shipfox/api-integration-core-dto';\nimport {giteaProviderKind} from '@shipfox/api-integration-gitea-dto';\nimport type {NodePgDatabase} from 'drizzle-orm/node-postgres';\nimport {createGiteaApiClient, type GiteaApiClient} from '#api/client.js';\nimport type {ConnectGiteaConnectionInput} from '#core/connect.js';\nimport {giteaConnectionExternalUrl} from '#core/connection-url.js';\nimport {GiteaSourceControlProvider} from '#core/source-control.js';\nimport {closeDb, db} from '#db/db.js';\nimport {migrationsPath} from '#db/migrations.js';\nimport {createGiteaConnectionRoutes} from '#presentation/routes/connections.js';\nimport {createGiteaWebhookRoutes} from '#presentation/routes/webhooks.js';\n\nexport type {\n  GiteaApiClient,\n  GiteaFileContent,\n  GiteaRepository,\n  GiteaRepositoryPage,\n  GiteaTree,\n  GiteaTreeBlob,\n} from '#api/client.js';\nexport {createGiteaApiClient} from '#api/client.js';\nexport type {ConnectGiteaConnectionInput} from '#core/connect.js';\nexport {handleGiteaConnect} from '#core/connect.js';\nexport {\n  GiteaIntegrationProviderError,\n  GiteaOrgAlreadyLinkedError,\n  GiteaOrganizationNotFoundError,\n} from '#core/errors.js';\nexport {GiteaSourceControlProvider} from '#core/source-control.js';\nexport type {GiteaConnection, UpsertGiteaConnectionParams} from '#db/connections.js';\nexport {\n  getGiteaConnectionByConnectionId,\n  getGiteaConnectionByOrg,\n  upsertGiteaConnection,\n} from '#db/connections.js';\nexport {closeDb, db, migrationsPath};\n\nexport interface CreateGiteaIntegrationProviderOptions {\n  gitea?: GiteaApiClient | undefined;\n  getExistingGiteaConnection: (input: {\n    org: string;\n  }) => Promise<IntegrationConnection<'gitea'> | undefined>;\n  connectGiteaConnection: (\n    input: ConnectGiteaConnectionInput,\n  ) => Promise<IntegrationConnection<'gitea'>>;\n  coreDb: () => NodePgDatabase<Record<string, unknown>>;\n  publishSourcePush: PublishSourcePushFn;\n  recordDeliveryOnly: RecordDeliveryOnlyFn;\n  getIntegrationConnectionById: GetIntegrationConnectionByIdFn;\n}\n\nexport function createGiteaIntegrationProvider(options: CreateGiteaIntegrationProviderOptions) {\n  const gitea = options.gitea ?? createGiteaApiClient();\n\n  return {\n    provider: giteaProviderKind,\n    displayName: 'Gitea',\n    adapters: {\n      source_control: new GiteaSourceControlProvider(gitea),\n    },\n    connectionExternalUrl(connection: {externalAccountId: string}): Promise<string | undefined> {\n      return Promise.resolve(giteaConnectionExternalUrl(connection.externalAccountId));\n    },\n    routes: [\n      createGiteaConnectionRoutes({\n        gitea,\n        getExistingGiteaConnection: options.getExistingGiteaConnection,\n        connectGiteaConnection: options.connectGiteaConnection,\n      }),\n      createGiteaWebhookRoutes({\n        coreDb: options.coreDb,\n        publishSourcePush: options.publishSourcePush,\n        recordDeliveryOnly: options.recordDeliveryOnly,\n        getIntegrationConnectionById: options.getIntegrationConnectionById,\n      }),\n    ],\n  };\n}\n"],"names":["giteaProviderKind","createGiteaApiClient","giteaConnectionExternalUrl","GiteaSourceControlProvider","closeDb","db","migrationsPath","createGiteaConnectionRoutes","createGiteaWebhookRoutes","handleGiteaConnect","GiteaIntegrationProviderError","GiteaOrgAlreadyLinkedError","GiteaOrganizationNotFoundError","getGiteaConnectionByConnectionId","getGiteaConnectionByOrg","upsertGiteaConnection","createGiteaIntegrationProvider","options","gitea","provider","displayName","adapters","source_control","connectionExternalUrl","connection","Promise","resolve","externalAccountId","routes","getExistingGiteaConnection","connectGiteaConnection","coreDb","publishSourcePush","recordDeliveryOnly","getIntegrationConnectionById"],"mappings":"AAMA,SAAQA,iBAAiB,QAAO,qCAAqC;AAErE,SAAQC,oBAAoB,QAA4B,iBAAiB;AAEzE,SAAQC,0BAA0B,QAAO,0BAA0B;AACnE,SAAQC,0BAA0B,QAAO,0BAA0B;AACnE,SAAQC,OAAO,EAAEC,EAAE,QAAO,YAAY;AACtC,SAAQC,cAAc,QAAO,oBAAoB;AACjD,SAAQC,2BAA2B,QAAO,sCAAsC;AAChF,SAAQC,wBAAwB,QAAO,mCAAmC;AAU1E,SAAQP,oBAAoB,QAAO,iBAAiB;AAEpD,SAAQQ,kBAAkB,QAAO,mBAAmB;AACpD,SACEC,6BAA6B,EAC7BC,0BAA0B,EAC1BC,8BAA8B,QACzB,kBAAkB;AACzB,SAAQT,0BAA0B,QAAO,0BAA0B;AAEnE,SACEU,gCAAgC,EAChCC,uBAAuB,EACvBC,qBAAqB,QAChB,qBAAqB;AAC5B,SAAQX,OAAO,EAAEC,EAAE,EAAEC,cAAc,GAAE;AAgBrC,OAAO,SAASU,+BAA+BC,OAA8C;IAC3F,MAAMC,QAAQD,QAAQC,KAAK,IAAIjB;IAE/B,OAAO;QACLkB,UAAUnB;QACVoB,aAAa;QACbC,UAAU;YACRC,gBAAgB,IAAInB,2BAA2Be;QACjD;QACAK,uBAAsBC,UAAuC;YAC3D,OAAOC,QAAQC,OAAO,CAACxB,2BAA2BsB,WAAWG,iBAAiB;QAChF;QACAC,QAAQ;YACNrB,4BAA4B;gBAC1BW;gBACAW,4BAA4BZ,QAAQY,0BAA0B;gBAC9DC,wBAAwBb,QAAQa,sBAAsB;YACxD;YACAtB,yBAAyB;gBACvBuB,QAAQd,QAAQc,MAAM;gBACtBC,mBAAmBf,QAAQe,iBAAiB;gBAC5CC,oBAAoBhB,QAAQgB,kBAAkB;gBAC9CC,8BAA8BjB,QAAQiB,4BAA4B;YACpE;SACD;IACH;AACF"}

package/dist/presentation/dto/integrations.d.ts

@@ -0,0 +1,17 @@
+import { type IntegrationConnection } from '@shipfox/api-integration-core-dto';
+export declare function toIntegrationConnectionDto(connection: IntegrationConnection<'gitea'>, options?: {
+    externalUrl?: string | undefined;
+}): {
+    created_at: string;
+    updated_at: string;
+    external_url?: string;
+    id: string;
+    workspace_id: string;
+    provider: string;
+    external_account_id: string;
+    slug: string;
+    display_name: string;
+    lifecycle_status: import("@shipfox/api-integration-core-dto").IntegrationConnectionLifecycleStatus;
+    capabilities: import("@shipfox/api-integration-core-dto").IntegrationCapability[];
+};
+//# sourceMappingURL=integrations.d.ts.map

package/dist/presentation/dto/integrations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"integrations.d.ts","sourceRoot":"","sources":["../../../src/presentation/dto/integrations.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,qBAAqB,EAE3B,MAAM,mCAAmC,CAAC;AAE3C,wBAAgB,0BAA0B,CACxC,UAAU,EAAE,qBAAqB,CAAC,OAAO,CAAC,EAC1C,OAAO,GAAE;IAAC,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CAAM;;;;;;;;;;;;EAMjD"}

package/dist/presentation/dto/integrations.js

@@ -0,0 +1,11 @@
+import { toIntegrationConnectionDto as toCoreIntegrationConnectionDto } from '@shipfox/api-integration-core-dto';
+export function toIntegrationConnectionDto(connection, options = {}) {
+    return toCoreIntegrationConnectionDto(connection, {
+        capabilities: [
+            'source_control'
+        ],
+        externalUrl: options.externalUrl
+    });
+}
+
+//# sourceMappingURL=integrations.js.map

package/dist/presentation/dto/integrations.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/presentation/dto/integrations.ts"],"sourcesContent":["import {\n  type IntegrationConnection,\n  toIntegrationConnectionDto as toCoreIntegrationConnectionDto,\n} from '@shipfox/api-integration-core-dto';\n\nexport function toIntegrationConnectionDto(\n  connection: IntegrationConnection<'gitea'>,\n  options: {externalUrl?: string | undefined} = {},\n) {\n  return toCoreIntegrationConnectionDto(connection, {\n    capabilities: ['source_control'],\n    externalUrl: options.externalUrl,\n  });\n}\n"],"names":["toIntegrationConnectionDto","toCoreIntegrationConnectionDto","connection","options","capabilities","externalUrl"],"mappings":"AAAA,SAEEA,8BAA8BC,8BAA8B,QACvD,oCAAoC;AAE3C,OAAO,SAASD,2BACdE,UAA0C,EAC1CC,UAA8C,CAAC,CAAC;IAEhD,OAAOF,+BAA+BC,YAAY;QAChDE,cAAc;YAAC;SAAiB;QAChCC,aAAaF,QAAQE,WAAW;IAClC;AACF"}

package/dist/presentation/routes/connections.d.ts

@@ -0,0 +1,13 @@
+import type { IntegrationConnection } from '@shipfox/api-integration-core-dto';
+import { type RouteGroup } from '@shipfox/node-fastify';
+import type { GiteaApiClient } from '#api/client.js';
+import { type ConnectGiteaConnectionInput } from '#core/connect.js';
+export interface CreateGiteaConnectionRoutesOptions {
+    gitea: GiteaApiClient;
+    getExistingGiteaConnection: (input: {
+        org: string;
+    }) => Promise<IntegrationConnection<'gitea'> | undefined>;
+    connectGiteaConnection: (input: ConnectGiteaConnectionInput) => Promise<IntegrationConnection<'gitea'>>;
+}
+export declare function createGiteaConnectionRoutes({ gitea, getExistingGiteaConnection, connectGiteaConnection, }: CreateGiteaConnectionRoutesOptions): RouteGroup;
+//# sourceMappingURL=connections.d.ts.map

package/dist/presentation/routes/connections.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connections.d.ts","sourceRoot":"","sources":["../../../src/presentation/routes/connections.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,qBAAqB,EAAC,MAAM,mCAAmC,CAAC;AAK7E,OAAO,EAAc,KAAK,UAAU,EAAC,MAAM,uBAAuB,CAAC;AACnE,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,gBAAgB,CAAC;AACnD,OAAO,EAAC,KAAK,2BAA2B,EAAqB,MAAM,kBAAkB,CAAC;AAKtF,MAAM,WAAW,kCAAkC;IACjD,KAAK,EAAE,cAAc,CAAC;IACtB,0BAA0B,EAAE,CAAC,KAAK,EAAE;QAClC,GAAG,EAAE,MAAM,CAAC;KACb,KAAK,OAAO,CAAC,qBAAqB,CAAC,OAAO,CAAC,GAAG,SAAS,CAAC,CAAC;IAC1D,sBAAsB,EAAE,CACtB,KAAK,EAAE,2BAA2B,KAC/B,OAAO,CAAC,qBAAqB,CAAC,OAAO,CAAC,CAAC,CAAC;CAC9C;AAED,wBAAgB,2BAA2B,CAAC,EAC1C,KAAK,EACL,0BAA0B,EAC1B,sBAAsB,GACvB,EAAE,kCAAkC,GAAG,UAAU,CAmCjD"}

package/dist/presentation/routes/connections.js

@@ -0,0 +1,47 @@
+import { AUTH_USER, requireWorkspaceAccess } from '@shipfox/api-auth-context';
+import { createGiteaConnectionBodySchema, createGiteaConnectionResponseSchema } from '@shipfox/api-integration-gitea-dto';
+import { defineRoute } from '@shipfox/node-fastify';
+import { handleGiteaConnect } from '#core/connect.js';
+import { giteaConnectionExternalUrl } from '#core/connection-url.js';
+import { toIntegrationConnectionDto } from '#presentation/dto/integrations.js';
+import { giteaRouteErrorHandler } from './errors.js';
+export function createGiteaConnectionRoutes({ gitea, getExistingGiteaConnection, connectGiteaConnection }) {
+    const createConnectionRoute = defineRoute({
+        method: 'POST',
+        path: '/connections',
+        auth: AUTH_USER,
+        description: 'Connect a Gitea organization to a workspace.',
+        schema: {
+            body: createGiteaConnectionBodySchema,
+            response: {
+                200: createGiteaConnectionResponseSchema
+            }
+        },
+        errorHandler: giteaRouteErrorHandler,
+        handler: async (request)=>{
+            const { workspace_id: workspaceId, org } = request.body;
+            requireWorkspaceAccess({
+                request,
+                workspaceId
+            });
+            const connection = await handleGiteaConnect({
+                gitea,
+                workspaceId,
+                org,
+                getExistingGiteaConnection,
+                connectGiteaConnection
+            });
+            return toIntegrationConnectionDto(connection, {
+                externalUrl: giteaConnectionExternalUrl(connection.externalAccountId)
+            });
+        }
+    });
+    return {
+        prefix: '/integrations/gitea',
+        routes: [
+            createConnectionRoute
+        ]
+    };
+}
+
+//# sourceMappingURL=connections.js.map

package/dist/presentation/routes/connections.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/presentation/routes/connections.ts"],"sourcesContent":["import {AUTH_USER, requireWorkspaceAccess} from '@shipfox/api-auth-context';\nimport type {IntegrationConnection} from '@shipfox/api-integration-core-dto';\nimport {\n  createGiteaConnectionBodySchema,\n  createGiteaConnectionResponseSchema,\n} from '@shipfox/api-integration-gitea-dto';\nimport {defineRoute, type RouteGroup} from '@shipfox/node-fastify';\nimport type {GiteaApiClient} from '#api/client.js';\nimport {type ConnectGiteaConnectionInput, handleGiteaConnect} from '#core/connect.js';\nimport {giteaConnectionExternalUrl} from '#core/connection-url.js';\nimport {toIntegrationConnectionDto} from '#presentation/dto/integrations.js';\nimport {giteaRouteErrorHandler} from './errors.js';\n\nexport interface CreateGiteaConnectionRoutesOptions {\n  gitea: GiteaApiClient;\n  getExistingGiteaConnection: (input: {\n    org: string;\n  }) => Promise<IntegrationConnection<'gitea'> | undefined>;\n  connectGiteaConnection: (\n    input: ConnectGiteaConnectionInput,\n  ) => Promise<IntegrationConnection<'gitea'>>;\n}\n\nexport function createGiteaConnectionRoutes({\n  gitea,\n  getExistingGiteaConnection,\n  connectGiteaConnection,\n}: CreateGiteaConnectionRoutesOptions): RouteGroup {\n  const createConnectionRoute = defineRoute({\n    method: 'POST',\n    path: '/connections',\n    auth: AUTH_USER,\n    description: 'Connect a Gitea organization to a workspace.',\n    schema: {\n      body: createGiteaConnectionBodySchema,\n      response: {\n        200: createGiteaConnectionResponseSchema,\n      },\n    },\n    errorHandler: giteaRouteErrorHandler,\n    handler: async (request) => {\n      const {workspace_id: workspaceId, org} = request.body;\n\n      requireWorkspaceAccess({request, workspaceId});\n      const connection = await handleGiteaConnect({\n        gitea,\n        workspaceId,\n        org,\n        getExistingGiteaConnection,\n        connectGiteaConnection,\n      });\n\n      return toIntegrationConnectionDto(connection, {\n        externalUrl: giteaConnectionExternalUrl(connection.externalAccountId),\n      });\n    },\n  });\n\n  return {\n    prefix: '/integrations/gitea',\n    routes: [createConnectionRoute],\n  };\n}\n"],"names":["AUTH_USER","requireWorkspaceAccess","createGiteaConnectionBodySchema","createGiteaConnectionResponseSchema","defineRoute","handleGiteaConnect","giteaConnectionExternalUrl","toIntegrationConnectionDto","giteaRouteErrorHandler","createGiteaConnectionRoutes","gitea","getExistingGiteaConnection","connectGiteaConnection","createConnectionRoute","method","path","auth","description","schema","body","response","errorHandler","handler","request","workspace_id","workspaceId","org","connection","externalUrl","externalAccountId","prefix","routes"],"mappings":"AAAA,SAAQA,SAAS,EAAEC,sBAAsB,QAAO,4BAA4B;AAE5E,SACEC,+BAA+B,EAC/BC,mCAAmC,QAC9B,qCAAqC;AAC5C,SAAQC,WAAW,QAAwB,wBAAwB;AAEnE,SAA0CC,kBAAkB,QAAO,mBAAmB;AACtF,SAAQC,0BAA0B,QAAO,0BAA0B;AACnE,SAAQC,0BAA0B,QAAO,oCAAoC;AAC7E,SAAQC,sBAAsB,QAAO,cAAc;AAYnD,OAAO,SAASC,4BAA4B,EAC1CC,KAAK,EACLC,0BAA0B,EAC1BC,sBAAsB,EACa;IACnC,MAAMC,wBAAwBT,YAAY;QACxCU,QAAQ;QACRC,MAAM;QACNC,MAAMhB;QACNiB,aAAa;QACbC,QAAQ;YACNC,MAAMjB;YACNkB,UAAU;gBACR,KAAKjB;YACP;QACF;QACAkB,cAAcb;QACdc,SAAS,OAAOC;YACd,MAAM,EAACC,cAAcC,WAAW,EAAEC,GAAG,EAAC,GAAGH,QAAQJ,IAAI;YAErDlB,uBAAuB;gBAACsB;gBAASE;YAAW;YAC5C,MAAME,aAAa,MAAMtB,mBAAmB;gBAC1CK;gBACAe;gBACAC;gBACAf;gBACAC;YACF;YAEA,OAAOL,2BAA2BoB,YAAY;gBAC5CC,aAAatB,2BAA2BqB,WAAWE,iBAAiB;YACtE;QACF;IACF;IAEA,OAAO;QACLC,QAAQ;QACRC,QAAQ;YAAClB;SAAsB;IACjC;AACF"}

package/dist/presentation/routes/errors.d.ts

@@ -0,0 +1,2 @@
+export declare function giteaRouteErrorHandler(error: unknown): never;
+//# sourceMappingURL=errors.d.ts.map

package/dist/presentation/routes/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/presentation/routes/errors.ts"],"names":[],"mappings":"AAiBA,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,CAiB5D"}