@necessarylion/adonis-autoswagger 0.0.3 → 0.0.5

package/dist/example.d.ts

@@ -1,18 +1,65 @@
 export default class ExampleGenerator {
     schemas: {};
     constructor(schemas: any);
+    /**
+     * Convert json to ref
+     * @param json any
+     * @returns
+     */
     jsonToRef(json: any): {};
+    /**
+     * Parse ref
+     * @param line string
+     * @param exampleOnly boolean
+     * @returns
+     */
     parseRef(line: string, exampleOnly?: boolean): {};
+    /**
+     * Example by validator rule
+     * @param rule string
+     * @returns
+     */
     exampleByValidatorRule(rule: string): "user@example.com" | "Some string";
+    /**
+     * Get schema example based on annotation
+     * @param schema string
+     * @param inc string
+     * @param exc string
+     * @param onl string
+     * @param first string
+     * @param parent string
+     * @param deepRels string[]
+     * @returns
+     */
     getSchemaExampleBasedOnAnnotation(schema: string, inc?: string, exc?: string, onl?: string, first?: string, parent?: string, deepRels?: string[]): any;
+    /**
+     * Example by type
+     * @param type any
+     * @returns
+     */
     exampleByType(type: any): any;
+    /**
+     * Example by field
+     * @param field any
+     * @param type string
+     * @returns
+     */
     exampleByField(field: any, type?: string): any;
+    /**
+     * Get paginated data
+     * @param line string
+     * @returns
+     */
     getPaginatedData(line: string): {
         dataName: string;
         metaName: string;
     };
 }
 export declare abstract class ExampleInterfaces {
+    /**
+     * Pagination interface
+     * @returns
+     */
     static paginationInterface(): {
         PaginationMeta: {
             type: string;

package/dist/example.js

@@ -2,12 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExampleInterfaces = void 0;
 const lodash_1 = require("lodash");
-const helpers_1 = require("./helpers");
+const helpers_1 = require("./parsers/helpers");
 class ExampleGenerator {
     schemas = {};
     constructor(schemas) {
         this.schemas = schemas;
     }
+    /**
+     * Convert json to ref
+     * @param json any
+     * @returns
+     */
     jsonToRef(json) {
         const jsonObjectIsArray = Array.isArray(json);
         let out = {};
@@ -30,6 +35,12 @@ class ExampleGenerator {
         }
         return outArr.length > 0 ? outArr.flat() : out;
     }
+    /**
+     * Parse ref
+     * @param line string
+     * @param exampleOnly boolean
+     * @returns
+     */
     parseRef(line, exampleOnly = false) {
         let rawRef = line.substring(line.indexOf("<") + 1, line.lastIndexOf(">"));
         if (rawRef === "") {
@@ -133,6 +144,11 @@ class ExampleGenerator {
             },
         };
     }
+    /**
+     * Example by validator rule
+     * @param rule string
+     * @returns
+     */
     exampleByValidatorRule(rule) {
         switch (rule) {
             case "email":
@@ -141,6 +157,17 @@ class ExampleGenerator {
                 return "Some string";
         }
     }
+    /**
+     * Get schema example based on annotation
+     * @param schema string
+     * @param inc string
+     * @param exc string
+     * @param onl string
+     * @param first string
+     * @param parent string
+     * @param deepRels string[]
+     * @returns
+     */
     getSchemaExampleBasedOnAnnotation(schema, inc = "", exc = "", onl = "", first = "", parent = "", deepRels = [""]) {
         let props = {};
         if (!this.schemas[schema]) {
@@ -244,6 +271,11 @@ class ExampleGenerator {
         }
         return props;
     }
+    /**
+     * Example by type
+     * @param type any
+     * @returns
+     */
     exampleByType(type) {
         switch (type) {
             case "string":
@@ -262,10 +294,18 @@ class ExampleGenerator {
                 return this.exampleByField("date");
             case "object":
                 return {};
+            case "uuid":
+                return this.exampleByField("uuid");
             default:
                 return null;
         }
     }
+    /**
+     * Example by field
+     * @param field any
+     * @param type string
+     * @returns
+     */
     exampleByField(field, type = "") {
         const ex = {
             datetime: "2021-03-23T16:13:08.489+01:00",
@@ -292,6 +332,7 @@ class ExampleGenerator {
             price: 10.5,
             avatar: "https://example.com/avatar.png",
             url: "https://example.com",
+            uuid: "2b0bf725-d404-481f-b431-17f1182a5e57"
         };
         if (typeof ex[field] !== "undefined") {
             return ex[field];
@@ -301,6 +342,11 @@ class ExampleGenerator {
         }
         return null;
     }
+    /**
+     * Get paginated data
+     * @param line string
+     * @returns
+     */
     getPaginatedData(line) {
         const match = line.match(/<.*>\.paginated\((.*)\)/);
         if (!match) {
@@ -314,6 +360,10 @@ class ExampleGenerator {
 }
 exports.default = ExampleGenerator;
 class ExampleInterfaces {
+    /**
+     * Pagination interface
+     * @returns
+     */
     static paginationInterface() {
         return {
             PaginationMeta: {

package/dist/file.d.ts

@@ -0,0 +1,44 @@
+import type { options } from "./types";
+import { AdonisRoutes } from "./types";
+export declare class FileService {
+    /**
+     * Convert json to yaml
+     * @param json any
+     * @returns
+     */
+    jsonToYaml(json: any): any;
+    /**
+     * Generate json output
+     * @param routes AdonisRoutes
+     * @param options options
+     * @returns
+     */
+    json(routes: AdonisRoutes, options: options, generate: (routes: AdonisRoutes, options: options) => Promise<any>): Promise<any>;
+    /**
+     * Write swagger file
+     * @param routes AdonisRoutes
+     * @param options options
+     */
+    writeFile(routes: AdonisRoutes, options: options, generate: (routes: AdonisRoutes, options: options) => Promise<any>): Promise<void>;
+    /**
+     * Read swagger file
+     * @param rootPath string
+     * @param type string
+     * @returns
+     */
+    readFile(rootPath: string, type?: string): Promise<string | undefined>;
+    /**
+     * Generate docs
+     * @param routes AdonisRoutes
+     * @param options options
+     * @returns
+     */
+    docs(routes: AdonisRoutes, options: options, generate: (routes: AdonisRoutes, options: options) => Promise<any>): Promise<string>;
+    /**
+     * Get files in directory
+     * @param dir string
+     * @param files_ string[]
+     * @returns
+     */
+    getFiles(dir: string, files_?: string[]): Promise<string[]>;
+}

package/dist/file.js

@@ -0,0 +1,93 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileService = void 0;
+const json_to_pretty_yaml_1 = __importDefault(require("json-to-pretty-yaml"));
+const fs_1 = __importDefault(require("fs"));
+class FileService {
+    /**
+     * Convert json to yaml
+     * @param json any
+     * @returns
+     */
+    jsonToYaml(json) {
+        return json_to_pretty_yaml_1.default.stringify(json);
+    }
+    /**
+     * Generate json output
+     * @param routes AdonisRoutes
+     * @param options options
+     * @returns
+     */
+    async json(routes, options, generate) {
+        if (process.env.NODE_ENV === (options.productionEnv || "production")) {
+            const str = await this.readFile(options.path, "json");
+            return JSON.parse(str);
+        }
+        return generate(routes, options);
+    }
+    /**
+     * Write swagger file
+     * @param routes AdonisRoutes
+     * @param options options
+     */
+    async writeFile(routes, options, generate) {
+        const json = await 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));
+    }
+    /**
+     * Read swagger file
+     * @param rootPath string
+     * @param type string
+     * @returns
+     */
+    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;
+    }
+    /**
+     * Generate docs
+     * @param routes AdonisRoutes
+     * @param options options
+     * @returns
+     */
+    async docs(routes, options, generate) {
+        if (process.env.NODE_ENV === (options.productionEnv || "production")) {
+            return this.readFile(options.path);
+        }
+        return this.jsonToYaml(await generate(routes, options));
+    }
+    /**
+     * Get files in directory
+     * @param dir string
+     * @param files_ string[]
+     * @returns
+     */
+    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_;
+    }
+}
+exports.FileService = FileService;

package/dist/helpers.d.ts

@@ -1,7 +1,16 @@
-export declare function isJSONString(str: string): boolean;
-export declare function getBetweenBrackets(value: string, start: string): string;
+/**
+ * Merge params
+ * @param initial any
+ * @param custom any
+ * @returns
+ */
 export declare function mergeParams(initial: any, custom: any): any[];
 /**
  * Helpers
  */
+/**
+ * Format operation id
+ * @param inputString string
+ * @returns
+ */
 export declare function formatOperationId(inputString: string): string;

package/dist/helpers.js

@@ -1,36 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isJSONString = isJSONString;
-exports.getBetweenBrackets = getBetweenBrackets;
 exports.mergeParams = mergeParams;
 exports.formatOperationId = formatOperationId;
 /**
  * Check if a string is a valid JSON
  */
 const lodash_1 = require("lodash");
-function isJSONString(str) {
-    try {
-        JSON.parse(str);
-        return true;
-    }
-    catch (error) {
-        return false;
-    }
-}
-function getBetweenBrackets(value, start) {
-    let match = value.match(new RegExp(start + "\\(([^()]*)\\)", "g"));
-    if (match !== null) {
-        let m = match[0].replace(start + "(", "").replace(")", "");
-        if (start !== "example") {
-            m = m.replace(/ /g, "");
-        }
-        if (start === "paginated") {
-            return "true";
-        }
-        return m;
-    }
-    return "";
-}
+/**
+ * Merge params
+ * @param initial any
+ * @param custom any
+ * @returns
+ */
 function mergeParams(initial, custom) {
     let merge = Object.assign(initial, custom);
     let params = [];
@@ -42,6 +23,11 @@ function mergeParams(initial, custom) {
 /**
  * Helpers
  */
+/**
+ * Format operation id
+ * @param inputString string
+ * @returns
+ */
 function formatOperationId(inputString) {
     // Remove non-alphanumeric characters and split the string into words
     const cleanedWords = inputString.replace(/[^a-zA-Z0-9]/g, " ").split(" ");

package/dist/index.d.ts

@@ -1,3 +1,3 @@
-import { AutoSwagger } from "./autoswagger";
+import { AutoSwagger } from "./auto_swagger";
 declare const _default: AutoSwagger;
 export default _default;

package/dist/index.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const autoswagger_1 = require("./autoswagger");
-exports.default = new autoswagger_1.AutoSwagger();
+const auto_swagger_1 = require("./auto_swagger");
+exports.default = new auto_swagger_1.AutoSwagger();

package/dist/parsers/comment_parser.d.ts

@@ -0,0 +1,10 @@
+import ExampleGenerator from "../example";
+import type { options } from "../types";
+export declare class CommentParser {
+    #private;
+    private parsedFiles;
+    exampleGenerator: ExampleGenerator;
+    options: options;
+    constructor(options: options);
+    getAnnotations(file: string, action: string): Promise<Record<string, any>>;
+}