json-schema-to-joi/dist/joi/object.js

Converts JSON schema to Joi typescript code

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.generateObjectJoi = exports.resolveJoiObjectSchema = void 0;
const types_1 = require("./types");
const _ = require("lodash");
const resolve_1 = require("./resolve");
const generate_1 = require("./generate");
const any_1 = require("./any");
function resolveProperties(schema, options) {
    const properties = schema.properties;
    if (!properties) {
        if (schema.required) {
            const requiredPropertiesSchema = {};
            schema.required.forEach((key) => {
                requiredPropertiesSchema[key] = types_1.createJoiItem('any');
                requiredPropertiesSchema[key].required = true;
            });
            return requiredPropertiesSchema;
        }
        else {
            return undefined;
        }
    }
    const propertiesSchema = _.mapValues(properties, (property, key) => {
        const joiSchema = resolve_1.resolveJSONSchema(property, options);
        const required = (schema.required && schema.required.includes(key));
        if (required) {
            joiSchema.required = true;
        }
        return joiSchema;
    });
    if (schema.required) {
        schema.required.forEach((key) => {
            if (!properties[key]) {
                propertiesSchema[key] = types_1.createJoiItem('any');
                propertiesSchema[key].required = true;
            }
        });
    }
    return propertiesSchema;
}
function resolveJoiObjectSchema(schema, options) {
    const joiSchema = types_1.createJoiItem('object');
    joiSchema.keys = resolveProperties(schema, options);
    let additionalProperties = schema.additionalProperties;
    if (additionalProperties === undefined) {
        additionalProperties = true;
    }
    if (typeof additionalProperties === 'boolean') {
        joiSchema.unknown = additionalProperties;
    }
    const minProperties = schema.minProperties;
    const maxProperties = schema.maxProperties;
    if (minProperties !== undefined) {
        if (minProperties === maxProperties) {
            joiSchema.length = minProperties;
        }
        else {
            joiSchema.min = minProperties;
        }
    }
    if (maxProperties !== undefined) {
        if (minProperties === maxProperties) {
            joiSchema.length = maxProperties;
        }
        else {
            joiSchema.max = maxProperties;
        }
    }
    if (schema.dependencies) {
        _.forIn(schema.dependencies, (dependency, key) => {
            if (_.isArray(dependency)) {
                if (!joiSchema.with) {
                    joiSchema.with = {};
                }
                joiSchema.with[key] = dependency;
            }
            else {
                if (dependency.required && _.isArray(dependency.required)) {
                    if (!joiSchema.with) {
                        joiSchema.with = {};
                    }
                    joiSchema.with[key] = dependency.required;
                }
                if (dependency.properties) {
                    const extraDependency = _.clone(dependency);
                    extraDependency.required = undefined;
                    const extraProperties = resolveProperties(extraDependency, options);
                    joiSchema.keys = _.assign(joiSchema.keys, extraProperties);
                }
            }
        });
    }
    if (schema.patternProperties) {
        if (!joiSchema.patterns) {
            joiSchema.patterns = [];
        }
        const pattern = joiSchema.patterns;
        _.forIn(schema.patternProperties, (patternProperty, key) => {
            pattern.push({
                targetPattern: key,
                schema: resolve_1.resolveJSONSchema(patternProperty),
            });
        });
    }
    if (typeof schema.additionalProperties !== 'boolean' && schema.additionalProperties) {
        if (!joiSchema.patterns) {
            joiSchema.patterns = [];
        }
        joiSchema.patterns.push({
            targetPattern: '^',
            schema: resolve_1.resolveJSONSchema(schema.additionalProperties, options),
        });
    }
    any_1.resolveJoiAnyMeta(joiSchema, schema);
    return joiSchema;
}
exports.resolveJoiObjectSchema = resolveJoiObjectSchema;
function generateObjectJoi(schema) {
    const content = generate_1.openJoi([
        200,
        'object()'
    ]);
    const keys = schema.keys;
    if (keys) {
        const keyWithQuota = _.keys(keys).some((v) => {
            return v.includes('-') || v.includes(' ');
        });
        content.push(...[
            '.keys',
            "(",
            "{",
        ]);
        _.keys(keys).forEach((key) => {
            let printKey = key;
            if (keyWithQuota) {
                printKey = '\'' + printKey + '\'';
            }
            content.push(...[
                printKey,
                ":",
                ...generate_1.generateJoiStatement(keys[key]),
                ",",
            ]);
        });
        content.push(...[
            "}",
            ")",
        ]);
    }
    if (schema.min !== undefined) {
        content.push(`.min(${schema.min})`);
    }
    if (schema.max !== undefined) {
        content.push(`.max(${schema.max})`);
    }
    if (schema.length !== undefined) {
        content.push(`.length(${schema.length})`);
    }
    if (schema.with) {
        _.forIn(schema.with, (peers, key) => {
            content.push(`.with('${key}', ['${peers.join(',')}'])`);
        });
    }
    if (schema.patterns) {
        schema.patterns.forEach((pattern) => {
            const target = pattern.targetPattern;
            const subSchema = pattern.schema;
            content.push(...[
                '.pattern',
                "(",
            ]);
            if (typeof target === 'string') {
                content.push('/' + target + '/');
            }
            else {
                content.push(...generate_1.generateJoiStatement(target));
            }
            content.push(",");
            content.push(...generate_1.generateJoiStatement(subSchema));
            content.push(")");
        });
    }
    content.push(...any_1.generateAnyJoi(schema));
    return generate_1.closeJoi(content);
}
exports.generateObjectJoi = generateObjectJoi;
//# sourceMappingURL=object.js.map