Class ConfigManager

packages/backend/src/configManager.ts:13–134

const logger = createLogger('config-manager');

export class ConfigManager {
    private watcher: FSWatcher;

    constructor(
        private db: PrismaClient,
        private connectionManager: ConnectionManager,
        configPath: string,
    ) {
        this.watcher = chokidar.watch(configPath, {
            ignoreInitial: true,           // Don't fire events for existing files
            awaitWriteFinish: {
                stabilityThreshold: 100,   // File size stable for 100ms
                pollInterval: 100          // Check every 100ms
            },
            atomic: true                   // Handle atomic writes (temp file + rename)
        });

        this.watcher.on('change', async () => {
            logger.debug(`Config file ${configPath} changed. Syncing config.`);
            try {
                await this.syncConfig(configPath);
            } catch (error) {
                logger.error(`Failed to sync config: ${error}`);
            }
        });

        this.syncConfig(configPath);
    }

    private syncConfig = async (configPath: string) => {
        const config = await loadConfig(configPath);

        await this.syncConnections(config.connections);
        await syncSearchContexts({
            contexts: config.contexts,
            orgId: SINGLE_TENANT_ORG_ID,
            db: this.db,
        });
    }

    private syncConnections = async (connections?: { [key: string]: ConnectionConfig }) => {
        if (connections) {
            for (const [key, newConnectionConfig] of Object.entries(connections)) {
                const existingConnection = await this.db.connection.findUnique({
                    where: {
                        name_orgId: {
                            name: key,
                            orgId: SINGLE_TENANT_ORG_ID,
                        }
                    }
                });


                const existingConnectionConfig = existingConnection ? existingConnection.config as unknown as ConnectionConfig : undefined;
                const connectionNeedsSyncing =
                    !existingConnectionConfig ||
                    !isEqual(existingConnectionConfig, newConnectionConfig);