@elliots/openapi-ts-backend/dist/utils.js

Enables easy implementions of OpenAPI REST APIs in TypeScript with full typings of schemas and operations.

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.inRange = exports.oneOrMany = exports.transform = exports.mapObject = exports.matchSchema = exports.getAjv = exports.getParametersSchema = exports.getParameterMap = exports.formatArray = exports.formatValidationError = exports.resolve = void 0;
const ajv_1 = __importDefault(require("ajv"));
const ajv_formats_1 = __importDefault(require("ajv-formats"));
function resolve(resolvable) {
    return typeof resolvable === 'function' ? resolvable() : resolvable;
}
exports.resolve = resolve;
function formatValidationError(error) {
    return `At '${error.dataPath}': ${Object.entries(error.params)
        .map(([k, v]) => `${k}: ${JSON.stringify(v)}`)
        .join(', ')}`;
}
exports.formatValidationError = formatValidationError;
function formatArray(items, formatter, prefix = `\n  * `) {
    return items.map(item => `${prefix}${formatter(item)}`).join('');
}
exports.formatArray = formatArray;
function getParameterMap({ parameters = [] }, type) {
    const result = {};
    for (const parameter of parameters) {
        if ('in' in parameter && parameter.in === type) {
            result[parameter.name] = parameter;
        }
    }
    return result;
}
exports.getParameterMap = getParameterMap;
function getParametersSchema(parameters) {
    const result = {
        type: 'object',
        required: [],
        properties: {},
        additionalProperties: true
    };
    for (const [name, parameter] of Object.entries(parameters)) {
        const { required = false, schema = {} } = parameter;
        result.properties[name] = schema;
        if (required) {
            result.required.push(name);
        }
    }
    return result;
}
exports.getParametersSchema = getParametersSchema;
function getAjv(ajvOptions) {
    return ajv_formats_1.default(new ajv_1.default(ajvOptions));
}
exports.getAjv = getAjv;
// Note that errors is an out parameter
function matchSchema(ajv, source, schema, errors) {
    // Ajv mutates the passed object so we pass a copy
    const result = cloneObject(source);
    const validate = ajv.compile(schema);
    validate(result);
    if (validate.errors) {
        errors.push(...validate.errors);
    }
    return result;
}
exports.matchSchema = matchSchema;
function cloneObject(source) {
    return JSON.parse(JSON.stringify(source));
}
/**
 * Map the values of an object
 * @param obj Source object
 * @param func Transform function
 */
function mapObject(obj, func) {
    return Object.fromEntries(Object.entries(obj).map(([k, v]) => [k, func(v, k, obj)]));
}
exports.mapObject = mapObject;
function transform(value, func) {
    return Array.isArray(value) ? value.map(func) : func(value);
}
exports.transform = transform;
/**
 * Apply a transformation to a single value or an array of values
 * @param func Transform function
 * @returns Single transformed value or array of transformed values
 */
function oneOrMany(func) {
    return value => Array.isArray(value) ? value.map(func) : func(value);
}
exports.oneOrMany = oneOrMany;
/**
 * Return a number range validator function
 * @param min Min value (inclusive)
 * @param max Max value (exclusive)
 */
function inRange(min, max) {
    return value => value >= min && value < max;
}
exports.inRange = inRange;
//# sourceMappingURL=utils.js.map