nest-scheduler-engine 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Your Organization
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,374 @@
+# @your-org/scheduler-engine
+
+A generic, event-type-driven scheduling engine for NestJS applications. This package provides a flexible and scalable solution for scheduling and executing recurring and one-time events with built-in retry logic, dead-letter handling, and RRULE support (RFC 5545).
+
+## Features
+
+- **Zero Infrastructure Ownership** - Package never creates DB connections, queues, or caches. All are injected via adapters.
+- **Adapter Pattern** - Works with any PostgreSQL client (pg, TypeORM, Knex, Prisma) and queue system (SQS, BullMQ, RabbitMQ).
+- **Ships Database Migrations** - Includes migration files that consumers run against their own database.
+- **Data-Driven Scheduling** - All scheduling decisions from DB, no hardcoded schedules.
+- **RRULE Support** - RFC 5545 compliant recurrence rules for complex recurring schedules.
+- **Built-in Retry & Dead-Letter** - Configurable retry policies with exponential backoff and dead-letter queue.
+- **Framework-Agnostic Core** - Core logic is framework-agnostic with a NestJS wrapper module.
+- **Horizontal Scalability** - Multiple instances can run concurrently with database-level locking.
+- **Observability Hooks** - Lifecycle hooks for monitoring, alerting, and audit logging.
+
+## Installation
+
+```bash
+npm install @your-org/scheduler-engine
+
+# Peer dependencies (consumer must install)
+npm install @nestjs/core @nestjs/common rxjs
+```
+
+## Quick Start
+
+### 1. Run Migrations
+
+First, export and run the migrations against your database:
+
+```typescript
+import { getMigrations } from '@your-org/scheduler-engine';
+
+const migrations = getMigrations({ tablePrefix: 'scheduler_' });
+
+// Use your migration tool (Knex, TypeORM, Flyway, etc.)
+// migrations is an array of { version, up, down }
+```
+
+Or use the CLI helper:
+
+```bash
+npx scheduler-engine migrations:export --output ./migrations/
+```
+
+### 2. Implement Adapters
+
+Create adapter implementations for your infrastructure:
+
+```typescript
+// adapters/pg-database.adapter.ts
+import { Injectable } from '@nestjs/common';
+import { Pool } from 'pg';
+import { IDatabaseAdapter, ITransactionClient } from '@your-org/scheduler-engine';
+
+@Injectable()
+export class PgDatabaseAdapter implements IDatabaseAdapter {
+  constructor(private readonly pool: Pool) {}
+
+  async query<T = any>(sql: string, params?: any[]): Promise<T[]> {
+    const result = await this.pool.query(sql, params);
+    return result.rows;
+  }
+
+  async transaction<T>(fn: (trx: ITransactionClient) => Promise<T>): Promise<T> {
+    const client = await this.pool.connect();
+    try {
+      await client.query('BEGIN');
+      const trx = {
+        query: async <T = any>(sql: string, params?: any[]) => {
+          const result = await client.query(sql, params);
+          return result.rows;
+        },
+      };
+      const result = await fn(trx);
+      await client.query('COMMIT');
+      return result;
+    } catch (error) {
+      await client.query('ROLLBACK');
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+
+  async ping(): Promise<boolean> {
+    try {
+      await this.pool.query('SELECT 1');
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}
+```
+
+```typescript
+// adapters/sqs-queue.adapter.ts
+import { Injectable } from '@nestjs/common';
+import { SQSClient, SendMessageCommand } from '@aws-sdk/client-sqs';
+import { IQueueAdapter, QueueMessage } from '@your-org/scheduler-engine';
+
+@Injectable()
+export class SqsQueueAdapter implements IQueueAdapter {
+  constructor(
+    private readonly sqs: SQSClient,
+    private readonly queueUrl: string,
+  ) {}
+
+  async publish(message: QueueMessage): Promise<void> {
+    await this.sqs.send(new SendMessageCommand({
+      QueueUrl: this.queueUrl,
+      MessageBody: JSON.stringify(message),
+    }));
+  }
+
+  async subscribe(handler: (msg: QueueMessage) => Promise<void>): Promise<void> {
+    // Implement SQS polling and handler invocation
+    // This is typically done in a separate worker process
+  }
+
+  async ack(messageId: string): Promise<void> {
+    // Delete message from SQS
+  }
+
+  async nack(messageId: string): Promise<void> {
+    // Change message visibility or move to DLQ
+  }
+}
+```
+
+### 3. Register the Module
+
+```typescript
+// app.module.ts
+import { Module } from '@nestjs/common';
+import { SchedulerModule } from '@your-org/scheduler-engine';
+import { PgDatabaseAdapter } from './adapters/pg-database.adapter';
+import { SqsQueueAdapter } from './adapters/sqs-queue.adapter';
+import { Pool } from 'pg';
+
+@Module({
+  imports: [
+    SchedulerModule.forRoot({
+      // Required adapters
+      database: {
+        useFactory: (pool: Pool) => new PgDatabaseAdapter(pool),
+        inject: [Pool],
+      },
+      queue: {
+        useFactory: (sqs: SQSClient) => new SqsQueueAdapter(sqs, process.env.QUEUE_URL),
+        inject: [SQSClient],
+      },
+
+      // Optional configuration
+      config: {
+        pollingIntervalMs: 5000,
+        lockDurationMs: 30000,
+        batchSize: 50,
+        concurrency: 10,
+        deadLetterEnabled: true,
+        tablePrefix: 'scheduler_',
+      },
+
+      // Optional hooks
+      hooks: {
+        onEventScheduled: async (event) => {
+          console.log('Event scheduled:', event.id);
+        },
+        onEventFailed: async (event, error, retryCount) => {
+          console.error('Event failed:', event.id, error);
+        },
+        onEventDeadLettered: async (event) => {
+          // Send alert to oncall
+        },
+      },
+    }),
+  ],
+  providers: [
+    // Your event handlers
+    ReminderHandler,
+    DataSyncHandler,
+    ReportHandler,
+  ],
+})
+export class AppModule {}
+```
+
+### 4. Create Event Handlers
+
+```typescript
+// handlers/reminder.handler.ts
+import { Injectable } from '@nestjs/common';
+import { EventHandler, IEventHandler, ExecutionContext, HandlerResult } from '@your-org/scheduler-engine';
+
+@Injectable()
+@EventHandler('REMINDER_NOTIFICATION')
+export class ReminderHandler implements IEventHandler {
+  readonly eventType = 'REMINDER_NOTIFICATION';
+
+  constructor(
+    private readonly notificationService: NotificationService,
+  ) {}
+
+  async handle(payload: Record<string, any>, ctx: ExecutionContext): Promise<HandlerResult> {
+    try {
+      await this.notificationService.send(payload.userId, payload.message);
+      return { success: true };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  }
+}
+```
+
+### 5. Schedule Events
+
+```typescript
+// some.service.ts
+import { Injectable } from '@nestjs/common';
+import { SchedulerService, ScheduleType } from '@your-org/scheduler-engine';
+
+@Injectable()
+export class NotificationService {
+  constructor(private readonly scheduler: SchedulerService) {}
+
+  async scheduleReminder(userId: string, message: string, sendAt: Date) {
+    // First, create the event type (usually done once on app startup)
+    await this.scheduler.createEventType({
+      name: 'REMINDER_NOTIFICATION',
+      description: 'Send reminder notifications to users',
+      retryPolicy: {
+        maxRetries: 3,
+        delayMs: 5000,
+        backoff: 'exponential',
+      },
+    });
+
+    // Schedule a one-time event
+    const event = await this.scheduler.scheduleEvent({
+      eventTypeName: 'REMINDER_NOTIFICATION',
+      payload: { userId, message },
+      scheduleType: ScheduleType.ONE_TIME,
+      scheduledAt: sendAt,
+    });
+
+    return event;
+  }
+
+  async scheduleRecurringReport() {
+    // Schedule a recurring event using RRULE
+    const event = await this.scheduler.scheduleEvent({
+      eventTypeName: 'WEEKLY_REPORT',
+      payload: { reportType: 'sales' },
+      scheduleType: ScheduleType.RECURRING,
+      rrule: 'FREQ=WEEKLY;BYDAY=MO;BYHOUR=9;BYMINUTE=0', // Every Monday at 9:00 AM
+    });
+
+    return event;
+  }
+}
+```
+
+## API Reference
+
+### SchedulerService
+
+Main service for interacting with the scheduler.
+
+#### Event Type Management
+
+- `createEventType(input: CreateEventTypeInput): Promise<EventType>`
+- `getEventType(id: string): Promise<EventType | null>`
+- `getEventTypeByName(name: string): Promise<EventType | null>`
+- `listEventTypes(): Promise<EventType[]>`
+- `deleteEventType(id: string): Promise<void>`
+
+#### Event Instance Management
+
+- `scheduleEvent(input: ScheduleEventInput): Promise<EventInstance>`
+- `getEvent(id: string): Promise<EventInstance | null>`
+- `listEvents(filters?: EventFilters): Promise<PaginatedResult<EventInstance>>`
+- `pauseEvent(id: string): Promise<EventInstance>`
+- `resumeEvent(id: string): Promise<EventInstance>`
+- `cancelEvent(id: string): Promise<void>`
+
+#### Execution History
+
+- `getExecutions(eventId: string): Promise<EventExecution[]>`
+
+#### Dead Letters
+
+- `listDeadLetters(): Promise<DeadLetter[]>`
+- `retryDeadLetter(id: string): Promise<EventInstance>`
+
+## Deployment Modes
+
+The package supports three deployment modes:
+
+### Combined Mode (Default)
+
+Polls + dispatches + consumes in one process.
+
+```typescript
+config: {
+  workerMode: true, // default
+}
+```
+
+### Poller Only
+
+Only polls and dispatches to queue. Separate workers consume.
+
+```typescript
+config: {
+  pollerOnly: true,
+}
+```
+
+### Worker Only
+
+Only consumes from queue. Separate poller dispatches.
+
+```typescript
+config: {
+  workerMode: true,
+  pollerOnly: false,
+}
+```
+
+## RRULE Examples
+
+```typescript
+// Every day at 10:00 AM
+rrule: 'FREQ=DAILY;BYHOUR=10;BYMINUTE=0'
+
+// Every Monday and Friday at 9:00 AM
+rrule: 'FREQ=WEEKLY;BYDAY=MO,FR;BYHOUR=9;BYMINUTE=0'
+
+// Last day of every month at 11:59 PM
+rrule: 'FREQ=MONTHLY;BYMONTHDAY=-1;BYHOUR=23;BYMINUTE=59'
+
+// Every 2 hours
+rrule: 'FREQ=HOURLY;INTERVAL=2'
+```
+
+See [RFC 5545](https://tools.ietf.org/html/rfc5545) for full RRULE specification.
+
+## Database Schema
+
+The package creates the following tables:
+
+- `event_types` - Event type definitions with retry policies
+- `event_instances` - Scheduled event instances
+- `event_executions` - Execution history for audit and debugging
+- `dead_letters` - Failed events that exhausted retries
+
+All tables support an optional prefix via `tablePrefix` config option.
+
+## License
+
+MIT
+
+## Contributing
+
+Contributions are welcome! Please see CONTRIBUTING.md for details.
+
+## Support
+
+For issues and feature requests, please use the GitHub issue tracker.

package/dist/decorators/event-handler.decorator.d.ts

@@ -0,0 +1,2 @@
+export declare const EVENT_HANDLER_METADATA = "scheduler:event_handler";
+export declare function EventHandler(eventType: string): ClassDecorator;

package/dist/decorators/event-handler.decorator.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EVENT_HANDLER_METADATA = void 0;
+exports.EventHandler = EventHandler;
+const common_1 = require("@nestjs/common");
+exports.EVENT_HANDLER_METADATA = "scheduler:event_handler";
+function EventHandler(eventType) {
+    return (target) => {
+        (0, common_1.SetMetadata)(exports.EVENT_HANDLER_METADATA, eventType)(target);
+    };
+}
+//# sourceMappingURL=event-handler.decorator.js.map

package/dist/decorators/event-handler.decorator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-handler.decorator.js","sourceRoot":"","sources":["../../src/decorators/event-handler.decorator.ts"],"names":[],"mappings":";;;AAWA,oCAIC;AAfD,2CAA6C;AAKhC,QAAA,sBAAsB,GAAG,yBAAyB,CAAC;AAMhE,SAAgB,YAAY,CAAC,SAAiB;IAC5C,OAAO,CAAC,MAAW,EAAE,EAAE;QACrB,IAAA,oBAAW,EAAC,8BAAsB,EAAE,SAAS,CAAC,CAAC,MAAM,CAAC,CAAC;IACzD,CAAC,CAAC;AACJ,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+export { SchedulerModule } from './scheduler.module';
+export { SchedulerService } from './services/scheduler.service';
+export { EventHandler } from './decorators/event-handler.decorator';
+export type { IDatabaseAdapter, ITransactionClient, } from './interfaces/database-adapter.interface';
+export type { IQueueAdapter, QueueMessage, } from './interfaces/queue-adapter.interface';
+export type { ILoggerAdapter } from './interfaces/logger-adapter.interface';
+export type { ICacheAdapter } from './interfaces/cache-adapter.interface';
+export type { IEventHandler, HandlerResult, ExecutionContext, } from './interfaces/event-handler.interface';
+export type { SchedulerConfig, SchedulerHooks, SchedulerModuleOptions, SchedulerModuleAsyncOptions, AdapterProvider, } from './interfaces/config.interface';
+export { EventStatus, ScheduleType, RetryBackoff, ExecutionStatus, } from './types/enums';
+export type { RetryPolicy, CreateEventTypeInput, ScheduleEventInput, EventFilters, PaginatedResult, } from './types/inputs';
+export { EventType } from './models/event-type.model';
+export { EventInstance } from './models/event-instance.model';
+export { EventExecution } from './models/event-execution.model';
+export { DeadLetter } from './models/dead-letter.model';
+export { getMigrations, Migration, MigrationOptions } from './migrations';

package/dist/index.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMigrations = exports.DeadLetter = exports.EventExecution = exports.EventInstance = exports.EventType = exports.ExecutionStatus = exports.RetryBackoff = exports.ScheduleType = exports.EventStatus = exports.EventHandler = exports.SchedulerService = exports.SchedulerModule = void 0;
+var scheduler_module_1 = require("./scheduler.module");
+Object.defineProperty(exports, "SchedulerModule", { enumerable: true, get: function () { return scheduler_module_1.SchedulerModule; } });
+var scheduler_service_1 = require("./services/scheduler.service");
+Object.defineProperty(exports, "SchedulerService", { enumerable: true, get: function () { return scheduler_service_1.SchedulerService; } });
+var event_handler_decorator_1 = require("./decorators/event-handler.decorator");
+Object.defineProperty(exports, "EventHandler", { enumerable: true, get: function () { return event_handler_decorator_1.EventHandler; } });
+var enums_1 = require("./types/enums");
+Object.defineProperty(exports, "EventStatus", { enumerable: true, get: function () { return enums_1.EventStatus; } });
+Object.defineProperty(exports, "ScheduleType", { enumerable: true, get: function () { return enums_1.ScheduleType; } });
+Object.defineProperty(exports, "RetryBackoff", { enumerable: true, get: function () { return enums_1.RetryBackoff; } });
+Object.defineProperty(exports, "ExecutionStatus", { enumerable: true, get: function () { return enums_1.ExecutionStatus; } });
+var event_type_model_1 = require("./models/event-type.model");
+Object.defineProperty(exports, "EventType", { enumerable: true, get: function () { return event_type_model_1.EventType; } });
+var event_instance_model_1 = require("./models/event-instance.model");
+Object.defineProperty(exports, "EventInstance", { enumerable: true, get: function () { return event_instance_model_1.EventInstance; } });
+var event_execution_model_1 = require("./models/event-execution.model");
+Object.defineProperty(exports, "EventExecution", { enumerable: true, get: function () { return event_execution_model_1.EventExecution; } });
+var dead_letter_model_1 = require("./models/dead-letter.model");
+Object.defineProperty(exports, "DeadLetter", { enumerable: true, get: function () { return dead_letter_model_1.DeadLetter; } });
+var migrations_1 = require("./migrations");
+Object.defineProperty(exports, "getMigrations", { enumerable: true, get: function () { return migrations_1.getMigrations; } });
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AACA,uDAAqD;AAA5C,mHAAA,eAAe,OAAA;AAGxB,kEAAgE;AAAvD,qHAAA,gBAAgB,OAAA;AAGzB,gFAAoE;AAA3D,uHAAA,YAAY,OAAA;AAgCrB,uCAKuB;AAJrB,oGAAA,WAAW,OAAA;AACX,qGAAA,YAAY,OAAA;AACZ,qGAAA,YAAY,OAAA;AACZ,wGAAA,eAAe,OAAA;AAYjB,8DAAsD;AAA7C,6GAAA,SAAS,OAAA;AAClB,sEAA8D;AAArD,qHAAA,aAAa,OAAA;AACtB,wEAAgE;AAAvD,uHAAA,cAAc,OAAA;AACvB,gEAAwD;AAA/C,+GAAA,UAAU,OAAA;AAGnB,2CAA0E;AAAjE,2GAAA,aAAa,OAAA"}

package/dist/interfaces/cache-adapter.interface.d.ts

@@ -0,0 +1,7 @@
+export interface ICacheAdapter {
+    get(key: string): Promise<any | null>;
+    set(key: string, value: any, ttlMs?: number): Promise<void>;
+    del(key: string): Promise<void>;
+    acquireLock(key: string, ttlMs: number): Promise<boolean>;
+    releaseLock(key: string): Promise<void>;
+}

package/dist/interfaces/cache-adapter.interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=cache-adapter.interface.js.map

package/dist/interfaces/cache-adapter.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache-adapter.interface.js","sourceRoot":"","sources":["../../src/interfaces/cache-adapter.interface.ts"],"names":[],"mappings":""}

package/dist/interfaces/config.interface.d.ts

@@ -0,0 +1,43 @@
+import { ModuleMetadata, Type } from "@nestjs/common";
+import { IDatabaseAdapter } from "./database-adapter.interface";
+import { IQueueAdapter } from "./queue-adapter.interface";
+import { ILoggerAdapter } from "./logger-adapter.interface";
+import { ICacheAdapter } from "./cache-adapter.interface";
+import { HandlerResult, ExecutionContext } from "./event-handler.interface";
+export interface SchedulerConfig {
+    pollingIntervalMs?: number;
+    lockDurationMs?: number;
+    batchSize?: number;
+    concurrency?: number;
+    deadLetterEnabled?: boolean;
+    tablePrefix?: string;
+    workerMode?: boolean;
+    pollerOnly?: boolean;
+}
+export interface SchedulerHooks {
+    onEventScheduled?: (event: any) => Promise<void>;
+    onEventExecuting?: (event: any, ctx: ExecutionContext) => Promise<void>;
+    onEventCompleted?: (event: any, result: HandlerResult) => Promise<void>;
+    onEventFailed?: (event: any, error: any, retryCount: number) => Promise<void>;
+    onEventDeadLettered?: (event: any) => Promise<void>;
+    onEventPaused?: (event: any) => Promise<void>;
+    onEventResumed?: (event: any) => Promise<void>;
+}
+export interface AdapterProvider<T = any> {
+    useClass?: Type<T>;
+    useFactory?: (...args: any[]) => T | Promise<T>;
+    useExisting?: Type<T>;
+    inject?: any[];
+}
+export interface SchedulerModuleOptions {
+    database: AdapterProvider<IDatabaseAdapter>;
+    queue: AdapterProvider<IQueueAdapter>;
+    logger?: AdapterProvider<ILoggerAdapter>;
+    cache?: AdapterProvider<ICacheAdapter>;
+    config?: SchedulerConfig;
+    hooks?: SchedulerHooks;
+}
+export interface SchedulerModuleAsyncOptions extends Pick<ModuleMetadata, "imports"> {
+    useFactory?: (...args: any[]) => Promise<SchedulerModuleOptions> | SchedulerModuleOptions;
+    inject?: any[];
+}

package/dist/interfaces/config.interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=config.interface.js.map

package/dist/interfaces/config.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.interface.js","sourceRoot":"","sources":["../../src/interfaces/config.interface.ts"],"names":[],"mappings":""}

package/dist/interfaces/database-adapter.interface.d.ts

@@ -0,0 +1,8 @@
+export interface ITransactionClient {
+    query<T = any>(sql: string, params?: any[]): Promise<T[]>;
+}
+export interface IDatabaseAdapter {
+    query<T = any>(sql: string, params?: any[]): Promise<T[]>;
+    transaction<T>(fn: (trx: ITransactionClient) => Promise<T>): Promise<T>;
+    ping(): Promise<boolean>;
+}

package/dist/interfaces/database-adapter.interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=database-adapter.interface.js.map

package/dist/interfaces/database-adapter.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"database-adapter.interface.js","sourceRoot":"","sources":["../../src/interfaces/database-adapter.interface.ts"],"names":[],"mappings":""}

package/dist/interfaces/event-handler.interface.d.ts

@@ -0,0 +1,15 @@
+export interface ExecutionContext {
+    executionId: string;
+    eventInstanceId: string;
+    attempt: number;
+    scheduledAt: Date;
+}
+export interface HandlerResult {
+    success: boolean;
+    data?: any;
+    error?: string;
+}
+export interface IEventHandler {
+    readonly eventType: string;
+    handle(payload: Record<string, any>, ctx: ExecutionContext): Promise<HandlerResult>;
+}

package/dist/interfaces/event-handler.interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=event-handler.interface.js.map

package/dist/interfaces/event-handler.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-handler.interface.js","sourceRoot":"","sources":["../../src/interfaces/event-handler.interface.ts"],"names":[],"mappings":""}

package/dist/interfaces/index.d.ts

@@ -0,0 +1,6 @@
+export * from './database-adapter.interface';
+export * from './queue-adapter.interface';
+export * from './logger-adapter.interface';
+export * from './cache-adapter.interface';
+export * from './event-handler.interface';
+export * from './config.interface';

package/dist/interfaces/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./database-adapter.interface"), exports);
+__exportStar(require("./queue-adapter.interface"), exports);
+__exportStar(require("./logger-adapter.interface"), exports);
+__exportStar(require("./cache-adapter.interface"), exports);
+__exportStar(require("./event-handler.interface"), exports);
+__exportStar(require("./config.interface"), exports);
+//# sourceMappingURL=index.js.map

package/dist/interfaces/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/interfaces/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,+DAA6C;AAC7C,4DAA0C;AAC1C,6DAA2C;AAC3C,4DAA0C;AAC1C,4DAA0C;AAC1C,qDAAmC"}

package/dist/interfaces/logger-adapter.interface.d.ts

@@ -0,0 +1,6 @@
+export interface ILoggerAdapter {
+    info(message: string, meta?: Record<string, any>): void;
+    warn(message: string, meta?: Record<string, any>): void;
+    error(message: string, meta?: Record<string, any>): void;
+    debug(message: string, meta?: Record<string, any>): void;
+}

package/dist/interfaces/logger-adapter.interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=logger-adapter.interface.js.map

package/dist/interfaces/logger-adapter.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger-adapter.interface.js","sourceRoot":"","sources":["../../src/interfaces/logger-adapter.interface.ts"],"names":[],"mappings":""}

package/dist/interfaces/queue-adapter.interface.d.ts

@@ -0,0 +1,14 @@
+export interface QueueMessage {
+    id: string;
+    eventInstanceId: string;
+    eventType: string;
+    payload: Record<string, any>;
+    attempt: number;
+    scheduledAt: Date;
+}
+export interface IQueueAdapter {
+    publish(message: QueueMessage): Promise<void>;
+    subscribe(handler: (msg: QueueMessage) => Promise<void>): Promise<void>;
+    ack(messageId: string): Promise<void>;
+    nack(messageId: string): Promise<void>;
+}

package/dist/interfaces/queue-adapter.interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=queue-adapter.interface.js.map

package/dist/interfaces/queue-adapter.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue-adapter.interface.js","sourceRoot":"","sources":["../../src/interfaces/queue-adapter.interface.ts"],"names":[],"mappings":""}

package/dist/migrations/index.d.ts

@@ -0,0 +1,9 @@
+export interface Migration {
+    version: string;
+    up: string;
+    down: string;
+}
+export interface MigrationOptions {
+    tablePrefix?: string;
+}
+export declare function getMigrations(options?: MigrationOptions): Migration[];