@showbridge/lib/dist/lib/config.js

Main library for showbridge protocol router

import { Ajv } from 'ajv';
import { cloneDeep, has } from 'lodash-es';
import { TriggerTypeClassMap } from './triggers/index.js';
import getConfigMigrations from './utils/migrations.js';
class Config {
    constructor(configObj, schema) {
        this.schema = schema;
        this.validate = new Ajv().compile(schema);
        const migratedConfig = this.migrate(configObj);
        if (!this.validate(migratedConfig)) {
            throw this.validate.errors;
        }
        this.obj = migratedConfig;
        this.loadHandlers();
        this.loadProtocols();
    }
    loadHandlers() {
        this.handlers = {
            http: {
                triggers: [],
            },
            midi: {
                triggers: [],
            },
            mqtt: {
                triggers: [],
            },
            osc: {
                triggers: [],
            },
            tcp: {
                triggers: [],
            },
            udp: {
                triggers: [],
            },
            ws: {
                triggers: [],
            },
        };
        Object.keys(this.obj.handlers).forEach((handlerType) => {
            if (this.obj.handlers) {
                this.handlers[handlerType] = this.obj.handlers[handlerType];
                // NOTE(jwetzell): turn trigger JSON into class instances
                this.handlers[handlerType].triggers = this.handlers[handlerType]?.triggers
                    ?.filter((trigger) => has(TriggerTypeClassMap, trigger.type))
                    .map((trigger) => new TriggerTypeClassMap[trigger.type](trigger));
            }
        });
    }
    loadProtocols() {
        this.protocols = {
            cloud: {
                params: {},
            },
            http: {
                params: {
                    port: 3000,
                },
            },
            midi: {
                params: {},
            },
            mqtt: {
                params: {
                    broker: '',
                    topics: [],
                },
            },
            tcp: {
                params: {
                    port: 8000,
                },
            },
            udp: {
                params: {
                    port: 8000,
                },
            },
        };
        Object.keys(this.obj.protocols).forEach((protocolType) => {
            if (this.obj.protocols) {
                this.protocols[protocolType] = this.obj.protocols[protocolType];
            }
        });
    }
    migrate(configObj) {
        const migrations = getConfigMigrations(configObj);
        let migratedConfig = cloneDeep(configObj);
        migrations.forEach((migration) => {
            migratedConfig = migration(migratedConfig);
        });
        return migratedConfig;
    }
    getTriggers(messageType) {
        if (this.handlers[messageType] && this.handlers[messageType].triggers) {
            return this.handlers[messageType].triggers;
        }
        return [];
    }
    toJSON() {
        const config = cloneDeep(this.obj);
        if (config.$schema) {
            delete config.$schema;
        }
        // TODO(jwetzell): should toJSON be called on triggers?
        return config;
    }
}
export default Config;