redis-smq-rest-api/dist/esm/src/lib/router/index.js

REST API for RedisSMQ: OpenAPI 3 schema and Swagger UI for managing queues, messages, and consumers.

import KoaRouter from '@koa/router';
import { RedisSMQError } from 'redis-smq-common';
import { Container } from '../../container/Container.js';
import { getErrorResponseParams } from '../../errors/getErrorResponseParams.js';
import { SchemaGenerator } from '../validator/schema-generator.js';
import { ValidateRequestMiddleware } from './middlewares/ValidateRequestMiddleware.js';
import { ValidateResponseMiddleware } from './middlewares/ValidateResponseMiddleware.js';
import { parseRoutingMap } from './parser.js';
const validatorCacheByController = new Map();
function getOrCreateValidatorsForController(schemaGenerator, controllerName, payloadSources) {
    const cacheKey = `${controllerName}:${payloadSources.join(',')}`;
    let cachedValidators = validatorCacheByController.get(cacheKey);
    if (!cachedValidators) {
        const requestSchemas = schemaGenerator.getRequestSchemas(controllerName, payloadSources);
        const requestValidators = schemaGenerator.getRequestValidators(requestSchemas);
        const responseSchemas = schemaGenerator.getResponseSchemas(controllerName);
        const responseValidators = schemaGenerator.getResponseValidators(responseSchemas);
        cachedValidators = {
            requestValidators,
            responseValidators,
        };
        validatorCacheByController.set(cacheKey, cachedValidators);
    }
    return cachedValidators;
}
async function registerRouteWithValidation(router, controllerHandler, controllerName, httpMethod, payloadSources, routePath, schemaGenerator) {
    const { requestValidators, responseValidators } = getOrCreateValidatorsForController(schemaGenerator, controllerName, payloadSources);
    router[httpMethod](routePath, ValidateRequestMiddleware(requestValidators), async (ctx, next) => {
        try {
            const [statusCode, responseData] = await controllerHandler(ctx, next);
            const responseBody = responseData ?? null;
            ctx.status = statusCode;
            ctx.body =
                responseBody === null && statusCode === 204
                    ? null
                    : { data: responseBody };
            ctx.state.responseSchemaKey = 'OK';
        }
        catch (error) {
            if (error instanceof RedisSMQError) {
                const [errorCode, errorMessage] = getErrorResponseParams(error);
                ctx.state.responseSchemaKey = errorMessage;
                ctx.status = errorCode;
                ctx.body = {
                    error: {
                        code: errorCode,
                        message: errorMessage,
                        details: {},
                    },
                };
            }
            else
                throw error;
        }
        return next();
    }, ValidateResponseMiddleware(responseValidators));
}
export async function registerResources(routingMap) {
    const { apiServer } = Container.getInstance().resolve('config');
    const { basePath } = apiServer;
    const apiRouter = new KoaRouter({
        prefix: basePath && basePath.length > 1 ? basePath : undefined,
    });
    const schemaGenerator = SchemaGenerator();
    await parseRoutingMap(routingMap, async (controllerHandler, controllerName, httpMethod, payloadSources, routePath) => {
        await registerRouteWithValidation(apiRouter, controllerHandler, controllerName, httpMethod, payloadSources, routePath, schemaGenerator);
    });
    return apiRouter;
}
//# sourceMappingURL=index.js.map