135 lines
3.2 KiB
TypeScript
135 lines
3.2 KiB
TypeScript
import { getLogger } from '@stock-bot/logger';
|
|
|
|
export interface JobHandler {
|
|
(payload: any): Promise<any>;
|
|
}
|
|
|
|
export interface JobData {
|
|
type?: string;
|
|
provider: string;
|
|
operation: string;
|
|
payload: any;
|
|
priority?: number;
|
|
immediately?: boolean;
|
|
}
|
|
|
|
export interface ScheduledJob {
|
|
type: string;
|
|
operation: string;
|
|
payload: any;
|
|
cronPattern: string;
|
|
priority?: number;
|
|
description?: string;
|
|
immediately?: boolean;
|
|
}
|
|
|
|
export interface ProviderConfig {
|
|
name: string;
|
|
operations: Record<string, JobHandler>;
|
|
scheduledJobs?: ScheduledJob[];
|
|
}
|
|
|
|
export interface ProviderRegistry {
|
|
registerProvider: (config: ProviderConfig) => void;
|
|
getHandler: (provider: string, operation: string) => JobHandler | null;
|
|
getAllScheduledJobs: () => Array<{ provider: string; job: ScheduledJob }>;
|
|
getProviders: () => Array<{ key: string; config: ProviderConfig }>;
|
|
hasProvider: (provider: string) => boolean;
|
|
clear: () => void;
|
|
}
|
|
|
|
/**
|
|
* Create a new provider registry instance
|
|
*/
|
|
export function createProviderRegistry(): ProviderRegistry {
|
|
const logger = getLogger('provider-registry');
|
|
const providers = new Map<string, ProviderConfig>();
|
|
|
|
/**
|
|
* Register a provider with its operations
|
|
*/
|
|
function registerProvider(config: ProviderConfig): void {
|
|
providers.set(config.name, config);
|
|
logger.info(`Registered provider: ${config.name}`, {
|
|
operations: Object.keys(config.operations),
|
|
scheduledJobs: config.scheduledJobs?.length || 0,
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Get a job handler for a specific provider and operation
|
|
*/
|
|
function getHandler(provider: string, operation: string): JobHandler | null {
|
|
const providerConfig = providers.get(provider);
|
|
|
|
if (!providerConfig) {
|
|
logger.warn(`Provider not found: ${provider}`);
|
|
return null;
|
|
}
|
|
|
|
const handler = providerConfig.operations[operation];
|
|
if (!handler) {
|
|
logger.warn(`Operation not found: ${operation} in provider ${provider}`);
|
|
return null;
|
|
}
|
|
|
|
return handler;
|
|
}
|
|
|
|
/**
|
|
* Get all scheduled jobs from all providers
|
|
*/
|
|
function getAllScheduledJobs(): Array<{ provider: string; job: ScheduledJob }> {
|
|
const allJobs: Array<{ provider: string; job: ScheduledJob }> = [];
|
|
|
|
for (const [, config] of providers) {
|
|
if (config.scheduledJobs) {
|
|
for (const job of config.scheduledJobs) {
|
|
allJobs.push({
|
|
provider: config.name,
|
|
job,
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
return allJobs;
|
|
}
|
|
|
|
/**
|
|
* Get all registered providers with their configurations
|
|
*/
|
|
function getProviders(): Array<{ key: string; config: ProviderConfig }> {
|
|
return Array.from(providers.entries()).map(([key, config]) => ({
|
|
key,
|
|
config,
|
|
}));
|
|
}
|
|
|
|
/**
|
|
* Check if a provider exists
|
|
*/
|
|
function hasProvider(provider: string): boolean {
|
|
return providers.has(provider);
|
|
}
|
|
|
|
/**
|
|
* Clear all providers (useful for testing)
|
|
*/
|
|
function clear(): void {
|
|
providers.clear();
|
|
logger.info('All providers cleared');
|
|
}
|
|
|
|
return {
|
|
registerProvider,
|
|
getHandler,
|
|
getAllScheduledJobs,
|
|
getProviders,
|
|
hasProvider,
|
|
clear,
|
|
};
|
|
}
|
|
|
|
// Create the default shared registry instance
|
|
export const providerRegistry = createProviderRegistry();
|