@valentine-efagene/qshelter-common 2.0.75 → 2.0.77

package/dist/src/events/workflow/event-config.service.d.ts

@@ -0,0 +1,123 @@
+/**
+ * Event Configuration Service
+ *
+ * Allows admins to configure event channels, types, and handlers.
+ * This is the "admin" side of the event system.
+ *
+ * Usage:
+ * ```typescript
+ * const configService = new EventConfigService(prisma);
+ *
+ * // Create a channel
+ * const channel = await configService.createChannel(tenantId, {
+ *   code: 'CONTRACTS',
+ *   name: 'Contract Events',
+ *   description: 'Events related to contract lifecycle',
+ * });
+ *
+ * // Create an event type
+ * const eventType = await configService.createEventType(tenantId, {
+ *   channelId: channel.id,
+ *   code: 'DOCUMENT_UPLOADED',
+ *   name: 'Document Uploaded',
+ *   description: 'Fired when a document is uploaded to a contract step',
+ * });
+ *
+ * // Create a webhook handler
+ * await configService.createHandler(tenantId, {
+ *   eventTypeId: eventType.id,
+ *   name: 'Notify CRM',
+ *   handlerType: 'WEBHOOK',
+ *   config: {
+ *     type: 'WEBHOOK',
+ *     url: 'https://crm.example.com/webhook',
+ *     method: 'POST',
+ *   },
+ * });
+ * ```
+ */
+import { PrismaClient } from '../../../generated/client/client';
+import type { CreateEventChannelInput, UpdateEventChannelInput, CreateEventTypeInput, UpdateEventTypeInput, CreateEventHandlerInput, UpdateEventHandlerInput, EventChannelWithTypes, EventTypeWithHandlers, EventHandlerWithType } from './workflow-types';
+export declare class EventConfigService {
+    private prisma;
+    constructor(prisma: PrismaClient);
+    /**
+     * Create an event channel
+     */
+    createChannel(tenantId: string, input: CreateEventChannelInput): Promise<EventChannelWithTypes>;
+    /**
+     * List all channels for a tenant
+     */
+    listChannels(tenantId: string): Promise<EventChannelWithTypes[]>;
+    /**
+     * Get a channel by ID
+     */
+    getChannel(tenantId: string, channelId: string): Promise<EventChannelWithTypes | null>;
+    /**
+     * Get a channel by code
+     */
+    getChannelByCode(tenantId: string, code: string): Promise<EventChannelWithTypes | null>;
+    /**
+     * Update a channel
+     */
+    updateChannel(tenantId: string, channelId: string, input: UpdateEventChannelInput): Promise<EventChannelWithTypes>;
+    /**
+     * Delete a channel (cascades to event types and handlers)
+     */
+    deleteChannel(tenantId: string, channelId: string): Promise<void>;
+    /**
+     * Create an event type
+     */
+    createEventType(tenantId: string, input: CreateEventTypeInput): Promise<EventTypeWithHandlers>;
+    /**
+     * List event types for a tenant, optionally filtered by channel
+     */
+    listEventTypes(tenantId: string, channelId?: string): Promise<EventTypeWithHandlers[]>;
+    /**
+     * Get an event type by ID
+     */
+    getEventType(tenantId: string, eventTypeId: string): Promise<EventTypeWithHandlers | null>;
+    /**
+     * Get an event type by code
+     */
+    getEventTypeByCode(tenantId: string, code: string): Promise<EventTypeWithHandlers | null>;
+    /**
+     * Update an event type
+     */
+    updateEventType(tenantId: string, eventTypeId: string, input: UpdateEventTypeInput): Promise<EventTypeWithHandlers>;
+    /**
+     * Delete an event type (cascades to handlers)
+     */
+    deleteEventType(tenantId: string, eventTypeId: string): Promise<void>;
+    /**
+     * Create an event handler
+     */
+    createHandler(tenantId: string, input: CreateEventHandlerInput): Promise<EventHandlerWithType>;
+    /**
+     * List handlers for an event type
+     */
+    listHandlers(tenantId: string, eventTypeId?: string): Promise<EventHandlerWithType[]>;
+    /**
+     * Get a handler by ID
+     */
+    getHandler(tenantId: string, handlerId: string): Promise<EventHandlerWithType | null>;
+    /**
+     * Update a handler
+     */
+    updateHandler(tenantId: string, handlerId: string, input: UpdateEventHandlerInput): Promise<EventHandlerWithType>;
+    /**
+     * Delete a handler
+     */
+    deleteHandler(tenantId: string, handlerId: string): Promise<void>;
+    /**
+     * Enable or disable a handler
+     */
+    setHandlerEnabled(tenantId: string, handlerId: string, enabled: boolean): Promise<void>;
+    private mapChannel;
+    private mapEventType;
+    private mapHandler;
+}
+/**
+ * Create an event config service instance
+ */
+export declare function createEventConfigService(prisma: PrismaClient): EventConfigService;

package/dist/src/events/workflow/event-config.service.js

@@ -0,0 +1,416 @@
+/**
+ * Event Configuration Service
+ *
+ * Allows admins to configure event channels, types, and handlers.
+ * This is the "admin" side of the event system.
+ *
+ * Usage:
+ * ```typescript
+ * const configService = new EventConfigService(prisma);
+ *
+ * // Create a channel
+ * const channel = await configService.createChannel(tenantId, {
+ *   code: 'CONTRACTS',
+ *   name: 'Contract Events',
+ *   description: 'Events related to contract lifecycle',
+ * });
+ *
+ * // Create an event type
+ * const eventType = await configService.createEventType(tenantId, {
+ *   channelId: channel.id,
+ *   code: 'DOCUMENT_UPLOADED',
+ *   name: 'Document Uploaded',
+ *   description: 'Fired when a document is uploaded to a contract step',
+ * });
+ *
+ * // Create a webhook handler
+ * await configService.createHandler(tenantId, {
+ *   eventTypeId: eventType.id,
+ *   name: 'Notify CRM',
+ *   handlerType: 'WEBHOOK',
+ *   config: {
+ *     type: 'WEBHOOK',
+ *     url: 'https://crm.example.com/webhook',
+ *     method: 'POST',
+ *   },
+ * });
+ * ```
+ */
+export class EventConfigService {
+    prisma;
+    constructor(prisma) {
+        this.prisma = prisma;
+    }
+    // ==========================================
+    // EVENT CHANNELS
+    // ==========================================
+    /**
+     * Create an event channel
+     */
+    async createChannel(tenantId, input) {
+        const channel = await this.prisma.eventChannel.create({
+            data: {
+                tenantId,
+                code: input.code.toUpperCase().replace(/\s+/g, '_'),
+                name: input.name,
+                description: input.description,
+                enabled: input.enabled ?? true,
+            },
+            include: {
+                eventTypes: {
+                    select: { id: true, code: true, name: true, enabled: true },
+                },
+            },
+        });
+        return this.mapChannel(channel);
+    }
+    /**
+     * List all channels for a tenant
+     */
+    async listChannels(tenantId) {
+        const channels = await this.prisma.eventChannel.findMany({
+            where: { tenantId },
+            include: {
+                eventTypes: {
+                    select: { id: true, code: true, name: true, enabled: true },
+                },
+            },
+            orderBy: { name: 'asc' },
+        });
+        return channels.map(this.mapChannel);
+    }
+    /**
+     * Get a channel by ID
+     */
+    async getChannel(tenantId, channelId) {
+        const channel = await this.prisma.eventChannel.findFirst({
+            where: { id: channelId, tenantId },
+            include: {
+                eventTypes: {
+                    select: { id: true, code: true, name: true, enabled: true },
+                },
+            },
+        });
+        return channel ? this.mapChannel(channel) : null;
+    }
+    /**
+     * Get a channel by code
+     */
+    async getChannelByCode(tenantId, code) {
+        const channel = await this.prisma.eventChannel.findFirst({
+            where: { tenantId, code: code.toUpperCase() },
+            include: {
+                eventTypes: {
+                    select: { id: true, code: true, name: true, enabled: true },
+                },
+            },
+        });
+        return channel ? this.mapChannel(channel) : null;
+    }
+    /**
+     * Update a channel
+     */
+    async updateChannel(tenantId, channelId, input) {
+        const channel = await this.prisma.eventChannel.update({
+            where: { id: channelId, tenantId },
+            data: {
+                ...(input.name !== undefined && { name: input.name }),
+                ...(input.description !== undefined && { description: input.description }),
+                ...(input.enabled !== undefined && { enabled: input.enabled }),
+            },
+            include: {
+                eventTypes: {
+                    select: { id: true, code: true, name: true, enabled: true },
+                },
+            },
+        });
+        return this.mapChannel(channel);
+    }
+    /**
+     * Delete a channel (cascades to event types and handlers)
+     */
+    async deleteChannel(tenantId, channelId) {
+        await this.prisma.eventChannel.delete({
+            where: { id: channelId, tenantId },
+        });
+    }
+    // ==========================================
+    // EVENT TYPES
+    // ==========================================
+    /**
+     * Create an event type
+     */
+    async createEventType(tenantId, input) {
+        const eventType = await this.prisma.eventType.create({
+            data: {
+                tenantId,
+                channelId: input.channelId,
+                code: input.code.toUpperCase().replace(/\s+/g, '_'),
+                name: input.name,
+                description: input.description,
+                payloadSchema: input.payloadSchema,
+                enabled: input.enabled ?? true,
+            },
+            include: {
+                channel: { select: { code: true, name: true } },
+                handlers: {
+                    select: { id: true, name: true, handlerType: true, enabled: true },
+                },
+            },
+        });
+        return this.mapEventType(eventType);
+    }
+    /**
+     * List event types for a tenant, optionally filtered by channel
+     */
+    async listEventTypes(tenantId, channelId) {
+        const eventTypes = await this.prisma.eventType.findMany({
+            where: {
+                tenantId,
+                ...(channelId && { channelId }),
+            },
+            include: {
+                channel: { select: { code: true, name: true } },
+                handlers: {
+                    select: { id: true, name: true, handlerType: true, enabled: true },
+                },
+            },
+            orderBy: { code: 'asc' },
+        });
+        return eventTypes.map(this.mapEventType);
+    }
+    /**
+     * Get an event type by ID
+     */
+    async getEventType(tenantId, eventTypeId) {
+        const eventType = await this.prisma.eventType.findFirst({
+            where: { id: eventTypeId, tenantId },
+            include: {
+                channel: { select: { code: true, name: true } },
+                handlers: {
+                    select: { id: true, name: true, handlerType: true, enabled: true },
+                },
+            },
+        });
+        return eventType ? this.mapEventType(eventType) : null;
+    }
+    /**
+     * Get an event type by code
+     */
+    async getEventTypeByCode(tenantId, code) {
+        const eventType = await this.prisma.eventType.findFirst({
+            where: { tenantId, code: code.toUpperCase() },
+            include: {
+                channel: { select: { code: true, name: true } },
+                handlers: {
+                    select: { id: true, name: true, handlerType: true, enabled: true },
+                },
+            },
+        });
+        return eventType ? this.mapEventType(eventType) : null;
+    }
+    /**
+     * Update an event type
+     */
+    async updateEventType(tenantId, eventTypeId, input) {
+        const eventType = await this.prisma.eventType.update({
+            where: { id: eventTypeId, tenantId },
+            data: {
+                ...(input.name !== undefined && { name: input.name }),
+                ...(input.description !== undefined && { description: input.description }),
+                ...(input.payloadSchema !== undefined && { payloadSchema: input.payloadSchema }),
+                ...(input.enabled !== undefined && { enabled: input.enabled }),
+            },
+            include: {
+                channel: { select: { code: true, name: true } },
+                handlers: {
+                    select: { id: true, name: true, handlerType: true, enabled: true },
+                },
+            },
+        });
+        return this.mapEventType(eventType);
+    }
+    /**
+     * Delete an event type (cascades to handlers)
+     */
+    async deleteEventType(tenantId, eventTypeId) {
+        await this.prisma.eventType.delete({
+            where: { id: eventTypeId, tenantId },
+        });
+    }
+    // ==========================================
+    // EVENT HANDLERS
+    // ==========================================
+    /**
+     * Create an event handler
+     */
+    async createHandler(tenantId, input) {
+        const handler = await this.prisma.eventHandler.create({
+            data: {
+                tenantId,
+                eventTypeId: input.eventTypeId,
+                name: input.name,
+                description: input.description,
+                handlerType: input.handlerType,
+                config: input.config,
+                priority: input.priority ?? 100,
+                enabled: input.enabled ?? true,
+                maxRetries: input.maxRetries ?? 3,
+                retryDelayMs: input.retryDelayMs ?? 1000,
+                filterCondition: input.filterCondition,
+            },
+            include: {
+                eventType: {
+                    select: {
+                        code: true,
+                        name: true,
+                        channel: { select: { code: true, name: true } },
+                    },
+                },
+            },
+        });
+        return this.mapHandler(handler);
+    }
+    /**
+     * List handlers for an event type
+     */
+    async listHandlers(tenantId, eventTypeId) {
+        const handlers = await this.prisma.eventHandler.findMany({
+            where: {
+                tenantId,
+                ...(eventTypeId && { eventTypeId }),
+            },
+            include: {
+                eventType: {
+                    select: {
+                        code: true,
+                        name: true,
+                        channel: { select: { code: true, name: true } },
+                    },
+                },
+            },
+            orderBy: [{ eventTypeId: 'asc' }, { priority: 'asc' }],
+        });
+        return handlers.map(this.mapHandler);
+    }
+    /**
+     * Get a handler by ID
+     */
+    async getHandler(tenantId, handlerId) {
+        const handler = await this.prisma.eventHandler.findFirst({
+            where: { id: handlerId, tenantId },
+            include: {
+                eventType: {
+                    select: {
+                        code: true,
+                        name: true,
+                        channel: { select: { code: true, name: true } },
+                    },
+                },
+            },
+        });
+        return handler ? this.mapHandler(handler) : null;
+    }
+    /**
+     * Update a handler
+     */
+    async updateHandler(tenantId, handlerId, input) {
+        const handler = await this.prisma.eventHandler.update({
+            where: { id: handlerId, tenantId },
+            data: {
+                ...(input.name !== undefined && { name: input.name }),
+                ...(input.description !== undefined && { description: input.description }),
+                ...(input.config !== undefined && { config: input.config }),
+                ...(input.priority !== undefined && { priority: input.priority }),
+                ...(input.enabled !== undefined && { enabled: input.enabled }),
+                ...(input.maxRetries !== undefined && { maxRetries: input.maxRetries }),
+                ...(input.retryDelayMs !== undefined && { retryDelayMs: input.retryDelayMs }),
+                ...(input.filterCondition !== undefined && { filterCondition: input.filterCondition }),
+            },
+            include: {
+                eventType: {
+                    select: {
+                        code: true,
+                        name: true,
+                        channel: { select: { code: true, name: true } },
+                    },
+                },
+            },
+        });
+        return this.mapHandler(handler);
+    }
+    /**
+     * Delete a handler
+     */
+    async deleteHandler(tenantId, handlerId) {
+        await this.prisma.eventHandler.delete({
+            where: { id: handlerId, tenantId },
+        });
+    }
+    /**
+     * Enable or disable a handler
+     */
+    async setHandlerEnabled(tenantId, handlerId, enabled) {
+        await this.prisma.eventHandler.update({
+            where: { id: handlerId, tenantId },
+            data: { enabled },
+        });
+    }
+    // ==========================================
+    // HELPER METHODS
+    // ==========================================
+    mapChannel(channel) {
+        return {
+            id: channel.id,
+            tenantId: channel.tenantId,
+            code: channel.code,
+            name: channel.name,
+            description: channel.description,
+            enabled: channel.enabled,
+            eventTypes: channel.eventTypes,
+            createdAt: channel.createdAt,
+            updatedAt: channel.updatedAt,
+        };
+    }
+    mapEventType(eventType) {
+        return {
+            id: eventType.id,
+            tenantId: eventType.tenantId,
+            channelId: eventType.channelId,
+            channel: eventType.channel,
+            code: eventType.code,
+            name: eventType.name,
+            description: eventType.description,
+            payloadSchema: eventType.payloadSchema,
+            enabled: eventType.enabled,
+            handlers: eventType.handlers,
+            createdAt: eventType.createdAt,
+            updatedAt: eventType.updatedAt,
+        };
+    }
+    mapHandler(handler) {
+        return {
+            id: handler.id,
+            tenantId: handler.tenantId,
+            eventTypeId: handler.eventTypeId,
+            eventType: handler.eventType,
+            name: handler.name,
+            description: handler.description,
+            handlerType: handler.handlerType,
+            config: handler.config,
+            priority: handler.priority,
+            enabled: handler.enabled,
+            maxRetries: handler.maxRetries,
+            retryDelayMs: handler.retryDelayMs,
+            filterCondition: handler.filterCondition,
+            createdAt: handler.createdAt,
+            updatedAt: handler.updatedAt,
+        };
+    }
+}
+/**
+ * Create an event config service instance
+ */
+export function createEventConfigService(prisma) {
+    return new EventConfigService(prisma);
+}

package/dist/src/events/workflow/event-seeder.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Event Type Seeder
+ *
+ * Utilities for seeding EventChannel, EventType, and EventHandler records.
+ * This allows admins to configure event-driven workflows programmatically.
+ *
+ * Usage:
+ * ```typescript
+ * import { seedContractEventTypes } from '@valentine-efagene/qshelter-common';
+ *
+ * await seedContractEventTypes(prisma, tenantId);
+ * ```
+ */
+import { PrismaClient } from '../../../generated/client/client';
+/**
+ * Event type definition for seeding
+ */
+export interface EventTypeDefinition {
+    code: string;
+    name: string;
+    description?: string;
+    channelCode: string;
+    payloadSchema?: any;
+    enabled?: boolean;
+}
+/**
+ * Event channel definition for seeding
+ */
+export interface EventChannelDefinition {
+    code: string;
+    name: string;
+    description?: string;
+    enabled?: boolean;
+}
+/**
+ * Event handler definition for seeding
+ */
+export interface EventHandlerDefinition {
+    eventTypeCode: string;
+    name: string;
+    description?: string;
+    handlerType: 'SEND_EMAIL' | 'SEND_SMS' | 'SEND_PUSH' | 'CALL_WEBHOOK' | 'ADVANCE_WORKFLOW' | 'RUN_AUTOMATION';
+    config: any;
+    priority?: number;
+    enabled?: boolean;
+    maxRetries?: number;
+    retryDelayMs?: number;
+    filterCondition?: string;
+}
+/**
+ * Seed event channels
+ */
+export declare function seedEventChannels(prisma: PrismaClient, tenantId: string, channels: EventChannelDefinition[]): Promise<void>;
+/**
+ * Seed event types
+ */
+export declare function seedEventTypes(prisma: PrismaClient, tenantId: string, eventTypes: EventTypeDefinition[]): Promise<void>;
+/**
+ * Seed event handlers
+ */
+export declare function seedEventHandlers(prisma: PrismaClient, tenantId: string, handlers: EventHandlerDefinition[]): Promise<void>;
+/**
+ * Contract event channels
+ */
+export declare const CONTRACT_CHANNELS: EventChannelDefinition[];
+/**
+ * Contract event types
+ */
+export declare const CONTRACT_EVENT_TYPES: EventTypeDefinition[];
+/**
+ * Seed all contract event types
+ */
+export declare function seedContractEventTypes(prisma: PrismaClient, tenantId: string): Promise<void>;
+/**
+ * Seed example email notification handlers
+ *
+ * Note: In production, admins would configure these via the UI.
+ * This is just an example for testing.
+ */
+export declare function seedExampleEmailHandlers(prisma: PrismaClient, tenantId: string): Promise<void>;