@vpriem/kafka-broker/dist/buildConfig.js

Easily compose and manage your kafka resources in one place

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.buildConfig = exports.buildSchemaRegistry = exports.buildSubscriptions = exports.buildPublications = exports.buildProducers = exports.buildKafka = void 0;
const kafkajs_1 = require("kafkajs");
const buildKafka = (config, clientId) => ({ clientId, ...config });
exports.buildKafka = buildKafka;
const { DefaultPartitioner: createPartitioner } = kafkajs_1.Partitioners;
const buildProducers = (producers, kafka, { batch: batchDefaults, ...defaults } = {}) => ({
    default: {
        kafka,
        producer: { createPartitioner, ...defaults },
        batch: batchDefaults,
    },
    ...Object.fromEntries(Object.entries(producers).map(([name, { batch: batchConfig, ...producerConfig }]) => [
        name,
        {
            kafka,
            producer: {
                createPartitioner,
                ...defaults,
                ...producerConfig,
            },
            batch: (batchDefaults || batchConfig) && {
                ...batchDefaults,
                ...batchConfig,
            },
        },
    ])),
});
exports.buildProducers = buildProducers;
const buildSchema = (schema) => {
    if (typeof schema === 'number')
        return { id: schema };
    if (typeof schema === 'string')
        // TODO: parse subject:version
        return { subject: schema, version: 'latest' };
    return schema;
};
const buildPublications = (publications, producer = 'default') => Object.fromEntries(Object.entries(publications).map(([name, publicationConfig]) => typeof publicationConfig === 'object' &&
    !Array.isArray(publicationConfig)
    ? [
        name,
        {
            producer,
            ...publicationConfig,
            schema: buildSchema(publicationConfig.schema),
        },
    ]
    : [name, { producer, topic: publicationConfig }]));
exports.buildPublications = buildPublications;
const buildTopics = (topics) => typeof topics === 'string'
    ? [{ topic: topics }]
    : topics.map((topic) => typeof topic === 'string' ? { topic } : topic);
const isSubscriptionConfig = (config) => typeof config.topics !== 'undefined';
const buildSubscriptions = (subscriptions, groupPrefix, kafka, defaults) => Object.fromEntries(Object.entries(subscriptions).map(([name, subscriptionConfig]) => {
    const consumer = { ...defaults, groupId: `${groupPrefix}.${name}` };
    if (isSubscriptionConfig(subscriptionConfig)) {
        return [
            name,
            {
                kafka,
                ...subscriptionConfig,
                consumer: {
                    ...consumer,
                    ...subscriptionConfig.consumer,
                },
                topics: buildTopics(subscriptionConfig.topics),
            },
        ];
    }
    return [
        name,
        {
            kafka,
            consumer,
            topics: buildTopics(subscriptionConfig),
        },
    ];
}));
exports.buildSubscriptions = buildSubscriptions;
const buildSchemaRegistry = (config) => typeof config === 'string' ? { host: config } : config;
exports.buildSchemaRegistry = buildSchemaRegistry;
const buildConfig = ({ namespace, defaults, config, schemaRegistry, producers = {}, publications = {}, subscriptions = {}, }) => ({
    namespace,
    kafka: {
        default: (0, exports.buildKafka)(config, namespace),
    },
    schemaRegistry: (0, exports.buildSchemaRegistry)(schemaRegistry),
    producers: (0, exports.buildProducers)(producers, 'default', defaults?.producer),
    publications: (0, exports.buildPublications)(publications),
    subscriptions: (0, exports.buildSubscriptions)(subscriptions, namespace, 'default', defaults?.consumer),
});
exports.buildConfig = buildConfig;
//# sourceMappingURL=buildConfig.js.map