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

removed deprecated code

Browse source
This commit is contained in:
Boki 2025-06-23 21:39:04 -04:00
parent 34c6c36695
commit ca5f09c459
10 changed files with 18 additions and 377 deletions
Download patch file Download diff file Expand all files Collapse all files

8
libs/core/config/src/cli.ts
View file

@ -11,7 +11,7 @@ import {
validateConfig,
} from './utils/validation';
import { ConfigManager } from './config-manager';
import { appConfigSchema } from './schemas';
import { baseAppSchema } from './schemas';
import type { Environment } from './types';
interface CliOptions {
@ -103,10 +103,10 @@ async function main() {
environment,
});
const config = await manager.initialize(appConfigSchema);
const config = await manager.initialize(baseAppSchema);
if (values.validate) {
const result = validateConfig(config, appConfigSchema);
const result = validateConfig(config, baseAppSchema);
if (values.json) {
console.log(JSON.stringify(result, null, 2));
@ -133,7 +133,7 @@ async function main() {
// Schema validation
console.log('1. Schema Validation:');
const schemaResult = validateConfig(config, appConfigSchema);
const schemaResult = validateConfig(config, baseAppSchema);
console.log(formatValidationResult(schemaResult));
console.log();

49
libs/core/config/src/index.ts
View file

@ -2,12 +2,12 @@
import { EnvLoader } from './loaders/env.loader';
import { FileLoader } from './loaders/file.loader';
import { ConfigManager } from './config-manager';
import type { AppConfig } from './schemas';
import { appConfigSchema } from './schemas';
import type { BaseAppConfig } from './schemas';
import { baseAppSchema } from './schemas';
import { z } from 'zod';
// Legacy singleton instance for backward compatibility
let configInstance: ConfigManager<AppConfig> | null = null;
let configInstance: ConfigManager<BaseAppConfig> | null = null;
// Synchronously load critical env vars for early initialization
function loadCriticalEnvVarsSync(): void {
@ -56,25 +56,6 @@ function loadCriticalEnvVarsSync(): void {
// Load critical env vars immediately
loadCriticalEnvVarsSync();
/**
* Initialize the global configuration synchronously.
* @deprecated Use initializeAppConfig with your own schema instead
*
* This loads configuration from all sources in the correct hierarchy:
* 1. Schema defaults (lowest priority)
* 2. default.json
* 3. [environment].json (e.g., development.json)
* 4. .env file values
* 5. process.env values (highest priority)
*/
export function initializeConfig(configPath?: string): AppConfig {
if (!configInstance) {
configInstance = new ConfigManager<AppConfig>({
configPath,
});
}
return configInstance.initialize(appConfigSchema);
}
/**
* Initialize configuration for a service in a monorepo.
@ -83,10 +64,10 @@ export function initializeConfig(configPath?: string): AppConfig {
* 2. Service-specific config directory (./config)
* 3. Environment variables
*/
export function initializeServiceConfig(): AppConfig {
export function initializeServiceConfig(): BaseAppConfig {
if (!configInstance) {
const environment = process.env.NODE_ENV || 'development';
configInstance = new ConfigManager<AppConfig>({
configInstance = new ConfigManager<BaseAppConfig>({
loaders: [
new FileLoader('../../config', environment), // Root config
new FileLoader('./config', environment), // Service config
@ -94,13 +75,13 @@ export function initializeServiceConfig(): AppConfig {
],
});
}
return configInstance.initialize(appConfigSchema);
return configInstance.initialize(baseAppSchema);
}
/**
* Get the current configuration
*/
export function getConfig(): AppConfig {
export function getConfig(): BaseAppConfig {
if (!configInstance) {
throw new Error('Configuration not initialized. Call initializeConfig() first.');
}
@ -110,7 +91,7 @@ export function getConfig(): AppConfig {
/**
* Get configuration manager instance
*/
export function getConfigManager(): ConfigManager<AppConfig> {
export function getConfigManager(): ConfigManager<BaseAppConfig> {
if (!configInstance) {
throw new Error('Configuration not initialized. Call initializeConfig() first.');
}
@ -140,21 +121,7 @@ export function getLogConfig() {
return getConfig().log;
}
// Deprecated alias for backward compatibility
export function getLoggingConfig() {
return getConfig().log;
}
// Deprecated - provider configs should be app-specific
// @deprecated Move provider configs to your app-specific config
export function getProviderConfig(_provider: string) {
const config = getConfig() as any;
const providers = config.providers;
if (!providers || !(_provider in providers)) {
throw new Error(`Provider configuration not found: ${_provider}`);
}
return (providers as Record<string, unknown>)[_provider];
}
export function getQueueConfig() {
return getConfig().queue;

11
libs/core/config/src/schemas/index.ts
View file

@ -16,14 +16,3 @@ export type { BaseAppConfig } from './base-app.schema';
export { unifiedAppSchema, toUnifiedConfig, getStandardServiceName } from './unified-app.schema';
export type { UnifiedAppConfig } from './unified-app.schema';
// Keep AppConfig for backward compatibility (deprecated)
// @deprecated Use baseAppSchema and extend it for your specific app
import { z } from 'zod';
import { baseAppSchema } from './base-app.schema';
import { providerConfigSchema } from './provider.schema';
export const appConfigSchema = baseAppSchema.extend({
providers: providerConfigSchema.optional(),
});
export type AppConfig = z.infer<typeof appConfigSchema>;

32
libs/core/di/src/awilix-container.ts
View file

@ -5,7 +5,7 @@
import type { Browser } from '@stock-bot/browser';
import type { CacheProvider } from '@stock-bot/cache';
import type { AppConfig as StockBotAppConfig } from '@stock-bot/config';
import type { BaseAppConfig as StockBotAppConfig } from '@stock-bot/config';
import type { IServiceContainer } from '@stock-bot/types';
import type { Logger } from '@stock-bot/logger';
import type { MongoDBClient } from '@stock-bot/mongodb';
@ -42,24 +42,6 @@ export interface ServiceDefinitions {
serviceContainer: IServiceContainer;
}
/**
* Create and configure the DI container with type safety
*/
export function createServiceContainer(rawConfig: unknown): AwilixContainer<ServiceDefinitions> {
// Deprecated - use the new modular structure
const { createServiceContainer: newCreateServiceContainer } = require('./container/factory');
return newCreateServiceContainer(rawConfig);
}
/**
* Initialize async services after container creation
*/
export async function initializeServices(container: AwilixContainer): Promise<void> {
// Deprecated - use the new modular structure
const { initializeServices: newInitializeServices } = await import('./container/factory');
return newInitializeServices(container as any);
}
// Export typed container
@ -79,16 +61,4 @@ export interface ServiceContainerOptions {
enableProxy?: boolean;
}
/**
* Create service container directly from AppConfig
* This eliminates the need for manual config mapping in each service
*/
export function createServiceContainerFromConfig(
appConfig: StockBotAppConfig,
options: ServiceContainerOptions = {}
): AwilixContainer<ServiceDefinitions> {
// Deprecated - use the new modular structure
const { createServiceContainerFromConfig: newCreateServiceContainerFromConfig } = require('./container/factory');
return newCreateServiceContainerFromConfig(appConfig, options);
}

2
libs/core/di/src/container/builder.ts
View file

@ -1,5 +1,5 @@
import { createContainer, InjectionMode, asFunction, type AwilixContainer } from 'awilix';
import type { AppConfig as StockBotAppConfig, UnifiedAppConfig } from '@stock-bot/config';
import type { BaseAppConfig as StockBotAppConfig, UnifiedAppConfig } from '@stock-bot/config';
import { appConfigSchema, type AppConfig } from '../config/schemas';
import { toUnifiedConfig } from '@stock-bot/config';
import {

81
libs/core/di/src/container/factory.ts
View file

@ -1,76 +1,8 @@
import type { AwilixContainer } from 'awilix';
import type { AppConfig as StockBotAppConfig } from '@stock-bot/config';
import type { BaseAppConfig as StockBotAppConfig } from '@stock-bot/config';
import { ServiceContainerBuilder } from './builder';
import type { ServiceDefinitions, ServiceContainerOptions } from './types';
/**
* Creates a service container from raw configuration
* @deprecated Use ServiceContainerBuilder instead
*/
export function createServiceContainer(rawConfig: unknown): AwilixContainer<ServiceDefinitions> {
// For backward compatibility, we need to create the container synchronously
// This means we'll use the original implementation pattern
const { createContainer, InjectionMode, asValue: _asValue, asFunction } = require('awilix');
const { appConfigSchema } = require('../config/schemas');
const config = appConfigSchema.parse(rawConfig);
const container = createContainer({
injectionMode: InjectionMode.PROXY,
strict: true,
});
// Register all services synchronously
const {
registerCoreServices,
registerCacheServices,
registerDatabaseServices,
registerApplicationServices
} = require('../registrations');
registerCoreServices(container, config);
registerCacheServices(container, config);
registerDatabaseServices(container, config);
registerApplicationServices(container, config);
// Register service container aggregate
container.register({
serviceContainer: asFunction((cradle: ServiceDefinitions) => ({
logger: cradle.logger,
cache: cradle.cache,
proxy: cradle.proxyManager, // Map proxyManager to proxy
browser: cradle.browser,
queue: cradle.queueManager, // Map queueManager to queue
mongodb: cradle.mongoClient, // Map mongoClient to mongodb
postgres: cradle.postgresClient, // Map postgresClient to postgres
questdb: cradle.questdbClient, // Map questdbClient to questdb
})).singleton(),
});
return container;
}
/**
* Creates a service container from StockBotAppConfig
* @deprecated Use ServiceContainerBuilder instead
*/
export function createServiceContainerFromConfig(
appConfig: StockBotAppConfig,
options: ServiceContainerOptions = {}
): AwilixContainer<ServiceDefinitions> {
const builder = new ServiceContainerBuilder();
return builder
.withConfig(appConfig)
.withOptions({
...options,
skipInitialization: true, // Legacy behavior
})
.build()
.then(container => container)
.catch(error => {
throw error;
}) as any; // Sync interface for backward compatibility
}
/**
* Modern async factory for creating service containers
@ -86,14 +18,3 @@ export async function createServiceContainerAsync(
.build();
}
/**
* Initialize services in an existing container
* @deprecated Handled automatically by ServiceContainerBuilder
*/
export async function initializeServices(
container: AwilixContainer<ServiceDefinitions>
): Promise<void> {
const { ServiceLifecycleManager } = await import('../utils/lifecycle');
const lifecycleManager = new ServiceLifecycleManager();
await lifecycleManager.initializeServices(container);
}

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

@ -6,11 +6,8 @@ export * from './types';
// Re-export IServiceContainer from types for convenience
export type { IServiceContainer } from '@stock-bot/types';
// Legacy exports for backward compatibility
// Type exports from awilix-container
export {
createServiceContainer,
createServiceContainerFromConfig,
initializeServices,
type AppConfig,
type ServiceCradle,
type ServiceContainer,
@ -21,9 +18,7 @@ export {
export * from './container/types';
export { ServiceContainerBuilder } from './container/builder';
export {
createServiceContainerAsync,
createServiceContainer as createServiceContainerNew,
createServiceContainerFromConfig as createServiceContainerFromConfigNew
createServiceContainerAsync
} from './container/factory';
// Configuration exports

2
libs/core/di/src/service-application.ts
View file

@ -7,7 +7,7 @@ import { Hono } from 'hono';
import { cors } from 'hono/cors';
import { getLogger, setLoggerConfig, shutdownLoggers, type Logger } from '@stock-bot/logger';
import { Shutdown } from '@stock-bot/shutdown';
import type { AppConfig as StockBotAppConfig, UnifiedAppConfig } from '@stock-bot/config';
import type { BaseAppConfig as StockBotAppConfig, UnifiedAppConfig } from '@stock-bot/config';
import { toUnifiedConfig } from '@stock-bot/config';
import type { IServiceContainer } from '@stock-bot/types';
import type { ServiceContainer } from './awilix-container';

98
libs/core/queue/src/service-registry.deprecated.ts
View file

@ -1,98 +0,0 @@
/**
* Service Registry Configuration
* Maps services to their Redis databases and configurations
*
* @deprecated This static service registry has been replaced by runtime discovery
* using the handler registry. Service ownership is now tracked when handlers are
* registered, eliminating the need for static configuration.
*
* Migration:
* - Service names are auto-discovered from handler registration
* - Cache prefixes are generated using generateCachePrefix()
* - Queue names use getFullQueueName() from service-utils
* - Handler ownership is tracked by handlerRegistry.getHandlerService()
*/
export interface ServiceConfig {
/** Prefix for cache keys (e.g., 'cache:data-ingestion') */
cachePrefix: string;
/** List of handlers this service owns (auto-discovered if not provided) */
handlers?: string[];
}
/**
* Central registry of all services and their configurations
*
* Database assignments:
* - db:0 = All queues (unified queue database)
* - db:1 = Global shared cache + service-specific caches
*/
export const SERVICE_REGISTRY: Record<string, ServiceConfig> = {
'data-ingestion': {
cachePrefix: 'cache:data-ingestion',
handlers: ['ceo', 'qm', 'webshare', 'ib', 'proxy'],
},
'data-pipeline': {
cachePrefix: 'cache:data-pipeline',
handlers: ['exchanges', 'symbols'],
},
'web-api': {
cachePrefix: 'cache:web-api',
},
// Add aliases for services with different naming conventions
'webApi': {
cachePrefix: 'cache:web-api',
},
'dataIngestion': {
cachePrefix: 'cache:data-ingestion',
handlers: ['ceo', 'qm', 'webshare', 'ib', 'proxy'],
},
'dataPipeline': {
cachePrefix: 'cache:data-pipeline',
handlers: ['exchanges', 'symbols'],
},
};
/**
* Get service configuration
*/
export function getServiceConfig(serviceName: string): ServiceConfig | undefined {
return SERVICE_REGISTRY[serviceName];
}
/**
* Find which service owns a handler
*/
export function findServiceForHandler(handlerName: string): string | undefined {
for (const [serviceName, config] of Object.entries(SERVICE_REGISTRY)) {
if (config.handlers?.includes(handlerName)) {
return serviceName;
}
}
return undefined;
}
/**
* Get full queue name with service namespace
*/
export function getFullQueueName(serviceName: string, handlerName: string): string {
// Use {service_handler} format for Dragonfly optimization and BullMQ compatibility
return `{${serviceName}_${handlerName}}`;
}
/**
* Parse a full queue name into service and handler
*/
export function parseQueueName(fullQueueName: string): { service: string; handler: string } | null {
// Match pattern {service_handler}
const match = fullQueueName.match(/^\{([^_]+)_([^}]+)\}$/);
if (!match || !match[1] || !match[2]) {
return null;
}
return {
service: match[1],
handler: match[2],
};
}