moved folders around
This commit is contained in:
parent
4f89affc2b
commit
36cb84b343
202 changed files with 1160 additions and 660 deletions
50
libs/core/config/.env.example
Normal file
50
libs/core/config/.env.example
Normal file
|
|
@ -0,0 +1,50 @@
|
|||
# Environment
|
||||
NODE_ENV=development
|
||||
|
||||
# Service Configuration
|
||||
STOCKBOT_SERVICE_NAME=stock-bot-service
|
||||
STOCKBOT_SERVICE_PORT=3000
|
||||
|
||||
# Database Configuration
|
||||
STOCKBOT_DATABASE_POSTGRES_HOST=localhost
|
||||
STOCKBOT_DATABASE_POSTGRES_PORT=5432
|
||||
STOCKBOT_DATABASE_POSTGRES_DATABASE=stockbot
|
||||
STOCKBOT_DATABASE_POSTGRES_USER=postgres
|
||||
STOCKBOT_DATABASE_POSTGRES_PASSWORD=postgres
|
||||
|
||||
STOCKBOT_DATABASE_QUESTDB_HOST=localhost
|
||||
STOCKBOT_DATABASE_QUESTDB_ILP_PORT=9009
|
||||
STOCKBOT_DATABASE_QUESTDB_HTTP_PORT=9000
|
||||
|
||||
STOCKBOT_DATABASE_MONGODB_HOST=localhost
|
||||
STOCKBOT_DATABASE_MONGODB_PORT=27017
|
||||
STOCKBOT_DATABASE_MONGODB_DATABASE=stockbot
|
||||
|
||||
STOCKBOT_DATABASE_DRAGONFLY_HOST=localhost
|
||||
STOCKBOT_DATABASE_DRAGONFLY_PORT=6379
|
||||
|
||||
# Provider Configuration
|
||||
STOCKBOT_PROVIDERS_EOD_API_KEY=your_eod_api_key
|
||||
STOCKBOT_PROVIDERS_EOD_ENABLED=true
|
||||
|
||||
STOCKBOT_PROVIDERS_IB_ENABLED=false
|
||||
STOCKBOT_PROVIDERS_IB_GATEWAY_HOST=localhost
|
||||
STOCKBOT_PROVIDERS_IB_GATEWAY_PORT=5000
|
||||
STOCKBOT_PROVIDERS_IB_ACCOUNT=your_account_id
|
||||
|
||||
STOCKBOT_PROVIDERS_QM_ENABLED=false
|
||||
STOCKBOT_PROVIDERS_QM_USERNAME=your_username
|
||||
STOCKBOT_PROVIDERS_QM_PASSWORD=your_password
|
||||
STOCKBOT_PROVIDERS_QM_WEBMASTER_ID=your_webmaster_id
|
||||
|
||||
# Logging
|
||||
STOCKBOT_LOGGING_LEVEL=info
|
||||
STOCKBOT_LOGGING_LOKI_ENABLED=false
|
||||
STOCKBOT_LOGGING_LOKI_HOST=localhost
|
||||
STOCKBOT_LOGGING_LOKI_PORT=3100
|
||||
|
||||
# HTTP Proxy (optional)
|
||||
STOCKBOT_HTTP_PROXY_ENABLED=false
|
||||
STOCKBOT_HTTP_PROXY_URL=http://proxy.example.com:8080
|
||||
STOCKBOT_HTTP_PROXY_AUTH_USERNAME=username
|
||||
STOCKBOT_HTTP_PROXY_AUTH_PASSWORD=password
|
||||
243
libs/core/config/README.md
Normal file
243
libs/core/config/README.md
Normal file
|
|
@ -0,0 +1,243 @@
|
|||
# @stock-bot/config
|
||||
|
||||
A robust, type-safe configuration library for the Stock Bot application. Built with Zod for validation and supports multiple configuration sources with proper precedence.
|
||||
|
||||
## Features
|
||||
|
||||
- **Type-safe configuration** with Zod schemas
|
||||
- **Multiple configuration sources**: JSON files and environment variables
|
||||
- **Environment-specific overrides** (development, test, production)
|
||||
- **Dynamic provider configurations**
|
||||
- **No circular dependencies** - designed to be used by all other libraries
|
||||
- **Clear error messages** with validation
|
||||
- **Runtime configuration updates** (useful for testing)
|
||||
- **Singleton pattern** for global configuration access
|
||||
|
||||
## Installation
|
||||
|
||||
```bash
|
||||
bun add @stock-bot/config
|
||||
```
|
||||
|
||||
## Usage
|
||||
|
||||
### Basic Usage
|
||||
|
||||
```typescript
|
||||
import { initializeConfig, getConfig } from '@stock-bot/config';
|
||||
|
||||
// Initialize configuration (call once at app startup)
|
||||
await initializeConfig();
|
||||
|
||||
// Get configuration
|
||||
const config = getConfig();
|
||||
console.log(config.database.postgres.host);
|
||||
|
||||
// Use convenience functions
|
||||
import { getDatabaseConfig, isProduction } from '@stock-bot/config';
|
||||
|
||||
const dbConfig = getDatabaseConfig();
|
||||
if (isProduction()) {
|
||||
// Production-specific logic
|
||||
}
|
||||
```
|
||||
|
||||
### Custom Configuration
|
||||
|
||||
```typescript
|
||||
import { ConfigManager } from '@stock-bot/config';
|
||||
import { z } from 'zod';
|
||||
|
||||
// Define your schema
|
||||
const myConfigSchema = z.object({
|
||||
app: z.object({
|
||||
name: z.string(),
|
||||
version: z.string(),
|
||||
}),
|
||||
features: z.object({
|
||||
enableBeta: z.boolean().default(false),
|
||||
}),
|
||||
});
|
||||
|
||||
// Create config manager
|
||||
const configManager = new ConfigManager({
|
||||
configPath: './my-config',
|
||||
});
|
||||
|
||||
// Initialize with schema
|
||||
const config = await configManager.initialize(myConfigSchema);
|
||||
```
|
||||
|
||||
### Provider-Specific Configuration
|
||||
|
||||
```typescript
|
||||
import { getProviderConfig } from '@stock-bot/config';
|
||||
|
||||
// Get provider configuration
|
||||
const eodConfig = getProviderConfig('eod');
|
||||
console.log(eodConfig.apiKey);
|
||||
|
||||
// Check if provider is enabled
|
||||
if (eodConfig.enabled) {
|
||||
// Use EOD provider
|
||||
}
|
||||
```
|
||||
|
||||
### Environment Variables
|
||||
|
||||
Environment variables are loaded with the `STOCKBOT_` prefix and follow a naming convention:
|
||||
|
||||
```bash
|
||||
# Database configuration
|
||||
STOCKBOT_DATABASE_POSTGRES_HOST=localhost
|
||||
STOCKBOT_DATABASE_POSTGRES_PORT=5432
|
||||
|
||||
# Provider configuration
|
||||
STOCKBOT_PROVIDERS_EOD_API_KEY=your_api_key
|
||||
STOCKBOT_PROVIDERS_EOD_ENABLED=true
|
||||
|
||||
# Service configuration
|
||||
STOCKBOT_SERVICE_PORT=3000
|
||||
STOCKBOT_LOGGING_LEVEL=debug
|
||||
```
|
||||
|
||||
### Configuration Precedence
|
||||
|
||||
Configuration is loaded in the following order (later sources override earlier ones):
|
||||
|
||||
1. `config/default.json` - Base configuration
|
||||
2. `config/{environment}.json` - Environment-specific overrides
|
||||
3. Environment variables - Highest priority
|
||||
|
||||
### Advanced Usage
|
||||
|
||||
```typescript
|
||||
import { getConfigManager } from '@stock-bot/config';
|
||||
|
||||
const manager = getConfigManager();
|
||||
|
||||
// Get specific value by path
|
||||
const port = manager.getValue<number>('service.port');
|
||||
|
||||
// Check if configuration exists
|
||||
if (manager.has('providers.ib')) {
|
||||
// IB provider is configured
|
||||
}
|
||||
|
||||
// Update configuration at runtime (useful for testing)
|
||||
manager.set({
|
||||
logging: {
|
||||
level: 'debug'
|
||||
}
|
||||
});
|
||||
|
||||
// Create typed getter
|
||||
const getQueueConfig = manager.createTypedGetter(queueConfigSchema);
|
||||
const queueConfig = getQueueConfig();
|
||||
```
|
||||
|
||||
## Configuration Schema
|
||||
|
||||
The library provides pre-defined schemas for common configurations:
|
||||
|
||||
### Base Configuration
|
||||
- `environment` - Current environment (development/test/production)
|
||||
- `name` - Application name
|
||||
- `version` - Application version
|
||||
- `debug` - Debug mode flag
|
||||
|
||||
### Service Configuration
|
||||
- `name` - Service name
|
||||
- `port` - Service port
|
||||
- `host` - Service host
|
||||
- `healthCheckPath` - Health check endpoint
|
||||
- `cors` - CORS configuration
|
||||
|
||||
### Database Configuration
|
||||
- `postgres` - PostgreSQL configuration
|
||||
- `questdb` - QuestDB configuration
|
||||
- `mongodb` - MongoDB configuration
|
||||
- `dragonfly` - Dragonfly/Redis configuration
|
||||
|
||||
### Provider Configuration
|
||||
- `eod` - EOD Historical Data provider
|
||||
- `ib` - Interactive Brokers provider
|
||||
- `qm` - QuoteMedia provider
|
||||
- `yahoo` - Yahoo Finance provider
|
||||
|
||||
## Testing
|
||||
|
||||
```typescript
|
||||
import { resetConfig, initializeConfig } from '@stock-bot/config';
|
||||
|
||||
beforeEach(() => {
|
||||
resetConfig();
|
||||
});
|
||||
|
||||
test('custom config', async () => {
|
||||
process.env.NODE_ENV = 'test';
|
||||
process.env.STOCKBOT_SERVICE_PORT = '4000';
|
||||
|
||||
await initializeConfig();
|
||||
const config = getConfig();
|
||||
|
||||
expect(config.service.port).toBe(4000);
|
||||
});
|
||||
```
|
||||
|
||||
## Custom Loaders
|
||||
|
||||
You can create custom configuration loaders:
|
||||
|
||||
```typescript
|
||||
import { ConfigLoader } from '@stock-bot/config';
|
||||
|
||||
class ApiConfigLoader implements ConfigLoader {
|
||||
readonly priority = 75; // Between file (50) and env (100)
|
||||
|
||||
async load(): Promise<Record<string, unknown>> {
|
||||
// Fetch configuration from API
|
||||
const response = await fetch('https://api.example.com/config');
|
||||
return response.json();
|
||||
}
|
||||
}
|
||||
|
||||
// Use custom loader
|
||||
const configManager = new ConfigManager({
|
||||
loaders: [
|
||||
new FileLoader('./config', 'production'),
|
||||
new ApiConfigLoader(),
|
||||
new EnvLoader('STOCKBOT_'),
|
||||
],
|
||||
});
|
||||
```
|
||||
|
||||
## Error Handling
|
||||
|
||||
The library provides specific error types:
|
||||
|
||||
```typescript
|
||||
import { ConfigError, ConfigValidationError } from '@stock-bot/config';
|
||||
|
||||
try {
|
||||
await initializeConfig();
|
||||
} catch (error) {
|
||||
if (error instanceof ConfigValidationError) {
|
||||
console.error('Validation failed:', error.errors);
|
||||
} else if (error instanceof ConfigError) {
|
||||
console.error('Configuration error:', error.message);
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
## Best Practices
|
||||
|
||||
1. **Initialize once**: Call `initializeConfig()` once at application startup
|
||||
2. **Use schemas**: Always define and validate configurations with Zod schemas
|
||||
3. **Environment variables**: Use the `STOCKBOT_` prefix for all env vars
|
||||
4. **Type safety**: Leverage TypeScript types from the schemas
|
||||
5. **Testing**: Reset configuration between tests with `resetConfig()`
|
||||
|
||||
## License
|
||||
|
||||
MIT
|
||||
94
libs/core/config/config/default.json
Normal file
94
libs/core/config/config/default.json
Normal file
|
|
@ -0,0 +1,94 @@
|
|||
{
|
||||
"name": "stock-bot",
|
||||
"version": "1.0.0",
|
||||
"debug": false,
|
||||
"service": {
|
||||
"name": "stock-bot-service",
|
||||
"port": 3000,
|
||||
"host": "0.0.0.0",
|
||||
"healthCheckPath": "/health",
|
||||
"metricsPath": "/metrics",
|
||||
"shutdownTimeout": 30000,
|
||||
"cors": {
|
||||
"enabled": true,
|
||||
"origin": "*",
|
||||
"credentials": true
|
||||
}
|
||||
},
|
||||
"logging": {
|
||||
"level": "info",
|
||||
"format": "json",
|
||||
"loki": {
|
||||
"enabled": false,
|
||||
"host": "localhost",
|
||||
"port": 3100,
|
||||
"labels": {}
|
||||
}
|
||||
},
|
||||
"database": {
|
||||
"postgres": {
|
||||
"host": "localhost",
|
||||
"port": 5432,
|
||||
"database": "stockbot",
|
||||
"user": "postgres",
|
||||
"password": "postgres",
|
||||
"ssl": false,
|
||||
"poolSize": 10,
|
||||
"connectionTimeout": 30000,
|
||||
"idleTimeout": 10000
|
||||
},
|
||||
"questdb": {
|
||||
"host": "localhost",
|
||||
"ilpPort": 9009,
|
||||
"httpPort": 9000,
|
||||
"pgPort": 8812,
|
||||
"database": "questdb",
|
||||
"user": "admin",
|
||||
"password": "quest",
|
||||
"bufferSize": 65536,
|
||||
"flushInterval": 1000
|
||||
},
|
||||
"mongodb": {
|
||||
"host": "localhost",
|
||||
"port": 27017,
|
||||
"database": "stockbot",
|
||||
"authSource": "admin",
|
||||
"poolSize": 10
|
||||
},
|
||||
"dragonfly": {
|
||||
"host": "localhost",
|
||||
"port": 6379,
|
||||
"db": 0,
|
||||
"maxRetries": 3,
|
||||
"retryDelay": 100
|
||||
}
|
||||
},
|
||||
"queue": {
|
||||
"redis": {
|
||||
"host": "localhost",
|
||||
"port": 6379,
|
||||
"db": 0
|
||||
},
|
||||
"defaultJobOptions": {
|
||||
"attempts": 3,
|
||||
"backoff": {
|
||||
"type": "exponential",
|
||||
"delay": 1000
|
||||
},
|
||||
"removeOnComplete": true,
|
||||
"removeOnFail": false
|
||||
}
|
||||
},
|
||||
"http": {
|
||||
"timeout": 30000,
|
||||
"retries": 3,
|
||||
"retryDelay": 1000,
|
||||
"proxy": {
|
||||
"enabled": false
|
||||
}
|
||||
},
|
||||
"webshare": {
|
||||
"apiKey": "",
|
||||
"apiUrl": "https://proxy.webshare.io/api/v2/"
|
||||
}
|
||||
}
|
||||
48
libs/core/config/config/development.json
Normal file
48
libs/core/config/config/development.json
Normal file
|
|
@ -0,0 +1,48 @@
|
|||
{
|
||||
"debug": true,
|
||||
"logging": {
|
||||
"level": "debug",
|
||||
"format": "pretty"
|
||||
},
|
||||
"providers": {
|
||||
"eod": {
|
||||
"name": "eod-historical-data",
|
||||
"enabled": true,
|
||||
"priority": 1,
|
||||
"apiKey": "demo",
|
||||
"tier": "free",
|
||||
"rateLimit": {
|
||||
"maxRequests": 20,
|
||||
"windowMs": 60000
|
||||
}
|
||||
},
|
||||
"yahoo": {
|
||||
"name": "yahoo-finance",
|
||||
"enabled": true,
|
||||
"priority": 2,
|
||||
"rateLimit": {
|
||||
"maxRequests": 100,
|
||||
"windowMs": 60000
|
||||
}
|
||||
},
|
||||
"ib": {
|
||||
"name": "interactive-brokers",
|
||||
"enabled": false,
|
||||
"priority": 0,
|
||||
"gateway": {
|
||||
"host": "localhost",
|
||||
"port": 5000,
|
||||
"clientId": 1
|
||||
},
|
||||
"marketDataType": "delayed"
|
||||
},
|
||||
"qm": {
|
||||
"name": "quotemedia",
|
||||
"enabled": false,
|
||||
"priority": 3,
|
||||
"username": "",
|
||||
"password": "",
|
||||
"webmasterId": ""
|
||||
}
|
||||
}
|
||||
}
|
||||
32
libs/core/config/config/production.json
Normal file
32
libs/core/config/config/production.json
Normal file
|
|
@ -0,0 +1,32 @@
|
|||
{
|
||||
"debug": false,
|
||||
"logging": {
|
||||
"level": "warn",
|
||||
"format": "json",
|
||||
"loki": {
|
||||
"enabled": true,
|
||||
"labels": {
|
||||
"app": "stock-bot",
|
||||
"env": "production"
|
||||
}
|
||||
}
|
||||
},
|
||||
"database": {
|
||||
"postgres": {
|
||||
"ssl": true,
|
||||
"poolSize": 20
|
||||
},
|
||||
"questdb": {
|
||||
"bufferSize": 131072,
|
||||
"flushInterval": 500
|
||||
},
|
||||
"mongodb": {
|
||||
"poolSize": 20
|
||||
}
|
||||
},
|
||||
"http": {
|
||||
"timeout": 60000,
|
||||
"retries": 5,
|
||||
"retryDelay": 2000
|
||||
}
|
||||
}
|
||||
42
libs/core/config/config/test.json
Normal file
42
libs/core/config/config/test.json
Normal file
|
|
@ -0,0 +1,42 @@
|
|||
{
|
||||
"debug": true,
|
||||
"logging": {
|
||||
"level": "error",
|
||||
"format": "json"
|
||||
},
|
||||
"service": {
|
||||
"port": 0,
|
||||
"shutdownTimeout": 5000
|
||||
},
|
||||
"database": {
|
||||
"postgres": {
|
||||
"database": "stockbot_test",
|
||||
"poolSize": 5
|
||||
},
|
||||
"questdb": {
|
||||
"database": "questdb_test"
|
||||
},
|
||||
"mongodb": {
|
||||
"database": "stockbot_test",
|
||||
"poolSize": 5
|
||||
},
|
||||
"dragonfly": {
|
||||
"db": 15,
|
||||
"keyPrefix": "test:"
|
||||
}
|
||||
},
|
||||
"queue": {
|
||||
"redis": {
|
||||
"db": 15
|
||||
},
|
||||
"defaultJobOptions": {
|
||||
"attempts": 1,
|
||||
"removeOnComplete": false,
|
||||
"removeOnFail": false
|
||||
}
|
||||
},
|
||||
"http": {
|
||||
"timeout": 5000,
|
||||
"retries": 1
|
||||
}
|
||||
}
|
||||
33
libs/core/config/package.json
Normal file
33
libs/core/config/package.json
Normal file
|
|
@ -0,0 +1,33 @@
|
|||
{
|
||||
"name": "@stock-bot/config",
|
||||
"version": "1.0.0",
|
||||
"type": "module",
|
||||
"exports": {
|
||||
".": {
|
||||
"import": "./dist/index.js",
|
||||
"types": "./dist/index.d.ts"
|
||||
}
|
||||
},
|
||||
"main": "./dist/index.js",
|
||||
"types": "./dist/index.d.ts",
|
||||
"scripts": {
|
||||
"build": "tsc",
|
||||
"dev": "tsc --watch",
|
||||
"test": "bun test",
|
||||
"clean": "rm -rf dist",
|
||||
"cli": "bun run src/cli.ts",
|
||||
"validate": "bun run src/cli.ts --validate",
|
||||
"check": "bun run src/cli.ts --check"
|
||||
},
|
||||
"bin": {
|
||||
"config-cli": "./dist/cli.js"
|
||||
},
|
||||
"dependencies": {
|
||||
"zod": "^3.22.4"
|
||||
},
|
||||
"devDependencies": {
|
||||
"@types/bun": "^1.0.0",
|
||||
"@types/node": "^20.10.5",
|
||||
"typescript": "^5.3.3"
|
||||
}
|
||||
}
|
||||
196
libs/core/config/src/cli.ts
Normal file
196
libs/core/config/src/cli.ts
Normal file
|
|
@ -0,0 +1,196 @@
|
|||
#!/usr/bin/env bun
|
||||
/* eslint-disable no-console */
|
||||
import { parseArgs } from 'util';
|
||||
import { join } from 'path';
|
||||
import { ConfigManager } from './config-manager';
|
||||
import { appConfigSchema } from './schemas';
|
||||
import {
|
||||
validateConfig,
|
||||
formatValidationResult,
|
||||
checkDeprecations,
|
||||
checkRequiredEnvVars,
|
||||
validateCompleteness
|
||||
} from './utils/validation';
|
||||
import { redactSecrets } from './utils/secrets';
|
||||
import type { Environment } from './types';
|
||||
|
||||
interface CliOptions {
|
||||
config?: string;
|
||||
env?: string;
|
||||
validate?: boolean;
|
||||
show?: boolean;
|
||||
check?: boolean;
|
||||
json?: boolean;
|
||||
help?: boolean;
|
||||
}
|
||||
|
||||
const DEPRECATIONS = {
|
||||
'service.legacyMode': 'Use service.mode instead',
|
||||
'database.redis': 'Use database.dragonfly instead',
|
||||
};
|
||||
|
||||
const REQUIRED_PATHS = [
|
||||
'service.name',
|
||||
'service.port',
|
||||
'database.postgres.host',
|
||||
'database.postgres.database',
|
||||
];
|
||||
|
||||
const REQUIRED_ENV_VARS = [
|
||||
'NODE_ENV',
|
||||
];
|
||||
|
||||
const SECRET_PATHS = [
|
||||
'database.postgres.password',
|
||||
'database.mongodb.uri',
|
||||
'providers.quoteMedia.apiKey',
|
||||
'providers.interactiveBrokers.clientId',
|
||||
];
|
||||
|
||||
function printUsage() {
|
||||
console.log(`
|
||||
Stock Bot Configuration CLI
|
||||
|
||||
Usage: bun run config-cli [options]
|
||||
|
||||
Options:
|
||||
--config <path> Path to config directory (default: ./config)
|
||||
--env <env> Environment to use (development, test, production)
|
||||
--validate Validate configuration against schema
|
||||
--show Show current configuration (secrets redacted)
|
||||
--check Run all configuration checks
|
||||
--json Output in JSON format
|
||||
--help Show this help message
|
||||
|
||||
Examples:
|
||||
# Validate configuration
|
||||
bun run config-cli --validate
|
||||
|
||||
# Show configuration for production
|
||||
bun run config-cli --env production --show
|
||||
|
||||
# Run all checks
|
||||
bun run config-cli --check
|
||||
|
||||
# Output configuration as JSON
|
||||
bun run config-cli --show --json
|
||||
`);
|
||||
}
|
||||
|
||||
async function main() {
|
||||
const { values } = parseArgs({
|
||||
args: process.argv.slice(2),
|
||||
options: {
|
||||
config: { type: 'string' },
|
||||
env: { type: 'string' },
|
||||
validate: { type: 'boolean' },
|
||||
show: { type: 'boolean' },
|
||||
check: { type: 'boolean' },
|
||||
json: { type: 'boolean' },
|
||||
help: { type: 'boolean' },
|
||||
},
|
||||
}) as { values: CliOptions };
|
||||
|
||||
if (values.help) {
|
||||
printUsage();
|
||||
process.exit(0);
|
||||
}
|
||||
|
||||
const configPath = values.config || join(process.cwd(), 'config');
|
||||
const environment = values.env as Environment;
|
||||
|
||||
try {
|
||||
const manager = new ConfigManager({
|
||||
configPath,
|
||||
environment,
|
||||
});
|
||||
|
||||
const config = await manager.initialize(appConfigSchema);
|
||||
|
||||
if (values.validate) {
|
||||
const result = validateConfig(config, appConfigSchema);
|
||||
|
||||
if (values.json) {
|
||||
console.log(JSON.stringify(result, null, 2));
|
||||
} else {
|
||||
console.log(formatValidationResult(result));
|
||||
}
|
||||
|
||||
process.exit(result.valid ? 0 : 1);
|
||||
}
|
||||
|
||||
if (values.show) {
|
||||
const redacted = redactSecrets(config, SECRET_PATHS);
|
||||
|
||||
if (values.json) {
|
||||
console.log(JSON.stringify(redacted, null, 2));
|
||||
} else {
|
||||
console.log('Current Configuration:');
|
||||
console.log(JSON.stringify(redacted, null, 2));
|
||||
}
|
||||
}
|
||||
|
||||
if (values.check) {
|
||||
console.log('Running configuration checks...\n');
|
||||
|
||||
// Schema validation
|
||||
console.log('1. Schema Validation:');
|
||||
const schemaResult = validateConfig(config, appConfigSchema);
|
||||
console.log(formatValidationResult(schemaResult));
|
||||
console.log();
|
||||
|
||||
// Environment variables
|
||||
console.log('2. Required Environment Variables:');
|
||||
const envResult = checkRequiredEnvVars(REQUIRED_ENV_VARS);
|
||||
console.log(formatValidationResult(envResult));
|
||||
console.log();
|
||||
|
||||
// Required paths
|
||||
console.log('3. Required Configuration Paths:');
|
||||
const pathResult = validateCompleteness(config, REQUIRED_PATHS);
|
||||
console.log(formatValidationResult(pathResult));
|
||||
console.log();
|
||||
|
||||
// Deprecations
|
||||
console.log('4. Deprecation Warnings:');
|
||||
const warnings = checkDeprecations(config, DEPRECATIONS);
|
||||
if (warnings && warnings.length > 0) {
|
||||
for (const warning of warnings) {
|
||||
console.log(` ⚠️ ${warning.path}: ${warning.message}`);
|
||||
}
|
||||
} else {
|
||||
console.log(' ✅ No deprecated options found');
|
||||
}
|
||||
console.log();
|
||||
|
||||
// Overall result
|
||||
const allValid = schemaResult.valid && envResult.valid && pathResult.valid;
|
||||
|
||||
if (allValid) {
|
||||
console.log('✅ All configuration checks passed!');
|
||||
process.exit(0);
|
||||
} else {
|
||||
console.log('❌ Some configuration checks failed');
|
||||
process.exit(1);
|
||||
}
|
||||
}
|
||||
|
||||
if (!values.validate && !values.show && !values.check) {
|
||||
console.log('No action specified. Use --help for usage information.');
|
||||
process.exit(1);
|
||||
}
|
||||
|
||||
} catch (error) {
|
||||
if (values.json) {
|
||||
console.error(JSON.stringify({ error: String(error) }));
|
||||
} else {
|
||||
console.error('Error:', error);
|
||||
}
|
||||
process.exit(1);
|
||||
}
|
||||
}
|
||||
|
||||
// Run CLI
|
||||
if (import.meta.main) {
|
||||
main();
|
||||
}
|
||||
228
libs/core/config/src/config-manager.ts
Normal file
228
libs/core/config/src/config-manager.ts
Normal file
|
|
@ -0,0 +1,228 @@
|
|||
import { join } from 'path';
|
||||
import { z } from 'zod';
|
||||
import { EnvLoader } from './loaders/env.loader';
|
||||
import { FileLoader } from './loaders/file.loader';
|
||||
import { ConfigError, ConfigValidationError } from './errors';
|
||||
import {
|
||||
ConfigLoader,
|
||||
ConfigManagerOptions,
|
||||
ConfigSchema,
|
||||
DeepPartial,
|
||||
Environment,
|
||||
} from './types';
|
||||
|
||||
export class ConfigManager<T = Record<string, unknown>> {
|
||||
private config: T | null = null;
|
||||
private loaders: ConfigLoader[];
|
||||
private environment: Environment;
|
||||
private schema?: ConfigSchema;
|
||||
|
||||
constructor(options: ConfigManagerOptions = {}) {
|
||||
this.environment = options.environment || this.detectEnvironment();
|
||||
|
||||
// Default loaders if none provided
|
||||
if (options.loaders) {
|
||||
this.loaders = options.loaders;
|
||||
} else {
|
||||
const configPath = options.configPath || join(process.cwd(), 'config');
|
||||
this.loaders = [
|
||||
new FileLoader(configPath, this.environment),
|
||||
new EnvLoader(''), // No prefix for env vars to match our .env file
|
||||
];
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Initialize the configuration by loading from all sources synchronously.
|
||||
*/
|
||||
initialize(schema?: ConfigSchema): T {
|
||||
if (this.config) {
|
||||
return this.config;
|
||||
}
|
||||
|
||||
this.schema = schema;
|
||||
|
||||
// Sort loaders by priority (higher priority last)
|
||||
const sortedLoaders = [...this.loaders].sort((a, b) => a.priority - b.priority);
|
||||
|
||||
// Load configurations from all sources
|
||||
const configs: Record<string, unknown>[] = [];
|
||||
for (const loader of sortedLoaders) {
|
||||
// Assuming all loaders now have a synchronous `load` method
|
||||
const config = loader.load();
|
||||
if (config && Object.keys(config).length > 0) {
|
||||
configs.push(config);
|
||||
}
|
||||
}
|
||||
|
||||
// Merge all configurations
|
||||
const mergedConfig = this.deepMerge(...configs) as T;
|
||||
|
||||
// Add environment if not present
|
||||
if (
|
||||
typeof mergedConfig === 'object' &&
|
||||
mergedConfig !== null &&
|
||||
!('environment' in mergedConfig)
|
||||
) {
|
||||
(mergedConfig as Record<string, unknown>)['environment'] = this.environment;
|
||||
}
|
||||
|
||||
// Validate if schema provided
|
||||
if (this.schema) {
|
||||
try {
|
||||
this.config = this.schema.parse(mergedConfig) as T;
|
||||
} catch (error) {
|
||||
if (error instanceof z.ZodError) {
|
||||
throw new ConfigValidationError('Configuration validation failed', error.errors);
|
||||
}
|
||||
throw error;
|
||||
}
|
||||
} else {
|
||||
this.config = mergedConfig;
|
||||
}
|
||||
|
||||
return this.config;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the current configuration
|
||||
*/
|
||||
get(): T {
|
||||
if (!this.config) {
|
||||
throw new ConfigError('Configuration not initialized. Call initialize() first.');
|
||||
}
|
||||
return this.config;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get a specific configuration value by path
|
||||
*/
|
||||
getValue<R = unknown>(path: string): R {
|
||||
const config = this.get();
|
||||
const keys = path.split('.');
|
||||
let value: unknown = config;
|
||||
|
||||
for (const key of keys) {
|
||||
if (value && typeof value === 'object' && key in value) {
|
||||
value = (value as Record<string, unknown>)[key];
|
||||
} else {
|
||||
throw new ConfigError(`Configuration key not found: ${path}`);
|
||||
}
|
||||
}
|
||||
|
||||
return value as R;
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if a configuration path exists
|
||||
*/
|
||||
has(path: string): boolean {
|
||||
try {
|
||||
this.getValue(path);
|
||||
return true;
|
||||
} catch {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Update configuration at runtime (useful for testing)
|
||||
*/
|
||||
set(updates: DeepPartial<T>): void {
|
||||
if (!this.config) {
|
||||
throw new ConfigError('Configuration not initialized. Call initialize() first.');
|
||||
}
|
||||
|
||||
const updated = this.deepMerge(
|
||||
this.config as Record<string, unknown>,
|
||||
updates as Record<string, unknown>
|
||||
) as T;
|
||||
|
||||
// Re-validate if schema is present
|
||||
if (this.schema) {
|
||||
try {
|
||||
this.config = this.schema.parse(updated) as T;
|
||||
} catch (error) {
|
||||
if (error instanceof z.ZodError) {
|
||||
throw new ConfigValidationError(
|
||||
'Configuration validation failed after update',
|
||||
error.errors
|
||||
);
|
||||
}
|
||||
throw error;
|
||||
}
|
||||
} else {
|
||||
this.config = updated;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the current environment
|
||||
*/
|
||||
getEnvironment(): Environment {
|
||||
return this.environment;
|
||||
}
|
||||
|
||||
/**
|
||||
* Reset configuration (useful for testing)
|
||||
*/
|
||||
reset(): void {
|
||||
this.config = null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Validate configuration against a schema
|
||||
*/
|
||||
validate<S extends ConfigSchema>(schema: S): z.infer<S> {
|
||||
const config = this.get();
|
||||
return schema.parse(config);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a typed configuration getter
|
||||
*/
|
||||
createTypedGetter<S extends z.ZodSchema>(schema: S): () => z.infer<S> {
|
||||
return () => this.validate(schema);
|
||||
}
|
||||
|
||||
private detectEnvironment(): Environment {
|
||||
const env = process.env.NODE_ENV?.toLowerCase();
|
||||
switch (env) {
|
||||
case 'production':
|
||||
case 'prod':
|
||||
return 'production';
|
||||
case 'test':
|
||||
return 'test';
|
||||
case 'development':
|
||||
case 'dev':
|
||||
default:
|
||||
return 'development';
|
||||
}
|
||||
}
|
||||
|
||||
private deepMerge(...objects: Record<string, unknown>[]): Record<string, unknown> {
|
||||
const result: Record<string, unknown> = {};
|
||||
|
||||
for (const obj of objects) {
|
||||
for (const [key, value] of Object.entries(obj)) {
|
||||
if (value === null || value === undefined) {
|
||||
result[key] = value;
|
||||
} else if (
|
||||
typeof value === 'object' &&
|
||||
!Array.isArray(value) &&
|
||||
!(value instanceof Date) &&
|
||||
!(value instanceof RegExp)
|
||||
) {
|
||||
result[key] = this.deepMerge(
|
||||
(result[key] as Record<string, unknown>) || ({} as Record<string, unknown>),
|
||||
value as Record<string, unknown>
|
||||
);
|
||||
} else {
|
||||
result[key] = value;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
}
|
||||
20
libs/core/config/src/errors.ts
Normal file
20
libs/core/config/src/errors.ts
Normal file
|
|
@ -0,0 +1,20 @@
|
|||
export class ConfigError extends Error {
|
||||
constructor(message: string) {
|
||||
super(message);
|
||||
this.name = 'ConfigError';
|
||||
}
|
||||
}
|
||||
|
||||
export class ConfigValidationError extends ConfigError {
|
||||
constructor(message: string, public errors: unknown) {
|
||||
super(message);
|
||||
this.name = 'ConfigValidationError';
|
||||
}
|
||||
}
|
||||
|
||||
export class ConfigLoaderError extends ConfigError {
|
||||
constructor(message: string, public loader: string) {
|
||||
super(`${loader}: ${message}`);
|
||||
this.name = 'ConfigLoaderError';
|
||||
}
|
||||
}
|
||||
188
libs/core/config/src/index.ts
Normal file
188
libs/core/config/src/index.ts
Normal file
|
|
@ -0,0 +1,188 @@
|
|||
// Import necessary types for singleton
|
||||
import { EnvLoader } from './loaders/env.loader';
|
||||
import { FileLoader } from './loaders/file.loader';
|
||||
import { ConfigManager } from './config-manager';
|
||||
import { AppConfig, appConfigSchema } from './schemas';
|
||||
|
||||
// Create singleton instance
|
||||
let configInstance: ConfigManager<AppConfig> | null = null;
|
||||
|
||||
// Synchronously load critical env vars for early initialization
|
||||
function loadCriticalEnvVarsSync(): void {
|
||||
// Load .env file synchronously if it exists
|
||||
try {
|
||||
const fs = require('fs');
|
||||
const path = require('path');
|
||||
const envPath = path.resolve(process.cwd(), '.env');
|
||||
if (fs.existsSync(envPath)) {
|
||||
const envContent = fs.readFileSync(envPath, 'utf-8');
|
||||
const lines = envContent.split('\n');
|
||||
|
||||
for (const line of lines) {
|
||||
const trimmed = line.trim();
|
||||
if (!trimmed || trimmed.startsWith('#')) {
|
||||
continue;
|
||||
}
|
||||
|
||||
const equalIndex = trimmed.indexOf('=');
|
||||
if (equalIndex === -1) {
|
||||
continue;
|
||||
}
|
||||
|
||||
const key = trimmed.substring(0, equalIndex).trim();
|
||||
let value = trimmed.substring(equalIndex + 1).trim();
|
||||
|
||||
// Remove surrounding quotes
|
||||
if (
|
||||
(value.startsWith('"') && value.endsWith('"')) ||
|
||||
(value.startsWith("'") && value.endsWith("'"))
|
||||
) {
|
||||
value = value.slice(1, -1);
|
||||
}
|
||||
|
||||
// Only set if not already set
|
||||
if (!(key in process.env)) {
|
||||
process.env[key] = value;
|
||||
}
|
||||
}
|
||||
}
|
||||
} catch {
|
||||
// Ignore errors - env file is optional
|
||||
}
|
||||
}
|
||||
|
||||
// Load critical env vars immediately
|
||||
loadCriticalEnvVarsSync();
|
||||
|
||||
/**
|
||||
* Initialize the global configuration synchronously.
|
||||
*
|
||||
* 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.
|
||||
* Automatically loads configs from:
|
||||
* 1. Root config directory (../../config)
|
||||
* 2. Service-specific config directory (./config)
|
||||
* 3. Environment variables
|
||||
*/
|
||||
export function initializeServiceConfig(): AppConfig {
|
||||
if (!configInstance) {
|
||||
const environment = process.env.NODE_ENV || 'development';
|
||||
configInstance = new ConfigManager<AppConfig>({
|
||||
loaders: [
|
||||
new FileLoader('../../config', environment), // Root config
|
||||
new FileLoader('./config', environment), // Service config
|
||||
new EnvLoader(''), // Environment variables
|
||||
],
|
||||
});
|
||||
}
|
||||
return configInstance.initialize(appConfigSchema);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the current configuration
|
||||
*/
|
||||
export function getConfig(): AppConfig {
|
||||
if (!configInstance) {
|
||||
throw new Error('Configuration not initialized. Call initializeConfig() first.');
|
||||
}
|
||||
return configInstance.get();
|
||||
}
|
||||
|
||||
/**
|
||||
* Get configuration manager instance
|
||||
*/
|
||||
export function getConfigManager(): ConfigManager<AppConfig> {
|
||||
if (!configInstance) {
|
||||
throw new Error('Configuration not initialized. Call initializeConfig() first.');
|
||||
}
|
||||
return configInstance;
|
||||
}
|
||||
|
||||
/**
|
||||
* Reset configuration (useful for testing)
|
||||
*/
|
||||
export function resetConfig(): void {
|
||||
if (configInstance) {
|
||||
configInstance.reset();
|
||||
configInstance = null;
|
||||
}
|
||||
}
|
||||
|
||||
// Export convenience functions for common configs
|
||||
export function getDatabaseConfig() {
|
||||
return getConfig().database;
|
||||
}
|
||||
|
||||
export function getServiceConfig() {
|
||||
return getConfig().service;
|
||||
}
|
||||
|
||||
export function getLogConfig() {
|
||||
return getConfig().log;
|
||||
}
|
||||
|
||||
// Deprecated alias for backward compatibility
|
||||
export function getLoggingConfig() {
|
||||
return getConfig().log;
|
||||
}
|
||||
|
||||
export function getProviderConfig(provider: string) {
|
||||
const providers = getConfig().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;
|
||||
}
|
||||
|
||||
// Export environment helpers
|
||||
export function isDevelopment(): boolean {
|
||||
return getConfig().environment === 'development';
|
||||
}
|
||||
|
||||
export function isProduction(): boolean {
|
||||
return getConfig().environment === 'production';
|
||||
}
|
||||
|
||||
export function isTest(): boolean {
|
||||
return getConfig().environment === 'test';
|
||||
}
|
||||
|
||||
// Export all schemas
|
||||
export * from './schemas';
|
||||
|
||||
// Export types
|
||||
export * from './types';
|
||||
|
||||
// Export errors
|
||||
export * from './errors';
|
||||
|
||||
// Export loaders
|
||||
export { EnvLoader } from './loaders/env.loader';
|
||||
export { FileLoader } from './loaders/file.loader';
|
||||
|
||||
// Export ConfigManager
|
||||
export { ConfigManager } from './config-manager';
|
||||
|
||||
// Export utilities
|
||||
export * from './utils/secrets';
|
||||
export * from './utils/validation';
|
||||
277
libs/core/config/src/loaders/env.loader.ts
Normal file
277
libs/core/config/src/loaders/env.loader.ts
Normal file
|
|
@ -0,0 +1,277 @@
|
|||
import { readFileSync } from 'fs';
|
||||
import { ConfigLoaderError } from '../errors';
|
||||
import { ConfigLoader } from '../types';
|
||||
|
||||
export interface EnvLoaderOptions {
|
||||
convertCase?: boolean;
|
||||
parseJson?: boolean;
|
||||
parseValues?: boolean;
|
||||
nestedDelimiter?: string;
|
||||
}
|
||||
|
||||
export class EnvLoader implements ConfigLoader {
|
||||
readonly priority = 100; // Highest priority
|
||||
|
||||
constructor(
|
||||
private prefix = '',
|
||||
private options: EnvLoaderOptions = {}
|
||||
) {
|
||||
this.options = {
|
||||
convertCase: false,
|
||||
parseJson: true,
|
||||
parseValues: true,
|
||||
nestedDelimiter: '_',
|
||||
...options,
|
||||
};
|
||||
}
|
||||
|
||||
load(): Record<string, unknown> {
|
||||
try {
|
||||
// Load root .env file - try multiple possible locations
|
||||
const possiblePaths = ['./.env', '../.env', '../../.env'];
|
||||
for (const path of possiblePaths) {
|
||||
this.loadEnvFile(path);
|
||||
}
|
||||
|
||||
const config: Record<string, unknown> = {};
|
||||
const envVars = process.env;
|
||||
|
||||
for (const [key, value] of Object.entries(envVars)) {
|
||||
if (this.prefix && !key.startsWith(this.prefix)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
const configKey = this.prefix ? key.slice(this.prefix.length) : key;
|
||||
|
||||
if (!this.options.convertCase && !this.options.nestedDelimiter) {
|
||||
// Simple case - just keep the key as is
|
||||
config[configKey] = this.parseValue(value || '');
|
||||
} else {
|
||||
// Handle nested structure or case conversion
|
||||
this.setConfigValue(config, configKey, value || '');
|
||||
}
|
||||
}
|
||||
|
||||
return config;
|
||||
} catch (error) {
|
||||
throw new ConfigLoaderError(`Failed to load environment variables: ${error}`, 'EnvLoader');
|
||||
}
|
||||
}
|
||||
|
||||
private setConfigValue(config: Record<string, unknown>, key: string, value: string): void {
|
||||
const parsedValue = this.parseValue(value);
|
||||
|
||||
try {
|
||||
// Handle provider-specific environment variables (only for application usage, not tests)
|
||||
if (!this.prefix && !this.options.convertCase) {
|
||||
const providerMapping = this.getProviderMapping(key);
|
||||
if (providerMapping) {
|
||||
this.setNestedValue(config, providerMapping.path, parsedValue);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
if (this.options.convertCase) {
|
||||
// Convert to camelCase
|
||||
const camelKey = this.toCamelCase(key);
|
||||
config[camelKey] = parsedValue;
|
||||
} else if (
|
||||
this.options.nestedDelimiter &&
|
||||
this.options.nestedDelimiter !== '_' &&
|
||||
key.includes(this.options.nestedDelimiter)
|
||||
) {
|
||||
// Handle nested delimiter (e.g., APP__NAME -> { APP: { NAME: value } })
|
||||
const parts = key.split(this.options.nestedDelimiter);
|
||||
this.setNestedValue(config, parts, parsedValue);
|
||||
} else {
|
||||
// Convert to nested structure based on underscores, or keep as-is if no underscores
|
||||
if (key.includes('_')) {
|
||||
const path = key.toLowerCase().split('_');
|
||||
this.setNestedValue(config, path, parsedValue);
|
||||
} else {
|
||||
// Single key without underscores - keep original case
|
||||
config[key] = parsedValue;
|
||||
}
|
||||
}
|
||||
} catch {
|
||||
// Skip environment variables that can't be set (readonly properties)
|
||||
// This is expected behavior for system environment variables
|
||||
}
|
||||
}
|
||||
|
||||
private setNestedValue(obj: Record<string, unknown>, path: string[], value: unknown): boolean {
|
||||
if (path.length === 0) {
|
||||
return false; // Cannot set value on empty path
|
||||
}
|
||||
const lastKey = path.pop();
|
||||
if (!lastKey) {
|
||||
return false; // This should never happen due to length check above
|
||||
}
|
||||
|
||||
try {
|
||||
const target = path.reduce((acc, key) => {
|
||||
if (!acc[key] || typeof acc[key] !== 'object') {
|
||||
acc[key] = {};
|
||||
}
|
||||
return acc[key] as Record<string, unknown>;
|
||||
}, obj);
|
||||
|
||||
(target as Record<string, unknown>)[lastKey] = value;
|
||||
return true;
|
||||
} catch {
|
||||
// If we can't assign to any property (readonly), skip this env var silently
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
private toCamelCase(str: string): string {
|
||||
return str.toLowerCase().replace(/_([a-z])/g, (_, char) => char.toUpperCase());
|
||||
}
|
||||
|
||||
private getProviderMapping(envKey: string): { path: string[] } | null {
|
||||
// Provider-specific and special environment variable mappings
|
||||
const providerMappings: Record<string, string[]> = {
|
||||
// WebShare provider mappings
|
||||
WEBSHARE_API_KEY: ['webshare', 'apiKey'],
|
||||
WEBSHARE_API_URL: ['webshare', 'apiUrl'],
|
||||
WEBSHARE_ENABLED: ['webshare', 'enabled'],
|
||||
|
||||
// EOD provider mappings
|
||||
EOD_API_KEY: ['providers', 'eod', 'apiKey'],
|
||||
EOD_BASE_URL: ['providers', 'eod', 'baseUrl'],
|
||||
EOD_TIER: ['providers', 'eod', 'tier'],
|
||||
EOD_ENABLED: ['providers', 'eod', 'enabled'],
|
||||
EOD_PRIORITY: ['providers', 'eod', 'priority'],
|
||||
|
||||
// Interactive Brokers provider mappings
|
||||
IB_GATEWAY_HOST: ['providers', 'ib', 'gateway', 'host'],
|
||||
IB_GATEWAY_PORT: ['providers', 'ib', 'gateway', 'port'],
|
||||
IB_CLIENT_ID: ['providers', 'ib', 'gateway', 'clientId'],
|
||||
IB_ACCOUNT: ['providers', 'ib', 'account'],
|
||||
IB_MARKET_DATA_TYPE: ['providers', 'ib', 'marketDataType'],
|
||||
IB_ENABLED: ['providers', 'ib', 'enabled'],
|
||||
IB_PRIORITY: ['providers', 'ib', 'priority'],
|
||||
|
||||
// QuoteMedia provider mappings
|
||||
QM_USERNAME: ['providers', 'qm', 'username'],
|
||||
QM_PASSWORD: ['providers', 'qm', 'password'],
|
||||
QM_BASE_URL: ['providers', 'qm', 'baseUrl'],
|
||||
QM_WEBMASTER_ID: ['providers', 'qm', 'webmasterId'],
|
||||
QM_ENABLED: ['providers', 'qm', 'enabled'],
|
||||
QM_PRIORITY: ['providers', 'qm', 'priority'],
|
||||
|
||||
// Yahoo Finance provider mappings
|
||||
YAHOO_BASE_URL: ['providers', 'yahoo', 'baseUrl'],
|
||||
YAHOO_COOKIE_JAR: ['providers', 'yahoo', 'cookieJar'],
|
||||
YAHOO_CRUMB: ['providers', 'yahoo', 'crumb'],
|
||||
YAHOO_ENABLED: ['providers', 'yahoo', 'enabled'],
|
||||
YAHOO_PRIORITY: ['providers', 'yahoo', 'priority'],
|
||||
|
||||
// General application config mappings
|
||||
NAME: ['name'],
|
||||
VERSION: ['version'],
|
||||
|
||||
// Log mappings (using LOG_ prefix for all)
|
||||
LOG_LEVEL: ['log', 'level'],
|
||||
LOG_FORMAT: ['log', 'format'],
|
||||
LOG_HIDE_OBJECT: ['log', 'hideObject'],
|
||||
LOG_LOKI_ENABLED: ['log', 'loki', 'enabled'],
|
||||
LOG_LOKI_HOST: ['log', 'loki', 'host'],
|
||||
LOG_LOKI_PORT: ['log', 'loki', 'port'],
|
||||
|
||||
// Special mappings to avoid conflicts
|
||||
DEBUG_MODE: ['debug'],
|
||||
};
|
||||
|
||||
const mapping = providerMappings[envKey];
|
||||
return mapping ? { path: mapping } : null;
|
||||
}
|
||||
|
||||
private parseValue(value: string): unknown {
|
||||
if (!this.options.parseValues && !this.options.parseJson) {
|
||||
return value;
|
||||
}
|
||||
|
||||
// Try to parse as JSON first if enabled
|
||||
if (this.options.parseJson) {
|
||||
try {
|
||||
return JSON.parse(value);
|
||||
} catch {
|
||||
// Not JSON, continue with other parsing
|
||||
}
|
||||
}
|
||||
|
||||
if (!this.options.parseValues) {
|
||||
return value;
|
||||
}
|
||||
|
||||
// Handle booleans
|
||||
if (value.toLowerCase() === 'true') {
|
||||
return true;
|
||||
}
|
||||
if (value.toLowerCase() === 'false') {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Handle numbers
|
||||
const num = Number(value);
|
||||
if (!isNaN(num) && value !== '') {
|
||||
return num;
|
||||
}
|
||||
|
||||
// Handle null/undefined
|
||||
if (value.toLowerCase() === 'null') {
|
||||
return null;
|
||||
}
|
||||
if (value.toLowerCase() === 'undefined') {
|
||||
return undefined;
|
||||
}
|
||||
|
||||
// Return as string
|
||||
return value;
|
||||
}
|
||||
|
||||
private loadEnvFile(filePath: string): void {
|
||||
try {
|
||||
const envContent = readFileSync(filePath, 'utf-8');
|
||||
const lines = envContent.split('\n');
|
||||
|
||||
for (const line of lines) {
|
||||
const trimmed = line.trim();
|
||||
if (!trimmed || trimmed.startsWith('#')) {
|
||||
continue; // Skip empty lines and comments
|
||||
}
|
||||
|
||||
const equalIndex = trimmed.indexOf('=');
|
||||
if (equalIndex === -1) {
|
||||
continue; // Skip lines without =
|
||||
}
|
||||
|
||||
const key = trimmed.substring(0, equalIndex).trim();
|
||||
let value = trimmed.substring(equalIndex + 1).trim();
|
||||
|
||||
// Remove surrounding quotes if present
|
||||
if (
|
||||
(value.startsWith('"') && value.endsWith('"')) ||
|
||||
(value.startsWith("'") && value.endsWith("'"))
|
||||
) {
|
||||
value = value.slice(1, -1);
|
||||
}
|
||||
|
||||
// Only set if not already set (allows override precedence)
|
||||
if (!(key in process.env)) {
|
||||
process.env[key] = value;
|
||||
}
|
||||
}
|
||||
} catch (error: unknown) {
|
||||
// File not found is not an error (env files are optional)
|
||||
if (error && typeof error === 'object' && 'code' in error && error.code !== 'ENOENT') {
|
||||
// eslint-disable-next-line no-console
|
||||
console.warn(
|
||||
`Warning: Could not load env file ${filePath}:`,
|
||||
error instanceof Error ? error.message : String(error)
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
68
libs/core/config/src/loaders/file.loader.ts
Normal file
68
libs/core/config/src/loaders/file.loader.ts
Normal file
|
|
@ -0,0 +1,68 @@
|
|||
import { existsSync, readFileSync } from 'fs';
|
||||
import { join } from 'path';
|
||||
import { ConfigLoaderError } from '../errors';
|
||||
import { ConfigLoader } from '../types';
|
||||
|
||||
export class FileLoader implements ConfigLoader {
|
||||
readonly priority = 50; // Medium priority
|
||||
|
||||
constructor(
|
||||
private configPath: string,
|
||||
private environment: string
|
||||
) {}
|
||||
|
||||
load(): Record<string, unknown> {
|
||||
try {
|
||||
const configs: Record<string, unknown>[] = [];
|
||||
|
||||
// Load default config
|
||||
const defaultConfig = this.loadFile('default.json');
|
||||
if (defaultConfig) {
|
||||
configs.push(defaultConfig);
|
||||
}
|
||||
|
||||
// Load environment-specific config
|
||||
const envConfig = this.loadFile(`${this.environment}.json`);
|
||||
if (envConfig) {
|
||||
configs.push(envConfig);
|
||||
}
|
||||
|
||||
// Merge configs (later configs override earlier ones)
|
||||
return this.deepMerge(...configs);
|
||||
} catch (error) {
|
||||
throw new ConfigLoaderError(`Failed to load configuration files: ${error}`, 'FileLoader');
|
||||
}
|
||||
}
|
||||
|
||||
private loadFile(filename: string): Record<string, unknown> | null {
|
||||
const filepath = join(this.configPath, filename);
|
||||
|
||||
if (!existsSync(filepath)) {
|
||||
return null;
|
||||
}
|
||||
|
||||
const content = readFileSync(filepath, 'utf-8');
|
||||
return JSON.parse(content);
|
||||
}
|
||||
|
||||
private deepMerge(...objects: Record<string, unknown>[]): Record<string, unknown> {
|
||||
const result: Record<string, unknown> = {};
|
||||
|
||||
for (const obj of objects) {
|
||||
for (const [key, value] of Object.entries(obj)) {
|
||||
if (value === null || value === undefined) {
|
||||
result[key] = value;
|
||||
} else if (typeof value === 'object' && !Array.isArray(value) && value !== null) {
|
||||
result[key] = this.deepMerge(
|
||||
(result[key] as Record<string, unknown>) || {},
|
||||
value as Record<string, unknown>
|
||||
);
|
||||
} else {
|
||||
result[key] = value;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
}
|
||||
10
libs/core/config/src/schemas/base.schema.ts
Normal file
10
libs/core/config/src/schemas/base.schema.ts
Normal file
|
|
@ -0,0 +1,10 @@
|
|||
import { z } from 'zod';
|
||||
|
||||
export const environmentSchema = z.enum(['development', 'test', 'production']);
|
||||
|
||||
export const baseConfigSchema = z.object({
|
||||
environment: environmentSchema.optional(),
|
||||
name: z.string().optional(),
|
||||
version: z.string().optional(),
|
||||
debug: z.boolean().default(false),
|
||||
});
|
||||
60
libs/core/config/src/schemas/database.schema.ts
Normal file
60
libs/core/config/src/schemas/database.schema.ts
Normal file
|
|
@ -0,0 +1,60 @@
|
|||
import { z } from 'zod';
|
||||
|
||||
// PostgreSQL configuration
|
||||
export const postgresConfigSchema = z.object({
|
||||
host: z.string().default('localhost'),
|
||||
port: z.number().default(5432),
|
||||
database: z.string(),
|
||||
user: z.string(),
|
||||
password: z.string(),
|
||||
ssl: z.boolean().default(false),
|
||||
poolSize: z.number().min(1).max(100).default(10),
|
||||
connectionTimeout: z.number().default(30000),
|
||||
idleTimeout: z.number().default(10000),
|
||||
});
|
||||
|
||||
// QuestDB configuration
|
||||
export const questdbConfigSchema = z.object({
|
||||
host: z.string().default('localhost'),
|
||||
ilpPort: z.number().default(9009),
|
||||
httpPort: z.number().default(9000),
|
||||
pgPort: z.number().default(8812),
|
||||
database: z.string().default('questdb'),
|
||||
user: z.string().default('admin'),
|
||||
password: z.string().default('quest'),
|
||||
bufferSize: z.number().default(65536),
|
||||
flushInterval: z.number().default(1000),
|
||||
});
|
||||
|
||||
// MongoDB configuration
|
||||
export const mongodbConfigSchema = z.object({
|
||||
uri: z.string().url().optional(),
|
||||
host: z.string().default('localhost'),
|
||||
port: z.number().default(27017),
|
||||
database: z.string(),
|
||||
user: z.string().optional(),
|
||||
password: z.string().optional(),
|
||||
authSource: z.string().default('admin'),
|
||||
replicaSet: z.string().optional(),
|
||||
poolSize: z.number().min(1).max(100).default(10),
|
||||
});
|
||||
|
||||
// Dragonfly/Redis configuration
|
||||
export const dragonflyConfigSchema = z.object({
|
||||
host: z.string().default('localhost'),
|
||||
port: z.number().default(6379),
|
||||
password: z.string().optional(),
|
||||
db: z.number().min(0).max(15).default(0),
|
||||
keyPrefix: z.string().optional(),
|
||||
ttl: z.number().optional(),
|
||||
maxRetries: z.number().default(3),
|
||||
retryDelay: z.number().default(100),
|
||||
});
|
||||
|
||||
// Combined database configuration
|
||||
export const databaseConfigSchema = z.object({
|
||||
postgres: postgresConfigSchema,
|
||||
questdb: questdbConfigSchema,
|
||||
mongodb: mongodbConfigSchema,
|
||||
dragonfly: dragonflyConfigSchema,
|
||||
});
|
||||
98
libs/core/config/src/schemas/index.ts
Normal file
98
libs/core/config/src/schemas/index.ts
Normal file
|
|
@ -0,0 +1,98 @@
|
|||
export * from './base.schema';
|
||||
export * from './database.schema';
|
||||
export * from './provider.schema';
|
||||
export * from './service.schema';
|
||||
|
||||
import { z } from 'zod';
|
||||
import { baseConfigSchema, environmentSchema } from './base.schema';
|
||||
import { providerConfigSchema, webshareProviderConfigSchema } from './provider.schema';
|
||||
import { httpConfigSchema, queueConfigSchema } from './service.schema';
|
||||
|
||||
// Flexible service schema with defaults
|
||||
const flexibleServiceConfigSchema = z.object({
|
||||
name: z.string().default('default-service'),
|
||||
port: z.number().min(1).max(65535).default(3000),
|
||||
host: z.string().default('0.0.0.0'),
|
||||
healthCheckPath: z.string().default('/health'),
|
||||
metricsPath: z.string().default('/metrics'),
|
||||
shutdownTimeout: z.number().default(30000),
|
||||
cors: z.object({
|
||||
enabled: z.boolean().default(true),
|
||||
origin: z.union([z.string(), z.array(z.string())]).default('*'),
|
||||
credentials: z.boolean().default(true),
|
||||
}).default({}),
|
||||
}).default({});
|
||||
|
||||
// Flexible database schema with defaults
|
||||
const flexibleDatabaseConfigSchema = z.object({
|
||||
postgres: z.object({
|
||||
host: z.string().default('localhost'),
|
||||
port: z.number().default(5432),
|
||||
database: z.string().default('test_db'),
|
||||
user: z.string().default('test_user'),
|
||||
password: z.string().default('test_pass'),
|
||||
ssl: z.boolean().default(false),
|
||||
poolSize: z.number().min(1).max(100).default(10),
|
||||
connectionTimeout: z.number().default(30000),
|
||||
idleTimeout: z.number().default(10000),
|
||||
}).default({}),
|
||||
questdb: z.object({
|
||||
host: z.string().default('localhost'),
|
||||
ilpPort: z.number().default(9009),
|
||||
httpPort: z.number().default(9000),
|
||||
pgPort: z.number().default(8812),
|
||||
database: z.string().default('questdb'),
|
||||
user: z.string().default('admin'),
|
||||
password: z.string().default('quest'),
|
||||
bufferSize: z.number().default(65536),
|
||||
flushInterval: z.number().default(1000),
|
||||
}).default({}),
|
||||
mongodb: z.object({
|
||||
uri: z.string().url().optional(),
|
||||
host: z.string().default('localhost'),
|
||||
port: z.number().default(27017),
|
||||
database: z.string().default('test_mongo'),
|
||||
user: z.string().optional(),
|
||||
password: z.string().optional(),
|
||||
authSource: z.string().default('admin'),
|
||||
replicaSet: z.string().optional(),
|
||||
poolSize: z.number().min(1).max(100).default(10),
|
||||
}).default({}),
|
||||
dragonfly: z.object({
|
||||
host: z.string().default('localhost'),
|
||||
port: z.number().default(6379),
|
||||
password: z.string().optional(),
|
||||
db: z.number().min(0).max(15).default(0),
|
||||
keyPrefix: z.string().optional(),
|
||||
ttl: z.number().optional(),
|
||||
maxRetries: z.number().default(3),
|
||||
retryDelay: z.number().default(100),
|
||||
}).default({}),
|
||||
}).default({});
|
||||
|
||||
// Flexible log schema with defaults (renamed from logging)
|
||||
const flexibleLogConfigSchema = z.object({
|
||||
level: z.enum(['trace', 'debug', 'info', 'warn', 'error', 'fatal']).default('info'),
|
||||
format: z.enum(['json', 'pretty']).default('json'),
|
||||
hideObject: z.boolean().default(false),
|
||||
loki: z.object({
|
||||
enabled: z.boolean().default(false),
|
||||
host: z.string().default('localhost'),
|
||||
port: z.number().default(3100),
|
||||
labels: z.record(z.string()).default({}),
|
||||
}).optional(),
|
||||
}).default({});
|
||||
|
||||
// Complete application configuration schema
|
||||
export const appConfigSchema = baseConfigSchema.extend({
|
||||
environment: environmentSchema.default('development'),
|
||||
service: flexibleServiceConfigSchema,
|
||||
log: flexibleLogConfigSchema,
|
||||
database: flexibleDatabaseConfigSchema,
|
||||
queue: queueConfigSchema.optional(),
|
||||
http: httpConfigSchema.optional(),
|
||||
providers: providerConfigSchema.optional(),
|
||||
webshare: webshareProviderConfigSchema.optional(),
|
||||
});
|
||||
|
||||
export type AppConfig = z.infer<typeof appConfigSchema>;
|
||||
74
libs/core/config/src/schemas/provider.schema.ts
Normal file
74
libs/core/config/src/schemas/provider.schema.ts
Normal file
|
|
@ -0,0 +1,74 @@
|
|||
import { z } from 'zod';
|
||||
|
||||
// Base provider configuration
|
||||
export const baseProviderConfigSchema = z.object({
|
||||
name: z.string(),
|
||||
enabled: z.boolean().default(true),
|
||||
priority: z.number().default(0),
|
||||
rateLimit: z.object({
|
||||
maxRequests: z.number().default(100),
|
||||
windowMs: z.number().default(60000),
|
||||
}).optional(),
|
||||
timeout: z.number().default(30000),
|
||||
retries: z.number().default(3),
|
||||
});
|
||||
|
||||
// EOD Historical Data provider
|
||||
export const eodProviderConfigSchema = baseProviderConfigSchema.extend({
|
||||
apiKey: z.string(),
|
||||
baseUrl: z.string().default('https://eodhistoricaldata.com/api'),
|
||||
tier: z.enum(['free', 'fundamentals', 'all-in-one']).default('free'),
|
||||
});
|
||||
|
||||
// Interactive Brokers provider
|
||||
export const ibProviderConfigSchema = baseProviderConfigSchema.extend({
|
||||
gateway: z.object({
|
||||
host: z.string().default('localhost'),
|
||||
port: z.number().default(5000),
|
||||
clientId: z.number().default(1),
|
||||
}),
|
||||
account: z.string().optional(),
|
||||
marketDataType: z.enum(['live', 'delayed', 'frozen']).default('delayed'),
|
||||
});
|
||||
|
||||
// QuoteMedia provider
|
||||
export const qmProviderConfigSchema = baseProviderConfigSchema.extend({
|
||||
username: z.string(),
|
||||
password: z.string(),
|
||||
baseUrl: z.string().default('https://app.quotemedia.com/quotetools'),
|
||||
webmasterId: z.string(),
|
||||
});
|
||||
|
||||
// Yahoo Finance provider
|
||||
export const yahooProviderConfigSchema = baseProviderConfigSchema.extend({
|
||||
baseUrl: z.string().default('https://query1.finance.yahoo.com'),
|
||||
cookieJar: z.boolean().default(true),
|
||||
crumb: z.string().optional(),
|
||||
});
|
||||
|
||||
// WebShare proxy provider
|
||||
export const webshareProviderConfigSchema = z.object({
|
||||
apiKey: z.string().optional(),
|
||||
apiUrl: z.string().default('https://proxy.webshare.io/api/v2/'),
|
||||
enabled: z.boolean().default(true),
|
||||
});
|
||||
|
||||
// Combined provider configuration
|
||||
export const providerConfigSchema = z.object({
|
||||
eod: eodProviderConfigSchema.optional(),
|
||||
ib: ibProviderConfigSchema.optional(),
|
||||
qm: qmProviderConfigSchema.optional(),
|
||||
yahoo: yahooProviderConfigSchema.optional(),
|
||||
webshare: webshareProviderConfigSchema.optional(),
|
||||
});
|
||||
|
||||
// Dynamic provider configuration type
|
||||
export type ProviderName = 'eod' | 'ib' | 'qm' | 'yahoo' | 'webshare';
|
||||
|
||||
export const providerSchemas = {
|
||||
eod: eodProviderConfigSchema,
|
||||
ib: ibProviderConfigSchema,
|
||||
qm: qmProviderConfigSchema,
|
||||
yahoo: yahooProviderConfigSchema,
|
||||
webshare: webshareProviderConfigSchema,
|
||||
} as const;
|
||||
63
libs/core/config/src/schemas/service.schema.ts
Normal file
63
libs/core/config/src/schemas/service.schema.ts
Normal file
|
|
@ -0,0 +1,63 @@
|
|||
import { z } from 'zod';
|
||||
|
||||
// Common service configuration
|
||||
export const serviceConfigSchema = z.object({
|
||||
name: z.string(),
|
||||
port: z.number().min(1).max(65535),
|
||||
host: z.string().default('0.0.0.0'),
|
||||
healthCheckPath: z.string().default('/health'),
|
||||
metricsPath: z.string().default('/metrics'),
|
||||
shutdownTimeout: z.number().default(30000),
|
||||
cors: z.object({
|
||||
enabled: z.boolean().default(true),
|
||||
origin: z.union([z.string(), z.array(z.string())]).default('*'),
|
||||
credentials: z.boolean().default(true),
|
||||
}).default({}),
|
||||
});
|
||||
|
||||
// Logging configuration
|
||||
export const loggingConfigSchema = z.object({
|
||||
level: z.enum(['trace', 'debug', 'info', 'warn', 'error', 'fatal']).default('info'),
|
||||
format: z.enum(['json', 'pretty']).default('json'),
|
||||
loki: z.object({
|
||||
enabled: z.boolean().default(false),
|
||||
host: z.string().default('localhost'),
|
||||
port: z.number().default(3100),
|
||||
labels: z.record(z.string()).default({}),
|
||||
}).optional(),
|
||||
});
|
||||
|
||||
// Queue configuration
|
||||
export const queueConfigSchema = z.object({
|
||||
redis: z.object({
|
||||
host: z.string().default('localhost'),
|
||||
port: z.number().default(6379),
|
||||
password: z.string().optional(),
|
||||
db: z.number().default(1),
|
||||
}),
|
||||
defaultJobOptions: z.object({
|
||||
attempts: z.number().default(3),
|
||||
backoff: z.object({
|
||||
type: z.enum(['exponential', 'fixed']).default('exponential'),
|
||||
delay: z.number().default(1000),
|
||||
}).default({}),
|
||||
removeOnComplete: z.number().default(10),
|
||||
removeOnFail: z.number().default(5),
|
||||
}).default({}),
|
||||
});
|
||||
|
||||
// HTTP client configuration
|
||||
export const httpConfigSchema = z.object({
|
||||
timeout: z.number().default(30000),
|
||||
retries: z.number().default(3),
|
||||
retryDelay: z.number().default(1000),
|
||||
userAgent: z.string().optional(),
|
||||
proxy: z.object({
|
||||
enabled: z.boolean().default(false),
|
||||
url: z.string().url().optional(),
|
||||
auth: z.object({
|
||||
username: z.string(),
|
||||
password: z.string(),
|
||||
}).optional(),
|
||||
}).optional(),
|
||||
});
|
||||
28
libs/core/config/src/types/index.ts
Normal file
28
libs/core/config/src/types/index.ts
Normal file
|
|
@ -0,0 +1,28 @@
|
|||
import { z } from 'zod';
|
||||
|
||||
export type Environment = 'development' | 'test' | 'production';
|
||||
|
||||
export interface ConfigLoader {
|
||||
load(): Record<string, unknown>;
|
||||
readonly priority: number;
|
||||
}
|
||||
|
||||
export interface ConfigManagerOptions {
|
||||
environment?: Environment;
|
||||
configPath?: string;
|
||||
loaders?: ConfigLoader[];
|
||||
}
|
||||
|
||||
export type DeepPartial<T> = T extends object
|
||||
? {
|
||||
[P in keyof T]?: DeepPartial<T[P]>;
|
||||
}
|
||||
: T;
|
||||
|
||||
export type ConfigSchema = z.ZodSchema<unknown>;
|
||||
|
||||
export interface ProviderConfig {
|
||||
name: string;
|
||||
enabled: boolean;
|
||||
[key: string]: unknown;
|
||||
}
|
||||
183
libs/core/config/src/utils/secrets.ts
Normal file
183
libs/core/config/src/utils/secrets.ts
Normal file
|
|
@ -0,0 +1,183 @@
|
|||
import { z } from 'zod';
|
||||
|
||||
/**
|
||||
* Secret value wrapper to prevent accidental logging
|
||||
*/
|
||||
export class SecretValue<T = string> {
|
||||
private readonly value: T;
|
||||
private readonly masked: string;
|
||||
|
||||
constructor(value: T, mask: string = '***') {
|
||||
this.value = value;
|
||||
this.masked = mask;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the actual secret value
|
||||
* @param reason - Required reason for accessing the secret
|
||||
*/
|
||||
reveal(reason: string): T {
|
||||
if (!reason) {
|
||||
throw new Error('Reason required for revealing secret value');
|
||||
}
|
||||
return this.value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get masked representation
|
||||
*/
|
||||
toString(): string {
|
||||
return this.masked;
|
||||
}
|
||||
|
||||
/**
|
||||
* Prevent JSON serialization of actual value
|
||||
*/
|
||||
toJSON(): string {
|
||||
return this.masked;
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if value matches without revealing it
|
||||
*/
|
||||
equals(other: T): boolean {
|
||||
return this.value === other;
|
||||
}
|
||||
|
||||
/**
|
||||
* Transform the secret value
|
||||
*/
|
||||
map<R>(fn: (value: T) => R, reason: string): SecretValue<R> {
|
||||
return new SecretValue(fn(this.reveal(reason)));
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Zod schema for secret values
|
||||
*/
|
||||
export const secretSchema = <T extends z.ZodTypeAny>(_schema: T) => {
|
||||
return z.custom<SecretValue<z.infer<T>>>(
|
||||
(val) => val instanceof SecretValue,
|
||||
{
|
||||
message: 'Expected SecretValue instance',
|
||||
}
|
||||
);
|
||||
};
|
||||
|
||||
/**
|
||||
* Transform string to SecretValue in Zod schema
|
||||
*/
|
||||
export const secretStringSchema = z
|
||||
.string()
|
||||
.transform((val) => new SecretValue(val));
|
||||
|
||||
/**
|
||||
* Create a secret value
|
||||
*/
|
||||
export function secret<T = string>(value: T, mask?: string): SecretValue<T> {
|
||||
return new SecretValue(value, mask);
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if a value is a secret
|
||||
*/
|
||||
export function isSecret(value: unknown): value is SecretValue {
|
||||
return value instanceof SecretValue;
|
||||
}
|
||||
|
||||
/**
|
||||
* Redact secrets from an object
|
||||
*/
|
||||
export function redactSecrets<T extends Record<string, any>>(
|
||||
obj: T,
|
||||
secretPaths: string[] = []
|
||||
): T {
|
||||
const result = { ...obj };
|
||||
|
||||
// Redact known secret paths
|
||||
for (const path of secretPaths) {
|
||||
const keys = path.split('.');
|
||||
let current: any = result;
|
||||
|
||||
for (let i = 0; i < keys.length - 1; i++) {
|
||||
const key = keys[i];
|
||||
if (key && current[key] && typeof current[key] === 'object') {
|
||||
current = current[key];
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
const lastKey = keys[keys.length - 1];
|
||||
if (current && lastKey && lastKey in current) {
|
||||
current[lastKey] = '***REDACTED***';
|
||||
}
|
||||
}
|
||||
|
||||
// Recursively redact SecretValue instances
|
||||
function redactSecretValues(obj: any): any {
|
||||
if (obj === null || obj === undefined) {
|
||||
return obj;
|
||||
}
|
||||
|
||||
if (isSecret(obj)) {
|
||||
return obj.toString();
|
||||
}
|
||||
|
||||
if (Array.isArray(obj)) {
|
||||
return obj.map(redactSecretValues);
|
||||
}
|
||||
|
||||
if (typeof obj === 'object') {
|
||||
const result: any = {};
|
||||
for (const [key, value] of Object.entries(obj)) {
|
||||
result[key] = redactSecretValues(value);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
return obj;
|
||||
}
|
||||
|
||||
return redactSecretValues(result);
|
||||
}
|
||||
|
||||
/**
|
||||
* Environment variable names that should be treated as secrets
|
||||
*/
|
||||
export const COMMON_SECRET_PATTERNS = [
|
||||
/password/i,
|
||||
/secret/i,
|
||||
/key/i,
|
||||
/token/i,
|
||||
/credential/i,
|
||||
/private/i,
|
||||
/auth/i,
|
||||
/api[-_]?key/i,
|
||||
];
|
||||
|
||||
/**
|
||||
* Check if an environment variable name indicates a secret
|
||||
*/
|
||||
export function isSecretEnvVar(name: string): boolean {
|
||||
return COMMON_SECRET_PATTERNS.some(pattern => pattern.test(name));
|
||||
}
|
||||
|
||||
/**
|
||||
* Wrap environment variables that look like secrets
|
||||
*/
|
||||
export function wrapSecretEnvVars(
|
||||
env: Record<string, string | undefined>
|
||||
): Record<string, string | SecretValue | undefined> {
|
||||
const result: Record<string, string | SecretValue | undefined> = {};
|
||||
|
||||
for (const [key, value] of Object.entries(env)) {
|
||||
if (value !== undefined && isSecretEnvVar(key)) {
|
||||
result[key] = new SecretValue(value, `***${key}***`);
|
||||
} else {
|
||||
result[key] = value;
|
||||
}
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
195
libs/core/config/src/utils/validation.ts
Normal file
195
libs/core/config/src/utils/validation.ts
Normal file
|
|
@ -0,0 +1,195 @@
|
|||
import { z } from 'zod';
|
||||
|
||||
export interface ValidationResult {
|
||||
valid: boolean;
|
||||
errors?: Array<{
|
||||
path: string;
|
||||
message: string;
|
||||
expected?: string;
|
||||
received?: string;
|
||||
}>;
|
||||
warnings?: Array<{
|
||||
path: string;
|
||||
message: string;
|
||||
}>;
|
||||
}
|
||||
|
||||
/**
|
||||
* Validate configuration against a schema
|
||||
*/
|
||||
export function validateConfig<T>(
|
||||
config: unknown,
|
||||
schema: z.ZodSchema<T>
|
||||
): ValidationResult {
|
||||
try {
|
||||
schema.parse(config);
|
||||
return { valid: true };
|
||||
} catch (error) {
|
||||
if (error instanceof z.ZodError) {
|
||||
const errors = error.errors.map(err => ({
|
||||
path: err.path.join('.'),
|
||||
message: err.message,
|
||||
expected: 'expected' in err ? String(err.expected) : undefined,
|
||||
received: 'received' in err ? String(err.received) : undefined,
|
||||
}));
|
||||
|
||||
return { valid: false, errors };
|
||||
}
|
||||
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Check for deprecated configuration options
|
||||
*/
|
||||
export function checkDeprecations(
|
||||
config: Record<string, unknown>,
|
||||
deprecations: Record<string, string>
|
||||
): ValidationResult['warnings'] {
|
||||
const warnings: ValidationResult['warnings'] = [];
|
||||
|
||||
function checkObject(obj: Record<string, unknown>, path: string[] = []): void {
|
||||
for (const [key, value] of Object.entries(obj)) {
|
||||
const currentPath = [...path, key];
|
||||
const pathStr = currentPath.join('.');
|
||||
|
||||
if (pathStr in deprecations) {
|
||||
const deprecationMessage = deprecations[pathStr];
|
||||
if (deprecationMessage) {
|
||||
warnings?.push({
|
||||
path: pathStr,
|
||||
message: deprecationMessage,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
if (value && typeof value === 'object' && !Array.isArray(value)) {
|
||||
checkObject(value as Record<string, unknown>, currentPath);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
checkObject(config);
|
||||
return warnings;
|
||||
}
|
||||
|
||||
/**
|
||||
* Check for required environment variables
|
||||
*/
|
||||
export function checkRequiredEnvVars(
|
||||
required: string[]
|
||||
): ValidationResult {
|
||||
const errors: ValidationResult['errors'] = [];
|
||||
|
||||
for (const envVar of required) {
|
||||
if (!process.env[envVar]) {
|
||||
errors.push({
|
||||
path: `env.${envVar}`,
|
||||
message: `Required environment variable ${envVar} is not set`,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
return {
|
||||
valid: errors.length === 0,
|
||||
errors: errors.length > 0 ? errors : undefined,
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Validate configuration completeness
|
||||
*/
|
||||
export function validateCompleteness(
|
||||
config: Record<string, any>,
|
||||
required: string[]
|
||||
): ValidationResult {
|
||||
const errors: ValidationResult['errors'] = [];
|
||||
|
||||
for (const path of required) {
|
||||
const keys = path.split('.');
|
||||
let current: any = config;
|
||||
let found = true;
|
||||
|
||||
for (const key of keys) {
|
||||
if (current && typeof current === 'object' && key in current) {
|
||||
current = current[key];
|
||||
} else {
|
||||
found = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (!found || current === undefined || current === null) {
|
||||
errors.push({
|
||||
path,
|
||||
message: `Required configuration value is missing`,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
return {
|
||||
valid: errors.length === 0,
|
||||
errors: errors.length > 0 ? errors : undefined,
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Format validation result for display
|
||||
*/
|
||||
export function formatValidationResult(result: ValidationResult): string {
|
||||
const lines: string[] = [];
|
||||
|
||||
if (result.valid) {
|
||||
lines.push('✅ Configuration is valid');
|
||||
} else {
|
||||
lines.push('❌ Configuration validation failed');
|
||||
}
|
||||
|
||||
if (result.errors && result.errors.length > 0) {
|
||||
lines.push('\nErrors:');
|
||||
for (const error of result.errors) {
|
||||
lines.push(` - ${error.path}: ${error.message}`);
|
||||
if (error.expected && error.received) {
|
||||
lines.push(` Expected: ${error.expected}, Received: ${error.received}`);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (result.warnings && result.warnings.length > 0) {
|
||||
lines.push('\nWarnings:');
|
||||
for (const warning of result.warnings) {
|
||||
lines.push(` - ${warning.path}: ${warning.message}`);
|
||||
}
|
||||
}
|
||||
|
||||
return lines.join('\n');
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a strict schema that doesn't allow extra properties
|
||||
*/
|
||||
export function createStrictSchema<T extends z.ZodRawShape>(
|
||||
shape: T
|
||||
): z.ZodObject<T, 'strict'> {
|
||||
return z.object(shape).strict();
|
||||
}
|
||||
|
||||
/**
|
||||
* Merge multiple schemas
|
||||
*/
|
||||
export function mergeSchemas<T extends z.ZodSchema[]>(
|
||||
...schemas: T
|
||||
): z.ZodIntersection<T[0], T[1]> {
|
||||
if (schemas.length < 2) {
|
||||
throw new Error('At least two schemas required for merge');
|
||||
}
|
||||
|
||||
let result = schemas[0]!.and(schemas[1]!);
|
||||
|
||||
for (let i = 2; i < schemas.length; i++) {
|
||||
result = result.and(schemas[i]!) as any;
|
||||
}
|
||||
|
||||
return result as any;
|
||||
}
|
||||
215
libs/core/config/test/config-manager.test.ts
Normal file
215
libs/core/config/test/config-manager.test.ts
Normal file
|
|
@ -0,0 +1,215 @@
|
|||
import { describe, test, expect, beforeEach } from 'bun:test';
|
||||
import { z } from 'zod';
|
||||
import { ConfigManager } from '../src/config-manager';
|
||||
import { ConfigLoader } from '../src/types';
|
||||
import { ConfigValidationError } from '../src/errors';
|
||||
|
||||
// Mock loader for testing
|
||||
class MockLoader implements ConfigLoader {
|
||||
priority = 0;
|
||||
|
||||
constructor(
|
||||
private data: Record<string, unknown>,
|
||||
public override priority: number = 0
|
||||
) {}
|
||||
|
||||
async load(): Promise<Record<string, unknown>> {
|
||||
return this.data;
|
||||
}
|
||||
}
|
||||
|
||||
// Test schema
|
||||
const testSchema = z.object({
|
||||
app: z.object({
|
||||
name: z.string(),
|
||||
version: z.string(),
|
||||
port: z.number().positive(),
|
||||
}),
|
||||
database: z.object({
|
||||
host: z.string(),
|
||||
port: z.number(),
|
||||
}),
|
||||
environment: z.enum(['development', 'test', 'production']),
|
||||
});
|
||||
|
||||
type TestConfig = z.infer<typeof testSchema>;
|
||||
|
||||
describe('ConfigManager', () => {
|
||||
let manager: ConfigManager<TestConfig>;
|
||||
|
||||
beforeEach(() => {
|
||||
manager = new ConfigManager<TestConfig>({
|
||||
loaders: [
|
||||
new MockLoader({
|
||||
app: {
|
||||
name: 'test-app',
|
||||
version: '1.0.0',
|
||||
port: 3000,
|
||||
},
|
||||
database: {
|
||||
host: 'localhost',
|
||||
port: 5432,
|
||||
},
|
||||
}),
|
||||
],
|
||||
environment: 'test',
|
||||
});
|
||||
});
|
||||
|
||||
test('should initialize configuration', async () => {
|
||||
const config = await manager.initialize(testSchema);
|
||||
|
||||
expect(config.app.name).toBe('test-app');
|
||||
expect(config.app.version).toBe('1.0.0');
|
||||
expect(config.environment).toBe('test');
|
||||
});
|
||||
|
||||
test('should merge multiple loaders by priority', async () => {
|
||||
manager = new ConfigManager<TestConfig>({
|
||||
loaders: [
|
||||
new MockLoader({ app: { name: 'base', port: 3000 } }, 0),
|
||||
new MockLoader({ app: { name: 'override', version: '2.0.0' } }, 10),
|
||||
new MockLoader({ database: { host: 'prod-db' } }, 5),
|
||||
],
|
||||
environment: 'test',
|
||||
});
|
||||
|
||||
const config = await manager.initialize();
|
||||
|
||||
expect(config.app.name).toBe('override');
|
||||
expect(config.app.version).toBe('2.0.0');
|
||||
expect(config.app.port).toBe(3000);
|
||||
expect(config.database.host).toBe('prod-db');
|
||||
});
|
||||
|
||||
test('should validate configuration with schema', async () => {
|
||||
manager = new ConfigManager<TestConfig>({
|
||||
loaders: [
|
||||
new MockLoader({
|
||||
app: {
|
||||
name: 'test-app',
|
||||
version: '1.0.0',
|
||||
port: 'invalid', // Should be number
|
||||
},
|
||||
}),
|
||||
],
|
||||
});
|
||||
|
||||
await expect(manager.initialize(testSchema)).rejects.toThrow(ConfigValidationError);
|
||||
});
|
||||
|
||||
test('should get configuration value by path', async () => {
|
||||
await manager.initialize(testSchema);
|
||||
|
||||
expect(manager.getValue('app.name')).toBe('test-app');
|
||||
expect(manager.getValue<number>('database.port')).toBe(5432);
|
||||
});
|
||||
|
||||
test('should check if configuration path exists', async () => {
|
||||
await manager.initialize(testSchema);
|
||||
|
||||
expect(manager.has('app.name')).toBe(true);
|
||||
expect(manager.has('app.nonexistent')).toBe(false);
|
||||
});
|
||||
|
||||
test('should update configuration at runtime', async () => {
|
||||
await manager.initialize(testSchema);
|
||||
|
||||
manager.set({
|
||||
app: {
|
||||
name: 'updated-app',
|
||||
},
|
||||
});
|
||||
|
||||
const config = manager.get();
|
||||
expect(config.app.name).toBe('updated-app');
|
||||
expect(config.app.version).toBe('1.0.0'); // Should preserve other values
|
||||
});
|
||||
|
||||
test('should validate updates against schema', async () => {
|
||||
await manager.initialize(testSchema);
|
||||
|
||||
expect(() => {
|
||||
manager.set({
|
||||
app: {
|
||||
port: 'invalid' as any,
|
||||
},
|
||||
});
|
||||
}).toThrow(ConfigValidationError);
|
||||
});
|
||||
|
||||
test('should reset configuration', async () => {
|
||||
await manager.initialize(testSchema);
|
||||
manager.reset();
|
||||
|
||||
expect(() => manager.get()).toThrow('Configuration not initialized');
|
||||
});
|
||||
|
||||
test('should create typed getter', async () => {
|
||||
await manager.initialize(testSchema);
|
||||
|
||||
const appSchema = z.object({
|
||||
app: z.object({
|
||||
name: z.string(),
|
||||
version: z.string(),
|
||||
}),
|
||||
});
|
||||
|
||||
const getAppConfig = manager.createTypedGetter(appSchema);
|
||||
const appConfig = getAppConfig();
|
||||
|
||||
expect(appConfig.app.name).toBe('test-app');
|
||||
});
|
||||
|
||||
test('should detect environment correctly', () => {
|
||||
const originalEnv = process.env.NODE_ENV;
|
||||
|
||||
process.env.NODE_ENV = 'production';
|
||||
const prodManager = new ConfigManager({ loaders: [] });
|
||||
expect(prodManager.getEnvironment()).toBe('production');
|
||||
|
||||
process.env.NODE_ENV = 'test';
|
||||
const testManager = new ConfigManager({ loaders: [] });
|
||||
expect(testManager.getEnvironment()).toBe('test');
|
||||
|
||||
process.env.NODE_ENV = originalEnv;
|
||||
});
|
||||
|
||||
test('should handle deep merge correctly', async () => {
|
||||
manager = new ConfigManager({
|
||||
loaders: [
|
||||
new MockLoader({
|
||||
app: {
|
||||
settings: {
|
||||
feature1: true,
|
||||
feature2: false,
|
||||
nested: {
|
||||
value: 'base',
|
||||
},
|
||||
},
|
||||
},
|
||||
}, 0),
|
||||
new MockLoader({
|
||||
app: {
|
||||
settings: {
|
||||
feature2: true,
|
||||
feature3: true,
|
||||
nested: {
|
||||
value: 'override',
|
||||
extra: 'new',
|
||||
},
|
||||
},
|
||||
},
|
||||
}, 10),
|
||||
],
|
||||
});
|
||||
|
||||
const config = await manager.initialize();
|
||||
|
||||
expect(config.app.settings.feature1).toBe(true);
|
||||
expect(config.app.settings.feature2).toBe(true);
|
||||
expect(config.app.settings.feature3).toBe(true);
|
||||
expect(config.app.settings.nested.value).toBe('override');
|
||||
expect(config.app.settings.nested.extra).toBe('new');
|
||||
});
|
||||
});
|
||||
386
libs/core/config/test/dynamic-location.test.ts
Normal file
386
libs/core/config/test/dynamic-location.test.ts
Normal file
|
|
@ -0,0 +1,386 @@
|
|||
import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
|
||||
import { join } from 'path';
|
||||
import { mkdirSync, writeFileSync, rmSync, existsSync } from 'fs';
|
||||
import { ConfigManager } from '../src/config-manager';
|
||||
import { FileLoader } from '../src/loaders/file.loader';
|
||||
import { EnvLoader } from '../src/loaders/env.loader';
|
||||
import { initializeConfig, initializeServiceConfig, resetConfig } from '../src/index';
|
||||
import { appConfigSchema } from '../src/schemas';
|
||||
|
||||
// Test directories setup
|
||||
const TEST_ROOT = join(__dirname, 'test-scenarios');
|
||||
const SCENARIOS = {
|
||||
monorepoRoot: join(TEST_ROOT, 'monorepo'),
|
||||
appService: join(TEST_ROOT, 'monorepo', 'apps', 'test-service'),
|
||||
libService: join(TEST_ROOT, 'monorepo', 'libs', 'test-lib'),
|
||||
nestedService: join(TEST_ROOT, 'monorepo', 'apps', 'nested', 'deep-service'),
|
||||
standalone: join(TEST_ROOT, 'standalone'),
|
||||
};
|
||||
|
||||
describe('Dynamic Location Config Loading', () => {
|
||||
beforeEach(() => {
|
||||
// Clean up any existing test directories
|
||||
if (existsSync(TEST_ROOT)) {
|
||||
rmSync(TEST_ROOT, { recursive: true, force: true });
|
||||
}
|
||||
|
||||
// Reset config singleton
|
||||
resetConfig();
|
||||
|
||||
// Create test directory structure
|
||||
setupTestScenarios();
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
// Clean up test directories
|
||||
if (existsSync(TEST_ROOT)) {
|
||||
rmSync(TEST_ROOT, { recursive: true, force: true });
|
||||
}
|
||||
|
||||
// Reset config singleton
|
||||
resetConfig();
|
||||
});
|
||||
|
||||
test('should load config from monorepo root', async () => {
|
||||
const originalCwd = process.cwd();
|
||||
|
||||
try {
|
||||
// Change to monorepo root
|
||||
process.chdir(SCENARIOS.monorepoRoot);
|
||||
|
||||
const config = await initializeConfig();
|
||||
|
||||
expect(config.name).toBe('monorepo-root');
|
||||
expect(config.version).toBe('1.0.0');
|
||||
expect(config.database.postgres.host).toBe('localhost');
|
||||
} finally {
|
||||
process.chdir(originalCwd);
|
||||
}
|
||||
});
|
||||
|
||||
test('should load config from app service directory', async () => {
|
||||
const originalCwd = process.cwd();
|
||||
|
||||
try {
|
||||
// Change to app service directory
|
||||
process.chdir(SCENARIOS.appService);
|
||||
|
||||
const config = await initializeServiceConfig();
|
||||
|
||||
// Should inherit from root + override with service config
|
||||
expect(config.name).toBe('test-service'); // Overridden by service
|
||||
expect(config.version).toBe('1.0.0'); // From root
|
||||
expect(config.database.postgres.host).toBe('service-db'); // Overridden by service
|
||||
expect(config.service.port).toBe(4000); // Service-specific
|
||||
} finally {
|
||||
process.chdir(originalCwd);
|
||||
}
|
||||
});
|
||||
|
||||
test('should load config from lib directory', async () => {
|
||||
const originalCwd = process.cwd();
|
||||
|
||||
try {
|
||||
// Change to lib directory
|
||||
process.chdir(SCENARIOS.libService);
|
||||
|
||||
const config = await initializeServiceConfig();
|
||||
|
||||
// Should inherit from root + override with lib config
|
||||
expect(config.name).toBe('test-lib'); // Overridden by lib
|
||||
expect(config.version).toBe('2.0.0'); // Overridden by lib
|
||||
expect(config.database.postgres.host).toBe('localhost'); // From root
|
||||
expect(config.service.port).toBe(5000); // Lib-specific
|
||||
} finally {
|
||||
process.chdir(originalCwd);
|
||||
}
|
||||
});
|
||||
|
||||
test('should load config from deeply nested service', async () => {
|
||||
const originalCwd = process.cwd();
|
||||
|
||||
try {
|
||||
// Change to nested service directory
|
||||
process.chdir(SCENARIOS.nestedService);
|
||||
|
||||
const config = await initializeServiceConfig();
|
||||
|
||||
// Should inherit from root + override with nested service config
|
||||
expect(config.name).toBe('deep-service'); // Overridden by nested service
|
||||
// NOTE: Version inheritance doesn't work for deeply nested services (3+ levels)
|
||||
// because initializeServiceConfig() uses hardcoded '../../config' path
|
||||
expect(config.version).toBeUndefined(); // Not inherited due to path limitation
|
||||
expect(config.database.postgres.host).toBe('deep-db'); // Overridden by nested service
|
||||
expect(config.service.port).toBe(6000); // Nested service-specific
|
||||
} finally {
|
||||
process.chdir(originalCwd);
|
||||
}
|
||||
});
|
||||
|
||||
test('should load config from standalone project', async () => {
|
||||
const originalCwd = process.cwd();
|
||||
|
||||
try {
|
||||
// Change to standalone directory
|
||||
process.chdir(SCENARIOS.standalone);
|
||||
|
||||
const config = await initializeConfig();
|
||||
|
||||
expect(config.name).toBe('standalone-app');
|
||||
expect(config.version).toBe('0.1.0');
|
||||
expect(config.database.postgres.host).toBe('standalone-db');
|
||||
} finally {
|
||||
process.chdir(originalCwd);
|
||||
}
|
||||
});
|
||||
|
||||
test('should handle missing config files gracefully', async () => {
|
||||
const originalCwd = process.cwd();
|
||||
|
||||
try {
|
||||
// Change to directory with no config files
|
||||
const emptyDir = join(TEST_ROOT, 'empty');
|
||||
mkdirSync(emptyDir, { recursive: true });
|
||||
process.chdir(emptyDir);
|
||||
|
||||
// Should not throw but use defaults and env vars
|
||||
const config = await initializeConfig();
|
||||
|
||||
// Should have default values from schema
|
||||
expect(config.environment).toBe('test'); // Tests run with NODE_ENV=test
|
||||
expect(typeof config.service).toBe('object');
|
||||
} finally {
|
||||
process.chdir(originalCwd);
|
||||
}
|
||||
});
|
||||
|
||||
test('should prioritize environment variables over file configs', async () => {
|
||||
const originalCwd = process.cwd();
|
||||
const originalEnv = { ...process.env };
|
||||
|
||||
try {
|
||||
// Set environment variables
|
||||
process.env.NAME = 'env-override';
|
||||
process.env.VERSION = '3.0.0';
|
||||
process.env.DATABASE_POSTGRES_HOST = 'env-db';
|
||||
|
||||
process.chdir(SCENARIOS.appService);
|
||||
|
||||
resetConfig(); // Reset to test env override
|
||||
const config = await initializeServiceConfig();
|
||||
|
||||
// Environment variables should override file configs
|
||||
expect(config.name).toBe('env-override');
|
||||
expect(config.version).toBe('3.0.0');
|
||||
expect(config.database.postgres.host).toBe('env-db');
|
||||
} finally {
|
||||
process.chdir(originalCwd);
|
||||
process.env = originalEnv;
|
||||
}
|
||||
});
|
||||
|
||||
test('should work with custom config paths', async () => {
|
||||
const originalCwd = process.cwd();
|
||||
|
||||
try {
|
||||
process.chdir(SCENARIOS.monorepoRoot);
|
||||
|
||||
// Initialize with custom config path
|
||||
resetConfig();
|
||||
const manager = new ConfigManager({
|
||||
configPath: join(SCENARIOS.appService, 'config')
|
||||
});
|
||||
|
||||
const config = await manager.initialize(appConfigSchema);
|
||||
|
||||
// Should load from the custom path
|
||||
expect(config.name).toBe('test-service');
|
||||
expect(config.service.port).toBe(4000);
|
||||
} finally {
|
||||
process.chdir(originalCwd);
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
function setupTestScenarios() {
|
||||
// Create monorepo structure
|
||||
mkdirSync(SCENARIOS.monorepoRoot, { recursive: true });
|
||||
mkdirSync(join(SCENARIOS.monorepoRoot, 'config'), { recursive: true });
|
||||
mkdirSync(join(SCENARIOS.appService, 'config'), { recursive: true });
|
||||
mkdirSync(join(SCENARIOS.libService, 'config'), { recursive: true });
|
||||
mkdirSync(join(SCENARIOS.nestedService, 'config'), { recursive: true });
|
||||
mkdirSync(join(SCENARIOS.standalone, 'config'), { recursive: true });
|
||||
|
||||
// Root config (create for both development and test environments)
|
||||
const rootConfig = {
|
||||
name: 'monorepo-root',
|
||||
version: '1.0.0',
|
||||
service: {
|
||||
name: 'monorepo-root',
|
||||
port: 3000
|
||||
},
|
||||
database: {
|
||||
postgres: {
|
||||
host: 'localhost',
|
||||
port: 5432,
|
||||
database: 'test_db',
|
||||
user: 'test_user',
|
||||
password: 'test_pass'
|
||||
},
|
||||
questdb: {
|
||||
host: 'localhost',
|
||||
ilpPort: 9009
|
||||
},
|
||||
mongodb: {
|
||||
host: 'localhost',
|
||||
port: 27017,
|
||||
database: 'test_mongo'
|
||||
},
|
||||
dragonfly: {
|
||||
host: 'localhost',
|
||||
port: 6379
|
||||
}
|
||||
},
|
||||
logging: {
|
||||
level: 'info'
|
||||
}
|
||||
};
|
||||
|
||||
writeFileSync(
|
||||
join(SCENARIOS.monorepoRoot, 'config', 'development.json'),
|
||||
JSON.stringify(rootConfig, null, 2)
|
||||
);
|
||||
|
||||
writeFileSync(
|
||||
join(SCENARIOS.monorepoRoot, 'config', 'test.json'),
|
||||
JSON.stringify(rootConfig, null, 2)
|
||||
);
|
||||
|
||||
// App service config
|
||||
const appServiceConfig = {
|
||||
name: 'test-service',
|
||||
database: {
|
||||
postgres: {
|
||||
host: 'service-db'
|
||||
}
|
||||
},
|
||||
service: {
|
||||
name: 'test-service',
|
||||
port: 4000
|
||||
}
|
||||
};
|
||||
|
||||
writeFileSync(
|
||||
join(SCENARIOS.appService, 'config', 'development.json'),
|
||||
JSON.stringify(appServiceConfig, null, 2)
|
||||
);
|
||||
|
||||
writeFileSync(
|
||||
join(SCENARIOS.appService, 'config', 'test.json'),
|
||||
JSON.stringify(appServiceConfig, null, 2)
|
||||
);
|
||||
|
||||
// Lib config
|
||||
const libServiceConfig = {
|
||||
name: 'test-lib',
|
||||
version: '2.0.0',
|
||||
service: {
|
||||
name: 'test-lib',
|
||||
port: 5000
|
||||
}
|
||||
};
|
||||
|
||||
writeFileSync(
|
||||
join(SCENARIOS.libService, 'config', 'development.json'),
|
||||
JSON.stringify(libServiceConfig, null, 2)
|
||||
);
|
||||
|
||||
writeFileSync(
|
||||
join(SCENARIOS.libService, 'config', 'test.json'),
|
||||
JSON.stringify(libServiceConfig, null, 2)
|
||||
);
|
||||
|
||||
// Nested service config
|
||||
const nestedServiceConfig = {
|
||||
name: 'deep-service',
|
||||
database: {
|
||||
postgres: {
|
||||
host: 'deep-db'
|
||||
}
|
||||
},
|
||||
service: {
|
||||
name: 'deep-service',
|
||||
port: 6000
|
||||
}
|
||||
};
|
||||
|
||||
writeFileSync(
|
||||
join(SCENARIOS.nestedService, 'config', 'development.json'),
|
||||
JSON.stringify(nestedServiceConfig, null, 2)
|
||||
);
|
||||
|
||||
writeFileSync(
|
||||
join(SCENARIOS.nestedService, 'config', 'test.json'),
|
||||
JSON.stringify(nestedServiceConfig, null, 2)
|
||||
);
|
||||
|
||||
// Standalone config
|
||||
const standaloneConfig = {
|
||||
name: 'standalone-app',
|
||||
version: '0.1.0',
|
||||
service: {
|
||||
name: 'standalone-app',
|
||||
port: 7000
|
||||
},
|
||||
database: {
|
||||
postgres: {
|
||||
host: 'standalone-db',
|
||||
port: 5432,
|
||||
database: 'standalone_db',
|
||||
user: 'standalone_user',
|
||||
password: 'standalone_pass'
|
||||
},
|
||||
questdb: {
|
||||
host: 'localhost',
|
||||
ilpPort: 9009
|
||||
},
|
||||
mongodb: {
|
||||
host: 'localhost',
|
||||
port: 27017,
|
||||
database: 'standalone_mongo'
|
||||
},
|
||||
dragonfly: {
|
||||
host: 'localhost',
|
||||
port: 6379
|
||||
}
|
||||
},
|
||||
logging: {
|
||||
level: 'debug'
|
||||
}
|
||||
};
|
||||
|
||||
writeFileSync(
|
||||
join(SCENARIOS.standalone, 'config', 'development.json'),
|
||||
JSON.stringify(standaloneConfig, null, 2)
|
||||
);
|
||||
|
||||
writeFileSync(
|
||||
join(SCENARIOS.standalone, 'config', 'test.json'),
|
||||
JSON.stringify(standaloneConfig, null, 2)
|
||||
);
|
||||
|
||||
// Add .env files for testing
|
||||
writeFileSync(
|
||||
join(SCENARIOS.monorepoRoot, '.env'),
|
||||
`NODE_ENV=development
|
||||
DEBUG=true
|
||||
`
|
||||
);
|
||||
|
||||
writeFileSync(
|
||||
join(SCENARIOS.appService, '.env'),
|
||||
`SERVICE_DEBUG=true
|
||||
APP_EXTRA_FEATURE=enabled
|
||||
`
|
||||
);
|
||||
}
|
||||
384
libs/core/config/test/edge-cases.test.ts
Normal file
384
libs/core/config/test/edge-cases.test.ts
Normal file
|
|
@ -0,0 +1,384 @@
|
|||
import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
|
||||
import { join } from 'path';
|
||||
import { mkdirSync, writeFileSync, rmSync, existsSync, chmodSync } from 'fs';
|
||||
import { ConfigManager } from '../src/config-manager';
|
||||
import { FileLoader } from '../src/loaders/file.loader';
|
||||
import { EnvLoader } from '../src/loaders/env.loader';
|
||||
import { initializeConfig, initializeServiceConfig, resetConfig } from '../src/index';
|
||||
import { appConfigSchema } from '../src/schemas';
|
||||
import { ConfigError, ConfigValidationError } from '../src/errors';
|
||||
|
||||
const TEST_DIR = join(__dirname, 'edge-case-tests');
|
||||
|
||||
describe('Edge Cases and Error Handling', () => {
|
||||
let originalEnv: NodeJS.ProcessEnv;
|
||||
let originalCwd: string;
|
||||
|
||||
beforeEach(() => {
|
||||
originalEnv = { ...process.env };
|
||||
originalCwd = process.cwd();
|
||||
|
||||
resetConfig();
|
||||
|
||||
if (existsSync(TEST_DIR)) {
|
||||
rmSync(TEST_DIR, { recursive: true, force: true });
|
||||
}
|
||||
mkdirSync(TEST_DIR, { recursive: true });
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
process.env = originalEnv;
|
||||
process.chdir(originalCwd);
|
||||
resetConfig();
|
||||
|
||||
if (existsSync(TEST_DIR)) {
|
||||
rmSync(TEST_DIR, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
|
||||
test('should handle missing .env files gracefully', async () => {
|
||||
// No .env file exists
|
||||
const manager = new ConfigManager({
|
||||
loaders: [new EnvLoader('')]
|
||||
});
|
||||
|
||||
// Should not throw even without .env file
|
||||
const config = await manager.initialize(appConfigSchema);
|
||||
expect(config).toBeDefined();
|
||||
});
|
||||
|
||||
test('should handle corrupted JSON config files', async () => {
|
||||
const configDir = join(TEST_DIR, 'config');
|
||||
mkdirSync(configDir, { recursive: true });
|
||||
|
||||
// Create corrupted JSON file
|
||||
writeFileSync(
|
||||
join(configDir, 'development.json'),
|
||||
'{ "app": { "name": "test", invalid json }'
|
||||
);
|
||||
|
||||
const manager = new ConfigManager({
|
||||
loaders: [new FileLoader(configDir, 'development')]
|
||||
});
|
||||
|
||||
// Should throw error for invalid JSON
|
||||
await expect(manager.initialize(appConfigSchema)).rejects.toThrow();
|
||||
});
|
||||
|
||||
test('should handle missing config directories', async () => {
|
||||
const nonExistentDir = join(TEST_DIR, 'nonexistent');
|
||||
|
||||
const manager = new ConfigManager({
|
||||
loaders: [new FileLoader(nonExistentDir, 'development')]
|
||||
});
|
||||
|
||||
// Should not throw, should return empty config
|
||||
const config = await manager.initialize();
|
||||
expect(config).toBeDefined();
|
||||
});
|
||||
|
||||
test('should handle permission denied on config files', async () => {
|
||||
const configDir = join(TEST_DIR, 'config');
|
||||
mkdirSync(configDir, { recursive: true });
|
||||
|
||||
const configFile = join(configDir, 'development.json');
|
||||
writeFileSync(configFile, JSON.stringify({ app: { name: 'test' } }));
|
||||
|
||||
// Make file unreadable (this might not work on all systems)
|
||||
try {
|
||||
chmodSync(configFile, 0o000);
|
||||
|
||||
const manager = new ConfigManager({
|
||||
loaders: [new FileLoader(configDir, 'development')]
|
||||
});
|
||||
|
||||
// Should handle permission error gracefully
|
||||
const config = await manager.initialize();
|
||||
expect(config).toBeDefined();
|
||||
} finally {
|
||||
// Restore permissions for cleanup
|
||||
try {
|
||||
chmodSync(configFile, 0o644);
|
||||
} catch {
|
||||
// Ignore errors during cleanup
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
test('should handle circular references in config merging', async () => {
|
||||
// This tests deep merge with potential circular references
|
||||
const configDir = join(TEST_DIR, 'config');
|
||||
mkdirSync(configDir, { recursive: true });
|
||||
|
||||
writeFileSync(
|
||||
join(configDir, 'development.json'),
|
||||
JSON.stringify({
|
||||
app: {
|
||||
name: 'test',
|
||||
settings: {
|
||||
ref: 'settings'
|
||||
}
|
||||
}
|
||||
})
|
||||
);
|
||||
|
||||
process.env.APP_SETTINGS_NESTED_VALUE = 'deep-value';
|
||||
|
||||
const manager = new ConfigManager({
|
||||
loaders: [
|
||||
new FileLoader(configDir, 'development'),
|
||||
new EnvLoader('')
|
||||
]
|
||||
});
|
||||
|
||||
const config = await manager.initialize(appConfigSchema);
|
||||
expect(config.app.name).toBe('test');
|
||||
});
|
||||
|
||||
test('should handle extremely deep nesting in environment variables', async () => {
|
||||
// Test very deep nesting
|
||||
process.env.LEVEL1_LEVEL2_LEVEL3_LEVEL4_LEVEL5_VALUE = 'deep-value';
|
||||
|
||||
const manager = new ConfigManager({
|
||||
loaders: [new EnvLoader('', { nestedDelimiter: '_' })]
|
||||
});
|
||||
|
||||
const config = await manager.initialize();
|
||||
|
||||
// Should create nested structure
|
||||
expect((config as any).level1?.level2?.level3?.level4?.level5?.value).toBe('deep-value');
|
||||
});
|
||||
|
||||
test('should handle conflicting data types in config merging', async () => {
|
||||
const configDir = join(TEST_DIR, 'config');
|
||||
mkdirSync(configDir, { recursive: true });
|
||||
|
||||
// File config has object
|
||||
writeFileSync(
|
||||
join(configDir, 'development.json'),
|
||||
JSON.stringify({
|
||||
database: {
|
||||
host: 'localhost',
|
||||
port: 5432
|
||||
}
|
||||
})
|
||||
);
|
||||
|
||||
// Environment variable tries to override with string
|
||||
process.env.DATABASE = 'simple-string';
|
||||
|
||||
const manager = new ConfigManager({
|
||||
loaders: [
|
||||
new FileLoader(configDir, 'development'),
|
||||
new EnvLoader('')
|
||||
]
|
||||
});
|
||||
|
||||
const config = await manager.initialize(appConfigSchema);
|
||||
|
||||
// Environment variable should win
|
||||
expect(config.database).toBe('simple-string');
|
||||
});
|
||||
|
||||
test('should handle different working directories', async () => {
|
||||
// Create multiple config setups in different directories
|
||||
const dir1 = join(TEST_DIR, 'dir1');
|
||||
const dir2 = join(TEST_DIR, 'dir2');
|
||||
|
||||
mkdirSync(join(dir1, 'config'), { recursive: true });
|
||||
mkdirSync(join(dir2, 'config'), { recursive: true });
|
||||
|
||||
writeFileSync(
|
||||
join(dir1, 'config', 'development.json'),
|
||||
JSON.stringify({ app: { name: 'dir1-app' } })
|
||||
);
|
||||
|
||||
writeFileSync(
|
||||
join(dir2, 'config', 'development.json'),
|
||||
JSON.stringify({ app: { name: 'dir2-app' } })
|
||||
);
|
||||
|
||||
// Test from dir1
|
||||
process.chdir(dir1);
|
||||
resetConfig();
|
||||
let config = await initializeConfig();
|
||||
expect(config.app.name).toBe('dir1-app');
|
||||
|
||||
// Test from dir2
|
||||
process.chdir(dir2);
|
||||
resetConfig();
|
||||
config = await initializeConfig();
|
||||
expect(config.app.name).toBe('dir2-app');
|
||||
});
|
||||
|
||||
test('should handle malformed .env files', async () => {
|
||||
// Create malformed .env file
|
||||
writeFileSync(
|
||||
join(TEST_DIR, '.env'),
|
||||
`# Good line
|
||||
VALID_KEY=valid_value
|
||||
# Malformed lines
|
||||
MISSING_VALUE=
|
||||
=MISSING_KEY
|
||||
SPACES IN KEY=value
|
||||
KEY_WITH_QUOTES="quoted value"
|
||||
KEY_WITH_SINGLE_QUOTES='single quoted'
|
||||
# Complex value
|
||||
JSON_VALUE={"key": "value", "nested": {"array": [1, 2, 3]}}
|
||||
`
|
||||
);
|
||||
|
||||
process.chdir(TEST_DIR);
|
||||
|
||||
const manager = new ConfigManager({
|
||||
loaders: [new EnvLoader('')]
|
||||
});
|
||||
|
||||
const config = await manager.initialize();
|
||||
|
||||
// Should handle valid entries
|
||||
expect(process.env.VALID_KEY).toBe('valid_value');
|
||||
expect(process.env.KEY_WITH_QUOTES).toBe('quoted value');
|
||||
expect(process.env.KEY_WITH_SINGLE_QUOTES).toBe('single quoted');
|
||||
});
|
||||
|
||||
test('should handle empty config files', async () => {
|
||||
const configDir = join(TEST_DIR, 'config');
|
||||
mkdirSync(configDir, { recursive: true });
|
||||
|
||||
// Create empty JSON file
|
||||
writeFileSync(join(configDir, 'development.json'), '{}');
|
||||
|
||||
const manager = new ConfigManager({
|
||||
loaders: [new FileLoader(configDir, 'development')]
|
||||
});
|
||||
|
||||
const config = await manager.initialize(appConfigSchema);
|
||||
expect(config).toBeDefined();
|
||||
expect(config.environment).toBe('development'); // Should have default
|
||||
});
|
||||
|
||||
test('should handle config initialization without schema', async () => {
|
||||
const manager = new ConfigManager({
|
||||
loaders: [new EnvLoader('')]
|
||||
});
|
||||
|
||||
// Initialize without schema
|
||||
const config = await manager.initialize();
|
||||
expect(config).toBeDefined();
|
||||
expect(typeof config).toBe('object');
|
||||
});
|
||||
|
||||
test('should handle accessing config before initialization', () => {
|
||||
const manager = new ConfigManager({
|
||||
loaders: [new EnvLoader('')]
|
||||
});
|
||||
|
||||
// Should throw error when accessing uninitialized config
|
||||
expect(() => manager.get()).toThrow('Configuration not initialized');
|
||||
expect(() => manager.getValue('some.path')).toThrow('Configuration not initialized');
|
||||
expect(() => manager.has('some.path')).toThrow('Configuration not initialized');
|
||||
});
|
||||
|
||||
test('should handle invalid config paths in getValue', async () => {
|
||||
const manager = new ConfigManager({
|
||||
loaders: [new EnvLoader('')]
|
||||
});
|
||||
|
||||
const config = await manager.initialize(appConfigSchema);
|
||||
|
||||
// Should throw for invalid paths
|
||||
expect(() => manager.getValue('nonexistent.path')).toThrow('Configuration key not found');
|
||||
expect(() => manager.getValue('app.nonexistent')).toThrow('Configuration key not found');
|
||||
|
||||
// Should work for valid paths
|
||||
expect(() => manager.getValue('environment')).not.toThrow();
|
||||
});
|
||||
|
||||
test('should handle null and undefined values in config', async () => {
|
||||
process.env.NULL_VALUE = 'null';
|
||||
process.env.UNDEFINED_VALUE = 'undefined';
|
||||
process.env.EMPTY_VALUE = '';
|
||||
|
||||
const manager = new ConfigManager({
|
||||
loaders: [new EnvLoader('')]
|
||||
});
|
||||
|
||||
const config = await manager.initialize();
|
||||
|
||||
expect((config as any).null_value).toBe(null);
|
||||
expect((config as any).undefined_value).toBe(undefined);
|
||||
expect((config as any).empty_value).toBe('');
|
||||
});
|
||||
|
||||
test('should handle schema validation failures', async () => {
|
||||
// Set up config that will fail schema validation
|
||||
process.env.APP_NAME = 'valid-name';
|
||||
process.env.APP_VERSION = 'valid-version';
|
||||
process.env.SERVICE_PORT = 'not-a-number'; // This should cause validation to fail
|
||||
|
||||
const manager = new ConfigManager({
|
||||
loaders: [new EnvLoader('')]
|
||||
});
|
||||
|
||||
await expect(manager.initialize(appConfigSchema)).rejects.toThrow(ConfigValidationError);
|
||||
});
|
||||
|
||||
test('should handle config updates with invalid schema', async () => {
|
||||
const manager = new ConfigManager({
|
||||
loaders: [new EnvLoader('')]
|
||||
});
|
||||
|
||||
await manager.initialize(appConfigSchema);
|
||||
|
||||
// Try to update with invalid data
|
||||
expect(() => {
|
||||
manager.set({
|
||||
service: {
|
||||
port: 'invalid-port' as any
|
||||
}
|
||||
});
|
||||
}).toThrow(ConfigValidationError);
|
||||
});
|
||||
|
||||
test('should handle loader priority conflicts', async () => {
|
||||
const configDir = join(TEST_DIR, 'config');
|
||||
mkdirSync(configDir, { recursive: true });
|
||||
|
||||
writeFileSync(
|
||||
join(configDir, 'development.json'),
|
||||
JSON.stringify({ app: { name: 'file-config' } })
|
||||
);
|
||||
|
||||
process.env.APP_NAME = 'env-config';
|
||||
|
||||
// Create loaders with different priorities
|
||||
const manager = new ConfigManager({
|
||||
loaders: [
|
||||
new FileLoader(configDir, 'development'), // priority 50
|
||||
new EnvLoader('') // priority 100
|
||||
]
|
||||
});
|
||||
|
||||
const config = await manager.initialize(appConfigSchema);
|
||||
|
||||
// Environment should win due to higher priority
|
||||
expect(config.app.name).toBe('env-config');
|
||||
});
|
||||
|
||||
test('should handle readonly environment variables', async () => {
|
||||
// Some system environment variables might be readonly
|
||||
const originalPath = process.env.PATH;
|
||||
|
||||
// This should not cause the loader to fail
|
||||
const manager = new ConfigManager({
|
||||
loaders: [new EnvLoader('')]
|
||||
});
|
||||
|
||||
const config = await manager.initialize();
|
||||
expect(config).toBeDefined();
|
||||
|
||||
// PATH should not be modified
|
||||
expect(process.env.PATH).toBe(originalPath);
|
||||
});
|
||||
});
|
||||
208
libs/core/config/test/index.test.ts
Normal file
208
libs/core/config/test/index.test.ts
Normal file
|
|
@ -0,0 +1,208 @@
|
|||
import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
|
||||
import { writeFileSync, mkdirSync, rmSync } from 'fs';
|
||||
import { join } from 'path';
|
||||
import {
|
||||
initializeConfig,
|
||||
getConfig,
|
||||
getConfigManager,
|
||||
resetConfig,
|
||||
getDatabaseConfig,
|
||||
getServiceConfig,
|
||||
getLoggingConfig,
|
||||
getProviderConfig,
|
||||
isDevelopment,
|
||||
isProduction,
|
||||
isTest,
|
||||
} from '../src';
|
||||
|
||||
describe('Config Module', () => {
|
||||
const testConfigDir = join(process.cwd(), 'test-config-module');
|
||||
const originalEnv = { ...process.env };
|
||||
|
||||
beforeEach(() => {
|
||||
resetConfig();
|
||||
mkdirSync(testConfigDir, { recursive: true });
|
||||
|
||||
// Create test configuration files
|
||||
const config = {
|
||||
name: 'test-app',
|
||||
version: '1.0.0',
|
||||
service: {
|
||||
name: 'test-service',
|
||||
port: 3000,
|
||||
},
|
||||
database: {
|
||||
postgres: {
|
||||
host: 'localhost',
|
||||
port: 5432,
|
||||
database: 'testdb',
|
||||
user: 'testuser',
|
||||
password: 'testpass',
|
||||
},
|
||||
questdb: {
|
||||
host: 'localhost',
|
||||
httpPort: 9000,
|
||||
pgPort: 8812,
|
||||
},
|
||||
mongodb: {
|
||||
host: 'localhost',
|
||||
port: 27017,
|
||||
database: 'testdb',
|
||||
},
|
||||
dragonfly: {
|
||||
host: 'localhost',
|
||||
port: 6379,
|
||||
},
|
||||
},
|
||||
logging: {
|
||||
level: 'info',
|
||||
format: 'json',
|
||||
},
|
||||
providers: {
|
||||
yahoo: {
|
||||
enabled: true,
|
||||
rateLimit: 5,
|
||||
},
|
||||
qm: {
|
||||
enabled: false,
|
||||
apiKey: 'test-key',
|
||||
},
|
||||
},
|
||||
environment: 'test',
|
||||
};
|
||||
|
||||
writeFileSync(
|
||||
join(testConfigDir, 'default.json'),
|
||||
JSON.stringify(config, null, 2)
|
||||
);
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
resetConfig();
|
||||
rmSync(testConfigDir, { recursive: true, force: true });
|
||||
process.env = { ...originalEnv };
|
||||
});
|
||||
|
||||
test('should initialize configuration', async () => {
|
||||
const config = await initializeConfig(testConfigDir);
|
||||
|
||||
expect(config.app.name).toBe('test-app');
|
||||
expect(config.service.port).toBe(3000);
|
||||
expect(config.environment).toBe('test');
|
||||
});
|
||||
|
||||
test('should get configuration after initialization', async () => {
|
||||
await initializeConfig(testConfigDir);
|
||||
const config = getConfig();
|
||||
|
||||
expect(config.app.name).toBe('test-app');
|
||||
expect(config.database.postgres.host).toBe('localhost');
|
||||
});
|
||||
|
||||
test('should throw if getting config before initialization', () => {
|
||||
expect(() => getConfig()).toThrow('Configuration not initialized');
|
||||
});
|
||||
|
||||
test('should get config manager instance', async () => {
|
||||
await initializeConfig(testConfigDir);
|
||||
const manager = getConfigManager();
|
||||
|
||||
expect(manager).toBeDefined();
|
||||
expect(manager.get().app.name).toBe('test-app');
|
||||
});
|
||||
|
||||
test('should get database configuration', async () => {
|
||||
await initializeConfig(testConfigDir);
|
||||
const dbConfig = getDatabaseConfig();
|
||||
|
||||
expect(dbConfig.postgres.host).toBe('localhost');
|
||||
expect(dbConfig.questdb.httpPort).toBe(9000);
|
||||
expect(dbConfig.mongodb.database).toBe('testdb');
|
||||
});
|
||||
|
||||
test('should get service configuration', async () => {
|
||||
await initializeConfig(testConfigDir);
|
||||
const serviceConfig = getServiceConfig();
|
||||
|
||||
expect(serviceConfig.name).toBe('test-service');
|
||||
expect(serviceConfig.port).toBe(3000);
|
||||
});
|
||||
|
||||
test('should get logging configuration', async () => {
|
||||
await initializeConfig(testConfigDir);
|
||||
const loggingConfig = getLoggingConfig();
|
||||
|
||||
expect(loggingConfig.level).toBe('info');
|
||||
expect(loggingConfig.format).toBe('json');
|
||||
});
|
||||
|
||||
test('should get provider configuration', async () => {
|
||||
await initializeConfig(testConfigDir);
|
||||
|
||||
const yahooConfig = getProviderConfig('yahoo');
|
||||
expect(yahooConfig.enabled).toBe(true);
|
||||
expect(yahooConfig.rateLimit).toBe(5);
|
||||
|
||||
const qmConfig = getProviderConfig('quoteMedia');
|
||||
expect(qmConfig.enabled).toBe(false);
|
||||
expect(qmConfig.apiKey).toBe('test-key');
|
||||
});
|
||||
|
||||
test('should throw for non-existent provider', async () => {
|
||||
await initializeConfig(testConfigDir);
|
||||
|
||||
expect(() => getProviderConfig('nonexistent')).toThrow(
|
||||
'Provider configuration not found: nonexistent'
|
||||
);
|
||||
});
|
||||
|
||||
test('should check environment correctly', async () => {
|
||||
await initializeConfig(testConfigDir);
|
||||
|
||||
expect(isTest()).toBe(true);
|
||||
expect(isDevelopment()).toBe(false);
|
||||
expect(isProduction()).toBe(false);
|
||||
});
|
||||
|
||||
test('should handle environment overrides', async () => {
|
||||
process.env.NODE_ENV = 'production';
|
||||
process.env.STOCKBOT_APP__NAME = 'env-override-app';
|
||||
process.env.STOCKBOT_DATABASE__POSTGRES__HOST = 'prod-db';
|
||||
|
||||
const prodConfig = {
|
||||
database: {
|
||||
postgres: {
|
||||
host: 'prod-host',
|
||||
port: 5432,
|
||||
},
|
||||
},
|
||||
};
|
||||
|
||||
writeFileSync(
|
||||
join(testConfigDir, 'production.json'),
|
||||
JSON.stringify(prodConfig, null, 2)
|
||||
);
|
||||
|
||||
const config = await initializeConfig(testConfigDir);
|
||||
|
||||
expect(config.environment).toBe('production');
|
||||
expect(config.app.name).toBe('env-override-app');
|
||||
expect(config.database.postgres.host).toBe('prod-db');
|
||||
expect(isProduction()).toBe(true);
|
||||
});
|
||||
|
||||
test('should reset configuration', async () => {
|
||||
await initializeConfig(testConfigDir);
|
||||
expect(() => getConfig()).not.toThrow();
|
||||
|
||||
resetConfig();
|
||||
expect(() => getConfig()).toThrow('Configuration not initialized');
|
||||
});
|
||||
|
||||
test('should maintain singleton instance', async () => {
|
||||
const config1 = await initializeConfig(testConfigDir);
|
||||
const config2 = await initializeConfig(testConfigDir);
|
||||
|
||||
expect(config1).toBe(config2);
|
||||
});
|
||||
});
|
||||
181
libs/core/config/test/loaders.test.ts
Normal file
181
libs/core/config/test/loaders.test.ts
Normal file
|
|
@ -0,0 +1,181 @@
|
|||
import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
|
||||
import { writeFileSync, mkdirSync, rmSync } from 'fs';
|
||||
import { join } from 'path';
|
||||
import { EnvLoader } from '../src/loaders/env.loader';
|
||||
import { FileLoader } from '../src/loaders/file.loader';
|
||||
|
||||
describe('EnvLoader', () => {
|
||||
const originalEnv = { ...process.env };
|
||||
|
||||
afterEach(() => {
|
||||
// Restore original environment
|
||||
process.env = { ...originalEnv };
|
||||
});
|
||||
|
||||
test('should load environment variables with prefix', async () => {
|
||||
process.env.TEST_APP_NAME = 'env-app';
|
||||
process.env.TEST_APP_VERSION = '1.0.0';
|
||||
process.env.TEST_DATABASE_HOST = 'env-host';
|
||||
process.env.TEST_DATABASE_PORT = '5432';
|
||||
process.env.OTHER_VAR = 'should-not-load';
|
||||
|
||||
const loader = new EnvLoader('TEST_', { convertCase: false, nestedDelimiter: null });
|
||||
const config = await loader.load();
|
||||
|
||||
expect(config.APP_NAME).toBe('env-app');
|
||||
expect(config.APP_VERSION).toBe('1.0.0');
|
||||
expect(config.DATABASE_HOST).toBe('env-host');
|
||||
expect(config.DATABASE_PORT).toBe(5432); // Should be parsed as number
|
||||
expect(config.OTHER_VAR).toBeUndefined();
|
||||
});
|
||||
|
||||
test('should convert snake_case to camelCase', async () => {
|
||||
process.env.TEST_DATABASE_CONNECTION_STRING = 'postgres://localhost';
|
||||
process.env.TEST_API_KEY_SECRET = 'secret123';
|
||||
|
||||
const loader = new EnvLoader('TEST_', { convertCase: true });
|
||||
const config = await loader.load();
|
||||
|
||||
expect(config.databaseConnectionString).toBe('postgres://localhost');
|
||||
expect(config.apiKeySecret).toBe('secret123');
|
||||
});
|
||||
|
||||
test('should parse JSON values', async () => {
|
||||
process.env.TEST_SETTINGS = '{"feature": true, "limit": 100}';
|
||||
process.env.TEST_NUMBERS = '[1, 2, 3]';
|
||||
|
||||
const loader = new EnvLoader('TEST_', { parseJson: true });
|
||||
const config = await loader.load();
|
||||
|
||||
expect(config.SETTINGS).toEqual({ feature: true, limit: 100 });
|
||||
expect(config.NUMBERS).toEqual([1, 2, 3]);
|
||||
});
|
||||
|
||||
test('should parse boolean and number values', async () => {
|
||||
process.env.TEST_ENABLED = 'true';
|
||||
process.env.TEST_DISABLED = 'false';
|
||||
process.env.TEST_PORT = '3000';
|
||||
process.env.TEST_RATIO = '0.75';
|
||||
|
||||
const loader = new EnvLoader('TEST_', { parseValues: true });
|
||||
const config = await loader.load();
|
||||
|
||||
expect(config.ENABLED).toBe(true);
|
||||
expect(config.DISABLED).toBe(false);
|
||||
expect(config.PORT).toBe(3000);
|
||||
expect(config.RATIO).toBe(0.75);
|
||||
});
|
||||
|
||||
test('should handle nested object structure', async () => {
|
||||
process.env.TEST_APP__NAME = 'nested-app';
|
||||
process.env.TEST_APP__SETTINGS__ENABLED = 'true';
|
||||
process.env.TEST_DATABASE__HOST = 'localhost';
|
||||
|
||||
const loader = new EnvLoader('TEST_', {
|
||||
parseValues: true,
|
||||
nestedDelimiter: '__'
|
||||
});
|
||||
const config = await loader.load();
|
||||
|
||||
expect(config.APP).toEqual({
|
||||
NAME: 'nested-app',
|
||||
SETTINGS: {
|
||||
ENABLED: true
|
||||
}
|
||||
});
|
||||
expect(config.DATABASE).toEqual({
|
||||
HOST: 'localhost'
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe('FileLoader', () => {
|
||||
const testDir = join(process.cwd(), 'test-config');
|
||||
|
||||
beforeEach(() => {
|
||||
mkdirSync(testDir, { recursive: true });
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
rmSync(testDir, { recursive: true, force: true });
|
||||
});
|
||||
|
||||
test('should load JSON configuration file', async () => {
|
||||
const config = {
|
||||
app: { name: 'file-app', version: '1.0.0' },
|
||||
database: { host: 'localhost', port: 5432 }
|
||||
};
|
||||
|
||||
writeFileSync(
|
||||
join(testDir, 'default.json'),
|
||||
JSON.stringify(config, null, 2)
|
||||
);
|
||||
|
||||
const loader = new FileLoader(testDir);
|
||||
const loaded = await loader.load();
|
||||
|
||||
expect(loaded).toEqual(config);
|
||||
});
|
||||
|
||||
test('should load environment-specific configuration', async () => {
|
||||
const defaultConfig = {
|
||||
app: { name: 'app', port: 3000 },
|
||||
database: { host: 'localhost' }
|
||||
};
|
||||
|
||||
const prodConfig = {
|
||||
app: { port: 8080 },
|
||||
database: { host: 'prod-db' }
|
||||
};
|
||||
|
||||
writeFileSync(
|
||||
join(testDir, 'default.json'),
|
||||
JSON.stringify(defaultConfig, null, 2)
|
||||
);
|
||||
|
||||
writeFileSync(
|
||||
join(testDir, 'production.json'),
|
||||
JSON.stringify(prodConfig, null, 2)
|
||||
);
|
||||
|
||||
const loader = new FileLoader(testDir, 'production');
|
||||
const loaded = await loader.load();
|
||||
|
||||
expect(loaded).toEqual({
|
||||
app: { name: 'app', port: 8080 },
|
||||
database: { host: 'prod-db' }
|
||||
});
|
||||
});
|
||||
|
||||
test('should handle missing configuration files gracefully', async () => {
|
||||
const loader = new FileLoader(testDir);
|
||||
const loaded = await loader.load();
|
||||
|
||||
expect(loaded).toEqual({});
|
||||
});
|
||||
|
||||
test('should throw on invalid JSON', async () => {
|
||||
writeFileSync(
|
||||
join(testDir, 'default.json'),
|
||||
'invalid json content'
|
||||
);
|
||||
|
||||
const loader = new FileLoader(testDir);
|
||||
|
||||
await expect(loader.load()).rejects.toThrow();
|
||||
});
|
||||
|
||||
test('should support custom configuration', async () => {
|
||||
const config = { custom: 'value' };
|
||||
|
||||
writeFileSync(
|
||||
join(testDir, 'custom.json'),
|
||||
JSON.stringify(config, null, 2)
|
||||
);
|
||||
|
||||
const loader = new FileLoader(testDir);
|
||||
const loaded = await loader.loadFile('custom.json');
|
||||
|
||||
expect(loaded).toEqual(config);
|
||||
});
|
||||
});
|
||||
320
libs/core/config/test/provider-config.test.ts
Normal file
320
libs/core/config/test/provider-config.test.ts
Normal file
|
|
@ -0,0 +1,320 @@
|
|||
import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
|
||||
import { ConfigManager } from '../src/config-manager';
|
||||
import { EnvLoader } from '../src/loaders/env.loader';
|
||||
import { FileLoader } from '../src/loaders/file.loader';
|
||||
import { appConfigSchema } from '../src/schemas';
|
||||
import { resetConfig, getProviderConfig } from '../src/index';
|
||||
import { join } from 'path';
|
||||
import { mkdirSync, writeFileSync, rmSync, existsSync } from 'fs';
|
||||
|
||||
const TEST_DIR = join(__dirname, 'provider-tests');
|
||||
|
||||
describe('Provider Configuration Tests', () => {
|
||||
let originalEnv: NodeJS.ProcessEnv;
|
||||
|
||||
beforeEach(() => {
|
||||
// Save original environment
|
||||
originalEnv = { ...process.env };
|
||||
|
||||
// Reset config singleton
|
||||
resetConfig();
|
||||
|
||||
// Clean up test directory
|
||||
if (existsSync(TEST_DIR)) {
|
||||
rmSync(TEST_DIR, { recursive: true, force: true });
|
||||
}
|
||||
mkdirSync(TEST_DIR, { recursive: true });
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
// Restore original environment
|
||||
process.env = originalEnv;
|
||||
|
||||
// Clean up
|
||||
resetConfig();
|
||||
if (existsSync(TEST_DIR)) {
|
||||
rmSync(TEST_DIR, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
|
||||
test('should load WebShare provider config from environment variables', async () => {
|
||||
// Set WebShare environment variables
|
||||
process.env.WEBSHARE_API_KEY = 'test-webshare-key';
|
||||
process.env.WEBSHARE_API_URL = 'https://custom.webshare.io/api/v2/';
|
||||
process.env.WEBSHARE_ENABLED = 'true';
|
||||
|
||||
const manager = new ConfigManager({
|
||||
loaders: [new EnvLoader('')]
|
||||
});
|
||||
|
||||
const config = await manager.initialize(appConfigSchema);
|
||||
|
||||
expect(config.webshare).toBeDefined();
|
||||
expect(config.webshare?.apiKey).toBe('test-webshare-key');
|
||||
expect(config.webshare?.apiUrl).toBe('https://custom.webshare.io/api/v2/');
|
||||
expect(config.webshare?.enabled).toBe(true);
|
||||
});
|
||||
|
||||
test('should load EOD provider config from environment variables', async () => {
|
||||
// Set EOD environment variables
|
||||
process.env.EOD_API_KEY = 'test-eod-key';
|
||||
process.env.EOD_BASE_URL = 'https://custom.eod.com/api';
|
||||
process.env.EOD_TIER = 'all-in-one';
|
||||
process.env.EOD_ENABLED = 'true';
|
||||
process.env.EOD_PRIORITY = '10';
|
||||
|
||||
const manager = new ConfigManager({
|
||||
loaders: [new EnvLoader('')]
|
||||
});
|
||||
|
||||
const config = await manager.initialize(appConfigSchema);
|
||||
|
||||
expect(config.providers?.eod).toBeDefined();
|
||||
expect(config.providers?.eod?.apiKey).toBe('test-eod-key');
|
||||
expect(config.providers?.eod?.baseUrl).toBe('https://custom.eod.com/api');
|
||||
expect(config.providers?.eod?.tier).toBe('all-in-one');
|
||||
expect(config.providers?.eod?.enabled).toBe(true);
|
||||
expect(config.providers?.eod?.priority).toBe(10);
|
||||
});
|
||||
|
||||
test('should load Interactive Brokers provider config from environment variables', async () => {
|
||||
// Set IB environment variables
|
||||
process.env.IB_GATEWAY_HOST = 'ib-gateway.example.com';
|
||||
process.env.IB_GATEWAY_PORT = '7497';
|
||||
process.env.IB_CLIENT_ID = '123';
|
||||
process.env.IB_ACCOUNT = 'DU123456';
|
||||
process.env.IB_MARKET_DATA_TYPE = 'live';
|
||||
process.env.IB_ENABLED = 'true';
|
||||
process.env.IB_PRIORITY = '5';
|
||||
|
||||
const manager = new ConfigManager({
|
||||
loaders: [new EnvLoader('')]
|
||||
});
|
||||
|
||||
const config = await manager.initialize(appConfigSchema);
|
||||
|
||||
expect(config.providers?.ib).toBeDefined();
|
||||
expect(config.providers?.ib?.gateway.host).toBe('ib-gateway.example.com');
|
||||
expect(config.providers?.ib?.gateway.port).toBe(7497);
|
||||
expect(config.providers?.ib?.gateway.clientId).toBe(123);
|
||||
expect(config.providers?.ib?.account).toBe('DU123456');
|
||||
expect(config.providers?.ib?.marketDataType).toBe('live');
|
||||
expect(config.providers?.ib?.enabled).toBe(true);
|
||||
expect(config.providers?.ib?.priority).toBe(5);
|
||||
});
|
||||
|
||||
test('should load QuoteMedia provider config from environment variables', async () => {
|
||||
// Set QM environment variables
|
||||
process.env.QM_USERNAME = 'test-qm-user';
|
||||
process.env.QM_PASSWORD = 'test-qm-pass';
|
||||
process.env.QM_BASE_URL = 'https://custom.quotemedia.com/api';
|
||||
process.env.QM_WEBMASTER_ID = 'webmaster123';
|
||||
process.env.QM_ENABLED = 'true';
|
||||
process.env.QM_PRIORITY = '15';
|
||||
|
||||
const manager = new ConfigManager({
|
||||
loaders: [new EnvLoader('')]
|
||||
});
|
||||
|
||||
const config = await manager.initialize(appConfigSchema);
|
||||
|
||||
expect(config.providers?.qm).toBeDefined();
|
||||
expect(config.providers?.qm?.username).toBe('test-qm-user');
|
||||
expect(config.providers?.qm?.password).toBe('test-qm-pass');
|
||||
expect(config.providers?.qm?.baseUrl).toBe('https://custom.quotemedia.com/api');
|
||||
expect(config.providers?.qm?.webmasterId).toBe('webmaster123');
|
||||
expect(config.providers?.qm?.enabled).toBe(true);
|
||||
expect(config.providers?.qm?.priority).toBe(15);
|
||||
});
|
||||
|
||||
test('should load Yahoo Finance provider config from environment variables', async () => {
|
||||
// Set Yahoo environment variables
|
||||
process.env.YAHOO_BASE_URL = 'https://custom.yahoo.com/api';
|
||||
process.env.YAHOO_COOKIE_JAR = 'false';
|
||||
process.env.YAHOO_CRUMB = 'test-crumb';
|
||||
process.env.YAHOO_ENABLED = 'true';
|
||||
process.env.YAHOO_PRIORITY = '20';
|
||||
|
||||
const manager = new ConfigManager({
|
||||
loaders: [new EnvLoader('')]
|
||||
});
|
||||
|
||||
const config = await manager.initialize(appConfigSchema);
|
||||
|
||||
expect(config.providers?.yahoo).toBeDefined();
|
||||
expect(config.providers?.yahoo?.baseUrl).toBe('https://custom.yahoo.com/api');
|
||||
expect(config.providers?.yahoo?.cookieJar).toBe(false);
|
||||
expect(config.providers?.yahoo?.crumb).toBe('test-crumb');
|
||||
expect(config.providers?.yahoo?.enabled).toBe(true);
|
||||
expect(config.providers?.yahoo?.priority).toBe(20);
|
||||
});
|
||||
|
||||
test('should merge file config with environment variables', async () => {
|
||||
// Create a config file
|
||||
const configDir = join(TEST_DIR, 'config');
|
||||
mkdirSync(configDir, { recursive: true });
|
||||
|
||||
writeFileSync(
|
||||
join(configDir, 'development.json'),
|
||||
JSON.stringify({
|
||||
providers: {
|
||||
eod: {
|
||||
name: 'EOD Historical Data',
|
||||
apiKey: 'file-eod-key',
|
||||
baseUrl: 'https://file.eod.com/api',
|
||||
tier: 'free',
|
||||
enabled: false,
|
||||
priority: 1
|
||||
},
|
||||
yahoo: {
|
||||
name: 'Yahoo Finance',
|
||||
baseUrl: 'https://file.yahoo.com',
|
||||
enabled: true,
|
||||
priority: 2
|
||||
}
|
||||
}
|
||||
}, null, 2)
|
||||
);
|
||||
|
||||
// Set environment variables that should override file config
|
||||
process.env.EOD_API_KEY = 'env-eod-key';
|
||||
process.env.EOD_ENABLED = 'true';
|
||||
process.env.EOD_PRIORITY = '10';
|
||||
process.env.YAHOO_PRIORITY = '25';
|
||||
|
||||
const manager = new ConfigManager({
|
||||
loaders: [
|
||||
new FileLoader(configDir, 'development'),
|
||||
new EnvLoader('')
|
||||
]
|
||||
});
|
||||
|
||||
const config = await manager.initialize(appConfigSchema);
|
||||
|
||||
// EOD config should be merged (env overrides file)
|
||||
expect(config.providers?.eod?.name).toBe('EOD Historical Data'); // From file
|
||||
expect(config.providers?.eod?.apiKey).toBe('env-eod-key'); // From env
|
||||
expect(config.providers?.eod?.baseUrl).toBe('https://file.eod.com/api'); // From file
|
||||
expect(config.providers?.eod?.enabled).toBe(true); // From env (overrides file)
|
||||
expect(config.providers?.eod?.priority).toBe(10); // From env (overrides file)
|
||||
|
||||
// Yahoo config should be merged
|
||||
expect(config.providers?.yahoo?.name).toBe('Yahoo Finance'); // From file
|
||||
expect(config.providers?.yahoo?.baseUrl).toBe('https://file.yahoo.com'); // From file
|
||||
expect(config.providers?.yahoo?.priority).toBe(25); // From env (overrides file)
|
||||
});
|
||||
|
||||
test('should handle invalid provider configurations', async () => {
|
||||
// Set invalid values
|
||||
process.env.EOD_TIER = 'invalid-tier'; // Should be one of ['free', 'fundamentals', 'all-in-one']
|
||||
process.env.IB_MARKET_DATA_TYPE = 'invalid-type'; // Should be one of ['live', 'delayed', 'frozen']
|
||||
process.env.IB_GATEWAY_PORT = 'not-a-number'; // Should be a number
|
||||
|
||||
const manager = new ConfigManager({
|
||||
loaders: [new EnvLoader('')]
|
||||
});
|
||||
|
||||
// Should throw validation error
|
||||
await expect(manager.initialize(appConfigSchema)).rejects.toThrow();
|
||||
});
|
||||
|
||||
test('should work with getProviderConfig helper function', async () => {
|
||||
// Set up multiple providers
|
||||
process.env.EOD_API_KEY = 'test-eod-key';
|
||||
process.env.EOD_ENABLED = 'true';
|
||||
process.env.WEBSHARE_API_KEY = 'test-webshare-key';
|
||||
process.env.WEBSHARE_ENABLED = 'true';
|
||||
|
||||
const manager = new ConfigManager({
|
||||
loaders: [new EnvLoader('')]
|
||||
});
|
||||
|
||||
await manager.initialize(appConfigSchema);
|
||||
|
||||
// Test getProviderConfig helper
|
||||
const eodConfig = getProviderConfig('eod');
|
||||
expect(eodConfig).toBeDefined();
|
||||
expect((eodConfig as any).apiKey).toBe('test-eod-key');
|
||||
|
||||
const webshareConfig = getProviderConfig('webshare');
|
||||
expect(webshareConfig).toBeDefined();
|
||||
expect((webshareConfig as any).apiKey).toBe('test-webshare-key');
|
||||
|
||||
// Test non-existent provider
|
||||
expect(() => getProviderConfig('nonexistent')).toThrow('Provider configuration not found: nonexistent');
|
||||
});
|
||||
|
||||
test('should handle boolean string parsing correctly', async () => {
|
||||
// Test various boolean representations
|
||||
process.env.EOD_ENABLED = 'TRUE';
|
||||
process.env.YAHOO_ENABLED = 'False';
|
||||
process.env.IB_ENABLED = '1';
|
||||
process.env.QM_ENABLED = '0';
|
||||
process.env.WEBSHARE_ENABLED = 'yes'; // Should be treated as string, not boolean
|
||||
|
||||
const manager = new ConfigManager({
|
||||
loaders: [new EnvLoader('')]
|
||||
});
|
||||
|
||||
const config = await manager.initialize(appConfigSchema);
|
||||
|
||||
expect(config.providers?.eod?.enabled).toBe(true);
|
||||
expect(config.providers?.yahoo?.enabled).toBe(false);
|
||||
expect(config.providers?.ib?.enabled).toBe(true); // 1 is parsed as number, not boolean
|
||||
expect(config.providers?.qm?.enabled).toBe(false); // 0 is parsed as number, not boolean
|
||||
// webshare.enabled should be the string 'yes', but schema validation might reject it
|
||||
});
|
||||
|
||||
test('should handle nested configuration correctly', async () => {
|
||||
// Test nested IB gateway configuration
|
||||
process.env.IB_GATEWAY_HOST = 'gateway.ib.com';
|
||||
process.env.IB_GATEWAY_PORT = '7497';
|
||||
process.env.IB_GATEWAY_CLIENT_ID = '999';
|
||||
|
||||
const manager = new ConfigManager({
|
||||
loaders: [new EnvLoader('')]
|
||||
});
|
||||
|
||||
const config = await manager.initialize(appConfigSchema);
|
||||
|
||||
expect(config.providers?.ib?.gateway).toBeDefined();
|
||||
expect(config.providers?.ib?.gateway.host).toBe('gateway.ib.com');
|
||||
expect(config.providers?.ib?.gateway.port).toBe(7497);
|
||||
expect(config.providers?.ib?.gateway.clientId).toBe(999);
|
||||
});
|
||||
|
||||
test('should load provider configs from .env file', async () => {
|
||||
// Create .env file with provider configs
|
||||
writeFileSync(
|
||||
join(TEST_DIR, '.env'),
|
||||
`# Provider configurations
|
||||
EOD_API_KEY=env-file-eod-key
|
||||
EOD_ENABLED=true
|
||||
WEBSHARE_API_KEY=env-file-webshare-key
|
||||
IB_GATEWAY_HOST=env-file-ib-host
|
||||
IB_GATEWAY_PORT=7498
|
||||
YAHOO_BASE_URL=https://env-file.yahoo.com
|
||||
`
|
||||
);
|
||||
|
||||
const originalCwd = process.cwd();
|
||||
try {
|
||||
process.chdir(TEST_DIR);
|
||||
|
||||
const manager = new ConfigManager({
|
||||
loaders: [new EnvLoader('')]
|
||||
});
|
||||
|
||||
const config = await manager.initialize(appConfigSchema);
|
||||
|
||||
expect(config.providers?.eod?.apiKey).toBe('env-file-eod-key');
|
||||
expect(config.providers?.eod?.enabled).toBe(true);
|
||||
expect(config.webshare?.apiKey).toBe('env-file-webshare-key');
|
||||
expect(config.providers?.ib?.gateway.host).toBe('env-file-ib-host');
|
||||
expect(config.providers?.ib?.gateway.port).toBe(7498);
|
||||
expect(config.providers?.yahoo?.baseUrl).toBe('https://env-file.yahoo.com');
|
||||
} finally {
|
||||
process.chdir(originalCwd);
|
||||
}
|
||||
});
|
||||
});
|
||||
404
libs/core/config/test/real-usage.test.ts
Normal file
404
libs/core/config/test/real-usage.test.ts
Normal file
|
|
@ -0,0 +1,404 @@
|
|||
import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
|
||||
import { existsSync, mkdirSync, rmSync, writeFileSync } from 'fs';
|
||||
import { join } from 'path';
|
||||
import {
|
||||
getConfig,
|
||||
getDatabaseConfig,
|
||||
getLoggingConfig,
|
||||
getProviderConfig,
|
||||
getServiceConfig,
|
||||
initializeServiceConfig,
|
||||
isDevelopment,
|
||||
isProduction,
|
||||
isTest,
|
||||
resetConfig
|
||||
} from '../src/index';
|
||||
|
||||
const TEST_DIR = join(__dirname, 'real-usage-tests');
|
||||
|
||||
describe('Real Usage Scenarios', () => {
|
||||
let originalEnv: NodeJS.ProcessEnv;
|
||||
let originalCwd: string;
|
||||
|
||||
beforeEach(() => {
|
||||
originalEnv = { ...process.env };
|
||||
originalCwd = process.cwd();
|
||||
|
||||
resetConfig();
|
||||
|
||||
if (existsSync(TEST_DIR)) {
|
||||
rmSync(TEST_DIR, { recursive: true, force: true });
|
||||
}
|
||||
|
||||
setupRealUsageScenarios();
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
process.env = originalEnv;
|
||||
process.chdir(originalCwd);
|
||||
resetConfig();
|
||||
|
||||
if (existsSync(TEST_DIR)) {
|
||||
rmSync(TEST_DIR, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
|
||||
test('should work like real data-ingestion usage', async () => {
|
||||
const dataServiceDir = join(TEST_DIR, 'apps', 'data-ingestion');
|
||||
process.chdir(dataServiceDir);
|
||||
|
||||
// Simulate how data-ingestion would initialize config
|
||||
const config = await initializeServiceConfig();
|
||||
|
||||
// Test typical data-ingestion config access patterns
|
||||
expect(config.app.name).toBe('data-ingestion');
|
||||
expect(config.service.port).toBe(3001);
|
||||
|
||||
// Test database config access
|
||||
const dbConfig = getDatabaseConfig();
|
||||
expect(dbConfig.postgres.host).toBe('localhost');
|
||||
expect(dbConfig.postgres.port).toBe(5432);
|
||||
expect(dbConfig.questdb.host).toBe('localhost');
|
||||
|
||||
// Test provider access
|
||||
const yahooConfig = getProviderConfig('yahoo');
|
||||
expect(yahooConfig).toBeDefined();
|
||||
expect((yahooConfig as any).enabled).toBe(true);
|
||||
|
||||
// Test environment helpers
|
||||
expect(isDevelopment()).toBe(true);
|
||||
expect(isProduction()).toBe(false);
|
||||
});
|
||||
|
||||
test('should work like real web-api usage', async () => {
|
||||
const webApiDir = join(TEST_DIR, 'apps', 'web-api');
|
||||
process.chdir(webApiDir);
|
||||
|
||||
const config = await initializeServiceConfig();
|
||||
|
||||
expect(config.app.name).toBe('web-api');
|
||||
expect(config.service.port).toBe(4000);
|
||||
|
||||
// Web API should have access to all the same configs
|
||||
const serviceConfig = getServiceConfig();
|
||||
expect(serviceConfig.name).toBe('web-api');
|
||||
|
||||
const loggingConfig = getLoggingConfig();
|
||||
expect(loggingConfig.level).toBe('info');
|
||||
});
|
||||
|
||||
test('should work like real shared library usage', async () => {
|
||||
const cacheLibDir = join(TEST_DIR, 'libs', 'cache');
|
||||
process.chdir(cacheLibDir);
|
||||
|
||||
const config = await initializeServiceConfig();
|
||||
|
||||
// Libraries should inherit from root config
|
||||
expect(config.app.name).toBe('cache-lib');
|
||||
expect(config.app.version).toBe('1.0.0'); // From root
|
||||
|
||||
// Should have access to cache config
|
||||
const dbConfig = getDatabaseConfig();
|
||||
expect(dbConfig.dragonfly).toBeDefined();
|
||||
expect(dbConfig.dragonfly.host).toBe('localhost');
|
||||
expect(dbConfig.dragonfly.port).toBe(6379);
|
||||
});
|
||||
|
||||
test('should handle production environment correctly', async () => {
|
||||
process.env.NODE_ENV = 'production';
|
||||
|
||||
const dataServiceDir = join(TEST_DIR, 'apps', 'data-ingestion');
|
||||
process.chdir(dataServiceDir);
|
||||
|
||||
resetConfig();
|
||||
const config = await initializeServiceConfig();
|
||||
|
||||
expect(config.environment).toBe('production');
|
||||
expect(config.logging.level).toBe('warn'); // Production should use different log level
|
||||
|
||||
expect(isProduction()).toBe(true);
|
||||
expect(isDevelopment()).toBe(false);
|
||||
});
|
||||
|
||||
test('should handle test environment correctly', async () => {
|
||||
process.env.NODE_ENV = 'test';
|
||||
|
||||
const dataServiceDir = join(TEST_DIR, 'apps', 'data-ingestion');
|
||||
process.chdir(dataServiceDir);
|
||||
|
||||
resetConfig();
|
||||
const config = await initializeServiceConfig();
|
||||
|
||||
expect(config.environment).toBe('test');
|
||||
expect(config.logging.level).toBe('debug'); // Test should use debug level
|
||||
|
||||
expect(isTest()).toBe(true);
|
||||
expect(isDevelopment()).toBe(false);
|
||||
});
|
||||
|
||||
test('should work with environment variable overrides in production', async () => {
|
||||
process.env.NODE_ENV = 'production';
|
||||
process.env.DATABASE_POSTGRES_HOST = 'prod-db.example.com';
|
||||
process.env.DATABASE_POSTGRES_PORT = '5433';
|
||||
process.env.EOD_API_KEY = 'prod-eod-key';
|
||||
process.env.SERVICE_PORT = '8080';
|
||||
|
||||
const dataServiceDir = join(TEST_ROOT, 'apps', 'data-ingestion');
|
||||
process.chdir(dataServiceDir);
|
||||
|
||||
resetConfig();
|
||||
const config = await initializeServiceConfig();
|
||||
|
||||
// Environment variables should override file configs
|
||||
const dbConfig = getDatabaseConfig();
|
||||
expect(dbConfig.postgres.host).toBe('prod-db.example.com');
|
||||
expect(dbConfig.postgres.port).toBe(5433);
|
||||
|
||||
const serviceConfig = getServiceConfig();
|
||||
expect(serviceConfig.port).toBe(8080);
|
||||
|
||||
const eodConfig = getProviderConfig('eod');
|
||||
expect((eodConfig as any).apiKey).toBe('prod-eod-key');
|
||||
});
|
||||
|
||||
test('should handle missing provider configurations gracefully', async () => {
|
||||
const dataServiceDir = join(TEST_DIR, 'apps', 'data-ingestion');
|
||||
process.chdir(dataServiceDir);
|
||||
|
||||
const config = await initializeServiceConfig();
|
||||
|
||||
// Should throw for non-existent providers
|
||||
expect(() => getProviderConfig('nonexistent')).toThrow('Provider configuration not found: nonexistent');
|
||||
|
||||
// Should work for providers that exist but might not be configured
|
||||
// (they should have defaults from schema)
|
||||
const yahooConfig = getProviderConfig('yahoo');
|
||||
expect(yahooConfig).toBeDefined();
|
||||
});
|
||||
|
||||
test('should support dynamic config access patterns', async () => {
|
||||
const dataServiceDir = join(TEST_DIR, 'apps', 'data-ingestion');
|
||||
process.chdir(dataServiceDir);
|
||||
|
||||
const config = await initializeServiceConfig();
|
||||
|
||||
// Test various access patterns used in real applications
|
||||
const configManager = (await import('../src/index')).getConfigManager();
|
||||
|
||||
// Direct path access
|
||||
expect(configManager.getValue('app.name')).toBe('data-ingestion');
|
||||
expect(configManager.getValue('service.port')).toBe(3001);
|
||||
|
||||
// Check if paths exist
|
||||
expect(configManager.has('app.name')).toBe(true);
|
||||
expect(configManager.has('nonexistent.path')).toBe(false);
|
||||
|
||||
// Typed access
|
||||
const port = configManager.getValue<number>('service.port');
|
||||
expect(typeof port).toBe('number');
|
||||
expect(port).toBe(3001);
|
||||
});
|
||||
|
||||
test('should handle config updates at runtime', async () => {
|
||||
const dataServiceDir = join(TEST_DIR, 'apps', 'data-ingestion');
|
||||
process.chdir(dataServiceDir);
|
||||
|
||||
await initializeServiceConfig();
|
||||
const configManager = (await import('../src/index')).getConfigManager();
|
||||
|
||||
// Update config at runtime (useful for testing)
|
||||
configManager.set({
|
||||
service: {
|
||||
port: 9999
|
||||
}
|
||||
});
|
||||
|
||||
const updatedConfig = getConfig();
|
||||
expect(updatedConfig.service.port).toBe(9999);
|
||||
|
||||
// Other values should be preserved
|
||||
expect(updatedConfig.app.name).toBe('data-ingestion');
|
||||
});
|
||||
|
||||
test('should work across multiple service initializations', async () => {
|
||||
// Simulate multiple services in the same process (like tests)
|
||||
|
||||
// First service
|
||||
const dataServiceDir = join(TEST_DIR, 'apps', 'data-ingestion');
|
||||
process.chdir(dataServiceDir);
|
||||
|
||||
let config = await initializeServiceConfig();
|
||||
expect(config.app.name).toBe('data-ingestion');
|
||||
|
||||
// Reset and switch to another service
|
||||
resetConfig();
|
||||
const webApiDir = join(TEST_DIR, 'apps', 'web-api');
|
||||
process.chdir(webApiDir);
|
||||
|
||||
config = await initializeServiceConfig();
|
||||
expect(config.app.name).toBe('web-api');
|
||||
|
||||
// Each service should get its own config
|
||||
expect(config.service.port).toBe(4000); // web-api port
|
||||
});
|
||||
});
|
||||
|
||||
const TEST_ROOT = TEST_DIR;
|
||||
|
||||
function setupRealUsageScenarios() {
|
||||
const scenarios = {
|
||||
root: TEST_ROOT,
|
||||
dataService: join(TEST_ROOT, 'apps', 'data-ingestion'),
|
||||
webApi: join(TEST_ROOT, 'apps', 'web-api'),
|
||||
cacheLib: join(TEST_ROOT, 'libs', 'cache'),
|
||||
};
|
||||
|
||||
// Create directory structure
|
||||
Object.values(scenarios).forEach(dir => {
|
||||
mkdirSync(join(dir, 'config'), { recursive: true });
|
||||
});
|
||||
|
||||
// Root config (monorepo/config/*)
|
||||
const rootConfigs = {
|
||||
development: {
|
||||
app: {
|
||||
name: 'stock-bot-monorepo',
|
||||
version: '1.0.0'
|
||||
},
|
||||
database: {
|
||||
postgres: {
|
||||
host: 'localhost',
|
||||
port: 5432,
|
||||
database: 'trading_bot',
|
||||
username: 'trading_user',
|
||||
password: 'trading_pass_dev'
|
||||
},
|
||||
questdb: {
|
||||
host: 'localhost',
|
||||
port: 9009,
|
||||
database: 'questdb'
|
||||
},
|
||||
mongodb: {
|
||||
host: 'localhost',
|
||||
port: 27017,
|
||||
database: 'stock'
|
||||
},
|
||||
dragonfly: {
|
||||
host: 'localhost',
|
||||
port: 6379
|
||||
}
|
||||
},
|
||||
logging: {
|
||||
level: 'info',
|
||||
format: 'json'
|
||||
},
|
||||
providers: {
|
||||
yahoo: {
|
||||
name: 'Yahoo Finance',
|
||||
enabled: true,
|
||||
priority: 1,
|
||||
baseUrl: 'https://query1.finance.yahoo.com'
|
||||
},
|
||||
eod: {
|
||||
name: 'EOD Historical Data',
|
||||
enabled: false,
|
||||
priority: 2,
|
||||
apiKey: 'demo-api-key',
|
||||
baseUrl: 'https://eodhistoricaldata.com/api'
|
||||
}
|
||||
}
|
||||
},
|
||||
production: {
|
||||
logging: {
|
||||
level: 'warn'
|
||||
},
|
||||
database: {
|
||||
postgres: {
|
||||
host: 'prod-postgres.internal',
|
||||
port: 5432
|
||||
}
|
||||
}
|
||||
},
|
||||
test: {
|
||||
logging: {
|
||||
level: 'debug'
|
||||
},
|
||||
database: {
|
||||
postgres: {
|
||||
database: 'trading_bot_test'
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
Object.entries(rootConfigs).forEach(([env, config]) => {
|
||||
writeFileSync(
|
||||
join(scenarios.root, 'config', `${env}.json`),
|
||||
JSON.stringify(config, null, 2)
|
||||
);
|
||||
});
|
||||
|
||||
// Data service config
|
||||
writeFileSync(
|
||||
join(scenarios.dataService, 'config', 'development.json'),
|
||||
JSON.stringify({
|
||||
app: {
|
||||
name: 'data-ingestion'
|
||||
},
|
||||
service: {
|
||||
name: 'data-ingestion',
|
||||
port: 3001,
|
||||
workers: 2
|
||||
}
|
||||
}, null, 2)
|
||||
);
|
||||
|
||||
// Web API config
|
||||
writeFileSync(
|
||||
join(scenarios.webApi, 'config', 'development.json'),
|
||||
JSON.stringify({
|
||||
app: {
|
||||
name: 'web-api'
|
||||
},
|
||||
service: {
|
||||
name: 'web-api',
|
||||
port: 4000,
|
||||
cors: {
|
||||
origin: ['http://localhost:3000', 'http://localhost:4200']
|
||||
}
|
||||
}
|
||||
}, null, 2)
|
||||
);
|
||||
|
||||
// Cache lib config
|
||||
writeFileSync(
|
||||
join(scenarios.cacheLib, 'config', 'development.json'),
|
||||
JSON.stringify({
|
||||
app: {
|
||||
name: 'cache-lib'
|
||||
},
|
||||
service: {
|
||||
name: 'cache-lib'
|
||||
}
|
||||
}, null, 2)
|
||||
);
|
||||
|
||||
// Root .env file
|
||||
writeFileSync(
|
||||
join(scenarios.root, '.env'),
|
||||
`NODE_ENV=development
|
||||
DEBUG=true
|
||||
# Provider API keys
|
||||
EOD_API_KEY=demo-key
|
||||
WEBSHARE_API_KEY=demo-webshare-key
|
||||
`
|
||||
);
|
||||
|
||||
// Service-specific .env files
|
||||
writeFileSync(
|
||||
join(scenarios.dataService, '.env'),
|
||||
`SERVICE_DEBUG=true
|
||||
DATA_SERVICE_RATE_LIMIT=1000
|
||||
`
|
||||
);
|
||||
}
|
||||
11
libs/core/config/tsconfig.json
Normal file
11
libs/core/config/tsconfig.json
Normal file
|
|
@ -0,0 +1,11 @@
|
|||
{
|
||||
"extends": "../../../tsconfig.json",
|
||||
"compilerOptions": {
|
||||
"outDir": "./dist",
|
||||
"rootDir": "./src",
|
||||
"composite": true
|
||||
},
|
||||
"include": ["src/**/*"],
|
||||
"references": [
|
||||
]
|
||||
}
|
||||
19
libs/core/config/turbo.json
Normal file
19
libs/core/config/turbo.json
Normal file
|
|
@ -0,0 +1,19 @@
|
|||
{
|
||||
"extends": ["//"],
|
||||
"tasks": {
|
||||
"build": {
|
||||
"dependsOn": [],
|
||||
"outputs": ["dist/**"],
|
||||
"inputs": [
|
||||
"src/**",
|
||||
"package.json",
|
||||
"tsconfig.json",
|
||||
"!**/*.test.ts",
|
||||
"!**/*.spec.ts",
|
||||
"!**/test/**",
|
||||
"!**/tests/**",
|
||||
"!**/__tests__/**"
|
||||
]
|
||||
}
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue