syslog-portal/dist/inversify.config.js

A portal for ingesting syslog data

import 'reflect-metadata';
import { Container } from 'inversify';
import { TYPES } from './types.js';
import { ArchiverType } from './models/config.js';
import config from 'config';
import { LoggerFactory } from './logger/logger.js';
import { ServerFactory } from './factories/serverFactory.js';
import { MetricServer } from './services/metricServer.js';
import { HealthMonitor } from './services/healthMonitor.js';
import { MongoArchiver } from './services/mongoArchiver.js';
import { MongoConnPool } from './services/mongoConnectionPool.js';
import { PouchArchiver } from './services/pouchArchiver.js';
import PouchDB from 'pouchdb';
import { readFileSync } from 'node:fs';
import { dirname, join } from 'node:path';
import { fileURLToPath } from 'node:url';
const __dirname = dirname(fileURLToPath(import.meta.url));
const defaultConfig = JSON.parse(readFileSync(join(__dirname, 'config', 'default.json'), {
    encoding: 'utf8',
}));
const appContainer = new Container();
const appConfig = config.has('server')
    ? config.get('server')
    : defaultConfig.server;
const logConfig = config.has('logger')
    ? config.get('logger')
    : defaultConfig.logger;
appContainer.bind(TYPES.Configurations.Main).toConstantValue(appConfig);
appContainer
    .bind(TYPES.Configurations.Logger)
    .toConstantValue(logConfig);
appContainer
    .bind(TYPES.Factories.LoggerFactory)
    .to(LoggerFactory)
    .inSingletonScope();
appContainer
    .bind(TYPES.Factories.ServerFactory)
    .to(ServerFactory)
    .inSingletonScope();
appContainer
    .bind(TYPES.Services.HealthMonitor)
    .to(HealthMonitor)
    .inSingletonScope();
appContainer
    .bind(TYPES.Services.MetricServer)
    .to(MetricServer)
    .inSingletonScope();
appContainer
    .bind(TYPES.Logger)
    .toDynamicValue((ctx) => {
    const factory = ctx.container.get(TYPES.Factories.LoggerFactory);
    return factory.createLogger();
});
if (appConfig.archiver.enabled) {
    if (appConfig.archiver.type === ArchiverType.MONGO) {
        appContainer
            .bind(TYPES.Services.MongoConnPool)
            .to(MongoConnPool)
            .inSingletonScope();
        appContainer
            .bind(TYPES.Listeners.MongoArchiver)
            .to(MongoArchiver)
            .inSingletonScope();
    }
    else if (appConfig.archiver.type === ArchiverType.POUCHDB) {
        appContainer
            .bind(TYPES.Connections.Database)
            .toDynamicValue((ctx) => {
            const config = ctx.container.get(TYPES.Configurations.Main);
            return new PouchDB(`${config.archiver.proto}://${config.archiver.hostname}:${config.archiver.port}/syslog`, {
                auth: {
                    username: config.archiver.usernameFile != null
                        ? readFileSync(config.archiver.usernameFile, {
                            encoding: 'utf8',
                        })
                        : config.archiver.username,
                    password: config.archiver.passwordFile != null
                        ? readFileSync(config.archiver.passwordFile, {
                            encoding: 'utf8',
                        })
                        : config.archiver.password,
                },
            });
        })
            .inSingletonScope();
        appContainer
            .bind(TYPES.Listeners.PouchArchiver)
            .to(PouchArchiver)
            .inSingletonScope();
    }
}
appContainer
    .bind(TYPES.Services.Server)
    .toDynamicValue(async (ctx) => {
    const factory = ctx.container.get(TYPES.Factories.ServerFactory);
    const config = ctx.container.get(TYPES.Configurations.Main);
    const logger = ctx.container.get(TYPES.Logger);
    const monitor = await ctx.container.getAsync(TYPES.Services.HealthMonitor);
    return factory.createServer(config, logger, monitor);
})
    .inSingletonScope();
export { appContainer };
//# sourceMappingURL=inversify.config.js.map