swaggular 0.2.2 → 0.2.3

package/dist/translators/generate-services.js

@@ -1,192 +0,0 @@
-"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

@@ -1,16 +0,0 @@
-"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

@@ -1,8 +0,0 @@
-"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/utils/generate-imports.js

@@ -1,33 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.primitivesTypes = void 0;
-exports.getImports = getImports;
-exports.primitivesTypes = [
-    "string",
-    "number",
-    "boolean",
-    "void",
-    "any",
-    "blob",
-    "file",
-];
-function getImports(typeNames) {
-    const realImports = new Set();
-    for (const typeName of typeNames) {
-        const transformedTypeName = typeName
-            .replaceAll("[", "")
-            .replaceAll("]", "");
-        if (exports.primitivesTypes.includes(transformedTypeName.toLowerCase())) {
-            continue;
-        }
-        if (transformedTypeName.includes("<")) {
-            const types = transformedTypeName.replaceAll(">", "").split("<");
-            types.forEach((t) => {
-                realImports.add(t.trim());
-            });
-            continue;
-        }
-        realImports.add(transformedTypeName);
-    }
-    return Array.from(realImports);
-}

package/dist/utils/grouping-paths.js

@@ -1,68 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.groupPaths = groupPaths;
-function isVariable(segment) {
-    return /^\{.+\}$/.test(segment);
-}
-function normalizeSegment(segment) {
-    return segment
-        .split("-")
-        .map((s) => s.charAt(0).toUpperCase() + s.slice(1))
-        .join("");
-}
-function toPascalCase(segments) {
-    return segments.map(normalizeSegment).join("");
-}
-function extractNonVariableSegments(path) {
-    return path
-        .split("/")
-        .filter(Boolean)
-        .filter((s) => s !== "api")
-        .filter((s) => !isVariable(s));
-}
-function groupPaths(paths) {
-    const temp = {};
-    // 1️⃣ recolectar segmentos NO variables (ignorando /api) pero guardar el path original
-    for (const originalPath of Object.keys(paths)) {
-        if (!originalPath.startsWith("/api/"))
-            continue;
-        const clean = originalPath.replace(/^\/api\//, "");
-        const segments = clean.split("/").filter((s) => s && !isVariable(s));
-        if (segments.length === 0)
-            continue;
-        const root = segments[0];
-        if (!temp[root])
-            temp[root] = [];
-        temp[root].push({
-            originalPath,
-            segments,
-        });
-    }
-    const groups = {};
-    // 2️⃣ decidir si colapsa por root o usa deep=2
-    for (const [root, entries] of Object.entries(temp)) {
-        const hasDeeperStructure = entries.some((e) => e.segments.length >= 3);
-        for (const entry of entries) {
-            let baseSegments;
-            if (!hasDeeperStructure) {
-                // colapsa por root común
-                baseSegments = [root];
-            }
-            else {
-                // deep máximo = 2
-                baseSegments = entry.segments.slice(0, 2);
-            }
-            const groupName = toPascalCase(baseSegments);
-            if (!groups[groupName]) {
-                groups[groupName] = {
-                    groupName,
-                    baseSegments,
-                    paths: [],
-                };
-            }
-            // ✅ path completo, con /api y variables
-            groups[groupName].paths.push(entry.originalPath);
-        }
-    }
-    return groups;
-}

package/dist/utils/method-builders.js

@@ -1,77 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.computeResponseType = computeResponseType;
-exports.computeRequestBodyType = computeRequestBodyType;
-exports.buildUrl = buildUrl;
-exports.buildGetContent = buildGetContent;
-exports.buildPutContent = buildPutContent;
-exports.buildPostContent = buildPostContent;
-exports.buildDeleteContent = buildDeleteContent;
-exports.buildPatchContent = buildPatchContent;
-const build_types_1 = require("./build-types");
-const to_case_1 = require("./to-case");
-function computeResponseType(successSchema) {
-    return (0, build_types_1.buildTypes)(successSchema, "void");
-}
-function computeRequestBodyType(requestBodySchema) {
-    const content = requestBodySchema?.content;
-    if (!content || Object.keys(content).length === 0)
-        return null;
-    return (0, build_types_1.buildTypes)(requestBodySchema, "any");
-}
-function buildUrl(path, baseUrl) {
-    const leftover = path.replace(baseUrl, "");
-    const segments = leftover.split("/").filter(Boolean);
-    let finalUrl = `\`\${this.baseUrl}`;
-    segments.forEach((s) => {
-        if (s.startsWith("{") && s.endsWith("}")) {
-            const id = (0, to_case_1.lowerFirst)(s.replace("{", "").replace("}", ""));
-            finalUrl += `/\${${id}}`;
-        }
-        else {
-            finalUrl += `/${s}`;
-        }
-    });
-    finalUrl += `\``;
-    return finalUrl;
-}
-function buildGetContent(responseType, path, baseUrl, hasParameters) {
-    const finalUrl = buildUrl(path, baseUrl);
-    if (hasParameters) {
-        return `\t\tconst params = HttpHelper.toHttpParams(parameters ?? {});
-\t\treturn this.http.get<${responseType}>(${finalUrl}, { params });`;
-    }
-    if (responseType === "Blob") {
-        return `\t\treturn this.http.get(${finalUrl}, { responseType: 'blob' });`;
-    }
-    return `\t\treturn this.http.get<${responseType}>(${finalUrl});`;
-}
-function buildPutContent(responseType, path, baseUrl, hasRequestBody) {
-    const finalUrl = buildUrl(path, baseUrl);
-    if (!hasRequestBody) {
-        return `\t\treturn this.http.put<${responseType}>(${finalUrl});`;
-    }
-    return `\t\treturn this.http.put<${responseType}>(${finalUrl}, requestBody);`;
-}
-function buildPostContent(responseType, path, baseUrl, hasRequestBody) {
-    const finalUrl = buildUrl(path, baseUrl);
-    if (!hasRequestBody) {
-        return `\t\treturn this.http.post<${responseType}>(${finalUrl});`;
-    }
-    return `\t\treturn this.http.post<${responseType}>(${finalUrl}, requestBody);`;
-}
-function buildDeleteContent(responseType, path, baseUrl, hasParameters) {
-    const finalUrl = buildUrl(path, baseUrl);
-    if (hasParameters) {
-        return `\t\tconst params = HttpHelper.toHttpParams(parameters ?? {});
-\t\treturn this.http.delete<${responseType}>(${finalUrl}, { params });`;
-    }
-    return `\t\treturn this.http.delete<${responseType}>(${finalUrl});`;
-}
-function buildPatchContent(responseType, path, baseUrl, hasRequestBody) {
-    const finalUrl = buildUrl(path, baseUrl);
-    if (!hasRequestBody) {
-        return `\t\treturn this.http.patch<${responseType}>(${finalUrl});`;
-    }
-    return `\t\treturn this.http.patch<${responseType}>(${finalUrl}, requestBody);`;
-}

package/dist/utils/to-case.js

@@ -1,47 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.kebabToCamelCase = kebabToCamelCase;
-exports.kebabToPascalCase = kebabToPascalCase;
-exports.toThisType = toThisType;
-exports.lowerFirst = lowerFirst;
-exports.upFirst = upFirst;
-exports.toKebabCase = toKebabCase;
-exports.normalizeSegment = normalizeSegment;
-exports.toPascalCase = toPascalCase;
-function kebabToCamelCase(str) {
-    return str.replace(/-([a-z])/g, (_, char) => char.toUpperCase());
-}
-/**
- *
- * @param str :
- * @returns
- */
-function kebabToPascalCase(str) {
-    const camel = str.replace(/-([a-z])/g, (_, char) => char.toUpperCase());
-    return camel.charAt(0).toUpperCase() + camel.slice(1);
-}
-function toThisType(str) {
-    return kebabToPascalCase(str).replace(/s$/, "");
-}
-function lowerFirst(str) {
-    return str.charAt(0).toLowerCase() + str.slice(1);
-}
-function upFirst(str) {
-    return str.charAt(0).toUpperCase() + str.slice(1);
-}
-function toKebabCase(input) {
-    const transformedInput = input.replaceAll("Dto", "");
-    return (transformedInput.length > 0 ? transformedInput : input)
-        .replace(/([a-z0-9])([A-Z])/g, "$1-$2")
-        .replace(/([A-Z])([A-Z][a-z])/g, "$1-$2")
-        .toLowerCase();
-}
-function normalizeSegment(segment) {
-    return segment
-        .split("-")
-        .map((s) => s.charAt(0).toUpperCase() + s.slice(1))
-        .join("");
-}
-function toPascalCase(segments) {
-    return segments.map(normalizeSegment).join("");
-}