@valentine-efagene/qshelter-common 2.0.75 → 2.0.76

package/dist/generated/client/models/index.d.ts

@@ -1,5 +1,6 @@
 export * from './Amenity';
 export * from './ApiKey';
+export * from './ApprovalRequest';
 export * from './Contract';
 export * from './ContractDocument';
 export * from './ContractEvent';
@@ -34,6 +35,7 @@ export * from './PropertyMedia';
 export * from './PropertyPaymentMethod';
 export * from './PropertyPaymentMethodLink';
 export * from './PropertyPaymentMethodPhase';
+export * from './PropertyTransferRequest';
 export * from './PropertyUnit';
 export * from './PropertyVariant';
 export * from './PropertyVariantAmenity';
@@ -43,6 +45,7 @@ export * from './Role';
 export * from './RolePermission';
 export * from './Settings';
 export * from './Social';
+export * from './StepEventAttachment';
 export * from './Tenant';
 export * from './Transaction';
 export * from './User';

package/dist/generated/client/models/index.js

@@ -1,5 +1,6 @@
 export * from './Amenity';
 export * from './ApiKey';
+export * from './ApprovalRequest';
 export * from './Contract';
 export * from './ContractDocument';
 export * from './ContractEvent';
@@ -34,6 +35,7 @@ export * from './PropertyMedia';
 export * from './PropertyPaymentMethod';
 export * from './PropertyPaymentMethodLink';
 export * from './PropertyPaymentMethodPhase';
+export * from './PropertyTransferRequest';
 export * from './PropertyUnit';
 export * from './PropertyVariant';
 export * from './PropertyVariantAmenity';
@@ -43,6 +45,7 @@ export * from './Role';
 export * from './RolePermission';
 export * from './Settings';
 export * from './Social';
+export * from './StepEventAttachment';
 export * from './Tenant';
 export * from './Transaction';
 export * from './User';

package/dist/generated/client/models.d.ts

@@ -33,13 +33,13 @@ export type * from './models/StepEventAttachment.js';
 export type * from './models/PaymentMethodPhaseDocument.js';
 export type * from './models/Contract.js';
 export type * from './models/ContractPhase.js';
+export type * from './models/ContractEvent.js';
 export type * from './models/DocumentationStep.js';
 export type * from './models/DocumentationStepDocument.js';
 export type * from './models/DocumentationStepApproval.js';
 export type * from './models/ContractInstallment.js';
 export type * from './models/ContractPayment.js';
 export type * from './models/ContractDocument.js';
-export type * from './models/ContractEvent.js';
 export type * from './models/DocumentTemplate.js';
 export type * from './models/OfferLetter.js';
 export type * from './models/ContractTermination.js';

package/dist/src/events/bus/event-bus.service.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Event Bus Service
+ *
+ * Multi-transport event delivery system for serverless microservices.
+ * Supports HTTP webhooks, AWS SNS, SQS, and EventBridge.
+ *
+ * This is a plain TypeScript implementation (no NestJS) designed for Lambda/serverless environments.
+ */
+import { EventHandler, EventResult, EventBusConfig } from './event-bus.types';
+/**
+ * Event Bus Service - Multi-transport event delivery
+ */
+export declare class EventBusService {
+    private eventHandlers;
+    private readonly config;
+    private readonly httpClient;
+    constructor(config?: Partial<EventBusConfig>);
+    /**
+     * Register an event handler/endpoint
+     */
+    registerHandler(handler: EventHandler): void;
+    /**
+     * Register multiple handlers at once
+     */
+    registerHandlers(handlers: EventHandler[]): void;
+    /**
+     * Publish an event to all registered handlers
+     */
+    publish<T = any>(eventType: string, data: T, options?: {
+        tenantId?: number;
+        source?: string;
+        metadata?: Record<string, any>;
+        correlationId?: string;
+    }): Promise<EventResult[]>;
+    /**
+     * Execute a single handler based on its transport type
+     */
+    private executeHandler;
+    /**
+     * Execute HTTP webhook call
+     */
+    private executeHttpHandler;
+    /**
+     * Publish to AWS SNS
+     */
+    private executeSnsHandler;
+    /**
+     * Publish to AWS EventBridge
+     */
+    private executeEventBridgeHandler;
+    /**
+     * Send to AWS SQS
+     */
+    private executeSqsHandler;
+    /**
+     * Execute internal handler function
+     */
+    private executeInternalHandler;
+    /**
+     * Send failed events to dead letter queue
+     */
+    private sendToDeadLetterQueue;
+    /**
+     * Generate unique event ID
+     */
+    private generateEventId;
+    /**
+     * Sleep helper for retries
+     */
+    private sleep;
+    /**
+     * Get all registered handlers
+     */
+    getHandlers(): Map<string, EventHandler[]>;
+    /**
+     * Clear all handlers (useful for testing)
+     */
+    clearHandlers(): void;
+}
+export declare function createEventBus(config?: Partial<EventBusConfig>): EventBusService;
+/**
+ * Get the singleton EventBus instance (must be created first)
+ */
+export declare function getEventBus(): EventBusService;

package/dist/src/events/bus/event-bus.service.js

@@ -0,0 +1,372 @@
+/**
+ * Event Bus Service
+ *
+ * Multi-transport event delivery system for serverless microservices.
+ * Supports HTTP webhooks, AWS SNS, SQS, and EventBridge.
+ *
+ * This is a plain TypeScript implementation (no NestJS) designed for Lambda/serverless environments.
+ */
+import axios from 'axios';
+import * as crypto from 'crypto';
+import { EventTransportType, } from './event-bus.types';
+/**
+ * Event Bus Service - Multi-transport event delivery
+ */
+export class EventBusService {
+    eventHandlers = new Map();
+    config;
+    httpClient;
+    constructor(config) {
+        this.config = {
+            defaultTransport: config?.defaultTransport || EventTransportType.HTTP,
+            defaultTimeout: config?.defaultTimeout || 30000,
+            defaultRetries: config?.defaultRetries || 3,
+            enableDeadLetterQueue: config?.enableDeadLetterQueue ?? true,
+            awsRegion: config?.awsRegion || process.env.AWS_REGION || 'us-east-1',
+        };
+        this.httpClient = axios.create({
+            timeout: this.config.defaultTimeout,
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+    }
+    /**
+     * Register an event handler/endpoint
+     */
+    registerHandler(handler) {
+        const handlers = this.eventHandlers.get(handler.eventType) || [];
+        handlers.push(handler);
+        this.eventHandlers.set(handler.eventType, handlers);
+        console.log(`[EventBus] Registered ${handler.transport} handler for event: ${handler.eventType}`);
+    }
+    /**
+     * Register multiple handlers at once
+     */
+    registerHandlers(handlers) {
+        handlers.forEach(handler => this.registerHandler(handler));
+    }
+    /**
+     * Publish an event to all registered handlers
+     */
+    async publish(eventType, data, options) {
+        const eventId = this.generateEventId();
+        const payload = {
+            eventType,
+            eventId,
+            timestamp: new Date(),
+            tenantId: options?.tenantId,
+            source: options?.source || 'event-bus',
+            data,
+            metadata: options?.metadata,
+            correlationId: options?.correlationId || eventId,
+        };
+        console.log(`[EventBus] Publishing event: ${eventType} [${eventId}]`);
+        const handlers = this.eventHandlers.get(eventType) || [];
+        if (handlers.length === 0) {
+            console.warn(`[EventBus] No handlers registered for event: ${eventType}`);
+            return [];
+        }
+        // Execute all handlers in parallel (fan-out pattern)
+        const results = await Promise.allSettled(handlers.map(handler => this.executeHandler(handler, payload)));
+        return results.map((result, index) => {
+            if (result.status === 'fulfilled') {
+                return result.value;
+            }
+            else {
+                const handler = handlers[index];
+                return {
+                    success: false,
+                    eventId,
+                    error: result.reason?.message || 'Unknown error',
+                    retryCount: 0,
+                    executionTime: 0,
+                    transport: handler.transport,
+                };
+            }
+        });
+    }
+    /**
+     * Execute a single handler based on its transport type
+     */
+    async executeHandler(handler, payload) {
+        const startTime = Date.now();
+        const retryConfig = handler.retryConfig || {
+            maxRetries: this.config.defaultRetries,
+            retryDelay: 1000,
+            backoffMultiplier: 2,
+        };
+        let lastError;
+        for (let attempt = 0; attempt <= retryConfig.maxRetries; attempt++) {
+            try {
+                let response;
+                switch (handler.transport) {
+                    case EventTransportType.HTTP:
+                        response = await this.executeHttpHandler(handler, payload);
+                        break;
+                    case EventTransportType.SNS:
+                        response = await this.executeSnsHandler(handler, payload);
+                        break;
+                    case EventTransportType.EVENTBRIDGE:
+                        response = await this.executeEventBridgeHandler(handler, payload);
+                        break;
+                    case EventTransportType.SQS:
+                        response = await this.executeSqsHandler(handler, payload);
+                        break;
+                    case EventTransportType.INTERNAL:
+                        response = await this.executeInternalHandler(handler, payload);
+                        break;
+                    default:
+                        throw new Error(`Unsupported transport: ${handler.transport}`);
+                }
+                const executionTime = Date.now() - startTime;
+                console.log(`[EventBus] Event ${payload.eventId} executed successfully via ${handler.transport} (attempt ${attempt + 1}/${retryConfig.maxRetries + 1})`);
+                return {
+                    success: true,
+                    eventId: payload.eventId,
+                    statusCode: response?.statusCode || 200,
+                    response: response?.data,
+                    retryCount: attempt,
+                    executionTime,
+                    transport: handler.transport,
+                };
+            }
+            catch (error) {
+                lastError = error;
+                console.error(`[EventBus] Event ${payload.eventId} failed via ${handler.transport} (attempt ${attempt + 1}/${retryConfig.maxRetries + 1}): ${error.message}`);
+                if (attempt < retryConfig.maxRetries) {
+                    const delay = retryConfig.retryDelay * Math.pow(retryConfig.backoffMultiplier, attempt);
+                    await this.sleep(delay);
+                }
+            }
+        }
+        // All retries exhausted
+        const executionTime = Date.now() - startTime;
+        // Send to dead letter queue if enabled
+        if (this.config.enableDeadLetterQueue) {
+            await this.sendToDeadLetterQueue(handler, payload, lastError);
+        }
+        return {
+            success: false,
+            eventId: payload.eventId,
+            error: lastError?.message || 'Unknown error',
+            retryCount: retryConfig.maxRetries,
+            executionTime,
+            transport: handler.transport,
+        };
+    }
+    /**
+     * Execute HTTP webhook call
+     */
+    async executeHttpHandler(handler, payload) {
+        if (!handler.endpoint) {
+            throw new Error('HTTP handler requires endpoint');
+        }
+        const headers = {
+            'Content-Type': 'application/json',
+            'X-Event-Id': payload.eventId,
+            'X-Event-Type': payload.eventType,
+            'X-Correlation-Id': payload.correlationId || '',
+            ...(handler.headers || {}),
+        };
+        // Add authentication
+        if (handler.authentication) {
+            switch (handler.authentication.type) {
+                case 'bearer':
+                    headers['Authorization'] = `Bearer ${handler.authentication.credentials}`;
+                    break;
+                case 'api-key':
+                    headers['X-API-Key'] = handler.authentication.credentials;
+                    break;
+                case 'basic':
+                    headers['Authorization'] = `Basic ${handler.authentication.credentials}`;
+                    break;
+            }
+        }
+        const timeout = handler.timeout || this.config.defaultTimeout;
+        const response = await this.httpClient.post(handler.endpoint, payload, {
+            headers,
+            timeout,
+        });
+        return {
+            statusCode: response.status,
+            data: response.data,
+        };
+    }
+    /**
+     * Publish to AWS SNS
+     */
+    async executeSnsHandler(handler, payload) {
+        if (!handler.snsTopicArn) {
+            throw new Error('SNS handler requires topic ARN');
+        }
+        try {
+            const { SNSClient, PublishCommand } = await import('@aws-sdk/client-sns');
+            const client = new SNSClient({ region: this.config.awsRegion });
+            const command = new PublishCommand({
+                TopicArn: handler.snsTopicArn,
+                Message: JSON.stringify(payload),
+                MessageAttributes: {
+                    eventType: { DataType: 'String', StringValue: payload.eventType },
+                    eventId: { DataType: 'String', StringValue: payload.eventId },
+                    ...(payload.tenantId && { tenantId: { DataType: 'Number', StringValue: String(payload.tenantId) } }),
+                    ...(payload.correlationId && { correlationId: { DataType: 'String', StringValue: payload.correlationId } }),
+                },
+            });
+            const result = await client.send(command);
+            console.log(`[EventBus] Published event ${payload.eventId} to SNS topic: ${handler.snsTopicArn}`);
+            return { MessageId: result.MessageId };
+        }
+        catch (error) {
+            console.error(`[EventBus] Failed to publish to SNS: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * Publish to AWS EventBridge
+     */
+    async executeEventBridgeHandler(handler, payload) {
+        if (!handler.eventBridgeDetail) {
+            throw new Error('EventBridge handler requires event bus configuration');
+        }
+        try {
+            const { EventBridgeClient, PutEventsCommand } = await import('@aws-sdk/client-eventbridge');
+            const client = new EventBridgeClient({ region: this.config.awsRegion });
+            const command = new PutEventsCommand({
+                Entries: [{
+                        EventBusName: handler.eventBridgeDetail.eventBusName,
+                        Source: handler.eventBridgeDetail.source,
+                        DetailType: handler.eventBridgeDetail.detailType,
+                        Detail: JSON.stringify(payload),
+                    }],
+            });
+            const result = await client.send(command);
+            console.log(`[EventBus] Published event ${payload.eventId} to EventBridge: ${handler.eventBridgeDetail.eventBusName}`);
+            return { Entries: result.Entries };
+        }
+        catch (error) {
+            console.error(`[EventBus] Failed to publish to EventBridge: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * Send to AWS SQS
+     */
+    async executeSqsHandler(handler, payload) {
+        if (!handler.sqsQueueUrl) {
+            throw new Error('SQS handler requires queue URL');
+        }
+        try {
+            const { SQSClient, SendMessageCommand } = await import('@aws-sdk/client-sqs');
+            const client = new SQSClient({ region: this.config.awsRegion });
+            const command = new SendMessageCommand({
+                QueueUrl: handler.sqsQueueUrl,
+                MessageBody: JSON.stringify(payload),
+                MessageAttributes: {
+                    eventType: { DataType: 'String', StringValue: payload.eventType },
+                    eventId: { DataType: 'String', StringValue: payload.eventId },
+                    ...(payload.tenantId && { tenantId: { DataType: 'Number', StringValue: String(payload.tenantId) } }),
+                },
+            });
+            const result = await client.send(command);
+            console.log(`[EventBus] Sent event ${payload.eventId} to SQS queue: ${handler.sqsQueueUrl}`);
+            return { MessageId: result.MessageId };
+        }
+        catch (error) {
+            console.error(`[EventBus] Failed to send to SQS: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * Execute internal handler function
+     */
+    async executeInternalHandler(handler, payload) {
+        if (!handler.handler) {
+            throw new Error('Internal handler requires handler function');
+        }
+        return await handler.handler(payload);
+    }
+    /**
+     * Send failed events to dead letter queue
+     */
+    async sendToDeadLetterQueue(handler, payload, error) {
+        console.error(`[EventBus] Sending event ${payload.eventId} to dead letter queue after exhausting retries`);
+        // Log to CloudWatch/console (in Lambda, this goes to CloudWatch Logs)
+        console.error({
+            message: 'Dead letter event',
+            eventId: payload.eventId,
+            eventType: payload.eventType,
+            handler: {
+                transport: handler.transport,
+                endpoint: handler.endpoint,
+            },
+            error: error?.message,
+            payload,
+        });
+        // If DLQ URL is configured, send to SQS
+        if (this.config.deadLetterQueueUrl) {
+            try {
+                const { SQSClient, SendMessageCommand } = await import('@aws-sdk/client-sqs');
+                const client = new SQSClient({ region: this.config.awsRegion });
+                await client.send(new SendMessageCommand({
+                    QueueUrl: this.config.deadLetterQueueUrl,
+                    MessageBody: JSON.stringify({
+                        payload,
+                        handler: {
+                            transport: handler.transport,
+                            endpoint: handler.endpoint,
+                        },
+                        error: error?.message,
+                        failedAt: new Date().toISOString(),
+                    }),
+                }));
+            }
+            catch (dlqError) {
+                console.error(`[EventBus] Failed to send to DLQ: ${dlqError.message}`);
+            }
+        }
+    }
+    /**
+     * Generate unique event ID
+     */
+    generateEventId() {
+        return `evt_${Date.now()}_${crypto.randomBytes(8).toString('hex')}`;
+    }
+    /**
+     * Sleep helper for retries
+     */
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    /**
+     * Get all registered handlers
+     */
+    getHandlers() {
+        return this.eventHandlers;
+    }
+    /**
+     * Clear all handlers (useful for testing)
+     */
+    clearHandlers() {
+        this.eventHandlers.clear();
+    }
+}
+/**
+ * Create a singleton EventBus instance
+ */
+let eventBusInstance = null;
+export function createEventBus(config) {
+    if (!eventBusInstance) {
+        eventBusInstance = new EventBusService(config);
+    }
+    return eventBusInstance;
+}
+/**
+ * Get the singleton EventBus instance (must be created first)
+ */
+export function getEventBus() {
+    if (!eventBusInstance) {
+        throw new Error('EventBus not initialized. Call createEventBus() first.');
+    }
+    return eventBusInstance;
+}

package/dist/src/events/bus/event-bus.types.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Event Bus Types
+ *
+ * Type definitions for the EventBus system.
+ */
+export declare enum EventTransportType {
+    HTTP = "http",// Direct HTTP webhook call
+    SNS = "sns",// AWS SNS topic
+    EVENTBRIDGE = "eventbridge",// AWS EventBridge
+    SQS = "sqs",// AWS SQS queue
+    INTERNAL = "internal"
+}
+export declare enum EventStatus {
+    PENDING = "pending",
+    PROCESSING = "processing",
+    SUCCESS = "success",
+    FAILED = "failed",
+    RETRY = "retry",
+    DEAD_LETTER = "dead_letter"
+}
+export interface EventPayload<T = any> {
+    eventType: string;
+    eventId: string;
+    timestamp: Date;
+    tenantId?: number;
+    source: string;
+    data: T;
+    metadata?: Record<string, any>;
+    correlationId?: string;
+    causationId?: string;
+}
+export interface EventHandler {
+    eventType: string;
+    transport: EventTransportType;
+    endpoint?: string;
+    snsTopicArn?: string;
+    eventBridgeDetail?: {
+        eventBusName: string;
+        source: string;
+        detailType: string;
+    };
+    sqsQueueUrl?: string;
+    handler?: (payload: EventPayload) => Promise<any>;
+    retryConfig?: {
+        maxRetries: number;
+        retryDelay: number;
+        backoffMultiplier: number;
+    };
+    timeout?: number;
+    headers?: Record<string, string>;
+    authentication?: {
+        type: 'bearer' | 'api-key' | 'basic';
+        credentials: string;
+    };
+}
+export interface EventBusConfig {
+    defaultTransport: EventTransportType;
+    defaultTimeout: number;
+    defaultRetries: number;
+    enableDeadLetterQueue: boolean;
+    deadLetterQueueUrl?: string;
+    awsRegion?: string;
+}
+export interface EventResult {
+    success: boolean;
+    eventId: string;
+    statusCode?: number;
+    response?: any;
+    error?: string;
+    retryCount: number;
+    executionTime: number;
+    transport: EventTransportType;
+}

package/dist/src/events/bus/event-bus.types.js

@@ -0,0 +1,22 @@
+/**
+ * Event Bus Types
+ *
+ * Type definitions for the EventBus system.
+ */
+export var EventTransportType;
+(function (EventTransportType) {
+    EventTransportType["HTTP"] = "http";
+    EventTransportType["SNS"] = "sns";
+    EventTransportType["EVENTBRIDGE"] = "eventbridge";
+    EventTransportType["SQS"] = "sqs";
+    EventTransportType["INTERNAL"] = "internal";
+})(EventTransportType || (EventTransportType = {}));
+export var EventStatus;
+(function (EventStatus) {
+    EventStatus["PENDING"] = "pending";
+    EventStatus["PROCESSING"] = "processing";
+    EventStatus["SUCCESS"] = "success";
+    EventStatus["FAILED"] = "failed";
+    EventStatus["RETRY"] = "retry";
+    EventStatus["DEAD_LETTER"] = "dead_letter";
+})(EventStatus || (EventStatus = {}));

package/dist/src/events/index.d.ts

@@ -1,6 +1,5 @@
-export * from './notification-enums';
-export * from './notification-event';
-export * from './event-publisher';
-export * from './workflow-types';
-export * from './event-config.service';
-export * from './workflow-event.service';
+export * from './notifications/notification-enums';
+export * from './notifications/notification-event';
+export * from './notifications/event-publisher';
+export * from './bus/event-bus.types';
+export * from './bus/event-bus.service';

package/dist/src/events/index.js

@@ -1,8 +1,7 @@
-// Notification events (legacy)
-export * from './notification-enums';
-export * from './notification-event';
-export * from './event-publisher';
-// Event-driven workflow system
-export * from './workflow-types';
-export * from './event-config.service';
-export * from './workflow-event.service';
+// Notification types and publisher (SNS-based)
+export * from './notifications/notification-enums';
+export * from './notifications/notification-event';
+export * from './notifications/event-publisher';
+// Event bus (multi-transport delivery)
+export * from './bus/event-bus.types';
+export * from './bus/event-bus.service';

package/dist/src/events/notifications/event-publisher.d.ts

@@ -0,0 +1,41 @@
+import { NotificationMeta } from './notification-event';
+import { NotificationType, NotificationChannel } from './notification-enums';
+/**
+ * Configuration for the event publisher
+ */
+interface EventPublisherConfig {
+    region?: string;
+    endpoint?: string;
+    topicArn?: string;
+}
+/**
+ * Event Publisher for sending notification events to SNS
+ * Used by all services to publish events to the notifications topic
+ */
+export declare class EventPublisher {
+    private readonly snsClient;
+    private readonly topicArn;
+    private readonly serviceName;
+    constructor(serviceName: string, config?: EventPublisherConfig);
+    /**
+     * Publish a notification event to SNS
+     */
+    publish<T>(type: NotificationType, channel: NotificationChannel, payload: T, meta?: Partial<NotificationMeta>): Promise<string>;
+    /**
+     * Convenience method for publishing email notifications
+     */
+    publishEmail<T>(type: NotificationType, payload: T, meta?: Partial<NotificationMeta>): Promise<string>;
+    /**
+     * Convenience method for publishing SMS notifications
+     */
+    publishSMS<T>(type: NotificationType, payload: T, meta?: Partial<NotificationMeta>): Promise<string>;
+    /**
+     * Convenience method for publishing push notifications
+     */
+    publishPush<T>(type: NotificationType, payload: T, meta?: Partial<NotificationMeta>): Promise<string>;
+}
+/**
+ * Get or create an EventPublisher for a service
+ */
+export declare function getEventPublisher(serviceName: string, config?: EventPublisherConfig): EventPublisher;
+export {};