swaggular 0.1.0

package/dist/utils/generate-imports.js

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

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

@@ -0,0 +1,77 @@
+"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/object-utils.d.ts

@@ -0,0 +1 @@
+export declare function removeFalsyValues(obj: Record<string, any>): Record<string, any>;

package/dist/utils/object-utils.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeFalsyValues = removeFalsyValues;
+function removeFalsyValues(obj) {
+    const newObj = {};
+    for (const [key, value] of Object.entries(obj)) {
+        if (value)
+            newObj[key] = value;
+    }
+    return newObj;
+}

package/dist/utils/path-utils.d.ts

@@ -0,0 +1,7 @@
+export declare function isVariable(segment: string): boolean;
+export declare function getExtraSegments(fullPath: string, baseUrl: string): string[];
+export declare function removeVariablesFromPath(path: string): string;
+export declare function createBaseUrl(baseSegments: string[]): string;
+export declare function findCommonBaseUrl(paths: string[]): string;
+export declare function pathWithoutVariables(segments: string[]): string;
+export declare function standarizedPath(path: string): string;

package/dist/utils/path-utils.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isVariable = isVariable;
+exports.getExtraSegments = getExtraSegments;
+exports.removeVariablesFromPath = removeVariablesFromPath;
+exports.createBaseUrl = createBaseUrl;
+exports.findCommonBaseUrl = findCommonBaseUrl;
+exports.pathWithoutVariables = pathWithoutVariables;
+exports.standarizedPath = standarizedPath;
+function isVariable(segment) {
+    return /^\{.+\}$/.test(segment);
+}
+function getExtraSegments(fullPath, baseUrl) {
+    if (!fullPath.startsWith('api') && !fullPath.startsWith('/api')) {
+        fullPath = '/api/' + fullPath;
+    }
+    const path = fullPath.replace(baseUrl, '');
+    return path.split('/').filter((p) => p !== '');
+}
+function removeVariablesFromPath(path) {
+    return path.replace(/{.+}/g, '');
+}
+function createBaseUrl(baseSegments) {
+    if (!baseSegments || baseSegments.length === 0)
+        return 'api';
+    if (baseSegments[0] === 'api')
+        return baseSegments.join('/');
+    return 'api/' + baseSegments.join('/');
+}
+function findCommonBaseUrl(paths) {
+    if (!paths || paths.length === 0)
+        return '';
+    if (paths.length === 1)
+        return pathWithoutVariables(paths[0].split('/'));
+    const splittedPaths = paths.map((p) => p.split('/'));
+    const firstPath = splittedPaths[0];
+    const commonSegments = [];
+    for (let i = 0; i < firstPath.length; i++) {
+        const segment = firstPath[i];
+        const isCommon = splittedPaths.every((p) => p[i] === segment);
+        if (isCommon) {
+            commonSegments.push(segment);
+        }
+        else {
+            break;
+        }
+    }
+    return pathWithoutVariables(commonSegments);
+}
+function pathWithoutVariables(segments) {
+    const firstVariableIndex = segments.findIndex((segment) => isVariable(segment));
+    if (firstVariableIndex !== -1) {
+        return segments.slice(0, firstVariableIndex).join('/');
+    }
+    return segments.join('/');
+}
+function standarizedPath(path) {
+    const splitted = path.split('/');
+    const filtered = splitted.filter((p) => p !== '').map((p) => p.toLowerCase());
+    return filtered.join('/');
+}

package/dist/utils/string-utils.d.ts

@@ -0,0 +1,13 @@
+export declare function kebabToCamelCase(str: string): string;
+/**
+ *
+ * @param str :
+ * @returns
+ */
+export declare function kebabToPascalCase(str: string): string;
+export declare function removeAllWhitespace(text: string): string;
+export declare function lowerFirst(str: string): string;
+export declare function upFirst(str: string): string;
+export declare function toKebabCase(input: string): string;
+export declare function normalizeSegment(segment: string): string;
+export declare function toPascalCase(segments: string[]): string;

package/dist/utils/string-utils.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.kebabToCamelCase = kebabToCamelCase;
+exports.kebabToPascalCase = kebabToPascalCase;
+exports.removeAllWhitespace = removeAllWhitespace;
+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 removeAllWhitespace(text) {
+    return text.replace(/\s+/g, '');
+}
+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('');
+}

package/dist/utils/to-case.js

@@ -0,0 +1,47 @@
+"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("");
+}

package/dist/utils/type-guard.d.ts

@@ -0,0 +1,5 @@
+import { OpenAPIV3 } from 'openapi-types';
+export declare function isReference(param: any): param is OpenAPIV3.ReferenceObject;
+export declare function isParameterObject(param: any): param is OpenAPIV3.ParameterObject;
+export declare function isNativeType(type: string): boolean;
+export declare function isArrayType(type: string): boolean;

package/dist/utils/type-guard.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isReference = isReference;
+exports.isParameterObject = isParameterObject;
+exports.isNativeType = isNativeType;
+exports.isArrayType = isArrayType;
+function isReference(param) {
+    return '$ref' in param;
+}
+function isParameterObject(param) {
+    return (param.in !== undefined &&
+        param.name !== undefined &&
+        param.schema !== undefined);
+}
+function isNativeType(type) {
+    const isArray = type.endsWith('[]');
+    let typeCopy = type;
+    if (isArray) {
+        typeCopy = type.replace('[]', '');
+    }
+    return [
+        'string',
+        'number',
+        'boolean',
+        'any',
+        'void',
+        'Blob',
+        'generic',
+        'FormData',
+        'Date',
+    ].includes(typeCopy);
+}
+function isArrayType(type) {
+    return type.endsWith('[]');
+}

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "swaggular",
+  "version": "0.1.0",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "swaggular": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "start": "node dist/index.js",
+    "serve": "npm run build && node dist/index.js",
+    "build": "tsc",
+    "lint": "eslint \"src/**/*.ts\"",
+    "format": "prettier --write \"src/**/*.ts\"",
+    "test": "jest",
+    "prepare": "husky"
+  },
+  "lint-staged": {
+    "src/**/*.ts": [
+      "eslint --fix",
+      "prettier --write"
+    ]
+  },
+  "keywords": [
+    "swagger",
+    "openapi",
+    "angular",
+    "typescript",
+    "code-generator"
+  ],
+  "author": "",
+  "license": "ISC",
+  "type": "commonjs",
+  "description": "A tool to generate Angular services and models from Swagger/OpenAPI specifications.",
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^25.1.0",
+    "@typescript-eslint/eslint-plugin": "^8.55.0",
+    "@typescript-eslint/parser": "^8.55.0",
+    "eslint": "^10.0.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.5",
+    "globals": "^17.3.0",
+    "husky": "^9.1.7",
+    "jest": "^30.2.0",
+    "lint-staged": "^16.2.7",
+    "prettier": "^3.8.1",
+    "ts-jest": "^29.4.6",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.55.0"
+  },
+  "dependencies": {
+    "openapi-types": "^12.1.3"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}