@message-in-the-middle/core/dist/cjs/factories.js

Framework-agnostic middleware pattern for message queue processing. Core package with all middlewares.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.parseJson = parseJson;
exports.log = log;
exports.validate = validate;
exports.deduplicate = deduplicate;
exports.retry = retry;
exports.decrypt = decrypt;
exports.transform = transform;
exports.handleErrors = handleErrors;
exports.collectMetrics = collectMetrics;
exports.trace = trace;
exports.correlationId = correlationId;
exports.circuitBreaker = circuitBreaker;
exports.batch = batch;
exports.schemaRegistry = schemaRegistry;
exports.stringifyJson = stringifyJson;
exports.logOutbound = logOutbound;
exports.validateOutbound = validateOutbound;
exports.encrypt = encrypt;
exports.transformOutbound = transformOutbound;
exports.throttle = throttle;
exports.collectMetricsOutbound = collectMetricsOutbound;
exports.traceOutbound = traceOutbound;
exports.correlationIdOutbound = correlationIdOutbound;
exports.dispatch = dispatch;
exports.createDispatcher = createDispatcher;
const dispatcher_1 = require("./dispatcher");
const json_middleware_1 = require("./middlewares/json.middleware");
const logging_middleware_1 = require("./middlewares/logging.middleware");
const validation_middleware_1 = require("./middlewares/validation.middleware");
const deduplication_middleware_1 = require("./middlewares/deduplication.middleware");
const immediate_retry_middleware_1 = require("./middlewares/immediate-retry.middleware");
const encryption_middleware_1 = require("./middlewares/encryption.middleware");
const transformation_middleware_1 = require("./middlewares/transformation.middleware");
const error_handler_middleware_1 = require("./middlewares/error-handler.middleware");
const metrics_middleware_1 = require("./middlewares/metrics.middleware");
const tracing_middleware_1 = require("./middlewares/tracing.middleware");
const correlation_id_middleware_1 = require("./middlewares/correlation-id.middleware");
const circuit_breaker_middleware_1 = require("./middlewares/circuit-breaker.middleware");
const batching_middleware_1 = require("./middlewares/batching.middleware");
const schema_registry_middleware_1 = require("./middlewares/schema-registry.middleware");
const throttling_middleware_1 = require("./middlewares/throttling.middleware");
const dispatcher_2 = require("./dispatcher");
function parseJson(options) {
    return new json_middleware_1.ParseJsonInboundMiddleware(options);
}
function log(logger, options) {
    return new logging_middleware_1.LogInboundMiddleware(logger, options);
}
function validate(validator, options) {
    return new validation_middleware_1.ValidateInboundMiddleware(validator, options);
}
function deduplicate(store, options) {
    return new deduplication_middleware_1.DeduplicateInboundMiddleware(store, options);
}
function retry(options) {
    return new immediate_retry_middleware_1.ImmediateRetryInboundMiddleware(options);
}
function decrypt(encryptionService, fields, options) {
    return new encryption_middleware_1.DecryptInboundMiddleware(encryptionService, fields, options);
}
function transform(transformer) {
    return new transformation_middleware_1.TransformInboundMiddleware(transformer);
}
function handleErrors(errorHandler, maxRetries = 3) {
    return new error_handler_middleware_1.ErrorHandlerInboundMiddleware(errorHandler, maxRetries);
}
function collectMetrics(collector, options) {
    return new metrics_middleware_1.MetricsInboundMiddleware(collector, options);
}
function trace(tracer, options) {
    return new tracing_middleware_1.TracingInboundMiddleware(tracer, options);
}
function correlationId(options) {
    return new correlation_id_middleware_1.CorrelationIdInboundMiddleware(options);
}
function circuitBreaker(options) {
    return new circuit_breaker_middleware_1.CircuitBreakerInboundMiddleware(options);
}
function batch(options) {
    return new batching_middleware_1.BatchingInboundMiddleware(options);
}
function schemaRegistry(registry) {
    return new schema_registry_middleware_1.SchemaRegistryMiddleware(registry);
}
function stringifyJson(options) {
    return new json_middleware_1.StringifyJsonOutboundMiddleware(options);
}
function logOutbound(logger) {
    return new logging_middleware_1.LogOutboundMiddleware(logger);
}
function validateOutbound(validator) {
    return new validation_middleware_1.ValidateOutboundMiddleware(validator);
}
function encrypt(encryptionService, fields) {
    return new encryption_middleware_1.EncryptOutboundMiddleware(encryptionService, fields);
}
function transformOutbound(transformer) {
    return new transformation_middleware_1.TransformOutboundMiddleware(transformer);
}
function throttle(limiter, options) {
    return new throttling_middleware_1.ThrottlingOutboundMiddleware(limiter, options);
}
function collectMetricsOutbound(collector, options) {
    return new metrics_middleware_1.MetricsOutboundMiddleware(collector, options);
}
function traceOutbound(tracer, options) {
    return new tracing_middleware_1.TracingOutboundMiddleware(tracer, options);
}
function correlationIdOutbound(options) {
    return new correlation_id_middleware_1.CorrelationIdOutboundMiddleware(options);
}
function dispatch(dispatcher) {
    return new dispatcher_2.DispatcherMiddleware(dispatcher);
}
function createDispatcher(options = {}, handlers) {
    const dispatcher = new dispatcher_1.MessageDispatcher(options);
    if (handlers) {
        dispatcher.registerMany(handlers);
    }
    return dispatcher;
}
//# sourceMappingURL=factories.js.map