@frostup/swr-request-generator/dist/resolvers/DefinitionsResolver.js

A tool for generating TypeScript code and interface from swagger by using SWR and axios as client.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.DefinitionsResolver = void 0;
const lodash_1 = require("lodash");
const SchemaResolver_1 = require("./SchemaResolver");
const specifications_1 = require("../utils/specifications");
const generators_1 = require("../utils/generators");
const formatters_1 = require("../utils/formatters");
const constants_1 = require("../constants");
// TODO: 1. Handle required params.
// TODO: handle `in: fromData`
// TODO: handle `in schema`
// TODO: 确认不同 endpoint 是否都会生成 openAPI
class DefinitionsResolver {
    constructor(components) {
        this.components = components;
        this.scanDefinitions = () => {
            const results = {};
            const requestBodies = lodash_1.get(this.components, "requestBodies");
            const schemas = lodash_1.get(this.components, "schemas");
            lodash_1.forEach(requestBodies, (requestBody, requestBodyName) => {
                if (specifications_1.isRequestBody(requestBody)) {
                    return (results[requestBodyName] = SchemaResolver_1.SchemaResolver.of({
                        results,
                        schema: lodash_1.get(requestBody, "content.application/json.schema"),
                        key: requestBodyName,
                        parentKey: requestBodyName,
                    })
                        .resolve()
                        .getSchemaType());
                }
                return (results[requestBodyName] = SchemaResolver_1.SchemaResolver.of({
                    results,
                    schema: requestBody,
                    key: requestBodyName,
                    parentKey: requestBodyName,
                })
                    .resolve()
                    .getSchemaType());
            });
            lodash_1.forEach(schemas, (schema, schemaName) => {
                return (results[schemaName] = SchemaResolver_1.SchemaResolver.of({
                    results,
                    schema: schema,
                    key: schemaName,
                    parentKey: schemaName,
                })
                    .resolve()
                    .getSchemaType());
            });
            this.resolvedDefinitions = results;
            return this;
        };
        this.toDeclarations = () => {
            const arr = Object.keys(this.resolvedDefinitions)
                .sort()
                .map((key) => {
                if (lodash_1.includes(key, constants_1.ENUM_SUFFIX)) {
                    return generators_1.generateEnums(this.resolvedDefinitions, key);
                }
                if (this.resolvedDefinitions[key] === "object" || lodash_1.isEmpty(this.resolvedDefinitions[key])) {
                    return `export interface ${formatters_1.addPrefixForInterface(formatters_1.toCapitalCase(key))} {[key:string]:any}`;
                }
                const val = formatters_1.toTypes(this.resolvedDefinitions[key]);
                if (val) {
                    return `export interface ${formatters_1.addPrefixForInterface(formatters_1.toCapitalCase(key))} ${val}`;
                }
            });
            return lodash_1.compact(arr);
        };
    }
    static of(components) {
        return new DefinitionsResolver(components);
    }
}
exports.DefinitionsResolver = DefinitionsResolver;