@necessarylion/adonis-autoswagger 0.0.4 → 0.0.6

package/dist/adonis_helpers.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Serialize v6 middleware
+ * @param middleware any
+ * @returns
+ */
+export declare function serializeV6Middleware(middleware: any): string[];
+/**
+ * Serialize v6 handler
+ * @param handler any
+ * @returns
+ */
+export declare function serializeV6Handler(handler: any): Promise<any>;
+/**
+ * Parse binding reference
+ * @param binding string | [any | any, any]
+ * @returns
+ */
+export declare function parseBindingReference(binding: string | [any | any, any]): Promise<{
+    moduleNameOrPath: string;
+    method: string;
+}>;

package/dist/{adonishelpers.js → adonis_helpers.js}

@@ -3,8 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.serializeV6Middleware = serializeV6Middleware;
 exports.serializeV6Handler = serializeV6Handler;
 exports.parseBindingReference = parseBindingReference;
-function serializeV6Middleware(mw) {
-    return [...mw.all()].reduce((result, one) => {
+/**
+ * Serialize v6 middleware
+ * @param middleware any
+ * @returns
+ */
+function serializeV6Middleware(middleware) {
+    return [...middleware.all()].reduce((result, one) => {
         if (typeof one === "function") {
             result.push(one.name || "closure");
             return result;
@@ -15,6 +20,11 @@ function serializeV6Middleware(mw) {
         return result;
     }, []);
 }
+/**
+ * Serialize v6 handler
+ * @param handler any
+ * @returns
+ */
 async function serializeV6Handler(handler) {
     /**
      * Value is a controller reference
@@ -33,6 +43,11 @@ async function serializeV6Handler(handler) {
         name: handler.name || "closure",
     };
 }
+/**
+ * Parse binding reference
+ * @param binding string | [any | any, any]
+ * @returns
+ */
 async function parseBindingReference(binding) {
     const parseImports = (await import("parse-imports")).default;
     /**

package/dist/auto_swagger.d.ts

@@ -0,0 +1,28 @@
+import type { options, AdonisRoutes } from "./types";
+declare class AutoSwagger {
+    private uiService;
+    private fileService;
+    private schemaService;
+    private options;
+    private schemas;
+    private commentParser;
+    private routeParser;
+    private customPaths;
+    constructor();
+    /**
+     * Get data based on adonis version
+     * @param route AdonisRoute
+     * @returns
+     */
+    ui(url: string, options?: options): string;
+    rapidoc(url: string, style?: string): string;
+    scalar(url: string, proxyUrl?: string): string;
+    stoplight(url: string, theme?: "light" | "dark"): string;
+    jsonToYaml(json: any): any;
+    json(routes: AdonisRoutes, options: options): Promise<any>;
+    writeFile(routes: AdonisRoutes, options: options): Promise<void>;
+    docs(routes: AdonisRoutes, options: options): Promise<string>;
+    private generate;
+    private getDataBasedOnAdonisVersion;
+}
+export { AutoSwagger };

package/dist/{autoswagger.js → auto_swagger.js}

@@ -37,183 +37,59 @@ var __importDefault = (this && this.__importDefault) || function (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 adonis_helpers_1 = require("./adonis_helpers");
+const index_1 = require("./parsers/index");
+const lodash_1 = __importStar(require("lodash"));
+const helpers_1 = require("./helpers");
+const example_1 = __importDefault(require("./example"));
 const path_1 = __importDefault(require("path"));
-const util_1 = __importDefault(require("util"));
-const lodash_1 = require("lodash");
+const fs_1 = __importDefault(require("fs"));
+const lodash_2 = require("lodash");
 const http_status_code_1 = __importDefault(require("http-status-code"));
-const lodash_2 = __importDefault(require("lodash"));
-const lodash_3 = 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"));
+const ui_1 = require("./ui");
+const file_1 = require("./file");
+const schema_1 = require("./schema");
 class AutoSwagger {
+    uiService;
+    fileService;
+    schemaService;
     options;
     schemas = {};
     commentParser;
-    modelParser;
-    interfaceParser;
-    enumParser;
     routeParser;
-    validatorParser;
     customPaths = {};
+    constructor() {
+        this.uiService = new ui_1.UIService();
+        this.fileService = new file_1.FileService();
+    }
+    /**
+     * Get data based on adonis version
+     * @param route AdonisRoute
+     * @returns
+     */
     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>`;
+        return this.uiService.ui(url, options);
     }
     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>
-    `);
+        return this.uiService.rapidoc(url, style);
     }
     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>
-    `;
+        return this.uiService.scalar(url, proxyUrl);
     }
     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>
-    `;
+        return this.uiService.stoplight(url, theme);
     }
     jsonToYaml(json) {
-        return json_to_pretty_yaml_1.default.stringify(json);
+        return this.fileService.jsonToYaml(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);
+        return this.fileService.json(routes, options, this.generate.bind(this));
     }
     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;
+        return this.fileService.writeFile(routes, options, this.generate.bind(this));
     }
     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));
+        return this.fileService.docs(routes, options, this.generate.bind(this));
     }
     async generate(adonisRoutes, options) {
         this.options = {
@@ -241,13 +117,10 @@ class AutoSwagger {
         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();
+        this.schemaService = new schema_1.SchemaService(this.options);
+        this.commentParser = new index_1.CommentParser(this.options);
+        this.routeParser = new index_1.RouteParser(this.options);
+        this.schemas = await this.schemaService.getSchemas();
         if (this.options.debug) {
             console.log(this.options);
             console.log("Found Schemas", Object.keys(this.schemas));
@@ -308,7 +181,7 @@ class AutoSwagger {
             sscheme = this.options.defaultSecurityScheme;
         }
         let securities = {
-            "auth": { [sscheme]: ["access"] },
+            auth: { [sscheme]: ["access"] },
             "auth:api": { [sscheme]: ["access"] },
             ...this.options.authMiddlewares
                 ?.map((am) => ({
@@ -342,7 +215,7 @@ class AutoSwagger {
                 PUT: "204",
             };
             if (!Array.isArray(route.middleware)) {
-                route.middleware = (0, adonishelpers_1.serializeV6Middleware)(route.middleware);
+                route.middleware = (0, adonis_helpers_1.serializeV6Middleware)(route.middleware);
             }
             route.middleware.forEach((m) => {
                 if (typeof securities[m] !== "undefined") {
@@ -371,7 +244,6 @@ class AutoSwagger {
                 let description = "";
                 let summary = "";
                 let tag = "";
-                let operationId;
                 if (security.length > 0) {
                     responses["401"] = {
                         description: `Returns **401** (${http_status_code_1.default.getMessage(401)})`,
@@ -398,11 +270,11 @@ class AutoSwagger {
                 parameters = (0, helpers_1.mergeParams)(parameters, actionParams);
                 if (tag != "") {
                     globalTags.push({
-                        name: tag.toUpperCase()
+                        name: tag.toUpperCase(),
                     });
                     tags = [tag.toUpperCase()];
                 }
-                if ((0, lodash_3.isEmpty)(responses)) {
+                if ((0, lodash_1.isEmpty)(responses)) {
                     responses[responseCodes[method]] = {
                         description: http_status_code_1.default.getMessage(responseCodes[method]),
                         content: {
@@ -453,7 +325,7 @@ class AutoSwagger {
                             break;
                     }
                 }
-                action = (0, lodash_1.startCase)(action);
+                action = (0, lodash_2.startCase)(action);
                 const sf = sourceFile.split("/").at(-1).replace(".ts", "");
                 let m = {
                     summary: `${summary}${action !== "" ? ` ${action}` : "route"}`,
@@ -478,7 +350,7 @@ class AutoSwagger {
             });
         }
         // filter unused tags
-        const usedTags = lodash_2.default.uniq(Object.entries(paths)
+        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));
@@ -497,7 +369,7 @@ class AutoSwagger {
                 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_3.isUndefined)(operationId) && route.handler) {
+                if (action !== "" && (0, lodash_1.isUndefined)(operationId) && route.handler) {
                     operationId = (0, helpers_1.formatOperationId)(route.handler);
                 }
             }
@@ -522,7 +394,7 @@ class AutoSwagger {
             else {
                 // handles lazy import
                 // const TestController = () => import('#controllers/test_controller')
-                v6handler = await (0, adonishelpers_1.serializeV6Handler)(v6handler);
+                v6handler = await (0, adonis_helpers_1.serializeV6Handler)(v6handler);
                 action = v6handler.method;
                 sourceFile = v6handler.moduleNameOrPath;
                 operationId = (0, helpers_1.formatOperationId)(sourceFile + "." + action);
@@ -548,235 +420,12 @@ class AutoSwagger {
         if (this.options.debug) {
             if (sourceFile !== "") {
                 console.log(typeof customAnnotations !== "undefined" &&
-                    !lodash_2.default.isEmpty(customAnnotations)
+                    !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",
-                properties: parsed.props,
-                description: name + " (Model)",
-            };
-            if (parsed.required.length > 0) {
-                schema['required'] = parsed.required;
-            }
-            if (name.toLowerCase().includes('readme.md'))
-                continue;
-            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;