@shipfox/api-integration-gitea 12.5.0 → 14.0.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shipfox/api-integration-gitea",
   "license": "MIT",
-  "version": "12.5.0",
+  "version": "14.0.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ShipfoxHQ/shipfox.git",
@@ -20,8 +20,8 @@
   "dependencies": {
     "drizzle-orm": "^0.45.2",
     "@shipfox/api-auth-context": "12.2.0",
-    "@shipfox/api-integration-spi": "1.1.1",
-    "@shipfox/api-integration-gitea-dto": "12.2.0",
+    "@shipfox/api-integration-spi": "2.0.0",
+    "@shipfox/api-integration-gitea-dto": "14.0.0",
     "@shipfox/config": "1.2.4",
     "@shipfox/node-drizzle": "0.3.5",
     "@shipfox/node-fastify": "0.4.2",

package/src/api/client.test.ts

@@ -115,6 +115,64 @@ describe('HttpGiteaApiClient', () => {
     await expect(result).rejects.toMatchObject({reason: 'repository-not-found'});
   });
 
+  it('gets a branch head commit', async () => {
+    fetchMock.mockResolvedValue(
+      jsonResponse({name: 'main', commit: {id: 'abc123', message: 'hi'}}),
+    );
+    const client = createGiteaApiClient();
+
+    const result = await client.getBranch({owner: 'shipfox', repo: 'platform', branch: 'main'});
+
+    expect(result).toEqual({commitSha: 'abc123'});
+    expect(requestedUrl().pathname).toBe('/api/v1/repos/shipfox/platform/branches/main');
+  });
+
+  it('gets a tag head commit', async () => {
+    fetchMock.mockResolvedValue(jsonResponse({name: 'v1.0.0', commit: {sha: 'abc123'}}));
+    const client = createGiteaApiClient();
+
+    const result = await client.getTag({owner: 'shipfox', repo: 'platform', tag: 'v1.0.0'});
+
+    expect(result).toEqual({commitSha: 'abc123'});
+    expect(requestedUrl().pathname).toBe('/api/v1/repos/shipfox/platform/tags/v1.0.0');
+  });
+
+  it('maps a missing branch to ref-not-found', async () => {
+    fetchMock.mockResolvedValue(jsonResponse({message: 'not found'}, {status: 404}));
+    const client = createGiteaApiClient();
+
+    const result = client.getBranch({owner: 'shipfox', repo: 'platform', branch: 'missing'});
+
+    await expect(result).rejects.toMatchObject({reason: 'ref-not-found'});
+  });
+
+  it('maps a missing tag to ref-not-found', async () => {
+    fetchMock.mockResolvedValue(jsonResponse({message: 'not found'}, {status: 404}));
+    const client = createGiteaApiClient();
+
+    const result = client.getTag({owner: 'shipfox', repo: 'platform', tag: 'missing'});
+
+    await expect(result).rejects.toMatchObject({reason: 'ref-not-found'});
+  });
+
+  it('rejects a branch response without a head commit', async () => {
+    fetchMock.mockResolvedValue(jsonResponse({name: 'main', commit: {}}));
+    const client = createGiteaApiClient();
+
+    const result = client.getBranch({owner: 'shipfox', repo: 'platform', branch: 'main'});
+
+    await expect(result).rejects.toMatchObject({reason: 'malformed-provider-response'});
+  });
+
+  it('rejects a tag response without a head commit', async () => {
+    fetchMock.mockResolvedValue(jsonResponse({name: 'v1.0.0', commit: {}}));
+    const client = createGiteaApiClient();
+
+    const result = client.getTag({owner: 'shipfox', repo: 'platform', tag: 'v1.0.0'});
+
+    await expect(result).rejects.toMatchObject({reason: 'malformed-provider-response'});
+  });
+
   it('lists the recursive tree, keeping blobs and dropping subtrees', async () => {
     fetchMock.mockResolvedValue(
       jsonResponse({

package/src/api/client.ts

@@ -41,6 +41,10 @@ export interface GiteaFileContent {
   size: number;
 }
 
+export interface GiteaRefCommit {
+  commitSha: string;
+}
+
 export interface GiteaApiClient {
   listOrgRepositories(input: {
     org: string;
@@ -49,6 +53,8 @@ export interface GiteaApiClient {
   }): Promise<GiteaRepositoryPage>;
   getRepository(input: {owner: string; repo: string}): Promise<GiteaRepository>;
   resolveRef(input: {owner: string; repo: string; ref: string}): Promise<string>;
+  getBranch(input: {owner: string; repo: string; branch: string}): Promise<GiteaRefCommit>;
+  getTag(input: {owner: string; repo: string; tag: string}): Promise<GiteaRefCommit>;
   listTree(input: {owner: string; repo: string; sha: string}): Promise<GiteaTree>;
   fetchFileContent(input: {
     owner: string;
@@ -113,6 +119,40 @@ class HttpGiteaApiClient implements GiteaApiClient {
     return head.sha;
   }
 
+  async getBranch(input: {owner: string; repo: string; branch: string}): Promise<GiteaRefCommit> {
+    const response = await this.request(
+      `repos/${encodeURIComponent(input.owner)}/${encodeURIComponent(input.repo)}/branches/${encodeURIComponent(input.branch)}`,
+      {},
+      {notFoundReason: 'ref-not-found'},
+    );
+    const data = await response.json();
+    const commit = isRecord(data) ? data.commit : undefined;
+    if (!isRecord(commit) || typeof commit.id !== 'string') {
+      throw new GiteaIntegrationProviderError(
+        'malformed-provider-response',
+        `Gitea branch ${input.branch} response is missing the head commit`,
+      );
+    }
+    return {commitSha: commit.id};
+  }
+
+  async getTag(input: {owner: string; repo: string; tag: string}): Promise<GiteaRefCommit> {
+    const response = await this.request(
+      `repos/${encodeURIComponent(input.owner)}/${encodeURIComponent(input.repo)}/tags/${encodeURIComponent(input.tag)}`,
+      {},
+      {notFoundReason: 'ref-not-found'},
+    );
+    const data = await response.json();
+    const commit = isRecord(data) ? data.commit : undefined;
+    if (!isRecord(commit) || typeof commit.sha !== 'string') {
+      throw new GiteaIntegrationProviderError(
+        'malformed-provider-response',
+        `Gitea tag ${input.tag} response is missing the head commit`,
+      );
+    }
+    return {commitSha: commit.sha};
+  }
+
   async listTree(input: {owner: string; repo: string; sha: string}): Promise<GiteaTree> {
     const response = await this.request(
       `repos/${encodeURIComponent(input.owner)}/${encodeURIComponent(input.repo)}/git/trees/${encodeURIComponent(input.sha)}`,
@@ -264,7 +304,7 @@ class HttpGiteaApiClient implements GiteaApiClient {
   }
 }
 
-type NotFoundReason = 'repository-not-found' | 'file-not-found';
+type NotFoundReason = 'repository-not-found' | 'file-not-found' | 'ref-not-found';
 
 function giteaHttpError(
   response: Response,

package/src/connection-external-url.test.ts

@@ -6,6 +6,8 @@ function giteaClient(): GiteaApiClient {
     listOrgRepositories: vi.fn(() => Promise.reject(new Error('not used'))),
     getRepository: vi.fn(() => Promise.reject(new Error('not used'))),
     resolveRef: vi.fn(() => Promise.reject(new Error('not used'))),
+    getBranch: vi.fn(() => Promise.reject(new Error('not used'))),
+    getTag: vi.fn(() => Promise.reject(new Error('not used'))),
     listTree: vi.fn(() => Promise.reject(new Error('not used'))),
     fetchFileContent: vi.fn(() => Promise.reject(new Error('not used'))),
     organizationExists: vi.fn(() => Promise.reject(new Error('not used'))),

package/src/core/connect.test.ts

@@ -8,6 +8,8 @@ function giteaClient(overrides: Partial<GiteaApiClient> = {}): GiteaApiClient {
     listOrgRepositories: vi.fn(() => Promise.reject(new Error('not used'))),
     getRepository: vi.fn(() => Promise.reject(new Error('not used'))),
     resolveRef: vi.fn(() => Promise.reject(new Error('not used'))),
+    getBranch: vi.fn(() => Promise.reject(new Error('not used'))),
+    getTag: vi.fn(() => Promise.reject(new Error('not used'))),
     listTree: vi.fn(() => Promise.reject(new Error('not used'))),
     fetchFileContent: vi.fn(() => Promise.reject(new Error('not used'))),
     organizationExists: vi.fn(() => Promise.resolve(true)),

package/src/core/source-control-clone-url.test.ts

@@ -16,6 +16,8 @@ function giteaClient(repository: GiteaRepository): GiteaApiClient {
     listOrgRepositories: vi.fn(),
     getRepository: vi.fn(() => Promise.resolve(repository)),
     resolveRef: vi.fn(),
+    getBranch: vi.fn(),
+    getTag: vi.fn(),
     listTree: vi.fn(),
     fetchFileContent: vi.fn(),
     organizationExists: vi.fn(),

package/src/core/source-control.test.ts

@@ -35,6 +35,8 @@ function giteaClient(overrides: Partial<GiteaApiClient> = {}): GiteaApiClient {
         size: 58,
       }),
     ),
+    getBranch: vi.fn(() => Promise.resolve({commitSha: 'branch-head'})),
+    getTag: vi.fn(() => Promise.reject(new Error('not used'))),
     organizationExists: vi.fn(() => Promise.resolve(true)),
     ...overrides,
   };
@@ -168,6 +170,178 @@ describe('GiteaSourceControlProvider', () => {
     expect(result).toBeNull();
   });
 
+  it('resolves a branch ref to the commit it points at', async () => {
+    const gitea = giteaClient();
+    const provider = new GiteaSourceControlProvider(gitea);
+
+    const result = await provider.resolveRef({
+      connection: connection(),
+      externalRepositoryId: 'gitea:shipfox/platform',
+      ref: 'refs/heads/main',
+    });
+
+    expect(result).toEqual({ref: 'refs/heads/main', commit: 'branch-head'});
+    expect(gitea.getBranch).toHaveBeenCalledWith({
+      owner: 'shipfox',
+      repo: 'platform',
+      branch: 'main',
+    });
+    expect(gitea.getTag).not.toHaveBeenCalled();
+  });
+
+  it('does not cross namespaces for a missing namespaced branch ref', async () => {
+    const gitea = giteaClient({
+      getBranch: vi.fn(() =>
+        Promise.reject(new GiteaIntegrationProviderError('ref-not-found', 'no branch')),
+      ),
+      getTag: vi.fn(() => Promise.resolve({commitSha: VALID_COMMIT})),
+    });
+    const provider = new GiteaSourceControlProvider(gitea);
+
+    const result = provider.resolveRef({
+      connection: connection(),
+      externalRepositoryId: 'gitea:shipfox/platform',
+      ref: 'refs/heads/release',
+    });
+
+    await expect(result).rejects.toMatchObject({reason: 'ref-not-found'});
+    expect(gitea.getBranch).toHaveBeenCalledWith({
+      owner: 'shipfox',
+      repo: 'platform',
+      branch: 'release',
+    });
+    expect(gitea.getTag).not.toHaveBeenCalled();
+  });
+
+  it('uses the tag endpoint first for a tag ref', async () => {
+    const gitea = giteaClient({
+      getTag: vi.fn(() => Promise.resolve({commitSha: VALID_COMMIT})),
+    });
+    const provider = new GiteaSourceControlProvider(gitea);
+
+    const result = await provider.resolveRef({
+      connection: connection(),
+      externalRepositoryId: 'gitea:shipfox/platform',
+      ref: 'refs/tags/v1.0.0',
+    });
+
+    expect(result).toEqual({ref: 'refs/tags/v1.0.0', commit: VALID_COMMIT});
+    expect(gitea.getTag).toHaveBeenCalledWith({
+      owner: 'shipfox',
+      repo: 'platform',
+      tag: 'v1.0.0',
+    });
+    expect(gitea.getBranch).not.toHaveBeenCalled();
+  });
+
+  it('maps a ref that is neither branch nor tag to ref-not-found', async () => {
+    const gitea = giteaClient({
+      getBranch: vi.fn(() =>
+        Promise.reject(new GiteaIntegrationProviderError('ref-not-found', 'no branch')),
+      ),
+      getTag: vi.fn(() =>
+        Promise.reject(new GiteaIntegrationProviderError('ref-not-found', 'no tag')),
+      ),
+    });
+    const provider = new GiteaSourceControlProvider(gitea);
+
+    const result = provider.resolveRef({
+      connection: connection(),
+      externalRepositoryId: 'gitea:shipfox/platform',
+      ref: 'feature/missing',
+    });
+
+    await expect(result).rejects.toMatchObject({reason: 'ref-not-found'});
+  });
+
+  it('falls back to a tag for an unnamespaced ref', async () => {
+    const gitea = giteaClient({
+      getBranch: vi.fn(() =>
+        Promise.reject(new GiteaIntegrationProviderError('ref-not-found', 'no branch')),
+      ),
+      getTag: vi.fn(() => Promise.resolve({commitSha: VALID_COMMIT})),
+    });
+    const provider = new GiteaSourceControlProvider(gitea);
+
+    const result = await provider.resolveRef({
+      connection: connection(),
+      externalRepositoryId: 'gitea:shipfox/platform',
+      ref: 'feature/release',
+    });
+
+    expect(result).toEqual({ref: 'feature/release', commit: VALID_COMMIT});
+    expect(gitea.getBranch).toHaveBeenCalledWith({
+      owner: 'shipfox',
+      repo: 'platform',
+      branch: 'feature/release',
+    });
+    expect(gitea.getTag).toHaveBeenCalledWith({
+      owner: 'shipfox',
+      repo: 'platform',
+      tag: 'feature/release',
+    });
+    expect(gitea.getRepository).not.toHaveBeenCalled();
+  });
+
+  it('preserves repository-not-found when the repository is missing', async () => {
+    const gitea = giteaClient({
+      getBranch: vi.fn(() =>
+        Promise.reject(new GiteaIntegrationProviderError('ref-not-found', 'no branch')),
+      ),
+      getRepository: vi.fn(() =>
+        Promise.reject(new GiteaIntegrationProviderError('repository-not-found', 'no repo')),
+      ),
+    });
+    const provider = new GiteaSourceControlProvider(gitea);
+
+    const result = provider.resolveRef({
+      connection: connection(),
+      externalRepositoryId: 'gitea:shipfox/platform',
+      ref: 'refs/heads/main',
+    });
+
+    await expect(result).rejects.toMatchObject({reason: 'repository-not-found'});
+    expect(gitea.getTag).not.toHaveBeenCalled();
+  });
+
+  it.each([
+    'a'.repeat(40),
+    'refs/pull/17/head',
+    'main',
+    '-evil',
+  ])('rejects ref %s as ref-invalid', async (ref) => {
+    const gitea = giteaClient();
+    const provider = new GiteaSourceControlProvider(gitea);
+
+    const result = provider.resolveRef({
+      connection: connection(),
+      externalRepositoryId: 'gitea:shipfox/platform',
+      ref,
+    });
+
+    await expect(result).rejects.toMatchObject({reason: 'ref-invalid'});
+    expect(gitea.getBranch).not.toHaveBeenCalled();
+    expect(gitea.getTag).not.toHaveBeenCalled();
+  });
+
+  it('propagates non-not-found branch failures without a tag fallback', async () => {
+    const gitea = giteaClient({
+      getBranch: vi.fn(() =>
+        Promise.reject(new GiteaIntegrationProviderError('access-denied', 'denied')),
+      ),
+    });
+    const provider = new GiteaSourceControlProvider(gitea);
+
+    const result = provider.resolveRef({
+      connection: connection(),
+      externalRepositoryId: 'gitea:shipfox/platform',
+      ref: 'refs/heads/main',
+    });
+
+    await expect(result).rejects.toMatchObject({reason: 'access-denied'});
+    expect(gitea.getTag).not.toHaveBeenCalled();
+  });
+
   it('lists org repositories scoped to the connection account', async () => {
     const gitea = giteaClient();
     const provider = new GiteaSourceControlProvider(gitea);

package/src/core/source-control.ts

@@ -11,6 +11,7 @@ import {
   type IntegrationConnection,
   isRecord,
   isValidGitObjectId,
+  isValidResolvableRef,
   isValidTriggerRef,
   type ListFilesInput,
   type ListRepositoriesInput,
@@ -21,6 +22,8 @@ import {
   type RepositoryPage,
   type RepositorySnapshot,
   type RepositoryVisibility,
+  type ResolvedRef,
+  type ResolveRefInput,
   type ResolveRepositoryInput,
   type SourceControlProvider,
   type TriggerReference,
@@ -32,6 +35,8 @@ import {GiteaIntegrationProviderError} from './errors.js';
 type GiteaIntegrationConnection = IntegrationConnection<'gitea'>;
 
 const TRAILING_SLASHES_RE = /\/+$/;
+const REFS_HEADS_PREFIX = 'refs/heads/';
+const REFS_TAGS_PREFIX = 'refs/tags/';
 const SEARCH_PAGE_SIZE = 100;
 const SEARCH_MAX_PAGES_PER_REQUEST = 5;
 
@@ -183,6 +188,44 @@ export class GiteaSourceControlProvider
     };
   }
 
+  async resolveRef(input: ResolveRefInput<GiteaIntegrationConnection>): Promise<ResolvedRef> {
+    if (!isValidResolvableRef(input.ref)) {
+      throw new GiteaIntegrationProviderError(
+        'ref-invalid',
+        `Gitea ref ${formatRefForMessage(input.ref)} is not a resolvable branch or tag name`,
+      );
+    }
+    const {owner, repo} = parseGiteaRepositoryLocator(
+      input.externalRepositoryId,
+      input.connection.externalAccountId,
+    );
+
+    const providerRef = providerRefName(input.ref);
+    const branchLookup = () => this.gitea.getBranch({owner, repo, branch: providerRef});
+    const tagLookup = () => this.gitea.getTag({owner, repo, tag: providerRef});
+    const lookups: Array<() => Promise<{commitSha: string}>> = input.ref.startsWith(
+      REFS_TAGS_PREFIX,
+    )
+      ? [tagLookup]
+      : input.ref.startsWith(REFS_HEADS_PREFIX)
+        ? [branchLookup]
+        : [branchLookup, tagLookup];
+    for (const lookup of lookups) {
+      try {
+        const resolved = await lookup();
+        return {ref: input.ref, commit: resolved.commitSha};
+      } catch (error) {
+        if (!isRefNotFound(error)) throw error;
+      }
+    }
+
+    await this.gitea.getRepository({owner, repo});
+    throw new GiteaIntegrationProviderError(
+      'ref-not-found',
+      `Gitea ref ${formatRefForMessage(input.ref)} does not resolve to a branch or tag`,
+    );
+  }
+
   async createCheckoutSpec(
     input: CreateCheckoutSpecInput<GiteaIntegrationConnection>,
   ): Promise<CheckoutSpec> {
@@ -225,6 +268,20 @@ function giteaEventActor(payload: Record<string, unknown>): string | null {
   return nonEmptyString(sender?.login) ?? nonEmptyString(sender?.username);
 }
 
+function isRefNotFound(error: unknown): boolean {
+  return error instanceof GiteaIntegrationProviderError && error.reason === 'ref-not-found';
+}
+
+function providerRefName(ref: string): string {
+  if (ref.startsWith(REFS_HEADS_PREFIX)) return ref.slice(REFS_HEADS_PREFIX.length);
+  if (ref.startsWith(REFS_TAGS_PREFIX)) return ref.slice(REFS_TAGS_PREFIX.length);
+  return ref;
+}
+
+function formatRefForMessage(ref: string): string {
+  return JSON.stringify(ref);
+}
+
 function sameGiteaRepository(
   first: Record<string, unknown>,
   second: Record<string, unknown>,

package/src/core/webhook.ts

@@ -2,6 +2,7 @@ import {
   type GiteaPushPayloadDto,
   giteaProviderKind,
   giteaPushPayloadSchema,
+  giteaWebhookEventNames,
 } from '@shipfox/api-integration-gitea-dto';
 import {
   buildProviderRepositoryId,
@@ -67,7 +68,7 @@ function isBranchDeletion(after: string): boolean {
 export async function handleGiteaWebhook(
   params: HandleGiteaWebhookParams,
 ): Promise<{outcome: HandleGiteaWebhookOutcome}> {
-  if (params.event !== 'push') {
+  if (!giteaWebhookEventNames.some((eventName) => eventName === params.event)) {
     await params.recordDeliveryOnly({
       tx: params.tx,
       provider: giteaProviderKind,

package/src/index.test.ts

@@ -13,6 +13,7 @@ describe('createGiteaIntegrationProvider', () => {
 
     expect(provider.provider).toBe('gitea');
     expect(provider.displayName).toBe('Gitea');
+    expect(provider.eventCatalog?.events.map((event) => event.name)).toEqual(['push']);
     expect(provider.adapters.source_control).toBeInstanceOf(GiteaSourceControlProvider);
     expect(provider.routes).toHaveLength(2);
     expect(provider.routes.map((group) => group.prefix)).toEqual([

package/src/index.ts

@@ -1,4 +1,4 @@
-import {giteaProviderKind} from '@shipfox/api-integration-gitea-dto';
+import {giteaEventCatalog, giteaProviderKind} from '@shipfox/api-integration-gitea-dto';
 import type {
   GetIntegrationConnectionByIdFn,
   IntegrationConnection,
@@ -67,6 +67,7 @@ export function createGiteaIntegrationProvider(options: CreateGiteaIntegrationPr
   return {
     provider: giteaProviderKind,
     displayName: 'Gitea',
+    eventCatalog: giteaEventCatalog,
     adapters: {
       source_control: new GiteaSourceControlProvider(gitea),
     },

package/src/presentation/routes/connections.test.ts

@@ -40,6 +40,8 @@ function giteaClient(overrides: Partial<GiteaApiClient> = {}): GiteaApiClient {
     listOrgRepositories: vi.fn(() => Promise.reject(new Error('not used'))),
     getRepository: vi.fn(() => Promise.reject(new Error('not used'))),
     resolveRef: vi.fn(() => Promise.reject(new Error('not used'))),
+    getBranch: vi.fn(() => Promise.reject(new Error('not used'))),
+    getTag: vi.fn(() => Promise.reject(new Error('not used'))),
     listTree: vi.fn(() => Promise.reject(new Error('not used'))),
     fetchFileContent: vi.fn(() => Promise.reject(new Error('not used'))),
     organizationExists: vi.fn(() => Promise.resolve(true)),