@necessarylion/adonis-autoswagger 0.0.3 → 0.0.5

package/dist/parsers.js

@@ -1,1137 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EnumParser = exports.InterfaceParser = exports.ValidatorParser = exports.ModelParser = exports.RouteParser = exports.CommentParser = void 0;
-const http_status_code_1 = __importDefault(require("http-status-code"));
-const helpers_1 = require("./helpers");
-const util_1 = __importDefault(require("util"));
-const extract_comments_1 = __importDefault(require("extract-comments"));
-const fs_1 = __importDefault(require("fs"));
-const lodash_1 = require("lodash");
-const example_1 = __importDefault(require("./example"));
-const types_1 = require("./types");
-const lodash_2 = __importDefault(require("lodash"));
-class CommentParser {
-    parsedFiles = {};
-    exampleGenerator;
-    options;
-    constructor(options) {
-        this.options = options;
-    }
-    parseAnnotations(lines) {
-        let summary = "";
-        let tag = "";
-        let description = "";
-        let operationId;
-        let responses = {};
-        let requestBody;
-        let parameters = {};
-        let headers = {};
-        lines.forEach((line) => {
-            if (line.startsWith("@summary")) {
-                summary = line.replace("@summary ", "");
-            }
-            if (line.startsWith("@tag")) {
-                tag = line.replace("@tag ", "");
-            }
-            if (line.startsWith("@description")) {
-                description = line.replace("@description ", "");
-            }
-            if (line.startsWith("@operationId")) {
-                operationId = line.replace("@operationId ", "");
-            }
-            if (line.startsWith("@responseBody")) {
-                responses = {
-                    ...responses,
-                    ...this.parseResponseBody(line),
-                };
-            }
-            if (line.startsWith("@responseHeader")) {
-                const header = this.parseResponseHeader(line);
-                if (header === null) {
-                    console.error("Error with line: " + line);
-                    return;
-                }
-                headers[header["status"]] = {
-                    ...headers[header["status"]],
-                    ...header["header"],
-                };
-            }
-            if (line.startsWith("@requestBody")) {
-                requestBody = this.parseBody(line, "requestBody");
-            }
-            if (line.startsWith("@requestFormDataBody")) {
-                const parsedBody = this.parseRequestFormDataBody(line);
-                if (parsedBody) {
-                    requestBody = parsedBody;
-                }
-            }
-            if (line.startsWith("@param")) {
-                parameters = { ...parameters, ...this.parseParam(line) };
-            }
-        });
-        for (const [key, value] of Object.entries(responses)) {
-            if (typeof headers[key] !== undefined) {
-                responses[key]["headers"] = headers[key];
-            }
-            if (!responses[key]["description"]) {
-                responses[key]["description"] = `Returns **${key}** (${http_status_code_1.default.getMessage(key)}) as **${Object.entries(responses[key]["content"])[0][0]}**`;
-            }
-        }
-        return {
-            description,
-            responses,
-            requestBody,
-            parameters,
-            summary,
-            operationId,
-            tag,
-        };
-    }
-    parseParam(line) {
-        let where = "path";
-        let required = true;
-        let type = "string";
-        let example = null;
-        let enums = [];
-        if (line.startsWith("@paramUse")) {
-            let use = (0, helpers_1.getBetweenBrackets)(line, "paramUse");
-            const used = use.split(",");
-            let h = [];
-            used.forEach((u) => {
-                if (typeof this.options.common.parameters[u] === "undefined") {
-                    return;
-                }
-                const common = this.options.common.parameters[u];
-                h = [...h, ...common];
-            });
-            return h;
-        }
-        if (line.startsWith("@paramPath")) {
-            required = true;
-        }
-        if (line.startsWith("@paramQuery")) {
-            required = false;
-        }
-        let m = line.match("@param([a-zA-Z]*)");
-        if (m !== null) {
-            where = m[1].toLowerCase();
-            line = line.replace(m[0] + " ", "");
-        }
-        let [param, des, meta] = line.split(" - ");
-        if (typeof param === "undefined") {
-            return;
-        }
-        if (typeof des === "undefined") {
-            des = "";
-        }
-        if (typeof meta !== "undefined") {
-            if (meta.includes("@required")) {
-                required = true;
-            }
-            let en = (0, helpers_1.getBetweenBrackets)(meta, "enum");
-            example = (0, helpers_1.getBetweenBrackets)(meta, "example");
-            const mtype = (0, helpers_1.getBetweenBrackets)(meta, "type");
-            if (mtype !== "") {
-                type = mtype;
-            }
-            if (en !== "") {
-                enums = en.split(",");
-                example = enums[0];
-            }
-        }
-        let p = {
-            in: where,
-            name: param,
-            description: des,
-            schema: {
-                example: example,
-                type: type,
-            },
-            required: required,
-        };
-        if (enums.length > 1) {
-            p["schema"]["enum"] = enums;
-        }
-        return { [param]: p };
-    }
-    parseResponseHeader(responseLine) {
-        let description = "";
-        let example = "";
-        let type = "string";
-        let enums = [];
-        const line = responseLine.replace("@responseHeader ", "");
-        let [status, name, desc, meta] = line.split(" - ");
-        if (typeof status === "undefined" || typeof name === "undefined") {
-            return null;
-        }
-        if (typeof desc !== "undefined") {
-            description = desc;
-        }
-        if (name.includes("@use")) {
-            let use = (0, helpers_1.getBetweenBrackets)(name, "use");
-            const used = use.split(",");
-            let h = {};
-            used.forEach((u) => {
-                if (typeof this.options.common.headers[u] === "undefined") {
-                    return;
-                }
-                const common = this.options.common.headers[u];
-                h = { ...h, ...common };
-            });
-            return {
-                status: status,
-                header: h,
-            };
-        }
-        if (typeof meta !== "undefined") {
-            example = (0, helpers_1.getBetweenBrackets)(meta, "example");
-            const mtype = (0, helpers_1.getBetweenBrackets)(meta, "type");
-            if (mtype !== "") {
-                type = mtype;
-            }
-        }
-        if (example === "" || example === null) {
-            switch (type) {
-                case "string":
-                    example = "string";
-                    break;
-                case "integer":
-                    example = 1;
-                    break;
-                case "float":
-                    example = 1.5;
-                    break;
-            }
-        }
-        let h = {
-            schema: { type: type, example: example },
-            description: description,
-        };
-        if (enums.length > 1) {
-            h["schema"]["enum"] = enums;
-        }
-        return {
-            status: status,
-            header: {
-                [name]: h,
-            },
-        };
-    }
-    parseResponseBody(responseLine) {
-        let responses = {};
-        const line = responseLine.replace("@responseBody ", "");
-        let [status, res, desc] = line.split(" - ");
-        if (typeof status === "undefined")
-            return;
-        responses[status] = this.parseBody(res, "responseBody");
-        responses[status]["description"] = desc;
-        return responses;
-    }
-    parseRequestFormDataBody(rawLine) {
-        const line = rawLine.replace("@requestFormDataBody ", "");
-        let json = {}, required = [];
-        const isJson = (0, helpers_1.isJSONString)(line);
-        if (!isJson) {
-            // try to get json from reference
-            let rawRef = line.substring(line.indexOf("<") + 1, line.lastIndexOf(">"));
-            const cleandRef = rawRef.replace("[]", "");
-            if (cleandRef === "") {
-                return;
-            }
-            const parsedRef = this.exampleGenerator.parseRef(line, true);
-            let props = [];
-            const ref = this.exampleGenerator.schemas[cleandRef];
-            const ks = [];
-            if (ref.required && Array.isArray(ref.required))
-                required.push(...ref.required);
-            Object.entries(ref.properties).map(([key, value]) => {
-                if (typeof parsedRef[key] === "undefined") {
-                    return;
-                }
-                ks.push(key);
-                if (value["required"])
-                    required.push(key);
-                props.push({
-                    [key]: {
-                        type: typeof value["type"] === "undefined" ? "string" : value["type"],
-                        format: typeof value["format"] === "undefined"
-                            ? "string"
-                            : value["format"],
-                    },
-                });
-            });
-            const p = props.reduce((acc, curr) => ({ ...acc, ...curr }), {});
-            const appends = Object.keys(parsedRef).filter((k) => !ks.includes(k));
-            json = p;
-            if (appends.length > 0) {
-                appends.forEach((a) => {
-                    json[a] = parsedRef[a];
-                });
-            }
-        }
-        else {
-            json = JSON.parse(line);
-            for (let key in json) {
-                if (json[key].required === "true") {
-                    required.push(key);
-                }
-            }
-        }
-        // No need to try/catch this JSON.parse as we already did that in the isJSONString function
-        return {
-            content: {
-                "multipart/form-data": {
-                    schema: {
-                        type: "object",
-                        properties: json,
-                        required,
-                    },
-                },
-            },
-        };
-    }
-    parseBody(rawLine, type) {
-        let line = rawLine.replace(`@${type} `, "");
-        const isJson = (0, helpers_1.isJSONString)(line);
-        if (isJson) {
-            // No need to try/catch this JSON.parse as we already did that in the isJSONString function
-            const json = JSON.parse(line);
-            const o = this.jsonToObj(json);
-            return {
-                content: {
-                    "application/json": {
-                        schema: {
-                            type: Array.isArray(json) ? "array" : "object",
-                            ...(Array.isArray(json) ? { items: this.arrayItems(json) } : o),
-                        },
-                        example: this.exampleGenerator.jsonToRef(json),
-                    },
-                },
-            };
-        }
-        return this.exampleGenerator.parseRef(line);
-    }
-    arrayItems(json) {
-        const oneOf = [];
-        const t = typeof json[0];
-        if (t === "string") {
-            json.forEach((j) => {
-                const value = this.exampleGenerator.parseRef(j);
-                if (lodash_2.default.has(value, "content.application/json.schema.$ref")) {
-                    oneOf.push({
-                        $ref: value["content"]["application/json"]["schema"]["$ref"],
-                    });
-                }
-            });
-        }
-        if (oneOf.length > 0) {
-            return { oneOf: oneOf };
-        }
-        return { type: typeof json[0] };
-    }
-    jsonToObj(json) {
-        const o = {
-            type: "object",
-            properties: Object.keys(json)
-                .map((key) => {
-                const t = typeof json[key];
-                const v = json[key];
-                let value = v;
-                if (t === "object") {
-                    value = this.jsonToObj(json[key]);
-                }
-                if (t === "string" && v.includes("<") && v.includes(">")) {
-                    value = this.exampleGenerator.parseRef(v);
-                    if (v.includes("[]")) {
-                        let ref = "";
-                        if (lodash_2.default.has(value, "content.application/json.schema.$ref")) {
-                            ref = value["content"]["application/json"]["schema"]["$ref"];
-                        }
-                        if (lodash_2.default.has(value, "content.application/json.schema.items.$ref")) {
-                            ref =
-                                value["content"]["application/json"]["schema"]["items"]["$ref"];
-                        }
-                        value = {
-                            type: "array",
-                            items: {
-                                $ref: ref,
-                            },
-                        };
-                    }
-                    else {
-                        value = {
-                            $ref: value["content"]["application/json"]["schema"]["$ref"],
-                        };
-                    }
-                }
-                return {
-                    [key]: value,
-                };
-            })
-                .reduce((acc, curr) => ({ ...acc, ...curr }), {}),
-        };
-        // console.dir(o, { depth: null });
-        // console.log(json);
-        return o;
-    }
-    async getAnnotations(file, action) {
-        let annotations = {};
-        let newdata = "";
-        if (typeof file === "undefined")
-            return;
-        if (typeof this.parsedFiles[file] !== "undefined") {
-            newdata = this.parsedFiles[file];
-        }
-        else {
-            try {
-                const readFile = util_1.default.promisify(fs_1.default.readFile);
-                const data = await readFile(file, "utf8");
-                for (const line of data.split("\n")) {
-                    const l = line.trim();
-                    if (!l.startsWith("@")) {
-                        newdata += l + "\n";
-                    }
-                }
-                this.parsedFiles[file] = newdata;
-            }
-            catch (e) {
-                console.error("\x1b[31m✗ File not found\x1b[0m", file);
-            }
-        }
-        const comments = (0, extract_comments_1.default)(newdata);
-        if (comments.length > 0) {
-            comments.forEach((comment) => {
-                if (comment.type !== "BlockComment")
-                    return;
-                let lines = comment.value.split("\n").filter((l) => l != "");
-                // fix for decorators
-                if (lines[0].trim() !== "@" + action)
-                    return;
-                lines = lines.filter((l) => l != "");
-                annotations[action] = this.parseAnnotations(lines);
-            });
-        }
-        return annotations;
-    }
-}
-exports.CommentParser = CommentParser;
-class RouteParser {
-    options;
-    constructor(options) {
-        this.options = options;
-    }
-    /*
-      extract path-variables, tags and the uri-pattern
-    */
-    extractInfos(p) {
-        let parameters = {};
-        let pattern = "";
-        let tags = [];
-        let required;
-        const split = p.split("/");
-        if (split.length > this.options.tagIndex) {
-            tags = [split[this.options.tagIndex].toUpperCase()];
-        }
-        split.forEach((part) => {
-            if (part.startsWith(":")) {
-                required = !part.endsWith("?");
-                const param = part.replace(":", "").replace("?", "");
-                part = "{" + param + "}";
-                parameters = {
-                    ...parameters,
-                    [param]: {
-                        in: "path",
-                        name: param,
-                        schema: {
-                            type: "string",
-                        },
-                        required: required,
-                    },
-                };
-            }
-            pattern += "/" + part;
-        });
-        if (pattern.endsWith("/")) {
-            pattern = pattern.slice(0, -1);
-        }
-        return { tags, parameters, pattern };
-    }
-}
-exports.RouteParser = RouteParser;
-class ModelParser {
-    exampleGenerator;
-    snakeCase;
-    constructor(snakeCase) {
-        this.snakeCase = snakeCase;
-        this.exampleGenerator = new example_1.default({});
-    }
-    parseModelProperties(data) {
-        let props = {};
-        let required = [];
-        // remove empty lines
-        data = data.replace(/\t/g, "").replace(/^(?=\n)$|^\s*|\s*$|\n\n+/gm, "");
-        const lines = data.split("\n");
-        let softDelete = false;
-        let name = "";
-        lines.forEach((line, index) => {
-            line = line.trim();
-            // skip comments
-            if (line.startsWith("export default class")) {
-                name = line.split(" ")[3];
-            }
-            if (line.includes("@swagger-softdelete") ||
-                line.includes("SoftDeletes")) {
-                softDelete = true;
-            }
-            if (line.startsWith("//") ||
-                line.startsWith("/*") ||
-                line.startsWith("*") ||
-                line.startsWith("public static ") ||
-                line.startsWith("private static ") ||
-                line.startsWith("static "))
-                return;
-            if (index > 0 && lines[index - 1].includes("serializeAs: null"))
-                return;
-            if (index > 0 && lines[index - 1].includes("@no-swagger"))
-                return;
-            if (!line.startsWith("public ") &&
-                !line.startsWith("public get") &&
-                !line.includes("declare "))
-                return;
-            let s = [];
-            if (line.includes("declare ")) {
-                s = line.split("declare ");
-            }
-            if (line.startsWith("public ")) {
-                if (line.startsWith("public get")) {
-                    s = line.split("public get");
-                    let s2 = s[1].replace(/;/g, "").split(":");
-                }
-                else {
-                    s = line.split("public ");
-                }
-            }
-            let s2 = s[1].replace(/;/g, "").split(":");
-            let field = s2[0];
-            let type = s2[1] || "";
-            type = type.trim();
-            let enums = [];
-            let format = "";
-            let keyprops = {};
-            let example = null;
-            if (index > 0 && lines[index - 1].includes("@enum")) {
-                const l = lines[index - 1];
-                let en = (0, helpers_1.getBetweenBrackets)(l, "enum");
-                if (en !== "") {
-                    enums = en.split(",");
-                    example = enums[0];
-                }
-            }
-            if (index > 0 && lines[index - 1].includes("@format")) {
-                const l = lines[index - 1];
-                let en = (0, helpers_1.getBetweenBrackets)(l, "format");
-                if (en !== "") {
-                    format = en;
-                }
-            }
-            if (index > 0 && lines[index - 1].includes("@example")) {
-                const l = lines[index - 1];
-                let match = l.match(/example\(([^()]*)\)/g);
-                if (match !== null) {
-                    const m = match[0].replace("example(", "").replace(")", "");
-                    example = m;
-                    if (type === "number") {
-                        example = parseInt(m);
-                    }
-                }
-            }
-            if (index > 0 && lines[index - 1].includes("@required")) {
-                required.push(field);
-            }
-            if (index > 0 && lines[index - 1].includes("@props")) {
-                const l = lines[index - 1].replace("@props", "props");
-                const j = (0, helpers_1.getBetweenBrackets)(l, "props");
-                if ((0, helpers_1.isJSONString)(j)) {
-                    keyprops = JSON.parse(j);
-                }
-            }
-            if (typeof type === "undefined") {
-                type = "string";
-                format = "";
-            }
-            field = field.trim();
-            type = type.trim();
-            //TODO: make oneOf
-            if (type.includes(" | ")) {
-                const types = type.split(" | ");
-                type = types.filter((t) => t !== "null")[0];
-            }
-            field = field.replace("()", "");
-            field = field.replace("get ", "");
-            type = type.replace("{", "").trim();
-            if (this.snakeCase) {
-                field = (0, lodash_1.snakeCase)(field);
-            }
-            let indicator = "type";
-            if (example === null) {
-                example = "string";
-            }
-            // if relation to another model
-            if (type.includes("typeof")) {
-                s = type.split("typeof ");
-                type = "#/components/schemas/" + s[1].slice(0, -1);
-                indicator = "$ref";
-            }
-            else {
-                if (types_1.standardTypes.includes(type.toLowerCase())) {
-                    type = type.toLowerCase();
-                }
-                else {
-                    // assume its a custom interface
-                    indicator = "$ref";
-                    type = "#/components/schemas/" + type;
-                }
-            }
-            type = type.trim();
-            let isArray = false;
-            if (line.includes("HasMany") ||
-                line.includes("ManyToMany") ||
-                line.includes("HasManyThrough") ||
-                type.includes("[]")) {
-                isArray = true;
-                if (type.slice(type.length - 2, type.length) === "[]") {
-                    type = type.split("[]")[0];
-                }
-            }
-            if (example === null || example === "string") {
-                example =
-                    this.exampleGenerator.exampleByField(field) ||
-                        this.exampleGenerator.exampleByType(type);
-            }
-            if (type === "datetime") {
-                indicator = "type";
-                type = "string";
-                format = "date-time";
-            }
-            if (type === "date") {
-                indicator = "type";
-                type = "string";
-                format = "date";
-            }
-            if (field === "email") {
-                indicator = "type";
-                type = "string";
-                format = "email";
-            }
-            if (field === "password") {
-                indicator = "type";
-                type = "string";
-                format = "password";
-            }
-            if (enums.length > 0) {
-                indicator = "type";
-                type = "string";
-            }
-            if (type === "any") {
-                indicator = "$ref";
-                type = "#/components/schemas/Any";
-            }
-            let prop = {};
-            if (type === "integer" || type === "number") {
-                if (example === null || example === "string") {
-                    example = Math.floor(Math.random() * 1000);
-                }
-            }
-            if (type === "boolean") {
-                example = true;
-            }
-            prop[indicator] = type;
-            prop["example"] = example;
-            // if array
-            if (isArray) {
-                props[field] = { type: "array", items: prop };
-            }
-            else {
-                props[field] = prop;
-                if (format !== "") {
-                    props[field]["format"] = format;
-                }
-            }
-            Object.entries(keyprops).map(([key, value]) => {
-                props[field][key] = value;
-            });
-            if (enums.length > 0) {
-                props[field]["enum"] = enums;
-            }
-        });
-        if (softDelete) {
-            props["deleted_at"] = {
-                type: "string",
-                format: "date-time",
-                example: "2021-03-23T16:13:08.489+01:00",
-            };
-        }
-        return { name: name, props: props, required: required };
-    }
-}
-exports.ModelParser = ModelParser;
-class ValidatorParser {
-    exampleGenerator;
-    constructor() {
-        this.exampleGenerator = new example_1.default({});
-    }
-    async validatorToObject(validator) {
-        // console.dir(validator.toJSON()["refs"], { depth: null });
-        // console.dir(json, { depth: null });
-        const obj = {
-            type: "object",
-            ...this.parseSchema(validator.toJSON()["schema"]["schema"], validator.toJSON()["refs"]),
-        };
-        // console.dir(obj, { depth: null });
-        const testObj = this.objToTest(obj["properties"]);
-        return await this.parsePropsAndMeta(obj, testObj, validator);
-    }
-    async parsePropsAndMeta(obj, testObj, validator) {
-        // console.log(Object.keys(errors));
-        const { SimpleMessagesProvider } = await import("@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 msgs = e.messages;
-        for (const m of msgs) {
-            const err = m["message"];
-            let objField = m["field"].replace(".", ".properties.");
-            if (m["field"].includes(".0")) {
-                objField = objField.replaceAll(`.0`, ".items");
-            }
-            if (err === "TYPE") {
-                lodash_2.default.set(obj["properties"], objField, {
-                    ...lodash_2.default.get(obj["properties"], objField),
-                    type: m["rule"],
-                    example: this.exampleGenerator.exampleByType(m["rule"]),
-                });
-                if (m["rule"] === "string") {
-                    if (lodash_2.default.get(obj["properties"], objField)["minimum"]) {
-                        lodash_2.default.set(obj["properties"], objField, {
-                            ...lodash_2.default.get(obj["properties"], objField),
-                            minLength: lodash_2.default.get(obj["properties"], objField)["minimum"],
-                        });
-                        lodash_2.default.unset(obj["properties"], objField + ".minimum");
-                    }
-                    if (lodash_2.default.get(obj["properties"], objField)["maximum"]) {
-                        lodash_2.default.set(obj["properties"], objField, {
-                            ...lodash_2.default.get(obj["properties"], objField),
-                            maxLength: lodash_2.default.get(obj["properties"], objField)["maximum"],
-                        });
-                        lodash_2.default.unset(obj["properties"], objField + ".maximum");
-                    }
-                }
-                lodash_2.default.set(testObj, m["field"], this.exampleGenerator.exampleByType(m["rule"]));
-            }
-            if (err === "FORMAT") {
-                lodash_2.default.set(obj["properties"], objField, {
-                    ...lodash_2.default.get(obj["properties"], objField),
-                    format: m["rule"],
-                    type: "string",
-                    example: this.exampleGenerator.exampleByValidatorRule(m["rule"]),
-                });
-                lodash_2.default.set(testObj, m["field"], this.exampleGenerator.exampleByValidatorRule(m["rule"]));
-            }
-        }
-        // console.dir(obj, { depth: null });
-        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 p of json["properties"]) {
-            let meta = this.getMetaFromValidations(p["validations"], refs);
-            // console.dir(p, { depth: null });
-            // console.dir(validations, { depth: null });
-            // console.log(min, max, choices, regex);
-            const type = p["type"];
-            const field = p["fieldName"];
-            if (type === "object") {
-                console.log(field, p);
-                obj[field] = { type: "object", ...this.parseSchema(p, refs) };
-            }
-            else {
-                // if array
-                if (type === "array") {
-                    if (p["each"]["type"] === "object") {
-                        obj[field] = {
-                            type: "array",
-                            items: {
-                                type: "object",
-                                ...this.parseSchema(p["each"], refs),
-                            }
-                        };
-                    }
-                    else {
-                        const meta = this.getMetaFromValidations(p["each"]["validations"], refs);
-                        obj[field] = {
-                            type: "array",
-                            items: {
-                                type: this.getType(p["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 (!p["isOptional"])
-                required.push(p["fieldName"]);
-        }
-        const res = { properties: obj };
-        if (required.length > 0)
-            res["required"] = required;
-        return res;
-    }
-    getType(type) {
-        if (type == 'literal') {
-            return 'string';
-        }
-        return type;
-    }
-    getMetaFromValidations(validations, refs) {
-        let meta = {};
-        for (const v of validations) {
-            if (refs[v["ruleFnId"]].options?.example) {
-                meta = { ...meta, example: refs[v["ruleFnId"]].options.example };
-            }
-            if (refs[v["ruleFnId"]].options?.min) {
-                meta = { ...meta, minimum: refs[v["ruleFnId"]].options.min };
-            }
-            if (refs[v["ruleFnId"]].options?.max) {
-                meta = { ...meta, maximum: refs[v["ruleFnId"]].options.max };
-            }
-            if (refs[v["ruleFnId"]].options?.choices) {
-                meta = { ...meta, enum: refs[v["ruleFnId"]].options.choices };
-            }
-            if (refs[v["ruleFnId"]].options?.toString().includes("/")) {
-                meta = { ...meta, pattern: refs[v["ruleFnId"]].options.toString() };
-            }
-        }
-        return meta;
-    }
-}
-exports.ValidatorParser = ValidatorParser;
-class InterfaceParser {
-    exampleGenerator;
-    snakeCase;
-    schemas = {};
-    constructor(snakeCase, schemas = {}) {
-        this.snakeCase = snakeCase;
-        this.exampleGenerator = new example_1.default({});
-        this.schemas = schemas;
-    }
-    objToExample(obj) {
-        let example = {};
-        Object.entries(obj).map(([key, value]) => {
-            if (typeof value === "object") {
-                example[key] = this.objToExample(value);
-            }
-            else {
-                example[key] = this.exampleGenerator.exampleByType(value);
-                if (example[key] === null) {
-                    example[key] = this.exampleGenerator.exampleByField(key);
-                }
-            }
-        });
-        return example;
-    }
-    parseProps(obj) {
-        const no = {};
-        Object.entries(obj).map(([f, value]) => {
-            if (typeof value === "object") {
-                no[f.replaceAll("?", "")] = {
-                    type: "object",
-                    nullable: f.includes("?"),
-                    properties: this.parseProps(value),
-                    example: this.objToExample(value),
-                };
-            }
-            else {
-                no[f.replaceAll("?", "")] = {
-                    ...this.parseType(value, f),
-                };
-            }
-        });
-        return no;
-    }
-    getInheritedProperties(baseType) {
-        if (this.schemas[baseType]?.properties) {
-            return {
-                properties: this.schemas[baseType].properties,
-                required: this.schemas[baseType].required || []
-            };
-        }
-        const cleanType = baseType
-            .split('/')
-            .pop()
-            ?.replace('.ts', '')
-            ?.replace(/^[#@]/, '');
-        if (!cleanType)
-            return { properties: {}, required: [] };
-        if (this.schemas[cleanType]?.properties) {
-            return {
-                properties: this.schemas[cleanType].properties,
-                required: this.schemas[cleanType].required || []
-            };
-        }
-        const variations = [
-            cleanType,
-            `#models/${cleanType}`,
-            cleanType.replace(/Model$/, ''),
-            `${cleanType}Model`
-        ];
-        for (const variation of variations) {
-            if (this.schemas[variation]?.properties) {
-                return {
-                    properties: this.schemas[variation].properties,
-                    required: this.schemas[variation].required || []
-                };
-            }
-        }
-        return { properties: {}, required: [] };
-    }
-    parseInterfaces(data) {
-        data = data.replace(/\t/g, "").replace(/^(?=\n)$|^\s*|\s*$|\n\n+/gm, "");
-        let currentInterface = null;
-        const interfaces = {};
-        const interfaceDefinitions = new Map();
-        const lines = data.split("\n");
-        for (let i = 0; i < lines.length; i++) {
-            const line = lines[i].trim();
-            const isDefault = line.startsWith("export default interface");
-            if (line.startsWith("interface") || line.startsWith("export interface") || isDefault) {
-                const sp = line.split(/\s+/);
-                const idx = line.endsWith("}") ? sp.length - 1 : sp.length - 2;
-                const name = sp[idx].split(/[{\s]/)[0];
-                const extendedTypes = this.parseExtends(line);
-                interfaceDefinitions.set(name, {
-                    extends: extendedTypes,
-                    properties: {},
-                    required: [],
-                    startLine: i,
-                    examples: {}
-                });
-                currentInterface = name;
-                continue;
-            }
-            if (currentInterface && line === "}") {
-                currentInterface = null;
-                continue;
-            }
-            if (currentInterface && line && !line.startsWith("//") && !line.startsWith("/*") && !line.startsWith("*")) {
-                const def = interfaceDefinitions.get(currentInterface);
-                if (def) {
-                    const previousLine = i > 0 ? lines[i - 1].trim() : "";
-                    const isRequired = previousLine.includes("@required");
-                    // extract example value from comment @example(john)
-                    const example = previousLine.match(/@example\((.*)\)/)?.[1];
-                    const [prop, type] = line.split(":").map(s => s.trim());
-                    if (prop && type) {
-                        const cleanProp = prop.replace("?", "");
-                        def.properties[cleanProp] = type.replace(";", "");
-                        if (isRequired || !prop.includes("?")) {
-                            def.required.push(cleanProp);
-                        }
-                        if (example)
-                            def.examples[cleanProp] = example;
-                    }
-                }
-            }
-        }
-        for (const [name, def] of interfaceDefinitions) {
-            let allProperties = {};
-            let requiredFields = new Set(def.required);
-            for (const baseType of def.extends) {
-                const baseSchema = this.schemas[baseType];
-                if (baseSchema) {
-                    if (baseSchema.properties) {
-                        Object.assign(allProperties, baseSchema.properties);
-                    }
-                    if (baseSchema.required) {
-                        baseSchema.required.forEach(field => requiredFields.add(field));
-                    }
-                }
-            }
-            Object.assign(allProperties, def.properties);
-            const parsedProperties = {};
-            for (const [key, value] of Object.entries(allProperties)) {
-                if (typeof value === 'object' && value !== null && 'type' in value) {
-                    parsedProperties[key] = value;
-                }
-                else {
-                    parsedProperties[key] = this.parseType(value, key);
-                }
-                if (def.examples[key]) {
-                    parsedProperties[key].example = def.examples[key];
-                }
-            }
-            const schema = {
-                type: "object",
-                properties: parsedProperties,
-                required: Array.from(requiredFields),
-                description: `${name}${def.extends.length ? ` extends ${def.extends.join(", ")}` : ""} (Interface)`
-            };
-            if (schema.required.length === 0) {
-                delete schema.required;
-            }
-            interfaces[name] = schema;
-        }
-        return interfaces;
-    }
-    parseExtends(line) {
-        const matches = line.match(/extends\s+([^{]+)/);
-        if (!matches)
-            return [];
-        return matches[1]
-            .split(",")
-            .map(type => type.trim())
-            .map(type => {
-            const cleanType = type.split('/').pop();
-            return cleanType?.replace(/\.ts$/, '') || type;
-        });
-    }
-    parseType(type, field) {
-        if (typeof type === 'object' && type !== null && 'type' in type) {
-            return type;
-        }
-        let isArray = false;
-        if (typeof type === 'string' && type.includes("[]")) {
-            type = type.replace("[]", "");
-            isArray = true;
-        }
-        if (typeof type === 'string') {
-            type = type.replace(/[;\r\n]/g, '').trim();
-        }
-        let prop = { type: type };
-        let notRequired = field.includes("?");
-        prop.nullable = notRequired;
-        if (typeof type === 'string' && type.toLowerCase() === "datetime") {
-            prop.type = "string";
-            prop.format = "date-time";
-            prop.example = "2021-03-23T16:13:08.489+01:00";
-        }
-        else if (typeof type === 'string' && type.toLowerCase() === "date") {
-            prop.type = "string";
-            prop.format = "date";
-            prop.example = "2021-03-23";
-        }
-        else {
-            const standardTypes = ["string", "number", "boolean", "integer"];
-            if (typeof type === 'string' && !standardTypes.includes(type.toLowerCase())) {
-                delete prop.type;
-                prop.$ref = `#/components/schemas/${type}`;
-            }
-            else {
-                if (typeof type === 'string') {
-                    prop.type = type.toLowerCase();
-                }
-                prop.example = this.exampleGenerator.exampleByType(type) ||
-                    this.exampleGenerator.exampleByField(field);
-            }
-        }
-        if (isArray) {
-            return {
-                type: "array",
-                items: prop
-            };
-        }
-        return prop;
-    }
-}
-exports.InterfaceParser = InterfaceParser;
-class EnumParser {
-    constructor() { }
-    parseEnums(data) {
-        const enums = {};
-        const lines = data.split("\n");
-        let currentEnum = null;
-        let description = null;
-        for (const line of lines) {
-            const trimmedLine = line.trim();
-            if (trimmedLine.startsWith("//")) {
-                description = trimmedLine.slice(2).trim();
-                continue;
-            }
-            if (trimmedLine.startsWith("enum") ||
-                trimmedLine.startsWith("export enum")) {
-                const match = trimmedLine.match(/(?:export\s+)?enum\s+(\w+)/);
-                if (match) {
-                    currentEnum = match[1];
-                    enums[currentEnum] = {
-                        type: "string",
-                        enum: [],
-                        properties: {},
-                        description: description || `${(0, lodash_1.startCase)(currentEnum)} enumeration`,
-                    };
-                    description = null;
-                }
-                continue;
-            }
-            if (currentEnum && trimmedLine !== "{" && trimmedLine !== "}") {
-                const [key, value] = trimmedLine.split("=").map((s) => s.trim());
-                if (key) {
-                    const enumValue = value ? this.parseEnumValue(value) : key;
-                    enums[currentEnum].enum.push(enumValue);
-                }
-            }
-            if (trimmedLine === "}") {
-                currentEnum = null;
-            }
-        }
-        return enums;
-    }
-    parseEnumValue(value) {
-        // Remove quotes and comma
-        return value.replace(/['",]/g, "").trim();
-    }
-}
-exports.EnumParser = EnumParser;