boki/stock-bot
1
0
Fork 0
Code Issues 1 Pull requests Projects Releases Packages Wiki Activity Actions

removed old working on ceo handler

Browse source
This commit is contained in:
Boki 2025-06-22 13:26:29 -04:00
parent acf66dbfb6
commit 5009ccbeda
8 changed files with 243 additions and 213 deletions
Download patch file Download diff file Expand all files Collapse all files

1
libs/core/di/src/index.ts
View file

@ -1,5 +1,4 @@
// Export all dependency injection components
export * from './service-container';
export * from './operation-context';
export * from './pool-size-calculator';
export * from './types';

5
libs/core/di/src/operation-context.ts
View file

@ -3,7 +3,10 @@
*/
import { getLogger, type Logger } from '@stock-bot/logger';
import type { ServiceResolver } from './service-container';
interface ServiceResolver {
resolve<T>(serviceName: string): T;
resolveAsync<T>(serviceName: string): Promise<T>;
}
export interface OperationContextOptions {
handlerName: string;

201
libs/core/di/src/service-container.ts
View file

@ -1,201 +0,0 @@
import { getLogger, type Logger } from '@stock-bot/logger';
import type { ConnectionFactory } from './connection-factory';
export interface ServiceRegistration<T = any> {
name: string;
factory: () => T | Promise<T>;
singleton?: boolean;
dispose?: (instance: T) => Promise<void>;
}
export interface ServiceResolver {
resolve<T>(name: string, options?: any): T;
resolveAsync<T>(name: string, options?: any): Promise<T>;
}
export class ServiceContainer implements ServiceResolver {
private readonly logger: Logger;
private readonly registrations = new Map<string, ServiceRegistration>();
private readonly instances = new Map<string, any>();
private readonly scopedInstances = new Map<string, any>();
private readonly parent?: ServiceContainer;
constructor(name: string, parent?: ServiceContainer) {
this.logger = getLogger(`service-container:${name}`);
this.parent = parent;
}
register<T>(registration: ServiceRegistration<T>): void {
this.registrations.set(registration.name, registration);
this.logger.debug('Service registered', { name: registration.name, singleton: registration.singleton });
}
resolve<T>(name: string, _options?: any): T {
// Check scoped instances first
if (this.scopedInstances.has(name)) {
return this.scopedInstances.get(name);
}
// Check singleton instances
if (this.instances.has(name)) {
return this.instances.get(name);
}
// Get registration from this container or parent
const registration = this.getRegistration(name);
if (!registration) {
throw new Error(`Service ${name} not registered`);
}
// Create instance synchronously
const instance = registration.factory();
// Check if factory returned a promise
if (instance instanceof Promise) {
throw new Error(`Service ${name} is async. Use resolveAsync() instead.`);
}
// Store based on singleton flag
if (registration.singleton) {
this.instances.set(name, instance);
} else {
this.scopedInstances.set(name, instance);
}
return instance as T;
}
async resolveAsync<T>(name: string, _options?: any): Promise<T> {
// Check scoped instances first
if (this.scopedInstances.has(name)) {
return this.scopedInstances.get(name);
}
// Check singleton instances
if (this.instances.has(name)) {
return this.instances.get(name);
}
// Get registration from this container or parent
const registration = this.getRegistration(name);
if (!registration) {
throw new Error(`Service ${name} not registered`);
}
// Create instance
const instance = await Promise.resolve(registration.factory());
// Store based on singleton flag
if (registration.singleton) {
this.instances.set(name, instance);
} else {
this.scopedInstances.set(name, instance);
}
return instance as T;
}
createScope(): ServiceContainer {
return new ServiceContainer('scoped', this);
}
async dispose(): Promise<void> {
// Dispose scoped instances
for (const [name, instance] of this.scopedInstances.entries()) {
const registration = this.getRegistration(name);
if (registration?.dispose) {
await registration.dispose(instance);
}
}
this.scopedInstances.clear();
// Only dispose singletons if this is the root container
if (!this.parent) {
for (const [name, instance] of this.instances.entries()) {
const registration = this.registrations.get(name);
if (registration?.dispose) {
await registration.dispose(instance);
}
}
this.instances.clear();
}
}
private getRegistration(name: string): ServiceRegistration | undefined {
return this.registrations.get(name) || this.parent?.getRegistration(name);
}
}
// Enhanced service container factory with infrastructure services
export function createServiceContainer(
serviceName: string,
connectionFactory: ConnectionFactory,
config?: any
): ServiceContainer {
const container = new ServiceContainer(serviceName);
// Register configuration if provided
if (config) {
container.register({
name: 'config',
factory: () => config,
singleton: true,
});
}
// Register connection factories
container.register({
name: 'mongodb',
factory: async () => {
const pool = await connectionFactory.createMongoDB({
name: 'default',
config: {} as any, // Config injected by factory
});
return pool.client;
},
singleton: true,
});
container.register({
name: 'postgres',
factory: async () => {
const pool = await connectionFactory.createPostgreSQL({
name: 'default',
config: {} as any, // Config injected by factory
});
return pool.client;
},
singleton: true,
});
container.register({
name: 'cache',
factory: async () => {
const pool = await connectionFactory.createCache({
name: 'default',
config: {} as any, // Config injected by factory
});
return pool.client;
},
singleton: true,
});
container.register({
name: 'queue',
factory: async () => {
const pool = await connectionFactory.createQueue({
name: 'default',
config: {} as any, // Config injected by factory
});
return pool.client;
},
singleton: true,
});
// Note: Additional services can be registered by individual applications as needed:
// - ProxyManager: container.register({ name: 'proxyManager', factory: () => ProxyManager.getInstance() })
// - Browser: container.register({ name: 'browser', factory: () => Browser })
// - HttpClient: container.register({ name: 'httpClient', factory: () => createHttpClient(...) })
return container;
}

12
libs/core/handlers/src/base/BaseHandler.ts
View file

@ -90,12 +90,6 @@ export abstract class BaseHandler implements IHandler {
await queue.add(operation, jobData, { delay });
}
/**
* Helper method to schedule an operation with delay in seconds
*/
async scheduleIn(operation: string, payload: unknown, delaySeconds: number): Promise<void> {
return this.scheduleOperation(operation, payload, delaySeconds * 1000);
}
/**
* Create execution context for operations
@ -118,11 +112,11 @@ export abstract class BaseHandler implements IHandler {
/**
* Get a MongoDB collection with type safety
*/
protected collection<T = any>(name: string): Collection<T> {
protected collection<T extends {} = any>(name: string): Collection<T> {
if (!this.mongodb) {
throw new Error('MongoDB service is not available');
}
return this.mongodb.collection<T>(name);
return this.mongodb.collection(name);
}
/**
@ -142,7 +136,7 @@ export abstract class BaseHandler implements IHandler {
if (!this.cache) {
return null;
}
return this.cache.get<T>(`${this.handlerName}:${key}`);
return this.cache.get(`${this.handlerName}:${key}`);
}
/**

3
libs/core/handlers/tsconfig.json
View file

@ -9,6 +9,7 @@
"references": [
{ "path": "../config" },
{ "path": "../logger" },
{ "path": "../di" }
{ "path": "../di" },
{ "path": "../../utils" }
]
}