@spec2ts/openapi-client/lib/server-parser.js

Utility to convert OpenAPI v3 specifications to Typescript HTTP client using TypeScript native compiler

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.defaultBaseUrl = exports.parseServers = void 0;
const ts = require("typescript");
const core = require("@spec2ts/core");
const util_1 = require("./util");
function parseServers(servers) {
    const props = servers.map((server, i) => [serverName(server, i), generateServerExpression(server)]);
    return core.createObjectLiteral(props);
}
exports.parseServers = parseServers;
function defaultBaseUrl(servers) {
    return ts.factory.createStringLiteral(defaultUrl(servers[0]));
}
exports.defaultBaseUrl = defaultBaseUrl;
function serverName(server, index) {
    return server.description ?
        (0, util_1.camelCase)(server.description.replace(/\W+/, " ")) :
        `server${index + 1}`;
}
function generateServerExpression(server) {
    return server.variables ?
        createServerFunction(server.url, server.variables) :
        ts.factory.createStringLiteral(server.url);
}
function createServerFunction(template, vars) {
    const params = [
        core.createParameter(core.createObjectBinding(Object.entries(vars || {}).map(([name, value]) => {
            return {
                name,
                initializer: createLiteral(value.default),
            };
        })), {
            type: ts.factory.createTypeLiteralNode(Object.entries(vars || {}).map(([name, value]) => {
                return core.createPropertySignature({
                    name,
                    type: value.enum ?
                        ts.factory.createUnionTypeNode(createUnion(value.enum)) :
                        ts.factory.createUnionTypeNode([
                            core.keywordType.string,
                            core.keywordType.number,
                            core.keywordType.boolean,
                        ]),
                });
            })),
        }),
    ];
    return core.createArrowFunction(params, createTemplate(template));
}
function createUnion(strs) {
    return strs.map((e) => ts.factory.createLiteralTypeNode(createLiteral(e)));
}
function createTemplate(url) {
    const tokens = url.split(/{([\s\S]+?)}/g);
    const spans = [];
    const len = tokens.length;
    for (let i = 1; i < len; i += 2) {
        spans.push(ts.factory.createTemplateSpan(ts.factory.createIdentifier(tokens[i]), (i === len - 2 ? ts.factory.createTemplateTail : ts.factory.createTemplateMiddle)(tokens[i + 1])));
    }
    return ts.factory.createTemplateExpression(ts.factory.createTemplateHead(tokens[0]), spans);
}
function createLiteral(v) {
    switch (typeof v) {
        case "string":
            return ts.factory.createStringLiteral(v);
        case "boolean":
            return v ? ts.factory.createTrue() : ts.factory.createFalse();
        case "number":
            return ts.factory.createNumericLiteral(String(v));
    }
}
function defaultUrl(server) {
    if (!server)
        return "/";
    const { url, variables } = server;
    if (!variables)
        return url;
    return url.replace(/\{(.+?)\}/g, (m, name) => variables[name] ? String(variables[name].default) : m);
}