@necessarylion/adonis-autoswagger 0.0.4 → 0.0.5

package/dist/parsers/interface_parser.js

@@ -0,0 +1,249 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InterfaceParser = void 0;
+const example_1 = __importDefault(require("../example"));
+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 newObject = {};
+        Object.entries(obj).map(([field, value]) => {
+            if (typeof value === "object") {
+                newObject[field.replaceAll("?", "")] = {
+                    type: "object",
+                    nullable: field.includes("?"),
+                    properties: this.parseProps(value),
+                    example: this.objToExample(value),
+                };
+            }
+            else {
+                newObject[field.replaceAll("?", "")] = {
+                    ...this.parseType(value, field),
+                };
+            }
+        });
+        return newObject;
+    }
+    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(fileContent) {
+        fileContent = fileContent
+            .replace(/\t/g, "")
+            .replace(/^(?=\n)$|^\s*|\s*$|\n\n+/gm, "");
+        let currentInterface = null;
+        const interfaces = {};
+        const interfaceDefinitions = new Map();
+        const lines = fileContent.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 splittedLine = line.split(/\s+/);
+                const index = line.endsWith("}")
+                    ? splittedLine.length - 1
+                    : splittedLine.length - 2;
+                const name = splittedLine[index].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 definition = interfaceDefinitions.get(currentInterface);
+                if (definition) {
+                    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("?", "");
+                        definition.properties[cleanProp] = type.replace(";", "");
+                        if (isRequired || !prop.includes("?")) {
+                            definition.required.push(cleanProp);
+                        }
+                        if (example)
+                            definition.examples[cleanProp] = example;
+                    }
+                }
+            }
+        }
+        for (const [name, definition] of interfaceDefinitions) {
+            let allProperties = {};
+            let requiredFields = new Set(definition.required);
+            for (const baseType of definition.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, definition.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 (definition.examples[key]) {
+                    parsedProperties[key].example = definition.examples[key];
+                }
+            }
+            const schema = {
+                type: "object",
+                properties: parsedProperties,
+                required: Array.from(requiredFields),
+                description: `${name}${definition.extends.length
+                    ? ` extends ${definition.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 property = { type: type };
+        let notRequired = field.includes("?");
+        property.nullable = notRequired;
+        if (typeof type === "string" && type.toLowerCase() === "datetime") {
+            property.type = "string";
+            property.format = "date-time";
+            property.example = "2021-03-23T16:13:08.489+01:00";
+        }
+        else if (typeof type === "string" && type.toLowerCase() === "date") {
+            property.type = "string";
+            property.format = "date";
+            property.example = "2021-03-23";
+        }
+        else {
+            const standardTypes = ["string", "number", "boolean", "integer"];
+            if (typeof type === "string" &&
+                !standardTypes.includes(type.toLowerCase())) {
+                delete property.type;
+                property.$ref = `#/components/schemas/${type}`;
+            }
+            else {
+                if (typeof type === "string") {
+                    property.type = type.toLowerCase();
+                }
+                property.example =
+                    this.exampleGenerator.exampleByType(type) ||
+                        this.exampleGenerator.exampleByField(field);
+            }
+        }
+        if (isArray) {
+            return {
+                type: "array",
+                items: property,
+            };
+        }
+        return property;
+    }
+}
+exports.InterfaceParser = InterfaceParser;

package/dist/parsers/model_parser.d.ts

@@ -0,0 +1,11 @@
+import ExampleGenerator from "../example";
+export declare class ModelParser {
+    exampleGenerator: ExampleGenerator;
+    snakeCase: boolean;
+    constructor(snakeCase: boolean);
+    parseModelProperties(fileContent: string): {
+        name: string;
+        props: Record<string, any>;
+        required: any[];
+    };
+}

package/dist/parsers/model_parser.js

@@ -0,0 +1,234 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelParser = void 0;
+const lodash_1 = require("lodash");
+const helpers_1 = require("./helpers");
+const example_1 = __importDefault(require("../example"));
+const types_1 = require("../types");
+class ModelParser {
+    exampleGenerator;
+    snakeCase;
+    constructor(snakeCase) {
+        this.snakeCase = snakeCase;
+        this.exampleGenerator = new example_1.default({});
+    }
+    parseModelProperties(fileContent) {
+        let props = {};
+        let required = [];
+        // remove empty lines
+        fileContent = fileContent
+            .replace(/\t/g, "")
+            .replace(/^(?=\n)$|^\s*|\s*$|\n\n+/gm, "");
+        const lines = fileContent.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 splittedLine = [];
+            if (line.includes("declare ")) {
+                splittedLine = line.split("declare ");
+            }
+            if (line.startsWith("public ")) {
+                if (line.startsWith("public get")) {
+                    splittedLine = line.split("public get");
+                    let splittedLine2 = splittedLine[1].replace(/;/g, "").split(":");
+                }
+                else {
+                    splittedLine = line.split("public ");
+                }
+            }
+            let splittedLine2 = splittedLine[1].replace(/;/g, "").split(":");
+            let field = splittedLine2[0];
+            let type = splittedLine2[1] || "";
+            type = type.trim();
+            let enums = [];
+            let format = "";
+            let keyprops = {};
+            let example = null;
+            if (index > 0 && lines[index - 1].includes("@enum")) {
+                const line = lines[index - 1];
+                let enumsFromLine = (0, helpers_1.getBetweenBrackets)(line, "enum");
+                if (enumsFromLine !== "") {
+                    enums = enumsFromLine.split(",");
+                    example = enums[0];
+                }
+            }
+            if (index > 0 && lines[index - 1].includes("@format")) {
+                const line = lines[index - 1];
+                let formatFromLine = (0, helpers_1.getBetweenBrackets)(line, "format");
+                if (formatFromLine !== "") {
+                    format = formatFromLine;
+                }
+            }
+            if (index > 0 && lines[index - 1].includes("@example")) {
+                const line = lines[index - 1];
+                let match = line.match(/example\(([^()]*)\)/g);
+                if (match !== null) {
+                    const exampleFromLine = match[0].replace("example(", "").replace(")", "");
+                    example = exampleFromLine;
+                    if (type === "number") {
+                        example = parseInt(exampleFromLine);
+                    }
+                }
+            }
+            if (index > 0 && lines[index - 1].includes("@required")) {
+                required.push(field);
+            }
+            if (index > 0 && lines[index - 1].includes("@props")) {
+                const line = lines[index - 1].replace("@props", "props");
+                const json = (0, helpers_1.getBetweenBrackets)(line, "props");
+                if ((0, helpers_1.isJSONString)(json)) {
+                    keyprops = JSON.parse(json);
+                }
+            }
+            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")) {
+                splittedLine = type.split("typeof ");
+                type = "#/components/schemas/" + splittedLine[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 (type === "uuid") {
+                indicator = "type";
+                type = "string";
+                format = "uuid";
+            }
+            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;

package/dist/parsers/route_parser.d.ts

@@ -0,0 +1,10 @@
+import type { options } from "../types";
+export declare class RouteParser {
+    options: options;
+    constructor(options: options);
+    extractInfos(path: string): {
+        tags: string[];
+        parameters: Record<string, any>;
+        pattern: string;
+    };
+}

package/dist/parsers/route_parser.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RouteParser = void 0;
+class RouteParser {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    /*
+      extract path-variables, tags and the uri-pattern
+    */
+    extractInfos(path) {
+        let parameters = {};
+        let pattern = "";
+        let tags = [];
+        let required;
+        const split = path.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;

package/dist/parsers/validator_parser.d.ts

@@ -0,0 +1,7 @@
+import ExampleGenerator from "../example";
+export declare class ValidatorParser {
+    #private;
+    exampleGenerator: ExampleGenerator;
+    constructor();
+    validatorToObject(validator: any): Promise<Record<string, any>>;
+}