Skip to content

armgit / papra

Public Imported from GitHub
0

The minimalistic document archiving platform.

11.9 KB
Raw Blame
import { eq } from 'drizzle-orm';
import { describe, expect, test } from 'vitest';
import { createInMemoryDatabase } from '../app/database/database.test-utils';
import { ORGANIZATION_ROLES } from '../organizations/organizations.constants';
import { createTestLogger } from '../shared/logger/logger.test-utils';
import { omit } from '../shared/objects';
import { createWebhookRepository } from './webhooks.repository';
import { webhookDeliveriesTable, webhookEventsTable, webhooksTable } from './webhooks.tables';
import { createWebhook, triggerWebhooks, updateWebhook } from './webhooks.usecases';

describe('webhook usecases', () => {
  describe('createWebhook', () => {
    test('when SSRF protection is enabled, creating a webhook with a private IP URL throws ssrf_unsafe_url', async () => {
      const { db } = await createInMemoryDatabase({
        organizations: [{ id: 'org_1', name: 'Test Organization' }],
        users: [{ id: 'user_1', email: '[email protected]', name: 'Test User' }],
        organizationMembers: [
          { organizationId: 'org_1', userId: 'user_1', role: ORGANIZATION_ROLES.OWNER },
        ],
      });
      const webhookRepository = createWebhookRepository({ db });

      await expect(
        createWebhook({
          name: 'Test Webhook',
          url: 'https://127.0.0.1/webhook',
          events: ['document:created'],
          webhookRepository,
          organizationId: 'org_1',
          createdBy: 'user_1',
          webhooksConfig: {
            isSsrfProtectionEnabled: true,
            webhookUrlAllowedHostnames: new Set<string>(),
          },
        }),
      ).rejects.toThrow('The provided URL is not safe to perform requests to');
    });

    test('creates a new webhook and saves the events in the webhook_events table', async () => {
      const { db } = await createInMemoryDatabase({
        organizations: [{ id: 'org_1', name: 'Test Organization' }],
        users: [{ id: 'user_1', email: '[email protected]', name: 'Test User' }],
        organizationMembers: [
          { organizationId: 'org_1', userId: 'user_1', role: ORGANIZATION_ROLES.OWNER },
        ],
      });
      const webhookRepository = createWebhookRepository({ db });

      const { webhook } = await createWebhook({
        name: 'Test Webhook',
        url: 'https://example.com/webhook',
        secret: 'test-secret',
        events: ['document:created', 'document:deleted'],
        webhookRepository,
        organizationId: 'org_1',
        createdBy: 'user_1',
        webhooksConfig: {
          isSsrfProtectionEnabled: false,
          webhookUrlAllowedHostnames: new Set<string>(),
        },
      });

      expect(webhook).to.deep.include({
        name: 'Test Webhook',
        url: 'https://example.com/webhook',
        secret: 'test-secret',
        enabled: true,
      });

      // Verify events were created
      const events = await db
        .select()
        .from(webhookEventsTable)
        .where(eq(webhookEventsTable.webhookId, webhook.id));
      expect(events.map((e) => omit(e, ['createdAt', 'updatedAt', 'id']))).to.eql([
        {
          webhookId: webhook.id,
          eventName: 'document:created',
        },
        {
          webhookId: webhook.id,
          eventName: 'document:deleted',
        },
      ]);
    });
  });

  describe('updateWebhook', () => {
    test('when SSRF protection is enabled, updating a webhook with a private IP URL throws ssrf_unsafe_url', async () => {
      const { db } = await createInMemoryDatabase({
        organizations: [{ id: 'org_1', name: 'Test Organization' }],
        webhooks: [
          {
            id: 'wbh_1',
            name: 'Test Webhook',
            url: 'https://example.com/webhook',
            organizationId: 'org_1',
          },
        ],
      });
      const webhookRepository = createWebhookRepository({ db });

      await expect(
        updateWebhook({
          webhookId: 'wbh_1',
          url: 'https://10.0.0.1/webhook',
          webhookRepository,
          organizationId: 'org_1',
          webhooksConfig: {
            isSsrfProtectionEnabled: true,
            webhookUrlAllowedHostnames: new Set<string>(),
          },
        }),
      ).rejects.toThrow('The provided URL is not safe to perform requests to');
    });

    test('updates a webhook and saves the events in the webhook_events table', async () => {
      const { db } = await createInMemoryDatabase({
        organizations: [{ id: 'org_1', name: 'Test Organization' }],
        webhooks: [
          {
            id: 'wbh_1',
            name: 'Test Webhook',
            url: 'https://example.com/webhook',
            organizationId: 'org_1',
          },
        ],
        webhookEvents: [
          { id: 'wbh_ev_1', webhookId: 'wbh_1', eventName: 'document:created' },
          { id: 'wbh_ev_2', webhookId: 'wbh_1', eventName: 'document:deleted' },
        ],
      });
      const webhookRepository = createWebhookRepository({ db });

      await updateWebhook({
        webhookId: 'wbh_1',
        name: 'Test Webhook',
        url: 'https://foo.bar',
        secret: 'test-secret',
        events: ['document:deleted'],
        webhookRepository,
        organizationId: 'org_1',
        webhooksConfig: {
          isSsrfProtectionEnabled: false,
          webhookUrlAllowedHostnames: new Set<string>(),
        },
      });

      const webhooks = await db.select().from(webhooksTable);
      expect(webhooks.length).to.eq(1);
      const [webhook] = webhooks;

      expect(webhook).to.deep.include({
        id: 'wbh_1',
        name: 'Test Webhook',
        url: 'https://foo.bar',
        secret: 'test-secret',
        organizationId: 'org_1',
      });

      const events = await db
        .select()
        .from(webhookEventsTable)
        .where(eq(webhookEventsTable.webhookId, 'wbh_1'));
      expect(events.map((e) => omit(e, ['createdAt', 'updatedAt', 'id']))).to.eql([
        {
          webhookId: 'wbh_1',
          eventName: 'document:deleted',
        },
      ]);
    });
  });

  describe('triggerWebhooks', () => {
    test('when one webhook delivery fails (e.g. blocked by SSRF protection at connect time), sibling webhooks still complete', async () => {
      const { db } = await createInMemoryDatabase({
        organizations: [{ id: 'org_1', name: 'Organization 1' }],
        webhooks: [
          {
            id: 'wbh_1',
            name: 'Unsafe Webhook',
            url: 'https://192.168.1.1/webhook',
            organizationId: 'org_1',
            enabled: true,
          },
          {
            id: 'wbh_2',
            name: 'Safe Webhook',
            url: 'https://example.com/webhook',
            organizationId: 'org_1',
            enabled: true,
          },
        ],
        webhookEvents: [
          { id: 'wbh_ev_1', webhookId: 'wbh_1', eventName: 'document:created' },
          { id: 'wbh_ev_2', webhookId: 'wbh_2', eventName: 'document:created' },
        ],
      });

      const webhookRepository = createWebhookRepository({ db });
      const { logger } = createTestLogger();
      const httpClientArgs: { url: string }[] = [];

      await triggerWebhooks({
        webhookRepository,
        organizationId: 'org_1',
        event: 'document:created',
        payloads: [
          {
            documentId: 'doc_1',
            organizationId: 'org_1',
            name: 'Document 1',
            createdAt: new Date('2025-01-01'),
            updatedAt: new Date('2025-01-01'),
          },
        ],
        logger,
        httpClient: async (args) => {
          httpClientArgs.push(args);

          if (args.url.includes('192.168')) {
            const error = new Error('IP 192.168.1.1 is blocked by net.BlockList') as Error & {
              code?: string;
            };
            error.code = 'ERR_IP_BLOCKED';
            throw error;
          }

          return { responseData: {}, responseStatus: 200 };
        },
      });

      expect(httpClientArgs.map((a) => a.url)).to.eql([
        'https://192.168.1.1/webhook',
        'https://example.com/webhook',
      ]);

      const deliveries = await db.select().from(webhookDeliveriesTable);

      expect(deliveries.length).to.eq(1);
      expect(deliveries[0]).to.include({ responseStatus: 200 });
    });

    test('when an organization has webhooks enabled for an event, the configured urls are called with the event payload', async () => {
      const { db } = await createInMemoryDatabase({
        organizations: [
          { id: 'org_1', name: 'Organization 1' },
          { id: 'org_2', name: 'Organization 2' },
        ],
        webhooks: [
          // webhook 1 is enabled and has the event document.created
          {
            id: 'wbh_1',
            name: 'Test Webhook',
            url: 'https://example.com/webhook1',
            organizationId: 'org_1',
            enabled: true,
          },
          // webhook 2 is enabled and has the event document.deleted (so it will not be triggered)
          {
            id: 'wbh_2',
            name: 'Test Webhook',
            url: 'https://example.com/webhook2',
            organizationId: 'org_1',
            enabled: true,
          },
          // webhook 3 is enabled and has the event document.created (so it will be triggered)
          {
            id: 'wbh_3',
            name: 'Test Webhook',
            url: 'https://example.com/webhook3',
            organizationId: 'org_1',
            secret: 'secret3',
          }, // by default the webhook is enabled
          // webhook 4 is disabled and has the event document.created (so it will not be triggered)
          {
            id: 'wbh_4',
            name: 'Test Webhook',
            url: 'https://example.com/webhook4',
            organizationId: 'org_1',
            enabled: false,
          },
          // webhook 5 is related to organization 2 and has the event document.created (so it will not be triggered)
          {
            id: 'wbh_5',
            name: 'Test Webhook',
            url: 'https://example.com/webhook5',
            organizationId: 'org_2',
            enabled: true,
          },
        ],
        webhookEvents: [
          { id: 'wbh_ev_1', webhookId: 'wbh_1', eventName: 'document:created' },
          { id: 'wbh_ev_2', webhookId: 'wbh_2', eventName: 'document:deleted' },
          { id: 'wbh_ev_3', webhookId: 'wbh_3', eventName: 'document:created' },
          { id: 'wbh_ev_4', webhookId: 'wbh_4', eventName: 'document:created' },
          { id: 'wbh_ev_5', webhookId: 'wbh_5', eventName: 'document:created' },
        ],
      });

      const webhookRepository = createWebhookRepository({ db });
      const { logger } = createTestLogger();
      const httpClientArgs: { url: string; body: string; headers: Record<string, string> }[] = [];

      const eventPayload = {
        documentId: 'doc_1',
        organizationId: 'org_1',
        name: 'Document 1',
        createdAt: new Date('2025-01-01'),
        updatedAt: new Date('2025-01-01'),
      };

      await triggerWebhooks({
        webhookRepository,
        organizationId: 'org_1',
        event: 'document:created',
        payloads: [eventPayload],
        logger,
        now: new Date('2025-05-04'),
        httpClient: async (args) => {
          httpClientArgs.push(args);
          return { responseData: {}, responseStatus: 200 };
        },
      });

      expect(httpClientArgs.map((a) => a.url)).to.eql([
        'https://example.com/webhook1',
        'https://example.com/webhook3',
      ]);

      for (const args of httpClientArgs) {
        expect(JSON.parse(args.body)).to.eql({
          type: 'document:created',
          timestamp: '2025-05-04T00:00:00.000Z',
          data: {
            ...eventPayload,
            createdAt: eventPayload.createdAt.toISOString(),
            updatedAt: eventPayload.updatedAt.toISOString(),
          },
        });
      }

      // Only the webhook with a configured secret should produce a signature header
      expect(httpClientArgs[0]?.headers['webhook-signature']).toBeUndefined();
      expect(typeof httpClientArgs[1]?.headers['webhook-signature']).to.eq('string');
    });
  });
});