kequapp/dist/router/util/cacher.js

A minimal, zero-magic Node web framework built on native APIs

import path from 'node:path';
import errorHandler from "../../built-in/error-handler.js";
import jsonRenderer from "../../built-in/json-renderer.js";
import textRenderer from "../../built-in/text-renderer.js";
import logger, { extendLogger } from "../../util/logger.js";
import createRegexp from "../create-regexp.js";
import { priorityContentType, priorityUrl } from "./priority.js";
import warnDuplicates from "./warn-duplicates.js";
export function cacheRoutes(structure) {
    const routes = cacheRoutesMeta(structure);
    warnDuplicates(routes, structure.logger?.warn ?? logger.warn);
    return routes.sort(priorityUrl).map((item) => ({
        ...sanitize(item),
        method: item.method,
    }));
}
function cacheRoutesMeta(target) {
    const routes = [];
    for (const route of target.routes ?? []) {
        routes.push({
            ...extendRoute(target, route),
            method: route.method,
            url: extendUrl(target.url, route.url),
        });
    }
    for (const branch of target.branches ?? []) {
        for (const source of cacheRoutesMeta(branch)) {
            routes.push({
                ...extendBranch(target, source),
                method: source.method,
                url: extendUrl(target.url, source.url),
            });
        }
    }
    return routes;
}
export function cacheBranches(structure) {
    const branches = cacheBranchesMeta(structure);
    branches.push({
        actions: [...(structure.actions ?? [])],
        errorHandlers: [...(structure.errorHandlers ?? [])],
        renderers: [...(structure.renderers ?? [])],
        autoHead: structure.autoHead,
        logger: { ...structure.logger },
        url: '/**',
    });
    return branches.map(sanitize);
}
function cacheBranchesMeta(target) {
    const branches = [];
    for (const branch of target.branches ?? []) {
        for (const source of cacheBranchesMeta(branch)) {
            branches.push({
                ...extendBranch(target, source),
                url: extendUrl(target.url, source.url),
            });
        }
    }
    return branches;
}
function sanitize(item) {
    return {
        actions: item.actions,
        regexp: createRegexp(item.url),
        errorHandlers: [
            ...item.errorHandlers.sort(priorityContentType),
            errorHandler,
        ],
        renderers: [
            ...item.renderers.sort(priorityContentType),
            jsonRenderer,
            textRenderer,
        ],
        autoHead: item.autoHead ?? true,
        logger: extendLogger(logger, item.logger),
    };
}
function extendBranch(target, source) {
    return {
        actions: [...(target.actions ?? []), ...source.actions],
        errorHandlers: [
            ...source.errorHandlers,
            ...(target.errorHandlers ?? []),
        ],
        renderers: [...source.renderers, ...(target.renderers ?? [])],
        autoHead: source.autoHead ?? target.autoHead,
        logger: source.logger ?? target.logger,
    };
}
function extendRoute(target, route) {
    return {
        actions: [...(target.actions ?? []), ...(route.actions ?? [])],
        errorHandlers: [...(target.errorHandlers ?? [])],
        renderers: [...(target.renderers ?? [])],
        autoHead: route.autoHead ?? target.autoHead,
        logger: route.logger ?? target.logger,
    };
}
function extendUrl(target = '/', source = '/') {
    return path.join('/', target, source);
}