Api keys and webhook migration to core (#13011)

TODO: check Zapier trigger records work as expected

---------

Co-authored-by: Weiko <corentin@twenty.com>

packages/twenty-server/test/integration/metadata/suites/developers/webhooks.integration-spec.ts

@@ -0,0 +1,311 @@
+import { gql } from 'graphql-tag';
+import { makeMetadataAPIRequest } from 'test/integration/metadata/suites/utils/make-metadata-api-request.util';
+
+describe('webhooksResolver (e2e)', () => {
+  let createdWebhookId: string | undefined;
+
+  afterEach(async () => {
+    if (createdWebhookId) {
+      await makeMetadataAPIRequest({
+        query: gql`
+          mutation DeleteWebhook($input: DeleteWebhookDTO!) {
+            deleteWebhook(input: $input)
+          }
+        `,
+        variables: {
+          input: { id: createdWebhookId },
+        },
+      }).catch(() => {});
+      createdWebhookId = undefined;
+    }
+  });
+
+  describe('webhooks query', () => {
+    it('should find many webhooks', async () => {
+      const response = await makeMetadataAPIRequest({
+        query: gql`
+          query GetWebhooks {
+            webhooks {
+              id
+              targetUrl
+              operations
+              description
+              secret
+            }
+          }
+        `,
+      });
+
+      expect(response.status).toBe(200);
+      expect(response.body.data).toBeDefined();
+      expect(response.body.errors).toBeUndefined();
+      expect(response.body.data.webhooks).toBeDefined();
+      expect(Array.isArray(response.body.data.webhooks)).toBe(true);
+    });
+  });
+
+  describe('createWebhook mutation', () => {
+    it('should create a webhook successfully', async () => {
+      const webhookInput = {
+        targetUrl: 'https://example.com/webhook',
+        operations: ['person.created', 'company.updated'],
+        description: 'Test webhook',
+        secret: 'test-secret',
+      };
+
+      const response = await makeMetadataAPIRequest({
+        query: gql`
+          mutation CreateWebhook($input: CreateWebhookDTO!) {
+            createWebhook(input: $input) {
+              id
+              targetUrl
+              operations
+              description
+              secret
+            }
+          }
+        `,
+        variables: {
+          input: webhookInput,
+        },
+      });
+
+      expect(response.status).toBe(200);
+      expect(response.body.data).toBeDefined();
+      expect(response.body.errors).toBeUndefined();
+
+      const createdWebhook = response.body.data.createWebhook;
+
+      expect(createdWebhook).toBeDefined();
+      expect(createdWebhook.id).toBeDefined();
+      expect(createdWebhook.targetUrl).toBe(webhookInput.targetUrl);
+      expect(createdWebhook.operations).toEqual(webhookInput.operations);
+      expect(createdWebhook.description).toBe(webhookInput.description);
+      expect(createdWebhook.secret).toBe(webhookInput.secret);
+
+      createdWebhookId = createdWebhook.id;
+    });
+
+    it('should fail to create webhook with invalid URL', async () => {
+      const webhookInput = {
+        targetUrl: 'invalid-url',
+        operations: ['person.created'],
+        description: 'Test webhook',
+        secret: 'test-secret',
+      };
+
+      const response = await makeMetadataAPIRequest({
+        query: gql`
+          mutation CreateWebhook($input: CreateWebhookDTO!) {
+            createWebhook(input: $input) {
+              id
+              targetUrl
+              operations
+              description
+              secret
+            }
+          }
+        `,
+        variables: {
+          input: webhookInput,
+        },
+      });
+
+      expect(response.status).toBe(200);
+      expect(response.body.errors).toBeDefined();
+      expect(response.body.errors.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('updateWebhook mutation', () => {
+    it('should update a webhook successfully', async () => {
+      const createResponse = await makeMetadataAPIRequest({
+        query: gql`
+          mutation CreateWebhook($input: CreateWebhookDTO!) {
+            createWebhook(input: $input) {
+              id
+              targetUrl
+              operations
+              description
+              secret
+            }
+          }
+        `,
+        variables: {
+          input: {
+            targetUrl: 'https://example.com/webhook',
+            operations: ['person.created'],
+            description: 'Test webhook',
+            secret: 'test-secret',
+          },
+        },
+      });
+
+      const createdWebhook = createResponse.body.data.createWebhook;
+
+      createdWebhookId = createdWebhook.id;
+
+      const updateInput = {
+        id: createdWebhook.id,
+        targetUrl: 'https://updated.com/webhook',
+        operations: ['person.updated', 'company.created'],
+        description: 'Updated webhook',
+        secret: 'updated-secret',
+      };
+
+      const updateResponse = await makeMetadataAPIRequest({
+        query: gql`
+          mutation UpdateWebhook($input: UpdateWebhookDTO!) {
+            updateWebhook(input: $input) {
+              id
+              targetUrl
+              operations
+              description
+              secret
+            }
+          }
+        `,
+        variables: {
+          input: updateInput,
+        },
+      });
+
+      expect(updateResponse.status).toBe(200);
+      expect(updateResponse.body.data).toBeDefined();
+      expect(updateResponse.body.errors).toBeUndefined();
+
+      const updatedWebhook = updateResponse.body.data.updateWebhook;
+
+      expect(updatedWebhook.id).toBe(createdWebhook.id);
+      expect(updatedWebhook.targetUrl).toBe(updateInput.targetUrl);
+      expect(updatedWebhook.operations).toEqual(updateInput.operations);
+      expect(updatedWebhook.description).toBe(updateInput.description);
+      expect(updatedWebhook.secret).toBe(updateInput.secret);
+    });
+  });
+
+  describe('webhook query', () => {
+    it('should find a specific webhook', async () => {
+      const createResponse = await makeMetadataAPIRequest({
+        query: gql`
+          mutation CreateWebhook($input: CreateWebhookDTO!) {
+            createWebhook(input: $input) {
+              id
+              targetUrl
+              operations
+              description
+              secret
+            }
+          }
+        `,
+        variables: {
+          input: {
+            targetUrl: 'https://example.com/webhook',
+            operations: ['person.created'],
+            description: 'Test webhook',
+            secret: 'test-secret',
+          },
+        },
+      });
+
+      const createdWebhook = createResponse.body.data.createWebhook;
+
+      createdWebhookId = createdWebhook.id;
+
+      const queryResponse = await makeMetadataAPIRequest({
+        query: gql`
+          query GetWebhook($input: GetWebhookDTO!) {
+            webhook(input: $input) {
+              id
+              targetUrl
+              operations
+              description
+              secret
+            }
+          }
+        `,
+        variables: {
+          input: { id: createdWebhook.id },
+        },
+      });
+
+      expect(queryResponse.status).toBe(200);
+      expect(queryResponse.body.data).toBeDefined();
+      expect(queryResponse.body.errors).toBeUndefined();
+
+      const webhook = queryResponse.body.data.webhook;
+
+      expect(webhook).toBeDefined();
+      expect(webhook.id).toBe(createdWebhook.id);
+      expect(webhook.targetUrl).toBe(createdWebhook.targetUrl);
+      expect(webhook.operations).toEqual(createdWebhook.operations);
+      expect(webhook.description).toBe(createdWebhook.description);
+      expect(webhook.secret).toBe(createdWebhook.secret);
+    });
+  });
+
+  describe('deleteWebhook mutation', () => {
+    it('should delete a webhook successfully', async () => {
+      const createResponse = await makeMetadataAPIRequest({
+        query: gql`
+          mutation CreateWebhook($input: CreateWebhookDTO!) {
+            createWebhook(input: $input) {
+              id
+              targetUrl
+              operations
+              description
+              secret
+            }
+          }
+        `,
+        variables: {
+          input: {
+            targetUrl: 'https://example.com/webhook',
+            operations: ['person.created'],
+            description: 'Test webhook',
+            secret: 'test-secret',
+          },
+        },
+      });
+
+      const createdWebhook = createResponse.body.data.createWebhook;
+
+      const deleteResponse = await makeMetadataAPIRequest({
+        query: gql`
+          mutation DeleteWebhook($input: DeleteWebhookDTO!) {
+            deleteWebhook(input: $input)
+          }
+        `,
+        variables: {
+          input: { id: createdWebhook.id },
+        },
+      });
+
+      expect(deleteResponse.status).toBe(200);
+      expect(deleteResponse.body.data).toBeDefined();
+      expect(deleteResponse.body.errors).toBeUndefined();
+
+      const queryResponse = await makeMetadataAPIRequest({
+        query: gql`
+          query GetWebhook($input: GetWebhookDTO!) {
+            webhook(input: $input) {
+              id
+              targetUrl
+              operations
+              description
+              secret
+            }
+          }
+        `,
+        variables: {
+          input: { id: createdWebhook.id },
+        },
+      });
+
+      expect(queryResponse.status).toBe(200);
+      expect(queryResponse.body.data.webhook).toBeNull();
+
+      createdWebhookId = undefined;
+    });
+  });
+});