@hed-hog/core 0.0.325 → 0.0.327

package/src/webhook-integration/event-webhook.service.ts

@@ -0,0 +1,384 @@
+import { DeleteDTO } from '@hed-hog/api';
+import { PaginationDTO, PaginationService } from '@hed-hog/api-pagination';
+import { PrismaService } from '@hed-hog/api-prisma';
+import { HttpService } from '@nestjs/axios';
+import {
+  BadRequestException,
+  Injectable,
+  Logger,
+  NotFoundException,
+  OnModuleInit,
+} from '@nestjs/common';
+import { firstValueFrom } from 'rxjs';
+import { IntegrationDeveloperApiService } from '../integration/services/integration-developer-api.service';
+import { DomainEvent } from '../integration/types';
+import {
+  normalizeJsonObject,
+  renderTemplate,
+  summarizePayload,
+} from './webhook-utils';
+
+@Injectable()
+export class EventWebhookService implements OnModuleInit {
+  private readonly logger = new Logger(EventWebhookService.name);
+  private readonly registeredEvents = new Set<string>();
+
+  constructor(
+    private readonly prisma: PrismaService,
+    private readonly pagination: PaginationService,
+    private readonly http: HttpService,
+    private readonly integrationApi: IntegrationDeveloperApiService,
+  ) {}
+
+  private get webhooks() {
+    return (this.prisma as any).event_webhook;
+  }
+
+  private get webhookEvents() {
+    return (this.prisma as any).event_webhook_event;
+  }
+
+  private get catalog() {
+    return (this.prisma as any).integration_event_catalog;
+  }
+
+  private get logs() {
+    return (this.prisma as any).event_webhook_delivery_log;
+  }
+
+  async onModuleInit() {
+    await this.registerConfiguredEvents();
+  }
+
+  async list(paginationParams: PaginationDTO) {
+    const fields = ['slug', 'name', 'description', 'url', 'method', 'status'];
+    const OR = this.prisma.createInsensitiveSearch(fields, paginationParams);
+
+    return this.pagination.paginate(this.webhooks, paginationParams, {
+      where: OR.length > 0 ? { OR } : {},
+      include: {
+        event_webhook_event: {
+          include: {
+            integration_event_catalog: true,
+          },
+        },
+      },
+      orderBy: [{ updated_at: 'desc' }, { id: 'desc' }],
+    });
+  }
+
+  async get(id: number) {
+    const record = await this.webhooks.findUnique({
+      where: { id },
+      include: {
+        event_webhook_event: {
+          include: {
+            integration_event_catalog: true,
+          },
+        },
+      },
+    });
+
+    if (!record) {
+      throw new NotFoundException(`Event webhook with id ${id} not found.`);
+    }
+
+    return record;
+  }
+
+  async create(data: any) {
+    await this.ensureSlugAvailable(data.slug);
+
+    const record = await this.webhooks.create({
+      data: {
+        ...this.normalizeWebhook(data),
+        event_webhook_event: {
+          create: this.normalizeEventIds(data.event_ids).map((eventId) => ({
+            integration_event_catalog_id: eventId,
+          })),
+        },
+      },
+      include: {
+        event_webhook_event: {
+          include: { integration_event_catalog: true },
+        },
+      },
+    });
+
+    await this.registerEventsFromWebhook(record);
+    return record;
+  }
+
+  async update(id: number, data: any) {
+    const existing = await this.get(id);
+    if (data.slug && data.slug !== existing.slug) {
+      await this.ensureSlugAvailable(data.slug);
+    }
+
+    const record = await this.webhooks.update({
+      where: { id },
+      data: this.normalizeWebhook(data, true),
+      include: {
+        event_webhook_event: {
+          include: { integration_event_catalog: true },
+        },
+      },
+    });
+
+    if (data.event_ids !== undefined) {
+      await this.webhookEvents.deleteMany({
+        where: { event_webhook_id: id },
+      });
+
+      const eventIds = this.normalizeEventIds(data.event_ids);
+      for (const eventId of eventIds) {
+        await this.webhookEvents.create({
+          data: {
+            event_webhook_id: id,
+            integration_event_catalog_id: eventId,
+          },
+        });
+      }
+    }
+
+    const refreshed = await this.get(id);
+    await this.registerEventsFromWebhook(refreshed);
+    return refreshed;
+  }
+
+  async delete(data: DeleteDTO) {
+    if (!data.ids?.length) {
+      throw new BadRequestException('You must select at least one item to delete.');
+    }
+
+    return this.webhooks.deleteMany({
+      where: { id: { in: data.ids } },
+    });
+  }
+
+  async listLogs(webhookId: number, paginationParams: PaginationDTO) {
+    await this.get(webhookId);
+    return this.pagination.paginate(this.logs, paginationParams, {
+      where: { event_webhook_id: webhookId },
+      orderBy: [{ created_at: 'desc' }, { id: 'desc' }],
+    });
+  }
+
+  async handleEvent(event: DomainEvent) {
+    const webhooks = await this.findActiveWebhooksForEvent(event.eventName);
+
+    for (const webhook of webhooks) {
+      await this.deliverWebhook(webhook, event);
+    }
+  }
+
+  async registerConfiguredEvents() {
+    const rows = await this.catalog.findMany({
+      where: {
+        status: 'active',
+        event_webhook_event: {
+          some: {
+            event_webhook: {
+              status: 'active',
+            },
+          },
+        },
+      },
+      select: { slug: true },
+    });
+
+    for (const row of rows) {
+      this.registerEvent(row.slug);
+    }
+  }
+
+  private async findActiveWebhooksForEvent(eventName: string) {
+    return this.webhooks.findMany({
+      where: {
+        status: 'active',
+        event_webhook_event: {
+          some: {
+            integration_event_catalog: {
+              slug: eventName,
+              status: 'active',
+            },
+          },
+        },
+      },
+      include: {
+        event_webhook_event: {
+          include: {
+            integration_event_catalog: true,
+          },
+        },
+      },
+      orderBy: [{ priority: 'desc' }, { id: 'asc' }],
+    });
+  }
+
+  private async deliverWebhook(webhook: any, event: DomainEvent) {
+    const startedAt = Date.now();
+    let attemptCount = 0;
+    let lastError: any = null;
+    let httpStatus: number | null = null;
+    let responseSummary: any = null;
+
+    const context = {
+      ...event,
+      timestamp: event.timestamp?.toISOString?.() ?? event.timestamp,
+      outboxEventId: (event as any).outboxEventId ?? null,
+    };
+
+    const url = renderTemplate(webhook.url, context) as string;
+    const method = webhook.method || 'POST';
+    const headers = renderTemplate(webhook.headers || {}, context) as Record<string, string>;
+    const query = renderTemplate(webhook.query || {}, context) as Record<string, string>;
+    const payload = renderTemplate(webhook.payload ?? event.payload ?? {}, context);
+    const maxAttempts = Math.max(1, Number(webhook.retry_count || 0) + 1);
+
+    for (attemptCount = 1; attemptCount <= maxAttempts; attemptCount++) {
+      try {
+        const result = await firstValueFrom(
+          this.http.request({
+            url,
+            method,
+            headers,
+            params: query,
+            data: ['GET', 'DELETE'].includes(method) ? undefined : payload,
+            timeout: Number(webhook.timeout_ms || 10000),
+          }),
+        );
+
+        httpStatus = result.status;
+        responseSummary = summarizePayload(result.data);
+        lastError = null;
+        break;
+      } catch (error: any) {
+        lastError = error;
+        httpStatus = error?.response?.status ?? null;
+        responseSummary = summarizePayload(error?.response?.data);
+      }
+    }
+
+    const success = !lastError;
+    await this.logs.create({
+      data: {
+        event_webhook_id: webhook.id,
+        integration_event_catalog_id:
+          webhook.event_webhook_event?.[0]?.integration_event_catalog?.id ?? null,
+        outbox_event_id: Number((event as any).outboxEventId || 0) || null,
+        event_name: event.eventName,
+        method,
+        url,
+        status: success ? 'success' : 'failed',
+        http_status: httpStatus,
+        duration_ms: Date.now() - startedAt,
+        attempt_count: attemptCount,
+        error_message: lastError
+          ? lastError instanceof Error
+            ? lastError.message
+            : String(lastError)
+          : null,
+        request_summary: summarizePayload({
+          headers,
+          query,
+          payload,
+        }),
+        response_summary: responseSummary,
+      },
+    });
+
+    if (!success) {
+      throw lastError;
+    }
+  }
+
+  private async registerEventsFromWebhook(webhook: any) {
+    const eventNames =
+      webhook.event_webhook_event
+        ?.map((row: any) => row.integration_event_catalog?.slug)
+        .filter(Boolean) || [];
+
+    for (const eventName of eventNames) {
+      this.registerEvent(eventName);
+    }
+  }
+
+  private registerEvent(eventName: string) {
+    if (this.registeredEvents.has(eventName)) {
+      return;
+    }
+
+    this.integrationApi.subscribe({
+      eventName,
+      consumerName: `core.event-webhook.${eventName}`,
+      priority: -100,
+      handler: async (event) => {
+        await this.handleEvent(event);
+      },
+    });
+
+    this.registeredEvents.add(eventName);
+    this.logger.log(`Registered event webhook dispatcher for ${eventName}`);
+  }
+
+  private async ensureSlugAvailable(slug: string) {
+    const existing = await this.webhooks.findUnique({
+      where: { slug: String(slug || '').trim() },
+      select: { id: true },
+    });
+
+    if (existing) {
+      throw new BadRequestException(`Event webhook "${slug}" already exists.`);
+    }
+  }
+
+  private normalizeWebhook(data: any, partial = false) {
+    const normalized: Record<string, any> = {};
+    const assign = (key: string, value: any) => {
+      if (!partial || value !== undefined) {
+        normalized[key] = value;
+      }
+    };
+
+    assign('slug', String(data.slug ?? '').trim());
+    assign('name', String(data.name ?? '').trim());
+    assign('description', this.nullableString(data.description, partial));
+    assign('status', data.status === 'inactive' ? 'inactive' : 'active');
+    assign('priority', Number(data.priority ?? 0));
+    assign('url', String(data.url ?? '').trim());
+    assign('method', String(data.method || 'POST').toUpperCase());
+    assign('headers', normalizeJsonObject(data.headers));
+    assign('query', normalizeJsonObject(data.query));
+    assign('payload', normalizeJsonObject(data.payload));
+    assign('timeout_ms', Number(data.timeout_ms || 10000));
+    assign('retry_count', Number(data.retry_count || 0));
+
+    return normalized;
+  }
+
+  private normalizeEventIds(value: any) {
+    if (!value) {
+      return [];
+    }
+
+    const values = Array.isArray(value) ? value : String(value).split(',');
+    return values
+      .map((item) => Number(item))
+      .filter((item) => Number.isFinite(item) && item > 0);
+  }
+
+  private nullableString(value: any, partial = false) {
+    if (value === undefined) {
+      return partial ? undefined : null;
+    }
+
+    if (value === null) {
+      return null;
+    }
+
+    const normalized = String(value).trim();
+    return normalized || null;
+  }
+}
+

package/src/webhook-integration/integration-event-catalog.controller.ts

@@ -0,0 +1,50 @@
+import { DeleteDTO, Role } from '@hed-hog/api';
+import { Pagination } from '@hed-hog/api-pagination';
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  Param,
+  ParseIntPipe,
+  Patch,
+  Post,
+} from '@nestjs/common';
+import { IntegrationEventCatalogService } from './integration-event-catalog.service';
+
+@Role()
+@Controller('integration-event-catalog')
+export class IntegrationEventCatalogController {
+  constructor(private readonly service: IntegrationEventCatalogService) {}
+
+  @Get()
+  list(@Pagination() paginationParams) {
+    return this.service.list(paginationParams);
+  }
+
+  @Get('options')
+  options() {
+    return this.service.options();
+  }
+
+  @Get(':id')
+  get(@Param('id', ParseIntPipe) id: number) {
+    return this.service.get(id);
+  }
+
+  @Post()
+  create(@Body() data: any) {
+    return this.service.create(data);
+  }
+
+  @Patch(':id')
+  update(@Param('id', ParseIntPipe) id: number, @Body() data: any) {
+    return this.service.update(id, data);
+  }
+
+  @Delete()
+  delete(@Body() data: DeleteDTO) {
+    return this.service.delete(data);
+  }
+}
+

package/src/webhook-integration/integration-event-catalog.service.ts

@@ -0,0 +1,117 @@
+import { DeleteDTO } from '@hed-hog/api';
+import { PaginationDTO, PaginationService } from '@hed-hog/api-pagination';
+import { PrismaService } from '@hed-hog/api-prisma';
+import {
+  BadRequestException,
+  Injectable,
+  NotFoundException,
+} from '@nestjs/common';
+
+@Injectable()
+export class IntegrationEventCatalogService {
+  constructor(
+    private readonly prisma: PrismaService,
+    private readonly pagination: PaginationService,
+  ) {}
+
+  private get delegate() {
+    return (this.prisma as any).integration_event_catalog;
+  }
+
+  async list(paginationParams: PaginationDTO) {
+    const fields = ['slug', 'name', 'module', 'description', 'status'];
+    const OR = this.prisma.createInsensitiveSearch(fields, paginationParams);
+
+    return this.pagination.paginate(this.delegate, paginationParams, {
+      where: OR.length > 0 ? { OR } : {},
+      orderBy: [{ module: 'asc' }, { slug: 'asc' }],
+    });
+  }
+
+  async options() {
+    return this.delegate.findMany({
+      where: { status: 'active' },
+      orderBy: [{ module: 'asc' }, { slug: 'asc' }],
+      select: {
+        id: true,
+        slug: true,
+        name: true,
+        module: true,
+        description: true,
+      },
+    });
+  }
+
+  async get(id: number) {
+    const record = await this.delegate.findUnique({ where: { id } });
+    if (!record) {
+      throw new NotFoundException(`Event catalog item with id ${id} not found.`);
+    }
+    return record;
+  }
+
+  async create(data: any) {
+    await this.ensureSlugAvailable(data.slug);
+    return this.delegate.create({
+      data: this.normalize(data),
+    });
+  }
+
+  async update(id: number, data: any) {
+    const existing = await this.get(id);
+    if (data.slug && data.slug !== existing.slug) {
+      await this.ensureSlugAvailable(data.slug);
+    }
+
+    return this.delegate.update({
+      where: { id },
+      data: this.normalize(data, true),
+    });
+  }
+
+  async delete(data: DeleteDTO) {
+    if (!data.ids?.length) {
+      throw new BadRequestException('You must select at least one item to delete.');
+    }
+
+    return this.delegate.deleteMany({
+      where: { id: { in: data.ids } },
+    });
+  }
+
+  private async ensureSlugAvailable(slug: string) {
+    const existing = await this.delegate.findUnique({
+      where: { slug: String(slug || '').trim() },
+      select: { id: true },
+    });
+
+    if (existing) {
+      throw new BadRequestException(`Event "${slug}" already exists.`);
+    }
+  }
+
+  private normalize(data: any, partial = false) {
+    const normalized: Record<string, any> = {};
+    const assign = (key: string, value: any) => {
+      if (!partial || value !== undefined) {
+        normalized[key] = value;
+      }
+    };
+
+    assign('slug', String(data.slug ?? '').trim());
+    assign('name', String(data.name ?? '').trim());
+    assign('module', String(data.module ?? '').trim());
+    assign(
+      'description',
+      data.description === undefined || data.description === null
+        ? partial
+          ? undefined
+          : null
+        : String(data.description).trim() || null,
+    );
+    assign('status', data.status === 'inactive' ? 'inactive' : 'active');
+
+    return normalized;
+  }
+}
+

package/src/webhook-integration/webhook-integration.controller.ts

@@ -0,0 +1,103 @@
+import { DeleteDTO, Public, Role } from '@hed-hog/api';
+import { Pagination } from '@hed-hog/api-pagination';
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  Headers,
+  Param,
+  ParseIntPipe,
+  Patch,
+  Post,
+  Req,
+} from '@nestjs/common';
+import { Request } from 'express';
+import { WebhookIntegrationService } from './webhook-integration.service';
+
+@Role()
+@Controller('webhook-integration')
+export class WebhookIntegrationController {
+  constructor(private readonly service: WebhookIntegrationService) {}
+
+  @Get()
+  list(@Pagination() paginationParams) {
+    return this.service.list(paginationParams);
+  }
+
+  @Get(':id')
+  get(@Param('id', ParseIntPipe) id: number) {
+    return this.service.get(id);
+  }
+
+  @Post()
+  create(@Body() data: any) {
+    return this.service.create(data);
+  }
+
+  @Patch(':id')
+  update(@Param('id', ParseIntPipe) id: number, @Body() data: any) {
+    return this.service.update(id, data);
+  }
+
+  @Delete()
+  delete(@Body() data: DeleteDTO) {
+    return this.service.delete(data);
+  }
+
+  @Post(':id/regenerate-uuid')
+  regenerateUuid(@Param('id', ParseIntPipe) id: number) {
+    return this.service.regenerateUuid(id);
+  }
+
+  @Post(':id/regenerate-token')
+  regenerateToken(@Param('id', ParseIntPipe) id: number) {
+    return this.service.regenerateToken(id);
+  }
+
+  @Get(':id/action')
+  listActions(@Param('id', ParseIntPipe) id: number) {
+    return this.service.listActions(id);
+  }
+
+  @Post(':id/action')
+  createAction(@Param('id', ParseIntPipe) id: number, @Body() data: any) {
+    return this.service.createAction(id, data);
+  }
+
+  @Patch(':id/action/:actionId')
+  updateAction(
+    @Param('id', ParseIntPipe) id: number,
+    @Param('actionId', ParseIntPipe) actionId: number,
+    @Body() data: any,
+  ) {
+    return this.service.updateAction(id, actionId, data);
+  }
+
+  @Delete(':id/action')
+  deleteActions(@Param('id', ParseIntPipe) id: number, @Body() data: DeleteDTO) {
+    return this.service.deleteActions(id, data);
+  }
+
+  @Get(':id/log')
+  listLogs(@Param('id', ParseIntPipe) id: number, @Pagination() paginationParams) {
+    return this.service.listLogs(id, paginationParams);
+  }
+}
+
+@Public()
+@Controller('webhook')
+export class PublicWebhookController {
+  constructor(private readonly service: WebhookIntegrationService) {}
+
+  @Post(':uuid')
+  execute(
+    @Param('uuid') uuid: string,
+    @Body() body: any,
+    @Headers() headers: any,
+    @Req() req: Request,
+  ) {
+    return this.service.executePublic(uuid, body, headers, req);
+  }
+}
+

package/src/webhook-integration/webhook-integration.module.ts

@@ -0,0 +1,45 @@
+import { MailModule as MailMainModule } from '@hed-hog/api-mail';
+import { PaginationModule } from '@hed-hog/api-pagination';
+import { PrismaModule } from '@hed-hog/api-prisma';
+import { HttpModule } from '@nestjs/axios';
+import { Module, forwardRef } from '@nestjs/common';
+import { IntegrationModule } from '../integration/integration.module';
+import { MailModule } from '../mail/mail.module';
+import { EventWebhookController } from './event-webhook.controller';
+import { EventWebhookService } from './event-webhook.service';
+import { IntegrationEventCatalogController } from './integration-event-catalog.controller';
+import { IntegrationEventCatalogService } from './integration-event-catalog.service';
+import {
+  PublicWebhookController,
+  WebhookIntegrationController,
+} from './webhook-integration.controller';
+import { WebhookIntegrationService } from './webhook-integration.service';
+
+@Module({
+  imports: [
+    HttpModule,
+    forwardRef(() => PrismaModule),
+    forwardRef(() => PaginationModule),
+    forwardRef(() => IntegrationModule),
+    forwardRef(() => MailModule),
+    forwardRef(() => MailMainModule),
+  ],
+  controllers: [
+    IntegrationEventCatalogController,
+    WebhookIntegrationController,
+    PublicWebhookController,
+    EventWebhookController,
+  ],
+  providers: [
+    IntegrationEventCatalogService,
+    WebhookIntegrationService,
+    EventWebhookService,
+  ],
+  exports: [
+    IntegrationEventCatalogService,
+    WebhookIntegrationService,
+    EventWebhookService,
+  ],
+})
+export class WebhookIntegrationModule {}
+