swaggular 0.1.0

package/dist/translators/generate-interfaces.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getImports = getImports;
+exports.buildInterface = buildInterface;
+exports.buildEnum = buildEnum;
+exports.generateSchemaInterfaces = generateSchemaInterfaces;
+exports.buildComments = buildComments;
+const paged_request_template_1 = require("../templates/paged-request-template");
+const paged_result_template_1 = require("../templates/paged-result-template");
+const build_types_1 = require("../utils/build-types");
+const to_case_1 = require("../utils/to-case");
+function getImports(schema, type) {
+    const imports = [];
+    if (!schema["$ref"]) {
+        return [];
+    }
+    if (type.startsWith("PagedResultDto")) {
+        imports.push("PagedResultDto");
+        const splited = type.replaceAll(">", "").split("<");
+        splited.forEach((s) => imports.push(s));
+    }
+    return imports;
+}
+function buildInterface(name, schema) {
+    if (name.endsWith("PagedResultDto"))
+        return { content: null, imports: [] };
+    const lines = [];
+    lines.push(`export interface ${name} {`);
+    const imports = new Set();
+    for (const [prop, def] of Object.entries(schema.properties)) {
+        const comments = buildComments(def);
+        const tsType = (0, build_types_1.switchTypeJson)(def);
+        if (def["$ref"]) {
+            getImports(def, tsType).forEach((i) => imports.add(i));
+        }
+        const optional = def.nullable || !schema.required?.includes(prop);
+        const nullable = def.nullable ? " | null" : "";
+        lines.push(`${comments}\n\t${(0, to_case_1.lowerFirst)(prop)}${optional ? "?" : ""}: ${tsType}${nullable};`);
+    }
+    lines.push(`}`);
+    return { content: lines.join("\n"), imports: [] };
+}
+function buildEnum(name, schema) {
+    const lines = [];
+    lines.push(`export enum ${name} {`);
+    for (const value of schema.enum) {
+        lines.push(`\t${value} = "${value}",`);
+    }
+    lines.push(`}`);
+    return lines.join("\n");
+}
+function generateSchemaInterfaces(schemas, paths, parametersTypes) {
+    const interfaces = {};
+    for (const [name, schema] of Object.entries(schemas)) {
+        if (schema.type === "string" && schema.enum && schema.enum.length > 0) {
+            const enumString = buildEnum(name, schema);
+            if (!enumString)
+                continue;
+            interfaces[name] = { content: enumString, imports: [] };
+            continue;
+        }
+        if (schema.type === "object" && schema.properties) {
+            const interfaceString = buildInterface(name, schema);
+            if (!interfaceString.content)
+                continue;
+            interfaces[name] = {
+                content: interfaceString.content,
+                imports: interfaceString.imports,
+            };
+            continue;
+        }
+    }
+    const defaultPagedRequestDtoKeys = [
+        "pageNumber",
+        "pageSize",
+        "searchTerm",
+        "sortBy",
+        "sortDescending",
+    ];
+    const requestImports = new Set();
+    for (const value of Object.values(parametersTypes)) {
+        const { method, parameterType } = value;
+        const path = paths[method];
+        if (!path.parameters || path.parameters.length === 0)
+            continue;
+        const properties = [];
+        for (const param of path.parameters) {
+            if (defaultPagedRequestDtoKeys.includes(param.name) ||
+                param.in !== "query")
+                continue;
+            const tsType = (0, build_types_1.switchTypeJson)(param.schema);
+            if (param.schema["$ref"]) {
+                getImports(param.schema, tsType).forEach((i) => requestImports.add(i));
+            }
+            const comments = buildComments(param.schema);
+            properties.push(`${comments}\n\t${(0, to_case_1.lowerFirst)(param.name)}?: ${tsType};`);
+        }
+        let interfaceTemplate = `export interface ${parameterType} extends PagedRequestDto {
+      ${properties.join("\n")}
+    }`;
+        requestImports.add("PagedRequestDto");
+        interfaces[parameterType] = {
+            content: interfaceTemplate,
+            imports: Array.from(requestImports),
+        };
+    }
+    return {
+        ...interfaces,
+        ["PagedRequestDto"]: { content: paged_request_template_1.pagedRequestTemplate, imports: [] },
+        ["PagedResultDto"]: { content: paged_result_template_1.pagedResultTemplate, imports: [] },
+    };
+}
+function buildComments(param) {
+    const comments = [];
+    if (param.format !== undefined) {
+        comments.push(`format: ${param.format}`);
+    }
+    if (param.minLength !== undefined) {
+        comments.push(`minLength: ${param.minLength}`);
+    }
+    if (param.maxLength !== undefined) {
+        comments.push(`maxLength: ${param.maxLength}`);
+    }
+    if (param.minimum !== undefined) {
+        comments.push(`minimum: ${param.minimum}`);
+    }
+    if (param.maximum !== undefined) {
+        comments.push(`maximum: ${param.maximum}`);
+    }
+    if (comments.length > 0) {
+        return `  /**\n   * ${comments.join("\n   * ")}\n   */`;
+    }
+    return "";
+}

package/dist/translators/generate-services.js

@@ -0,0 +1,192 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toCamelCase = toCamelCase;
+exports.toExtra = toExtra;
+exports.generateBaseUrl = generateBaseUrl;
+exports.transformGroupedPathsToAngularServices = transformGroupedPathsToAngularServices;
+const generate_imports_1 = require("../utils/generate-imports");
+const method_builders_1 = require("../utils/method-builders");
+/* ============================================================
+ * LOW-LEVEL HELPERS
+ * ============================================================ */
+function isVariable(segment) {
+    return /^\{.+\}$/.test(segment);
+}
+function kebabToPascal(value) {
+    return value
+        .split("-")
+        .map((v) => v.charAt(0).toUpperCase() + v.slice(1))
+        .join("");
+}
+function extractPathVariables(path) {
+    return path
+        .split("/")
+        .filter(isVariable)
+        .map((v) => v.slice(1, -1));
+}
+function endsWithVariable(path) {
+    const parts = path.split("/").filter(Boolean);
+    return isVariable(parts[parts.length - 1]);
+}
+/**
+ * Detecta si la ruta es hija del grupo y devuelve el nombre del recurso hijo
+ * /A/{id}/B/{x}  ->  B
+ */
+function getChildResource(path, baseSegments) {
+    const segments = path
+        .split("/")
+        .filter(Boolean)
+        .filter((s) => s !== "api");
+    let count = 0;
+    for (const seg of segments) {
+        if (isVariable(seg))
+            continue;
+        count++;
+        if (count > baseSegments.length) {
+            return seg;
+        }
+    }
+    return null;
+}
+/* ============================================================
+ * METHOD NAME RESOLUTION (TU DICCIONARIO)
+ * ============================================================ */
+function resolveMethodName(http, endsInVar, child, putNoVarAlreadyExists = false) {
+    let base;
+    switch (http) {
+        case "get":
+            base = endsInVar ? "get" : "getAll";
+            break;
+        case "post":
+            base = "create";
+            break;
+        case "put":
+            base = endsInVar
+                ? "update"
+                : putNoVarAlreadyExists
+                    ? "updateAll"
+                    : "update";
+            break;
+        case "delete":
+            base = "delete";
+            break;
+        case "patch":
+            base = "patch";
+            break;
+    }
+    return child ? base + kebabToPascal(child) : base;
+}
+function toCamelCase(value) {
+    const firstCharacter = value.at(0);
+    return firstCharacter?.toLowerCase() + value.slice(1);
+}
+function toExtra(segments) {
+    let path = ``;
+    segments.forEach((s) => {
+        const isVariable = s.startsWith("{");
+        path += isVariable ? `/\${${toCamelCase(s.slice(1, -1))}}` : `/${s}`;
+    });
+    return path;
+}
+function generateBaseUrl(baseSegments, paths) {
+    const splitted = paths[0].split("/").filter(Boolean);
+    const foundIndex = splitted.findIndex((s) => s === baseSegments[baseSegments.length - 1]);
+    const foundVariable = splitted.findIndex((s) => s.includes("{"));
+    if (foundIndex > foundVariable && foundVariable >= 0) {
+        const base = "/" + splitted.slice(0, foundVariable).join("/");
+        return base;
+    }
+    return "/" + splitted.slice(0, foundIndex + 1).join("/");
+}
+/* ============================================================
+ * 🚀 MAIN TRANSFORMER
+ * ============================================================ */
+function transformGroupedPathsToAngularServices(grouped, openApiPaths) {
+    const services = [];
+    const parametersTypes = {};
+    for (const group of Object.values(grouped)) {
+        const groupName = group.groupName;
+        const baseUrl = generateBaseUrl(group.baseSegments, group.paths);
+        const methods = [];
+        const imports = [];
+        let putWithoutVarExists = false;
+        for (const path of group.paths) {
+            const ops = openApiPaths[path];
+            if (!ops)
+                continue;
+            const variables = extractPathVariables(path);
+            const endsInVar = endsWithVariable(path);
+            const child = getChildResource(path, group.baseSegments);
+            for (const http of Object.keys(ops)) {
+                const op = ops[http];
+                const methodName = resolveMethodName(http, endsInVar, child ?? undefined, putWithoutVarExists);
+                if (http === "put" && !endsInVar) {
+                    if (putWithoutVarExists)
+                        continue;
+                    putWithoutVarExists = true;
+                }
+                /* =====================
+                 * PARAMS
+                 * ===================== */
+                const params = [];
+                variables.forEach((v) => params.push(`${v}: string`));
+                let hasParameters = false;
+                // QUERY PARAMS (group-scoped)
+                if (http === "get" && op.parameters?.some((p) => p.in === "query")) {
+                    hasParameters = true;
+                    params.push(`parameters?: ${groupName}Parameters`);
+                    imports.push(`${groupName}Parameters`);
+                }
+                // REQUEST BODY (group-scoped + validated against schemas)
+                let requestBodyType = (0, method_builders_1.computeRequestBodyType)(op.requestBody);
+                if (requestBodyType) {
+                    params.push(`requestBody: ${requestBodyType}`);
+                    imports.push(requestBodyType);
+                    if (requestBodyType.endsWith("Parameters")) {
+                        parametersTypes[methodName] = {
+                            method: http,
+                            parameterType: requestBodyType,
+                        };
+                    }
+                }
+                /* =====================
+                 * RESPONSE TYPE (group-scoped)
+                 * ===================== */
+                let responseType = (0, method_builders_1.computeResponseType)(op.responses?.["200"]);
+                imports.push(responseType);
+                /* =====================
+                 * METHOD BODY
+                 * ===================== */
+                let body = "";
+                if (http === "get") {
+                    body = (0, method_builders_1.buildGetContent)(responseType, path, baseUrl, hasParameters);
+                }
+                if (http === "post") {
+                    body = (0, method_builders_1.buildPostContent)(responseType, path, baseUrl, !!requestBodyType);
+                }
+                if (http === "put") {
+                    body = (0, method_builders_1.buildPutContent)(responseType, path, baseUrl, !!requestBodyType);
+                }
+                if (http === "patch") {
+                    body = (0, method_builders_1.buildPatchContent)(responseType, path, baseUrl, !!requestBodyType);
+                }
+                if (http === "delete") {
+                    body = (0, method_builders_1.buildDeleteContent)(responseType, path, baseUrl, hasParameters);
+                }
+                methods.push(`\t${methodName}(${params.join(", ")}): Observable<${responseType}> {
+${body}
+\t}\n`);
+            }
+        }
+        services.push({
+            name: groupName,
+            baseUrl,
+            methods: methods.join("\n"),
+            imports: (0, generate_imports_1.getImports)(imports).join(", "),
+        });
+    }
+    return {
+        forTemplate: services,
+        parametersTypes,
+    };
+}

package/dist/translators/join-with-templates.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.joinWithTemplates = joinWithTemplates;
+const angular_template_1 = require("../templates/angular-template");
+function joinWithTemplates(services) {
+    const templates = [];
+    services.forEach((s) => {
+        if (s.baseUrl.trim() === "" ||
+            s.methods.trim() === "" ||
+            s.name.trim() === "") {
+            return;
+        }
+        templates.push((0, angular_template_1.angularServiceTemplate)(s));
+    });
+    return templates;
+}

package/dist/translators/splitPaths.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitPaths = splitPaths;
+const grouping_paths_1 = require("../utils/grouping-paths");
+function splitPaths(swagger) {
+    const groupedPaths = (0, grouping_paths_1.groupPaths)(swagger.paths);
+    return groupedPaths;
+}

package/dist/types/file-content.d.ts

@@ -0,0 +1,6 @@
+export interface FileContent {
+    location: string[];
+    name: string;
+    content: string;
+    extension: string;
+}

package/dist/types/file-content.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/grouped-paths.d.ts

@@ -0,0 +1,7 @@
+export type GroupedPaths = Record<string, GroupedPath>;
+export interface GroupedPath {
+    groupName: string;
+    baseSegments: string[];
+    paths: string[];
+    baseUrl: string;
+}

package/dist/types/grouped-paths.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/interface-data.d.ts

@@ -0,0 +1,13 @@
+export interface InterfaceData {
+    name: string;
+    imports: string[];
+    type: 'interface' | 'enum' | 'type';
+    properties: InterfaceDataProperty[];
+    extendsFrom?: string[];
+}
+export interface InterfaceDataProperty {
+    name: string;
+    type: string;
+    optional: boolean;
+    comments: string;
+}

package/dist/types/interface-data.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/parsed-args.d.ts

@@ -0,0 +1,9 @@
+export type ParsedArgs = {
+    args: Record<string, string | boolean>;
+    positional: string[];
+};
+export interface ArgsVariables {
+    groupingMode: 'tags' | 'path';
+    segmentsToIgnore: string[];
+    ignoreVariables: boolean;
+}

package/dist/types/parsed-args.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/service-data.d.ts

@@ -0,0 +1,21 @@
+import { AngularRequestType } from './types';
+export interface ServiceData {
+    name: string;
+    imports: string[];
+    baseUrl: string;
+    methods: ServiceDataMethod[];
+}
+export interface ServiceDataMethod {
+    name: string;
+    path: string;
+    method: AngularRequestType;
+    parameters: ServiceDataParameter[];
+    responseType: string;
+    comments: string;
+}
+export interface ServiceDataParameter {
+    name: string;
+    in: string;
+    required: boolean;
+    type: string;
+}

package/dist/types/service-data.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/types.d.ts

@@ -0,0 +1,23 @@
+export declare enum NativeType {
+    String = "string",
+    Number = "number",
+    Boolean = "boolean",
+    Array = "Array",
+    Date = "Date",
+    File = "File",
+    Any = "any",
+    Void = "void"
+}
+export declare enum AngularResponseType {
+    Json = "json",
+    Text = "text",
+    Blob = "blob",
+    ArrayBuffer = "arrayBuffer"
+}
+export declare enum AngularRequestType {
+    Get = "get",
+    Post = "post",
+    Put = "put",
+    Delete = "delete",
+    Patch = "patch"
+}

package/dist/types/types.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AngularRequestType = exports.AngularResponseType = exports.NativeType = void 0;
+var NativeType;
+(function (NativeType) {
+    NativeType["String"] = "string";
+    NativeType["Number"] = "number";
+    NativeType["Boolean"] = "boolean";
+    NativeType["Array"] = "Array";
+    NativeType["Date"] = "Date";
+    NativeType["File"] = "File";
+    NativeType["Any"] = "any";
+    NativeType["Void"] = "void";
+})(NativeType || (exports.NativeType = NativeType = {}));
+var AngularResponseType;
+(function (AngularResponseType) {
+    AngularResponseType["Json"] = "json";
+    AngularResponseType["Text"] = "text";
+    AngularResponseType["Blob"] = "blob";
+    AngularResponseType["ArrayBuffer"] = "arrayBuffer";
+})(AngularResponseType || (exports.AngularResponseType = AngularResponseType = {}));
+var AngularRequestType;
+(function (AngularRequestType) {
+    AngularRequestType["Get"] = "get";
+    AngularRequestType["Post"] = "post";
+    AngularRequestType["Put"] = "put";
+    AngularRequestType["Delete"] = "delete";
+    AngularRequestType["Patch"] = "patch";
+})(AngularRequestType || (exports.AngularRequestType = AngularRequestType = {}));

package/dist/utils/build-types.d.ts

@@ -0,0 +1,2 @@
+export declare function buildTypes(masterSchema: any, defaultType?: string): string;
+export declare function switchTypeJson(schema: any): string;

package/dist/utils/build-types.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildTypes = buildTypes;
+exports.switchTypeJson = switchTypeJson;
+function buildTypes(masterSchema, defaultType = 'any') {
+    if (!masterSchema)
+        return defaultType;
+    const jsonSchema = masterSchema?.['content']?.['application/json'];
+    if (!jsonSchema) {
+        const formData = masterSchema?.['content']?.['multipart/form-data'];
+        if (formData) {
+            return 'FormData';
+        }
+        return defaultType;
+    }
+    const schema = jsonSchema?.['schema'];
+    if (!schema || Object.keys(schema).length === 0)
+        return defaultType;
+    const ref = schema?.['$ref'];
+    if (ref) {
+        const iface = ref.split('/').pop();
+        const isPagedResultDto = iface.endsWith('PagedResultDto');
+        if (isPagedResultDto) {
+            return `PagedResultDto<${iface.replace('PagedResultDto', '')}>`;
+        }
+        return iface;
+    }
+    return switchTypeJson(schema);
+}
+function switchTypeJson(schema) {
+    if (!schema || Object.keys(schema).length === 0)
+        return 'any';
+    const ref = schema?.['$ref'];
+    const type = schema?.['type'];
+    const format = schema?.['format'];
+    if (ref) {
+        const iface = ref.split('/').pop();
+        const isPagedResultDto = iface.endsWith('PagedResultDto');
+        if (isPagedResultDto) {
+            return `PagedResultDto<${iface.replace('PagedResultDto', '')}>`;
+        }
+        return iface;
+    }
+    if (type === 'object') {
+        return 'any';
+    }
+    if (type === 'array') {
+        return switchTypeJson(schema?.['items']) + '[]';
+    }
+    if (type === 'number') {
+        return 'number';
+    }
+    if (type === 'integer') {
+        return 'number';
+    }
+    if (type === 'string') {
+        if (format === 'binary') {
+            return 'Blob';
+        }
+        return 'string';
+    }
+    if (type === 'boolean') {
+        return 'boolean';
+    }
+    return 'any';
+}

package/dist/utils/create-file.d.ts

@@ -0,0 +1,7 @@
+import { FileContent } from '../types/file-content';
+export declare function generateFile(content: string, group: string): void;
+export declare function createFolderWithFiles(folderPath: string, files: string[], filesContent: Record<string, {
+    content: string;
+    imports: string[];
+}>, withIndex?: boolean): void;
+export declare function createFileFromFileContents(basePath: string, fileContent: FileContent[]): Promise<void>;

package/dist/utils/create-file.js

@@ -0,0 +1,74 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateFile = generateFile;
+exports.createFolderWithFiles = createFolderWithFiles;
+exports.createFileFromFileContents = createFileFromFileContents;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const string_utils_1 = require("./string-utils");
+function generateFile(content, group) {
+    const dir = `results/${group}`;
+    if (fs_1.default.existsSync(dir)) {
+        for (const file of fs_1.default.readdirSync(dir)) {
+            fs_1.default.unlinkSync(path_1.default.join(dir, file));
+        }
+    }
+    else {
+        fs_1.default.mkdirSync(dir, { recursive: true });
+    }
+    fs_1.default.writeFileSync(path_1.default.join(dir, `${new Date().toISOString().replaceAll(':', '-')}.ts`), content, 'utf8');
+}
+function createFolderWithFiles(folderPath, files, filesContent, withIndex = true) {
+    fs_1.default.mkdirSync(folderPath, { recursive: true });
+    const exports = [];
+    for (const fileName of files) {
+        if (!fileName || !filesContent[fileName]) {
+            continue;
+        }
+        const realFileName = (0, string_utils_1.toKebabCase)(fileName);
+        const finalName = `${realFileName}.model.ts`;
+        const filePath = path_1.default.join(folderPath, finalName);
+        fs_1.default.writeFileSync(filePath, filesContent[fileName].content, 'utf8');
+        if (withIndex) {
+            exports.push(`export * from "./${realFileName}.model";`);
+        }
+    }
+    if (withIndex && exports.length > 0) {
+        fs_1.default.writeFileSync(path_1.default.join(folderPath, 'index.ts'), exports.join('\n'), 'utf8');
+    }
+}
+async function createFileFromFileContents(basePath, fileContent) {
+    const folderExports = new Map();
+    for (const file of fileContent) {
+        const dir = path_1.default.join(basePath, ...file.location);
+        await fs_1.default.promises.mkdir(dir, { recursive: true });
+        await fs_1.default.promises.writeFile(path_1.default.join(dir, `${file.name}.${file.extension}`), file.content, 'utf8');
+        if (file.extension.endsWith('ts') && file.name !== 'index') {
+            if (!folderExports.has(dir)) {
+                folderExports.set(dir, new Set());
+            }
+            folderExports.get(dir).add(file.name);
+        }
+        const currentLoc = [...file.location];
+        while (currentLoc.length > 0) {
+            const childName = currentLoc.pop();
+            const parentDir = path_1.default.join(basePath, ...currentLoc);
+            if (!folderExports.has(parentDir)) {
+                folderExports.set(parentDir, new Set());
+            }
+            folderExports.get(parentDir).add(childName);
+        }
+    }
+    for (const [dir, exports] of folderExports.entries()) {
+        const indexContent = Array.from(exports)
+            .sort()
+            .map((item) => `export * from "./${item}";`)
+            .join('\n');
+        if (indexContent) {
+            await fs_1.default.promises.writeFile(path_1.default.join(dir, 'index.ts'), indexContent + '\n', 'utf8');
+        }
+    }
+}