@necessarylion/adonis-autoswagger 0.0.4 → 0.0.5

package/dist/parsers/validator_parser.js

@@ -0,0 +1,192 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidatorParser = void 0;
+const example_1 = __importDefault(require("../example"));
+const lodash_1 = __importDefault(require("lodash"));
+class ValidatorParser {
+    exampleGenerator;
+    constructor() {
+        this.exampleGenerator = new example_1.default({});
+    }
+    async validatorToObject(validator) {
+        const obj = {
+            type: "object",
+            ...this.#parseSchema(validator.toJSON()["schema"]["schema"], validator.toJSON()["refs"]),
+        };
+        const testObj = this.#objToTest(obj["properties"]);
+        return await this.#parsePropsAndMeta(obj, testObj, validator);
+    }
+    async #parsePropsAndMeta(obj, testObj, validator) {
+        const { SimpleMessagesProvider } = require("@vinejs/vine");
+        const [e] = await validator.tryValidate(testObj, {
+            messagesProvider: new SimpleMessagesProvider({
+                required: "REQUIRED",
+                string: "TYPE",
+                object: "TYPE",
+                number: "TYPE",
+                boolean: "TYPE",
+            }),
+        });
+        // if no errors, this means all object-fields are of type number (which we use by default)
+        // and we can return the object
+        if (e === null) {
+            obj["example"] = testObj;
+            return obj;
+        }
+        const messages = e.messages;
+        for (const message of messages) {
+            const error = message["message"];
+            let objField = message["field"].replace(".", ".properties.");
+            if (message["field"].includes(".0")) {
+                objField = objField.replaceAll(`.0`, ".items");
+            }
+            if (error === "TYPE") {
+                lodash_1.default.set(obj["properties"], objField, {
+                    ...lodash_1.default.get(obj["properties"], objField),
+                    type: message["rule"],
+                    example: this.exampleGenerator.exampleByType(message["rule"]),
+                });
+                if (message["rule"] === "string") {
+                    if (lodash_1.default.get(obj["properties"], objField)["minimum"]) {
+                        lodash_1.default.set(obj["properties"], objField, {
+                            ...lodash_1.default.get(obj["properties"], objField),
+                            minLength: lodash_1.default.get(obj["properties"], objField)["minimum"],
+                        });
+                        lodash_1.default.unset(obj["properties"], objField + ".minimum");
+                    }
+                    if (lodash_1.default.get(obj["properties"], objField)["maximum"]) {
+                        lodash_1.default.set(obj["properties"], objField, {
+                            ...lodash_1.default.get(obj["properties"], objField),
+                            maxLength: lodash_1.default.get(obj["properties"], objField)["maximum"],
+                        });
+                        lodash_1.default.unset(obj["properties"], objField + ".maximum");
+                    }
+                }
+                lodash_1.default.set(testObj, message["field"], this.exampleGenerator.exampleByType(message["rule"]));
+            }
+            if (error === "FORMAT") {
+                lodash_1.default.set(obj["properties"], objField, {
+                    ...lodash_1.default.get(obj["properties"], objField),
+                    format: message["rule"],
+                    type: "string",
+                    example: this.exampleGenerator.exampleByValidatorRule(message["rule"]),
+                });
+                lodash_1.default.set(testObj, message["field"], this.exampleGenerator.exampleByValidatorRule(message["rule"]));
+            }
+        }
+        obj["example"] = testObj;
+        return obj;
+    }
+    #objToTest(obj) {
+        const res = {};
+        Object.keys(obj).forEach((key) => {
+            if (obj[key]["type"] === "object") {
+                res[key] = this.#objToTest(obj[key]["properties"]);
+            }
+            else if (obj[key]["type"] === "array") {
+                if (obj[key]["items"]["type"] === "object") {
+                    res[key] = [this.#objToTest(obj[key]["items"]["properties"])];
+                }
+                else {
+                    res[key] = [obj[key]["items"]["example"]];
+                }
+            }
+            else {
+                res[key] = obj[key]["example"];
+            }
+        });
+        return res;
+    }
+    #parseSchema(json, refs) {
+        const obj = {};
+        const required = [];
+        for (const property of json["properties"]) {
+            let meta = this.#getMetaFromValidations(property["validations"], refs);
+            const type = property["type"];
+            const field = property["fieldName"];
+            if (type === "object") {
+                console.log(field, property);
+                obj[field] = { type: "object", ...this.#parseSchema(property, refs) };
+            }
+            else {
+                // if array
+                if (type === "array") {
+                    if (property["each"]["type"] === "object") {
+                        obj[field] = {
+                            type: "array",
+                            items: {
+                                type: "object",
+                                ...this.#parseSchema(property["each"], refs),
+                            },
+                        };
+                    }
+                    else {
+                        const meta = this.#getMetaFromValidations(property["each"]["validations"], refs);
+                        obj[field] = {
+                            type: "array",
+                            items: {
+                                type: this.#getType(property["each"]["type"]),
+                                ...meta,
+                                example: meta.example ??
+                                    meta.minimum ??
+                                    this.exampleGenerator.exampleByType("number"),
+                            },
+                        };
+                    }
+                }
+                else {
+                    obj[field] = {
+                        type: this.#getType(type),
+                        example: meta.example ??
+                            meta.minimum ??
+                            this.exampleGenerator.exampleByType("number"),
+                        ...meta,
+                    };
+                }
+            }
+            if (!property["isOptional"])
+                required.push(property["fieldName"]);
+        }
+        const result = { properties: obj };
+        if (required.length > 0)
+            result["required"] = required;
+        return result;
+    }
+    #getType(type) {
+        if (type == "literal") {
+            return "string";
+        }
+        return type;
+    }
+    #getMetaFromValidations(validations, refs) {
+        let meta = {};
+        for (const validation of validations) {
+            if (refs[validation["ruleFnId"]].options?.example) {
+                meta = {
+                    ...meta,
+                    example: refs[validation["ruleFnId"]].options.example,
+                };
+            }
+            if (refs[validation["ruleFnId"]].options?.min) {
+                meta = { ...meta, minimum: refs[validation["ruleFnId"]].options.min };
+            }
+            if (refs[validation["ruleFnId"]].options?.max) {
+                meta = { ...meta, maximum: refs[validation["ruleFnId"]].options.max };
+            }
+            if (refs[validation["ruleFnId"]].options?.choices) {
+                meta = { ...meta, enum: refs[validation["ruleFnId"]].options.choices };
+            }
+            if (refs[validation["ruleFnId"]].options?.toString().includes("/")) {
+                meta = {
+                    ...meta,
+                    pattern: refs[validation["ruleFnId"]].options.toString(),
+                };
+            }
+        }
+        return meta;
+    }
+}
+exports.ValidatorParser = ValidatorParser;

package/dist/schema.d.ts

@@ -0,0 +1,46 @@
+import { InterfaceParser, ModelParser, ValidatorParser, EnumParser, CommentParser, RouteParser } from "./parsers/index";
+import { FileService } from "./file";
+import { options } from "./types";
+export declare class SchemaService {
+    protected options: options;
+    protected schemas: Record<string, any>;
+    protected commentParser: CommentParser;
+    protected modelParser: ModelParser;
+    protected interfaceParser: InterfaceParser;
+    protected enumParser: EnumParser;
+    protected routeParser: RouteParser;
+    protected validatorParser: ValidatorParser;
+    protected customPaths: Record<string, any>;
+    protected fileService: FileService;
+    constructor(options: options);
+    /**
+     * Get all schemas
+     * @returns
+     */
+    getSchemas(): Promise<Record<string, any>>;
+    /**
+     * Get all validators
+     * @returns
+     */
+    getValidators(): Promise<Record<string, any>>;
+    /**
+     * Get all serializers
+     * @returns
+     */
+    getSerializers(): Promise<Record<string, any>>;
+    /**
+     * Get all models
+     * @returns
+     */
+    getModels(): Promise<Record<string, any>>;
+    /**
+     * Get all interfaces
+     * @returns
+     */
+    getInterfaces(): Promise<Record<string, any>>;
+    /**
+     * Get all enums
+     * @returns
+     */
+    getEnums(): Promise<Record<string, any>>;
+}

package/dist/schema.js

@@ -0,0 +1,266 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaService = void 0;
+const path_1 = __importDefault(require("path"));
+const util_1 = __importDefault(require("util"));
+const fs_1 = __importDefault(require("fs"));
+const index_1 = require("./parsers/index");
+const example_1 = require("./example");
+const file_1 = require("./file");
+const fs_2 = require("fs");
+class SchemaService {
+    options;
+    schemas = {};
+    commentParser;
+    modelParser;
+    interfaceParser;
+    enumParser;
+    routeParser;
+    validatorParser;
+    customPaths = {};
+    fileService;
+    constructor(options) {
+        this.options = options;
+        this.modelParser = new index_1.ModelParser(this.options.snakeCase);
+        this.interfaceParser = new index_1.InterfaceParser(this.options.snakeCase);
+        this.validatorParser = new index_1.ValidatorParser();
+        this.enumParser = new index_1.EnumParser();
+        this.fileService = new file_1.FileService();
+    }
+    /**
+     * Get all schemas
+     * @returns
+     */
+    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;
+    }
+    /**
+     * Get all validators
+     * @returns
+     */
+    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.fileService.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;
+    }
+    /**
+     * Get all serializers
+     * @returns
+     */
+    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.fileService.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;
+    }
+    /**
+     * Get all models
+     * @returns
+     */
+    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.fileService.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;
+    }
+    /**
+     * Get all interfaces
+     * @returns
+     */
+    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.fileService.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;
+    }
+    /**
+     * Get all enums
+     * @returns
+     */
+    async getEnums() {
+        let enums = {};
+        const enumParser = new index_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.fileService.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.SchemaService = SchemaService;

package/dist/types.d.ts

@@ -29,32 +29,31 @@ export interface common {
  * Adonis routes
  */
 export interface AdonisRouteMeta {
-    resolvedHandler: {
-        type: string;
+    resolvedHandler?: {
+        type?: string;
         namespace?: string;
         method?: string;
     };
-    resolvedMiddleware: Array<{
-        type: string;
+    resolvedMiddleware?: Array<{
+        type?: string;
         args?: any[];
     }>;
 }
-export interface v6Handler {
+export interface V6Handler {
     method?: string;
-    moduleNameOrPath?: string;
-    reference: string | any[];
-    name: string;
+    moduleNameOrPath?: any;
+    reference?: any;
+    handle?: any;
+    name?: any;
 }
 export interface AdonisRoute {
-    methods: string[];
-    pattern: string;
-    meta: AdonisRouteMeta;
-    middleware: string[] | any;
+    methods?: string[];
+    pattern?: string;
+    meta?: AdonisRouteMeta;
+    middleware?: string[] | any;
     name?: string;
-    params: string[];
-    handler?: string | v6Handler;
-}
-export interface AdonisRoutes {
-    root: AdonisRoute[];
+    params?: string[];
+    handler?: any;
 }
+export type AdonisRoutes = Record<string, AdonisRoute[]>;
 export declare const standardTypes: string[];

package/dist/ui.d.ts

@@ -0,0 +1,31 @@
+import type { options } from "./types";
+export declare class UIService {
+    /**
+     * Swagger UI
+     * @param url string
+     * @param options options
+     * @returns
+     */
+    ui(url: string, options?: options): string;
+    /**
+     * Rapidoc UI
+     * @param url string
+     * @param style string
+     * @returns
+     */
+    rapidoc(url: string, style?: string): string;
+    /**
+     * Scalar UI
+     * @param url string
+     * @param proxyUrl string
+     * @returns
+     */
+    scalar(url: string, proxyUrl?: string): string;
+    /**
+     * Stoplight UI
+     * @param url string
+     * @param theme "light" | "dark"
+     * @returns
+     */
+    stoplight(url: string, theme?: "light" | "dark"): string;
+}