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

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

import { MessageDispatcher } from './dispatcher';
import { ParseJsonInboundMiddleware, StringifyJsonOutboundMiddleware } from './middlewares/json.middleware';
import { LogInboundMiddleware, LogOutboundMiddleware } from './middlewares/logging.middleware';
import { ValidateInboundMiddleware, ValidateOutboundMiddleware } from './middlewares/validation.middleware';
import { DeduplicateInboundMiddleware } from './middlewares/deduplication.middleware';
import { ImmediateRetryInboundMiddleware } from './middlewares/immediate-retry.middleware';
import { DecryptInboundMiddleware, EncryptOutboundMiddleware } from './middlewares/encryption.middleware';
import { TransformInboundMiddleware, TransformOutboundMiddleware } from './middlewares/transformation.middleware';
import { ErrorHandlerInboundMiddleware } from './middlewares/error-handler.middleware';
import { MetricsInboundMiddleware, MetricsOutboundMiddleware } from './middlewares/metrics.middleware';
import { TracingInboundMiddleware, TracingOutboundMiddleware } from './middlewares/tracing.middleware';
import { CorrelationIdInboundMiddleware, CorrelationIdOutboundMiddleware } from './middlewares/correlation-id.middleware';
import { CircuitBreakerInboundMiddleware } from './middlewares/circuit-breaker.middleware';
import { BatchingInboundMiddleware } from './middlewares/batching.middleware';
import { SchemaRegistryMiddleware } from './middlewares/schema-registry.middleware';
import { ThrottlingOutboundMiddleware } from './middlewares/throttling.middleware';
import { DispatcherMiddleware } from './dispatcher';
export function parseJson(options) {
    return new ParseJsonInboundMiddleware(options);
}
export function log(logger, options) {
    return new LogInboundMiddleware(logger, options);
}
export function validate(validator, options) {
    return new ValidateInboundMiddleware(validator, options);
}
export function deduplicate(store, options) {
    return new DeduplicateInboundMiddleware(store, options);
}
export function retry(options) {
    return new ImmediateRetryInboundMiddleware(options);
}
export function decrypt(encryptionService, fields, options) {
    return new DecryptInboundMiddleware(encryptionService, fields, options);
}
export function transform(transformer) {
    return new TransformInboundMiddleware(transformer);
}
export function handleErrors(errorHandler, maxRetries = 3) {
    return new ErrorHandlerInboundMiddleware(errorHandler, maxRetries);
}
export function collectMetrics(collector, options) {
    return new MetricsInboundMiddleware(collector, options);
}
export function trace(tracer, options) {
    return new TracingInboundMiddleware(tracer, options);
}
export function correlationId(options) {
    return new CorrelationIdInboundMiddleware(options);
}
export function circuitBreaker(options) {
    return new CircuitBreakerInboundMiddleware(options);
}
export function batch(options) {
    return new BatchingInboundMiddleware(options);
}
export function schemaRegistry(registry) {
    return new SchemaRegistryMiddleware(registry);
}
export function stringifyJson(options) {
    return new StringifyJsonOutboundMiddleware(options);
}
export function logOutbound(logger) {
    return new LogOutboundMiddleware(logger);
}
export function validateOutbound(validator) {
    return new ValidateOutboundMiddleware(validator);
}
export function encrypt(encryptionService, fields) {
    return new EncryptOutboundMiddleware(encryptionService, fields);
}
export function transformOutbound(transformer) {
    return new TransformOutboundMiddleware(transformer);
}
export function throttle(limiter, options) {
    return new ThrottlingOutboundMiddleware(limiter, options);
}
export function collectMetricsOutbound(collector, options) {
    return new MetricsOutboundMiddleware(collector, options);
}
export function traceOutbound(tracer, options) {
    return new TracingOutboundMiddleware(tracer, options);
}
export function correlationIdOutbound(options) {
    return new CorrelationIdOutboundMiddleware(options);
}
export function dispatch(dispatcher) {
    return new DispatcherMiddleware(dispatcher);
}
export function createDispatcher(options = {}, handlers) {
    const dispatcher = new MessageDispatcher(options);
    if (handlers) {
        dispatcher.registerMany(handlers);
    }
    return dispatcher;
}
//# sourceMappingURL=factories.js.map