kequapp/dist/utils/validate.js

DEPRECATED: renamed to @kequtech/arbor

import { getParts } from "../router/tools/extract.js";
export const PATHNAME_REGEX = /^(?:\/:[a-zA-Z_]\w*|\/[^/*:\\? ]*|\/\*{2})+$/;
export const CONTENT_TYPE_REGEX = /^[a-zA-Z]+\/(?:[a-zA-Z]+|\*)|\*$/;
export function validateObject(topic, name, type) {
    if (topic !== undefined) {
        if (typeof topic !== 'object' || topic === null || Array.isArray(topic)) {
            throw new Error(`${name} must be an object`);
        }
        if (type !== undefined) {
            for (const key of Object.keys(topic)) {
                validateType(topic[key], `${name} ${key}`, type);
            }
        }
    }
}
export function validateArray(topic, name, type) {
    if (topic !== undefined) {
        if (!Array.isArray(topic)) {
            throw new Error(`${name} must be an array`);
        }
        if (type !== undefined) {
            for (const value of topic) {
                validateType(value, `${name} item`, type);
            }
        }
    }
}
export function validateType(topic, name, type) {
    if (topic !== undefined) {
        if (type === 'object') {
            validateObject(topic, name);
        }
        else if (typeof topic !== type) {
            throw new Error(`${name} must be a ${type}`);
        }
    }
}
export function validatePathname(topic, name, isWild = false) {
    if (topic !== undefined) {
        validateType(topic, name, 'string');
        if (topic[0] !== '/') {
            throw new Error(`${name} must start with '/'`);
        }
        if (isWild && !topic.endsWith('/**')) {
            throw new Error(`${name} must end with '/**'`);
        }
        if (!PATHNAME_REGEX.test(topic)) {
            throw new Error(`${name} invalid format '${topic}'`);
        }
        const existing = [];
        for (const part of getParts(topic)) {
            if (!part.startsWith(':'))
                continue;
            if (part === ':wild') {
                throw new Error(`${name} cannot contain :wild '${topic}'`);
            }
            if (existing.includes(part)) {
                throw new Error(`${name} duplicate ${part} '${topic}'`);
            }
            existing.push(part);
        }
    }
}
export function validateContentType(topic, name) {
    if (topic !== undefined) {
        validateType(topic, name, 'string');
        if (!CONTENT_TYPE_REGEX.test(topic)) {
            throw new Error(`${name} invalid format '${topic}'`);
        }
    }
}
export function validateExists(topic, name) {
    if (topic === undefined) {
        throw new Error(`${name} is undefined`);
    }
}
export function validateBranch(branch) {
    validateExists(branch, 'Branch');
    validateObject(branch, 'Branch');
    validatePathname(branch.url, 'Branch url');
    validateArray(branch.actions, 'Branch actions', 'function');
    validateArray(branch.branches, 'Branch actions');
    validateArray(branch.routes, 'Branch routes');
    validateArray(branch.errorHandlers, 'Branch errorHandlers');
    validateArray(branch.renderers, 'Branch renderers');
    validateLogger(branch.logger);
    validateType(branch.autoHead, 'Branch autoHead', 'boolean');
}
export function validateRoute(route) {
    validateExists(route, 'Route');
    validateObject(route, 'Route');
    validateExists(route.method, 'Route method');
    validateType(route.method, 'Route method', 'string');
    validatePathname(route.url, 'Route url');
    validateArray(route.actions, 'Route actions', 'function');
    validateLogger(route.logger);
    validateType(route.autoHead, 'Route autoHead', 'boolean');
}
export function validateErrorHandler(errorHandler) {
    validateExists(errorHandler, 'Error handler');
    validateObject(errorHandler, 'Error handler');
    validateExists(errorHandler.contentType, 'Error handler contentType');
    validateContentType(errorHandler.contentType, 'Error handler contentType');
    validateExists(errorHandler.action, 'Error handler action');
    validateType(errorHandler.action, 'Error handler action', 'function');
}
export function validateRenderer(renderer) {
    validateExists(renderer, 'Renderer');
    validateObject(renderer, 'Renderer');
    validateExists(renderer.contentType, 'Renderer contentType');
    validateContentType(renderer.contentType, 'Renderer contentType');
    validateExists(renderer.action, 'Renderer action');
    validateType(renderer.action, 'Renderer action', 'function');
}
export function validateLogger(logger) {
    validateObject(logger, 'Logger');
    if (logger !== undefined) {
        validateExists(logger.error, 'Logger error');
        validateType(logger.error, 'Logger error', 'function');
        validateExists(logger.warn, 'Logger warn');
        validateType(logger.warn, 'Logger warn', 'function');
        validateExists(logger.info, 'Logger info');
        validateType(logger.info, 'Logger info', 'function');
    }
}