swagger-typed-express-docs/dist/jsValueToSchema.js

Simple express runtime parser and documentation swagger generator with 100% support of Typescript static types

"use strict";
var __read = (this && this.__read) || function (o, n) {
    var m = typeof Symbol === "function" && o[Symbol.iterator];
    if (!m) return o;
    var i = m.call(o), r, ar = [], e;
    try {
        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
    }
    catch (error) { e = { error: error }; }
    finally {
        try {
            if (r && !r.done && (m = i["return"])) m.call(i);
        }
        finally { if (e) throw e.error; }
    }
    return ar;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.tSchemaToJSValue = exports.jsValueToSchema = void 0;
var schemaBuilder_1 = require("./schemaBuilder");
var jsValueToSchema = function (jsValue) {
    if (typeof jsValue === 'string') {
        return schemaBuilder_1.T.string;
    }
    else if (typeof jsValue === 'boolean') {
        return schemaBuilder_1.T.boolean;
    }
    else if (typeof jsValue === 'number' && !isNaN(jsValue)) {
        return schemaBuilder_1.T.number;
    }
    else if (Array.isArray(jsValue)) {
        var itemsSchema = void 0;
        if (jsValue.length > 0) {
            itemsSchema = (0, exports.jsValueToSchema)(jsValue[0]);
        }
        else {
            itemsSchema = schemaBuilder_1.T.any;
        }
        return schemaBuilder_1.T.list(itemsSchema);
    }
    else if (typeof jsValue === 'object' && jsValue !== null) {
        var properties = {};
        for (var key in jsValue) {
            if (jsValue.hasOwnProperty(key)) {
                properties[key] = (0, exports.jsValueToSchema)(jsValue[key]);
            }
        }
        return schemaBuilder_1.T.object(properties);
    }
    return schemaBuilder_1.T.any;
};
exports.jsValueToSchema = jsValueToSchema;
var tSchemaToJSValue = function (schema) {
    var _a;
    switch (schema.type) {
        case 'enum':
            return schema.options[0];
        case 'object':
            return Object.fromEntries(Object.entries(schema.properties)
                .map(function (_a) {
                var _b = __read(_a, 2), k = _b[0], v = _b[1];
                return [k, (0, exports.tSchemaToJSValue)(v)];
            }));
        case 'hashMap':
            return {
                key1: (0, exports.tSchemaToJSValue)(schema.property),
                key2: (0, exports.tSchemaToJSValue)(schema.property),
            };
        case 'array':
            return [(0, exports.tSchemaToJSValue)(schema.items), (0, exports.tSchemaToJSValue)(schema.items)];
        case 'oneOf':
            return (0, exports.tSchemaToJSValue)((_a = schema.options) === null || _a === void 0 ? void 0 : _a[0]);
        case 'any':
            return null;
        case 'string':
            return 'text content';
        case 'boolean':
            return true;
        case 'number':
            return 1.1;
        case 'transformType':
            return (0, exports.tSchemaToJSValue)(schema.encodedTSchema);
        default:
            throw new Error("unsupported type: ".concat(JSON.stringify(schema)));
    }
};
exports.tSchemaToJSValue = tSchemaToJSValue;