@necessarylion/adonis-autoswagger 0.0.1

package/dist/autoswagger.js

@@ -0,0 +1,777 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutoSwagger = void 0;
+const json_to_pretty_yaml_1 = __importDefault(require("json-to-pretty-yaml"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const util_1 = __importDefault(require("util"));
+const http_status_code_1 = __importDefault(require("http-status-code"));
+const lodash_1 = __importDefault(require("lodash"));
+const lodash_2 = require("lodash");
+const fs_2 = require("fs");
+const scalarCustomCss_1 = require("./scalarCustomCss");
+const adonishelpers_1 = require("./adonishelpers");
+const parsers_1 = require("./parsers");
+const helpers_1 = require("./helpers");
+const example_1 = __importStar(require("./example"));
+class AutoSwagger {
+    options;
+    schemas = {};
+    commentParser;
+    modelParser;
+    interfaceParser;
+    enumParser;
+    routeParser;
+    validatorParser;
+    customPaths = {};
+    ui(url, options) {
+        const persistAuthString = options?.persistAuthorization
+            ? "persistAuthorization: true,"
+            : "";
+        return `<!DOCTYPE html>
+		<html lang="en">
+		<head>
+				<meta charset="UTF-8">
+				<meta name="viewport" content="width=device-width, initial-scale=1.0">
+				<meta http-equiv="X-UA-Compatible" content="ie=edge">
+				<script src="https://cdnjs.cloudflare.com/ajax/libs/swagger-ui/4.1.3/swagger-ui-standalone-preset.js"></script>
+				<script src="https://cdnjs.cloudflare.com/ajax/libs/swagger-ui/4.1.3/swagger-ui-bundle.js"></script>
+				<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/swagger-ui/4.1.3/swagger-ui.css" />
+				<title>Documentation</title>
+		</head>
+		<body>
+				<div id="swagger-ui"></div>
+				<script>
+						window.onload = function() {
+							SwaggerUIBundle({
+								url: "${url}",
+								dom_id: '#swagger-ui',
+								presets: [
+									SwaggerUIBundle.presets.apis,
+									SwaggerUIStandalonePreset
+								],
+								layout: "BaseLayout",
+                ${persistAuthString}
+							})
+						}
+				</script>
+		</body>
+		</html>`;
+    }
+    rapidoc(url, style = "view") {
+        return (`
+    <!doctype html> <!-- Important: must specify -->
+    <html>
+      <head>
+        <meta charset="utf-8"> <!-- Important: rapi-doc uses utf8 characters -->
+        <script type="module" src="https://unpkg.com/rapidoc/dist/rapidoc-min.js"></script>
+        <title>Documentation</title>
+      </head>
+      <body>
+        <rapi-doc
+          spec-url = "` +
+            url +
+            `"
+      theme = "dark"
+      bg-color = "#24283b"
+      schema-style="tree"
+      schema-expand-level = "10"
+      header-color = "#1a1b26"
+      allow-try = "true"
+      nav-hover-bg-color = "#1a1b26"
+      nav-bg-color = "#24283b"
+      text-color = "#c0caf5"
+      nav-text-color = "#c0caf5"
+      primary-color = "#9aa5ce"
+      heading-text = "Documentation"
+      sort-tags = "true"
+      render-style = "` +
+            style +
+            `"
+      default-schema-tab = "example"
+      show-components = "true"
+      allow-spec-url-load = "false"
+      allow-spec-file-load = "false"
+      sort-endpoints-by = "path"
+
+        > </rapi-doc>
+      </body>
+    </html>
+    `);
+    }
+    scalar(url, proxyUrl = "https://proxy.scalar.com") {
+        return `
+      <!doctype html>
+      <html>
+        <head>
+          <title>API Reference</title>
+          <meta charset="utf-8" />
+          <meta
+            name="viewport"
+            content="width=device-width, initial-scale=1" />
+          <style>
+          ${scalarCustomCss_1.scalarCustomCss}
+          </style>
+        </head>
+        <body>
+          <script
+            id="api-reference"
+            data-url="${url}"
+            data-proxy-url="${proxyUrl}"></script>
+          <script src="https://cdn.jsdelivr.net/npm/@scalar/api-reference"></script>
+        </body>
+      </html>
+    `;
+    }
+    stoplight(url, theme = "dark") {
+        return `
+      <!doctype html>
+      <html data-theme="${theme}">
+        <head>
+          <title>API Documentation - Stoplight</title>
+          <meta charset="utf-8" />
+          <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
+		  <script src="https://unpkg.com/@stoplight/elements/web-components.min.js"></script>
+          <link rel="stylesheet" href="https://unpkg.com/@stoplight/elements/styles.min.css">
+        </head>
+        <body style="min-height:100vh">
+	      <elements-api
+		    style="display:block;height:100vh;width:100%;"
+		    apiDescriptionUrl=${url}
+		    router="hash"
+		    layout="sidebar"
+		  />
+        </body>
+      </html>
+    `;
+    }
+    jsonToYaml(json) {
+        return json_to_pretty_yaml_1.default.stringify(json);
+    }
+    async json(routes, options) {
+        if (process.env.NODE_ENV === (options.productionEnv || "production")) {
+            const str = await this.readFile(options.path, "json");
+            return JSON.parse(str);
+        }
+        return await this.generate(routes, options);
+    }
+    async writeFile(routes, options) {
+        const json = await this.generate(routes, options);
+        const contents = this.jsonToYaml(json);
+        const filePath = options.path + "swagger.yml";
+        const filePathJson = options.path + "swagger.json";
+        fs_1.default.writeFileSync(filePath, contents);
+        fs_1.default.writeFileSync(filePathJson, JSON.stringify(json, null, 2));
+    }
+    async readFile(rootPath, type = "yml") {
+        const filePath = rootPath + "swagger." + type;
+        const data = fs_1.default.readFileSync(filePath, "utf-8");
+        if (!data) {
+            console.error("Error reading file");
+            return;
+        }
+        return data;
+    }
+    async docs(routes, options) {
+        if (process.env.NODE_ENV === (options.productionEnv || "production")) {
+            return this.readFile(options.path);
+        }
+        return this.jsonToYaml(await this.generate(routes, options));
+    }
+    async generate(adonisRoutes, options) {
+        this.options = {
+            ...{
+                snakeCase: true,
+                preferredPutPatch: "PUT",
+                debug: false,
+            },
+            ...options,
+        };
+        const routes = adonisRoutes.root;
+        this.options.appPath = this.options.path + "app";
+        try {
+            const pj = fs_1.default.readFileSync(path_1.default.join(this.options.path, "package.json"));
+            const pjson = JSON.parse(pj.toString());
+            if (pjson.imports) {
+                Object.entries(pjson.imports).forEach(([key, value]) => {
+                    const k = key.replaceAll("/*", "");
+                    this.customPaths[k] = value
+                        .replaceAll("/*.js", "")
+                        .replaceAll("./", "");
+                });
+            }
+        }
+        catch (e) {
+            console.error(e);
+        }
+        this.commentParser = new parsers_1.CommentParser(this.options);
+        this.routeParser = new parsers_1.RouteParser(this.options);
+        this.modelParser = new parsers_1.ModelParser(this.options.snakeCase);
+        this.interfaceParser = new parsers_1.InterfaceParser(this.options.snakeCase);
+        this.validatorParser = new parsers_1.ValidatorParser();
+        this.enumParser = new parsers_1.EnumParser();
+        this.schemas = await this.getSchemas();
+        if (this.options.debug) {
+            console.log(this.options);
+            console.log("Found Schemas", Object.keys(this.schemas));
+            console.log("Using custom paths", this.customPaths);
+        }
+        this.commentParser.exampleGenerator = new example_1.default(this.schemas);
+        const docs = {
+            openapi: "3.0.0",
+            info: options.info || {
+                title: options.title,
+                version: options.version,
+                description: options.description ||
+                    "Generated by AdonisJS AutoSwagger https://github.com/ad-on-is/adonis-autoswagger",
+            },
+            components: {
+                responses: {
+                    Forbidden: {
+                        description: "Access token is missing or invalid",
+                    },
+                    Accepted: {
+                        description: "The request was accepted",
+                    },
+                    Created: {
+                        description: "The resource has been created",
+                    },
+                    NotFound: {
+                        description: "The resource has been created",
+                    },
+                    NotAcceptable: {
+                        description: "The resource has been created",
+                    },
+                },
+                securitySchemes: {
+                    BearerAuth: {
+                        type: "http",
+                        scheme: "bearer",
+                    },
+                    BasicAuth: {
+                        type: "http",
+                        scheme: "basic",
+                    },
+                    ApiKeyAuth: {
+                        type: "apiKey",
+                        in: "header",
+                        name: "X-API-Key",
+                    },
+                    ...this.options.securitySchemes,
+                },
+                schemas: this.schemas,
+            },
+            paths: {},
+            tags: [],
+        };
+        let paths = {};
+        let sscheme = "BearerAuth";
+        if (this.options.defaultSecurityScheme) {
+            sscheme = this.options.defaultSecurityScheme;
+        }
+        let securities = {
+            "auth": { [sscheme]: ["access"] },
+            "auth:api": { [sscheme]: ["access"] },
+            ...this.options.authMiddlewares
+                ?.map((am) => ({
+                [am]: { [sscheme]: ["access"] },
+            }))
+                .reduce((acc, val) => ({ ...acc, ...val }), {}),
+        };
+        let globalTags = [];
+        if (this.options.debug) {
+            console.log("Route annotations:");
+            console.log("Checking if controllers have propper comment annotations");
+            console.log("-----");
+        }
+        for await (const route of routes) {
+            let ignore = false;
+            for (const i of options.ignore) {
+                if (route.pattern == i ||
+                    (i.endsWith("*") && route.pattern.startsWith(i.slice(0, -1))) ||
+                    (i.startsWith("*") && route.pattern.endsWith(i.slice(1)))) {
+                    ignore = true;
+                    break;
+                }
+            }
+            if (ignore)
+                continue;
+            let security = [];
+            const responseCodes = {
+                GET: "200",
+                POST: "201",
+                DELETE: "202",
+                PUT: "204",
+            };
+            if (!Array.isArray(route.middleware)) {
+                route.middleware = (0, adonishelpers_1.serializeV6Middleware)(route.middleware);
+            }
+            route.middleware.forEach((m) => {
+                if (typeof securities[m] !== "undefined") {
+                    security.push(securities[m]);
+                }
+            });
+            let { tags, parameters, pattern } = this.routeParser.extractInfos(route.pattern);
+            tags.forEach((tag) => {
+                if (globalTags.filter((e) => e.name === tag).length > 0)
+                    return;
+                if (tag === "")
+                    return;
+                globalTags.push({
+                    name: tag,
+                    description: "Everything related to " + tag,
+                });
+            });
+            const { sourceFile, action, customAnnotations, operationId } = await this.getDataBasedOnAdonisVersion(route);
+            route.methods.forEach((method) => {
+                let responses = {};
+                if (method === "HEAD")
+                    return;
+                if (route.methods.includes("PUT") &&
+                    route.methods.includes("PATCH") &&
+                    method !== this.options.preferredPutPatch)
+                    return;
+                let description = "";
+                let summary = "";
+                let tag = "";
+                let operationId;
+                if (security.length > 0) {
+                    responses["401"] = {
+                        description: `Returns **401** (${http_status_code_1.default.getMessage(401)})`,
+                    };
+                    responses["403"] = {
+                        description: `Returns **403** (${http_status_code_1.default.getMessage(403)})`,
+                    };
+                }
+                let requestBody = {
+                    content: {
+                        "application/json": {},
+                    },
+                };
+                let actionParams = {};
+                if (action !== "" && typeof customAnnotations[action] !== "undefined") {
+                    description = customAnnotations[action].description;
+                    summary = customAnnotations[action].summary;
+                    operationId = customAnnotations[action].operationId;
+                    responses = { ...responses, ...customAnnotations[action].responses };
+                    requestBody = customAnnotations[action].requestBody;
+                    actionParams = customAnnotations[action].parameters;
+                    tag = customAnnotations[action].tag;
+                }
+                parameters = (0, helpers_1.mergeParams)(parameters, actionParams);
+                if (tag != "") {
+                    globalTags.push({
+                        name: tag.toUpperCase(),
+                        description: "Everything related to " + tag.toUpperCase(),
+                    });
+                    tags = [tag.toUpperCase()];
+                }
+                if ((0, lodash_2.isEmpty)(responses)) {
+                    responses[responseCodes[method]] = {
+                        description: http_status_code_1.default.getMessage(responseCodes[method]),
+                        content: {
+                            "application/json": {},
+                        },
+                    };
+                }
+                else {
+                    if (typeof responses[responseCodes[method]] !== "undefined" &&
+                        typeof responses[responseCodes[method]]["summary"] !== "undefined") {
+                        if (summary === "") {
+                            summary = responses[responseCodes[method]]["summary"];
+                        }
+                        delete responses[responseCodes[method]]["summary"];
+                    }
+                    if (typeof responses[responseCodes[method]] !== "undefined" &&
+                        typeof responses[responseCodes[method]]["description"] !==
+                            "undefined") {
+                        description = responses[responseCodes[method]]["description"];
+                    }
+                }
+                if (action !== "" && summary === "") {
+                    // Solve toLowerCase undefined exception
+                    // https://github.com/ad-on-is/adonis-autoswagger/issues/28
+                    tags[0] = tags[0] ?? "";
+                    switch (action) {
+                        case "index":
+                            summary = "Get a list of " + tags[0].toLowerCase();
+                            break;
+                        case "show":
+                            summary = "Get a single instance of " + tags[0].toLowerCase();
+                            break;
+                        case "update":
+                            summary = "Update " + tags[0].toLowerCase();
+                            break;
+                        case "destroy":
+                            summary = "Delete " + tags[0].toLowerCase();
+                            break;
+                        case "store":
+                            summary = "Create " + tags[0].toLowerCase();
+                            break;
+                        // frontend defaults
+                        case "create":
+                            summary = "Create (Frontend) " + tags[0].toLowerCase();
+                            break;
+                        case "edit":
+                            summary = "Update (Frontend) " + tags[0].toLowerCase();
+                            break;
+                    }
+                }
+                const sf = sourceFile.split("/").at(-1).replace(".ts", "");
+                let m = {
+                    summary: `${summary}${action !== "" ? ` (${action})` : "route"}`,
+                    description: description + "\n\n _" + sourceFile + "_ - **" + action + "**",
+                    operationId: operationId,
+                    parameters: parameters,
+                    tags: tags,
+                    responses: responses,
+                    security: security,
+                };
+                if (method !== "GET" && method !== "DELETE") {
+                    m["requestBody"] = requestBody;
+                }
+                pattern = pattern.slice(1);
+                if (pattern === "") {
+                    pattern = "/";
+                }
+                paths = {
+                    ...paths,
+                    [pattern]: { ...paths[pattern], [method.toLowerCase()]: m },
+                };
+            });
+        }
+        // filter unused tags
+        const usedTags = lodash_1.default.uniq(Object.entries(paths)
+            .map(([p, val]) => Object.entries(val)[0][1].tags)
+            .flat());
+        docs.tags = globalTags.filter((tag) => usedTags.includes(tag.name));
+        docs.paths = paths;
+        return docs;
+    }
+    async getDataBasedOnAdonisVersion(route) {
+        let sourceFile = "";
+        let action = "";
+        let customAnnotations;
+        let operationId = "";
+        if (route.meta.resolvedHandler !== null &&
+            route.meta.resolvedHandler !== undefined) {
+            if (typeof route.meta.resolvedHandler.namespace !== "undefined" &&
+                route.meta.resolvedHandler.method !== "handle") {
+                sourceFile = route.meta.resolvedHandler.namespace;
+                action = route.meta.resolvedHandler.method;
+                // If not defined by an annotation, use the combination of "controllerNameMethodName"
+                if (action !== "" && (0, lodash_2.isUndefined)(operationId) && route.handler) {
+                    operationId = (0, helpers_1.formatOperationId)(route.handler);
+                }
+            }
+        }
+        let v6handler = route.handler;
+        if (v6handler.reference !== null &&
+            v6handler.reference !== undefined &&
+            v6handler.reference !== "") {
+            if (!Array.isArray(v6handler.reference)) {
+                // handles magic strings
+                // router.resource('/test', '#controllers/test_controller')
+                [sourceFile, action] = v6handler.reference.split(".");
+                const split = sourceFile.split("/");
+                if (split[0].includes("#")) {
+                    sourceFile = sourceFile.replaceAll(split[0], this.customPaths[split[0]]);
+                }
+                else {
+                    sourceFile = this.options.appPath + "/controllers/" + sourceFile;
+                }
+                operationId = (0, helpers_1.formatOperationId)(v6handler.reference);
+            }
+            else {
+                // handles lazy import
+                // const TestController = () => import('#controllers/test_controller')
+                v6handler = await (0, adonishelpers_1.serializeV6Handler)(v6handler);
+                action = v6handler.method;
+                sourceFile = v6handler.moduleNameOrPath;
+                operationId = (0, helpers_1.formatOperationId)(sourceFile + "." + action);
+                const split = sourceFile.split("/");
+                if (split[0].includes("#")) {
+                    sourceFile = sourceFile.replaceAll(split[0], this.customPaths[split[0]]);
+                }
+                else {
+                    sourceFile = this.options.appPath + "/" + sourceFile;
+                }
+            }
+        }
+        if (sourceFile !== "" && action !== "") {
+            sourceFile = sourceFile.replace("App/", "app/") + ".ts";
+            sourceFile = sourceFile.replace(".js", "");
+            customAnnotations = await this.commentParser.getAnnotations(sourceFile, action);
+        }
+        if (typeof customAnnotations !== "undefined" &&
+            typeof customAnnotations.operationId !== "undefined" &&
+            customAnnotations.operationId !== "") {
+            operationId = customAnnotations.operationId;
+        }
+        if (this.options.debug) {
+            if (sourceFile !== "") {
+                console.log(typeof customAnnotations !== "undefined" &&
+                    !lodash_1.default.isEmpty(customAnnotations)
+                    ? `\x1b[32m✓ FOUND for ${action}\x1b[0m`
+                    : `\x1b[33m✗ MISSING for ${action}\x1b[0m`, `${sourceFile} (${route.methods[0].toUpperCase()} ${route.pattern})`);
+            }
+        }
+        return { sourceFile, action, customAnnotations, operationId };
+    }
+    async getSchemas() {
+        let schemas = {
+            Any: {
+                description: "Any JSON object not defined as schema",
+            },
+        };
+        schemas = {
+            ...schemas,
+            ...(await this.getInterfaces()),
+            ...(await this.getSerializers()),
+            ...(await this.getModels()),
+            ...(await this.getValidators()),
+            ...(await this.getEnums()),
+        };
+        return schemas;
+    }
+    async getValidators() {
+        const validators = {};
+        let p6 = path_1.default.join(this.options.appPath, "validators");
+        if (typeof this.customPaths["#validators"] !== "undefined") {
+            // it's v6
+            p6 = p6.replaceAll("app/validators", this.customPaths["#validators"]);
+            p6 = p6.replaceAll("app\\validators", this.customPaths["#validators"]);
+        }
+        if (!(0, fs_2.existsSync)(p6)) {
+            if (this.options.debug) {
+                console.log("Validators paths don't exist", p6);
+            }
+            return validators;
+        }
+        const files = await this.getFiles(p6, []);
+        if (this.options.debug) {
+            console.log("Found validator files", files);
+        }
+        try {
+            for (let file of files) {
+                if (/^[a-zA-Z]:/.test(file)) {
+                    file = "file:///" + file;
+                }
+                const val = await import(file);
+                for (const [key, value] of Object.entries(val)) {
+                    if (value.constructor.name.includes("VineValidator")) {
+                        validators[key] = await this.validatorParser.validatorToObject(value);
+                        validators[key].description = key + " (Validator)";
+                    }
+                }
+            }
+        }
+        catch (e) {
+            console.log("**You are probably using 'node ace serve --hmr', which is not supported yet. Use 'node ace serve --watch' instead.**");
+            console.error(e.message);
+        }
+        return validators;
+    }
+    async getSerializers() {
+        const serializers = {};
+        let p6 = path_1.default.join(this.options.appPath, "serializers");
+        if (typeof this.customPaths["#serializers"] !== "undefined") {
+            // it's v6
+            p6 = p6.replaceAll("app/serializers", this.customPaths["#serializers"]);
+            p6 = p6.replaceAll("app\\serializers", this.customPaths["#serializers"]);
+        }
+        if (!(0, fs_2.existsSync)(p6)) {
+            if (this.options.debug) {
+                console.log("Serializers paths don't exist", p6);
+            }
+            return serializers;
+        }
+        const files = await this.getFiles(p6, []);
+        if (this.options.debug) {
+            console.log("Found serializer files", files);
+        }
+        for (let file of files) {
+            if (/^[a-zA-Z]:/.test(file)) {
+                file = "file:///" + file;
+            }
+            const val = await import(file);
+            for (const [key, value] of Object.entries(val)) {
+                if (key.indexOf("Serializer") > -1) {
+                    serializers[key] = value;
+                }
+            }
+        }
+        return serializers;
+    }
+    async getModels() {
+        const models = {};
+        let p = path_1.default.join(this.options.appPath, "Models");
+        let p6 = path_1.default.join(this.options.appPath, "models");
+        if (typeof this.customPaths["#models"] !== "undefined") {
+            // it's v6
+            p6 = p6.replaceAll("app/models", this.customPaths["#models"]);
+            p6 = p6.replaceAll("app\\models", this.customPaths["#models"]);
+        }
+        if (!(0, fs_2.existsSync)(p) && !(0, fs_2.existsSync)(p6)) {
+            if (this.options.debug) {
+                console.log("Model paths don't exist", p, p6);
+            }
+            return models;
+        }
+        if ((0, fs_2.existsSync)(p6)) {
+            p = p6;
+        }
+        const files = await this.getFiles(p, []);
+        const readFile = util_1.default.promisify(fs_1.default.readFile);
+        if (this.options.debug) {
+            console.log("Found model files", files);
+        }
+        for (let file of files) {
+            file = file.replace(".js", "");
+            const data = await readFile(file, "utf8");
+            file = file.replace(".ts", "");
+            const split = file.split("/");
+            let name = split[split.length - 1].replace(".ts", "");
+            file = file.replace("app/", "/app/");
+            const parsed = this.modelParser.parseModelProperties(data);
+            if (parsed.name !== "") {
+                name = parsed.name;
+            }
+            let schema = {
+                type: "object",
+                required: parsed.required,
+                properties: parsed.props,
+                description: name + " (Model)",
+            };
+            models[name] = schema;
+        }
+        return models;
+    }
+    async getInterfaces() {
+        let interfaces = {
+            ...example_1.ExampleInterfaces.paginationInterface(),
+        };
+        let p = path_1.default.join(this.options.appPath, "Interfaces");
+        let p6 = path_1.default.join(this.options.appPath, "interfaces");
+        if (typeof this.customPaths["#interfaces"] !== "undefined") {
+            // it's v6
+            p6 = p6.replaceAll("app/interfaces", this.customPaths["#interfaces"]);
+            p6 = p6.replaceAll("app\\interfaces", this.customPaths["#interfaces"]);
+        }
+        if (!(0, fs_2.existsSync)(p) && !(0, fs_2.existsSync)(p6)) {
+            if (this.options.debug) {
+                console.log("Interface paths don't exist", p, p6);
+            }
+            return interfaces;
+        }
+        if ((0, fs_2.existsSync)(p6)) {
+            p = p6;
+        }
+        const files = await this.getFiles(p, []);
+        if (this.options.debug) {
+            console.log("Found interfaces files", files);
+        }
+        const readFile = util_1.default.promisify(fs_1.default.readFile);
+        for (let file of files) {
+            file = file.replace(".js", "");
+            const data = await readFile(file, "utf8");
+            file = file.replace(".ts", "");
+            interfaces = {
+                ...interfaces,
+                ...this.interfaceParser.parseInterfaces(data),
+            };
+        }
+        return interfaces;
+    }
+    async getFiles(dir, files_) {
+        const fs = require("fs");
+        files_ = files_ || [];
+        var files = await fs.readdirSync(dir);
+        for (let i in files) {
+            var name = dir + "/" + files[i];
+            if (fs.statSync(name).isDirectory()) {
+                await this.getFiles(name, files_);
+            }
+            else {
+                files_.push(name);
+            }
+        }
+        return files_;
+    }
+    async getEnums() {
+        let enums = {};
+        const enumParser = new parsers_1.EnumParser();
+        let p = path_1.default.join(this.options.appPath, "Types");
+        let p6 = path_1.default.join(this.options.appPath, "types");
+        if (typeof this.customPaths["#types"] !== "undefined") {
+            // it's v6
+            p6 = p6.replaceAll("app/types", this.customPaths["#types"]);
+            p6 = p6.replaceAll("app\\types", this.customPaths["#types"]);
+        }
+        if (!(0, fs_2.existsSync)(p) && !(0, fs_2.existsSync)(p6)) {
+            if (this.options.debug) {
+                console.log("Enum paths don't exist", p, p6);
+            }
+            return enums;
+        }
+        if ((0, fs_2.existsSync)(p6)) {
+            p = p6;
+        }
+        const files = await this.getFiles(p, []);
+        if (this.options.debug) {
+            console.log("Found enum files", files);
+        }
+        const readFile = util_1.default.promisify(fs_1.default.readFile);
+        for (let file of files) {
+            file = file.replace(".js", "");
+            const data = await readFile(file, "utf8");
+            file = file.replace(".ts", "");
+            const split = file.split("/");
+            const name = split[split.length - 1].replace(".ts", "");
+            file = file.replace("app/", "/app/");
+            const parsedEnums = enumParser.parseEnums(data);
+            enums = {
+                ...enums,
+                ...parsedEnums,
+            };
+        }
+        return enums;
+    }
+}
+exports.AutoSwagger = AutoSwagger;