swaggular 0.1.3 → 0.2.2

package/dist/cli/variables.js

@@ -4,20 +4,18 @@ exports.toVariables = toVariables;
 function toVariables(parsed) {
     const variables = {};
     if (parsed.args.mode) {
-        variables.groupingMode = parsed.args.mode;
+        variables.groupingMode = parsed.args.mode || 'path';
     }
     if (parsed.args.segmentsToIgnore) {
         if (typeof parsed.args.segmentsToIgnore === 'string') {
             variables.segmentsToIgnore = parsed.args.segmentsToIgnore.split(',');
         }
     }
-    if (parsed.args.ignoreVariables) {
-        variables.ignoreVariables =
-            parsed.args.ignoreVariables === 'true' || parsed.args.ignoreVariables === true;
-    }
     return {
+        input: parsed.args.input || 'swagger.json',
+        output: parsed.args.output || 'results',
+        noGenerate: parsed.args.noGenerate || false,
         groupingMode: variables.groupingMode || 'path',
         segmentsToIgnore: variables.segmentsToIgnore || ['api'],
-        ignoreVariables: variables.ignoreVariables || true,
     };
 }

package/dist/index.js

@@ -16,25 +16,25 @@ async function main() {
     try {
         const parsed = (0, args_1.getParseArgs)(process.argv.slice(2));
         const variables = (0, variables_1.toVariables)(parsed);
-        swagger_parser_1.SwaggerParser.parse(parsed.args.input, {
+        swagger_parser_1.SwaggerParser.parse(variables.input, {
             mode: variables.groupingMode,
             segmentsToIgnore: variables.segmentsToIgnore,
-            ignoreVariables: variables.ignoreVariables,
+            ignoreVariables: true,
         });
         (0, generate_interface_1.generateInterfaces)();
         (0, generate_service_1.generateServices)();
         const interfaceFiles = (0, generate_interface_1.generateInterfacesFiles)();
         const serviceFiles = (0, generate_service_1.generateServiceFiles)();
-        if (parsed.args.noGenerate) {
-            console.log('No se generaron archivos');
+        if (variables.noGenerate) {
+            console.log('Files not generated');
             return;
         }
-        if (fs_1.default.existsSync('results')) {
-            fs_1.default.rmSync('results', { recursive: true, force: true });
+        if (fs_1.default.existsSync(variables.output)) {
+            fs_1.default.rmSync(variables.output, { recursive: true, force: true });
         }
-        await (0, create_file_1.createFileFromFileContents)('results/models', interfaceFiles);
-        await (0, create_file_1.createFileFromFileContents)('results', serviceFiles);
-        console.log('Archivo creado correctamente');
+        await (0, create_file_1.createFileFromFileContents)(`${variables.output}/models`, interfaceFiles);
+        await (0, create_file_1.createFileFromFileContents)(variables.output, serviceFiles);
+        console.log('Files created successfully');
     }
     catch (err) {
         console.error('Failed to read JSON:', err);

package/dist/parsers/path-grouper.js

@@ -194,6 +194,8 @@ class PathGrouper {
         const common = [];
         for (let i = 0; i < firstPath.length; i++) {
             const segment = firstPath[i];
+            if ((0, path_utils_1.isVariable)(segment))
+                break;
             if (pathSegments.every((ps) => ps[i] === segment)) {
                 common.push(segment);
             }

package/dist/renderers/generate-comments.js

@@ -26,8 +26,9 @@ function generateInterfaceComments(param) {
 }
 function generateServiceComments(summary, responseType, parameters) {
     const summarySplited = [];
-    for (let i = 0; i < summary.length; i += 100) {
-        summarySplited.push(summary.slice(i, i + 100));
+    const summaryWords = summary.split(' ');
+    for (let i = 0; i < summaryWords.length; i += 10) {
+        summarySplited.push(summaryWords.slice(i, i + 10).join(' '));
     }
     const comments = summarySplited;
     if (parameters && parameters.length > 0) {
@@ -36,5 +37,5 @@ function generateServiceComments(summary, responseType, parameters) {
     if (responseType) {
         comments.push(`@returns Observable<${responseType}>`);
     }
-    return `\t/**\n${comments.map((c) => `\t* ${c}\n`).join('')}\n */`;
+    return `\t/**\n${comments.map((c) => `\t* ${c}\n`).join('')} */`;
 }

package/dist/renderers/generate-service.d.ts

@@ -1,3 +1,4 @@
+import { OpenAPIV3 } from 'openapi-types';
 import { FileContent } from '../types/file-content';
 import { GroupedPath } from '../types/grouped-paths';
 import { ServiceDataMethod } from '../types/service-data';
@@ -6,4 +7,4 @@ import { ServiceDataMethod } from '../types/service-data';
  */
 export declare function generateServices(): void;
 export declare function generateServiceFiles(locations?: Record<string, string[]>): FileContent[];
-export declare function buildMethods(groupedPath: GroupedPath): ServiceDataMethod[];
+export declare function buildMethods(groupedPath: GroupedPath, pathData: OpenAPIV3.PathsObject): ServiceDataMethod[];

package/dist/renderers/generate-service.js

@@ -22,21 +22,17 @@ function generateServices() {
     if (!groupedPaths || !paths)
         return;
     for (const [key, value] of Object.entries(groupedPaths)) {
-        const serviceMethods = buildMethods(value);
+        const serviceMethods = buildMethods(value, paths);
         const imports = new Set();
         serviceMethods.forEach((method) => {
-            if (!(0, type_guard_1.isNativeType)(method.responseType)) {
-                imports.add(method.responseType);
-            }
+            addTypeToImports(method.responseType, imports);
             method.parameters.forEach((param) => {
-                if (!(0, type_guard_1.isNativeType)(param.type)) {
-                    imports.add(param.type);
-                }
+                addTypeToImports(param.type, imports);
             });
         });
         const serviceData = {
             name: key,
-            imports: Array.from(imports),
+            imports: Array.from(imports).sort(),
             baseUrl: value.baseUrl,
             methods: serviceMethods,
         };
@@ -44,6 +40,22 @@ function generateServices() {
     }
     service_state_1.serviceState.addServices(servicesData);
 }
+function addTypeToImports(type, imports) {
+    if (!type || (0, type_guard_1.isNativeType)(type))
+        return;
+    const baseType = type.replace('[]', '');
+    if (baseType.includes('<')) {
+        const parts = baseType.split(/[<>]/);
+        parts.forEach((p) => {
+            if (p && !(0, type_guard_1.isNativeType)(p)) {
+                imports.add(p);
+            }
+        });
+    }
+    else {
+        imports.add(baseType);
+    }
+}
 function generateServiceFiles(locations) {
     const services = Object.values(service_state_1.serviceState.services);
     const filesContent = [];
@@ -71,22 +83,22 @@ function generateServiceFiles(locations) {
     }
     return filesContent;
 }
-function buildMethods(groupedPath) {
+function buildMethods(groupedPath, pathData) {
     const methods = [];
-    const pathData = swagger_state_1.swaggerState.getPaths();
     const usedNames = [];
     for (const path of groupedPath.paths) {
         if (!pathData || !pathData[path])
             continue;
-        const pathItem = pathItemToMethods(pathData[path]);
-        for (const [method, operation] of Object.entries(pathItem)) {
+        const pathItem = pathData[path];
+        const operations = pathItemToMethods(pathItem);
+        for (const [method, operation] of Object.entries(operations)) {
             const name = buildMethodName(method, path, groupedPath, usedNames);
             usedNames.push(name);
-            const parameters = buildParameters(operation.parameters ?? []);
+            const parameters = buildParameters(operation, pathItem.parameters);
             const responseType = buildResponseType(operation.responses);
             methods.push({
                 name,
-                path: (0, path_utils_1.removeVariablesFromPath)((0, path_utils_1.getExtraSegments)(path, (0, path_utils_1.createBaseUrl)(groupedPath.baseSegments)).join('')),
+                path: (0, path_utils_1.getExtraSegments)(path, groupedPath.baseUrl).join('/'),
                 method: method,
                 parameters,
                 responseType,
@@ -114,16 +126,20 @@ function buildMethodName(method, path, groupedPath, usedNames) {
         patch: 'patch',
     };
     const prefix = dict[method];
-    const extra = (0, string_utils_1.kebabToPascalCase)((0, path_utils_1.removeVariablesFromPath)((0, path_utils_1.getExtraSegments)(path, (0, path_utils_1.createBaseUrl)(groupedPath.baseSegments)).join('')));
+    const extraSegments = (0, path_utils_1.getExtraSegments)(path, groupedPath.baseUrl);
+    // Create name segments, removing variables from name
+    const nameSegments = extraSegments.map((s) => s.replace(/[{}]/g, ''));
+    const extra = (0, string_utils_1.kebabToPascalCase)(nameSegments.join(''));
     let name = prefix + (0, string_utils_1.upFirst)(extra);
     if (usedNames.includes(name)) {
         name += (0, string_utils_1.upFirst)(method);
     }
     return name;
 }
-function buildParameters(parameters) {
+function buildParameters(operation, pathParameters) {
     const results = [];
-    for (const param of parameters) {
+    const allParams = [...(pathParameters ?? []), ...(operation.parameters ?? [])];
+    for (const param of allParams) {
         if ((0, type_guard_1.isReference)(param)) {
             const ref = param.$ref.split('/').pop();
             results.push({
@@ -141,12 +157,30 @@ function buildParameters(parameters) {
             type: (0, build_types_1.switchTypeJson)(param.schema),
         });
     }
-    // Check for body (simplified)
-    // In a real implementation we would look at requestBody
+    // Handle requestBody in V3
+    if (operation.requestBody) {
+        let bodyType = 'any';
+        if (!(0, type_guard_1.isReference)(operation.requestBody)) {
+            const content = operation.requestBody.content?.['application/json'] ||
+                operation.requestBody.content?.['multipart/form-data'];
+            if (content && content.schema) {
+                bodyType = (0, build_types_1.switchTypeJson)(content.schema);
+            }
+        }
+        else {
+            bodyType = operation.requestBody.$ref.split('/').pop();
+        }
+        results.push({
+            name: bodyType === 'FormData' ? 'formData' : 'body',
+            in: 'body',
+            required: true,
+            type: bodyType,
+        });
+    }
     return results;
 }
 function buildResponseType(responses) {
-    const success = responses['200'] || responses['201'] || responses['default'];
+    const success = responses['200'] || responses['201'] || responses['204'] || responses['default'];
     if (!success)
         return 'any';
     if ((0, type_guard_1.isReference)(success))
@@ -160,19 +194,28 @@ function buildMethodTemplate(method) {
     const params = method.parameters
         .map((p) => `${p.name}${p.required ? '' : '?'}: ${p.type}`)
         .join(', ');
-    const path = method.path
+    let pathStr = method.path
         .split('/')
+        .filter((s) => s !== '')
         .map((s) => ((0, path_utils_1.isVariable)(s) ? `\${${s.replace(/[{}]/g, '')}}` : s))
         .join('/');
+    if (pathStr) {
+        pathStr = '/' + pathStr;
+    }
     const queryParams = method.parameters.filter((p) => p.in === 'query');
     const bodyParam = method.parameters.find((p) => p.in === 'body');
     let options = '';
     if (queryParams.length > 0) {
         options = `, { params: HttpHelper.toHttpParams({ ${queryParams.map((p) => p.name).join(', ')} }) }`;
     }
-    const httpCall = `this.http.${method.method}<${method.responseType}>(this.baseUrl + \`${path}\`${bodyParam ? `, ${bodyParam.name}` : ['post', 'put', 'patch'].includes(method.method) ? ', {}' : ''}${options})`;
+    const url = `\`\${this.baseUrl}${pathStr}\``;
+    const methodCall = bodyParam
+        ? `this.http.${method.method}<${method.responseType}>(${url}, ${bodyParam.name}${options})`
+        : ['post', 'put', 'patch'].includes(method.method)
+            ? `this.http.${method.method}<${method.responseType}>(${url}, {}${options})`
+            : `this.http.${method.method}<${method.responseType}>(${url}${options})`;
     return `${method.comments}
   ${method.name}(${params}): Observable<${method.responseType}> {
-    return ${httpCall};
+    return ${methodCall};
   }`;
 }

package/dist/templates/services/angular-template.d.ts

@@ -1,3 +1,6 @@
+/**
+ * Modify this interface according to your needs and your template
+ */
 export interface AngularServiceTemplate {
     name: string;
     baseUrl: string;

package/dist/templates/services/angular-template.js

@@ -7,7 +7,7 @@ const angularTemplate = (params) => {
 import { HttpClient } from "@angular/common/http";
 import { Observable } from "rxjs";
 import { inject, Injectable } from '@angular/core';
-import { ${params.imports} } from '../../models';
+import { ${params.imports} } from '../models';
 ${params.hasHttpParamsHandler ? (0, http_params_handler_1.httpParamsHandlerImport)() : ''}
 
 @Injectable({
@@ -15,7 +15,7 @@ ${params.hasHttpParamsHandler ? (0, http_params_handler_1.httpParamsHandlerImpor
 })
 export class ${params.name}Service {    
 
-  private readonly baseUrl = "${params.baseUrl}";
+  private readonly baseUrl = \`${params.baseUrl}\`;
   private readonly http = inject(HttpClient);
 
 ${params.methods}

package/dist/templates/services/http-params-handler.d.ts

@@ -1,2 +1,11 @@
+/**
+ * Modify this function according to your needs and your template.
+ * This function is used to handle the http params and how you want it to be
+ * used in your service.
+ */
 export declare function httpParamsHandler(params: any): string;
+/**
+ * Modify this function according to your needs and your template.
+ * This function is used to import anything you need to handle the http params.
+ */
 export declare function httpParamsHandlerImport(): string;

package/dist/templates/services/http-params-handler.js

@@ -2,11 +2,20 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.httpParamsHandler = httpParamsHandler;
 exports.httpParamsHandlerImport = httpParamsHandlerImport;
+/**
+ * Modify this function according to your needs and your template.
+ * This function is used to handle the http params and how you want it to be
+ * used in your service.
+ */
 function httpParamsHandler(params) {
     return `
   const params = HttpHelper.toHttpParams(${params} || {})
 `;
 }
+/**
+ * Modify this function according to your needs and your template.
+ * This function is used to import anything you need to handle the http params.
+ */
 function httpParamsHandlerImport() {
     return `import { HttpHelper } from '@umss/shared/utils';`;
 }

package/dist/templates/types/extends-from-types.d.ts

@@ -1,3 +1,8 @@
 import { InterfaceData } from '../../types/interface-data';
+/**
+ * Modify this to add your extends from types.
+ * This will be used by the extends from types function
+ * to determine if a new interface extends from one of the extends from types.
+ */
 export declare const extendsFromTypes: InterfaceData[];
 export declare function computeExtendsFromType(newInterface: InterfaceData): InterfaceData;

package/dist/templates/types/extends-from-types.js

@@ -2,6 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.extendsFromTypes = void 0;
 exports.computeExtendsFromType = computeExtendsFromType;
+/**
+ * Modify this to add your extends from types.
+ * This will be used by the extends from types function
+ * to determine if a new interface extends from one of the extends from types.
+ */
 exports.extendsFromTypes = [
     {
         name: 'PagedRequestDto',

package/dist/templates/types/generic-types.d.ts

@@ -1,4 +1,9 @@
 import { InterfaceData } from '../../types/interface-data';
+/**
+ * Modify this to add your generic types.
+ * This will be used by the generic types function
+ * to determine if a new interface is a generic type.
+ */
 export declare const genericTypesData: InterfaceData[];
 export declare function isGenericType(newInterface: InterfaceData): InterfaceData | undefined;
 export declare function computeGenericType(newInterface: InterfaceData, genericType: InterfaceData): string;

package/dist/templates/types/generic-types.js

@@ -3,6 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.genericTypesData = void 0;
 exports.isGenericType = isGenericType;
 exports.computeGenericType = computeGenericType;
+/**
+ * Modify this to add your generic types.
+ * This will be used by the generic types function
+ * to determine if a new interface is a generic type.
+ */
 exports.genericTypesData = [
     {
         name: 'PagedResultDto',

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

@@ -5,5 +5,7 @@ export type ParsedArgs = {
 export interface ArgsVariables {
     groupingMode: 'tags' | 'path';
     segmentsToIgnore: string[];
-    ignoreVariables: boolean;
+    input: string;
+    output: string;
+    noGenerate: boolean;
 }

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

@@ -3,5 +3,4 @@ export declare function getExtraSegments(fullPath: string, baseUrl: string): str
 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

@@ -5,54 +5,58 @@ 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 p1 = fullPath.split('/').filter((s) => s !== '');
+    const p2 = baseUrl.split('/').filter((s) => s !== '');
+    // Find where baseUrl ends in fullPath
+    let i = 0;
+    while (i < p1.length && i < p2.length && p1[i].toLowerCase() === p2[i].toLowerCase()) {
+        i++;
     }
-    const path = fullPath.replace(baseUrl, '');
-    return path.split('/').filter((p) => p !== '');
+    return p1.slice(i);
 }
 function removeVariablesFromPath(path) {
-    return path.replace(/{.+}/g, '');
+    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('/');
+    const filtered = baseSegments.filter((s) => s !== '');
+    if (filtered.length === 0)
+        return '/api';
+    if (filtered[0].toLowerCase() === 'api')
+        return '/' + filtered.join('/');
+    return '/api/' + filtered.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 splittedPaths = paths.map((p) => p.split('/').filter((s) => s !== ''));
+    if (splittedPaths.length === 1)
+        return createBaseUrl(pathSegmentsWithoutVariables(splittedPaths[0]));
     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) {
+        const isVariableSegment = isVariable(segment);
+        if (isCommon && !isVariableSegment) {
             commonSegments.push(segment);
         }
         else {
             break;
         }
     }
-    return pathWithoutVariables(commonSegments);
+    return createBaseUrl(commonSegments);
 }
-function pathWithoutVariables(segments) {
+function pathSegmentsWithoutVariables(segments) {
     const firstVariableIndex = segments.findIndex((segment) => isVariable(segment));
     if (firstVariableIndex !== -1) {
-        return segments.slice(0, firstVariableIndex).join('/');
+        return segments.slice(0, firstVariableIndex);
     }
-    return segments.join('/');
+    return segments;
 }
 function standarizedPath(path) {
     const splitted = path.split('/');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "swaggular",
-  "version": "0.1.3",
+  "version": "0.2.2",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "bin": {