Class WebhooksService

backend/src/webhooks/webhooks.service.ts:27–536

@Injectable()
export class WebhooksService {
  private readonly logger = new Logger(WebhooksService.name);

  constructor(
    private readonly repository: WebhookRepository,
    private readonly deliveryRepository: WebhookDeliveryRepository,
    private readonly workflowsService: WorkflowsService,
    private readonly temporalService: TemporalService,
  ) {}

  // Management methods (auth required)

  async list(auth: AuthContext | null): Promise<WebhookConfiguration[]> {
    const organizationId = this.requireOrganizationId(auth);
    const records = await this.repository.list({ organizationId });
    return records.map((r) => this.mapConfigurationRecord(r));
  }

  async get(auth: AuthContext | null, id: string): Promise<WebhookConfiguration> {
    const organizationId = this.requireOrganizationId(auth);
    const record = await this.repository.findById(id, { organizationId });
    if (!record) {
      throw new NotFoundException(`Webhook ${id} not found`);
    }
    return this.mapConfigurationRecord(record);
  }

  async create(
    auth: AuthContext | null,
    dto: {
      workflowId: string;
      workflowVersionId?: string;
      name: string;
      description?: string;
      parsingScript: string;
      expectedInputs: {
        id: string;
        label: string;
        type: string;
        required: boolean;
        description?: string;
      }[];
    },
  ): Promise<WebhookConfiguration> {
    // Validate workflow exists and user has admin access
    await this.workflowsService.ensureWorkflowAdminAccess(dto.workflowId, auth);

    // Get organization ID
    const organizationId = this.requireOrganizationId(auth);

    // Generate unique webhook path
    const webhookPath = this.generateWebhookPath();

    // Validate expected inputs against workflow's entry point
    await this.validateExpectedInputs(dto.workflowId, dto.expectedInputs, auth);

    const record = await this.repository.create({
      workflowId: dto.workflowId,