swaggular 0.1.0

package/dist/stores/swagger-store.js

@@ -0,0 +1,324 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.swaggerStore = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const path_utils_1 = require("../utils/path-utils");
+const string_utils_1 = require("../utils/string-utils");
+class SwaggerStore {
+    swagger = undefined;
+    pathsGroupedByScope = undefined;
+    addSwagger(filePath, options = { mode: "tags" }) {
+        const absolutePath = path.resolve(filePath);
+        const content = fs.readFileSync(absolutePath, { encoding: "utf8" });
+        this.swagger = JSON.parse(content);
+        if (!this.swagger)
+            return;
+        this.groupByScopes(this.swagger, options);
+    }
+    getSwagger() {
+        return this.swagger;
+    }
+    getPaths() {
+        return this.swagger?.paths;
+    }
+    getSchemas() {
+        return this.swagger?.components?.schemas;
+    }
+    getPathsGroupedByScope() {
+        return this.pathsGroupedByScope;
+    }
+    getGroupByPath(path) {
+        if (!this.pathsGroupedByScope)
+            return;
+        for (const value of Object.values(this.pathsGroupedByScope)) {
+            if (value.paths.includes(path))
+                return value;
+        }
+        return undefined;
+    }
+    groupByScopes(swagger, options) {
+        this.pathsGroupedByScope = this.groupPaths(swagger.paths, options);
+    }
+    /**
+     * Groups OpenAPI paths based on the specified mode (tags or path).
+     *
+     * @param paths - The OpenAPI paths object to group.
+     * @param options - Configuration for grouping:
+     *  - `mode`: 'tags' to group by OpenAPI tags, or 'path' to group by path segments.
+     *  - `segmentsToIgnore`: (mode 'path' only) Array of path segments to skip during normalization.
+     *  - `ignoreVariables`: (mode 'path' only) Whether to ignore template variables like {id} during grouping.
+     * @returns A record where keys are group names and values are GroupedPath objects.
+     *
+     * @remarks
+     * When in 'path' mode, it creates primary groups using the first non-ignored segment.
+     * If a group contains more than 8 HTTP methods across all its paths, it attempts to
+     * create subgroups for paths that have at least 2 HTTP methods and additional segments.
+     */
+    groupPaths(paths, options = { mode: "tags" }) {
+        if (options.mode === "tags") {
+            return this.groupByTags(paths, options);
+        }
+        else {
+            return this.groupByPath(paths, options);
+        }
+    }
+    groupByTags(paths, options) {
+        const tagGroups = {};
+        const methods = [
+            "get",
+            "put",
+            "post",
+            "delete",
+            "options",
+            "head",
+            "patch",
+            "trace",
+        ];
+        for (const [pathKey, pathItem] of Object.entries(paths)) {
+            if (!pathItem)
+                continue;
+            const tags = new Set();
+            for (const method of methods) {
+                const operation = pathItem[method];
+                if (operation?.tags && operation.tags.length > 0) {
+                    operation.tags.forEach((tag) => tags.add((0, string_utils_1.removeAllWhitespace)(tag)));
+                }
+            }
+            if (tags.size === 0) {
+                const groupKey = "Default";
+                if (!tagGroups[groupKey])
+                    tagGroups[groupKey] = [];
+                tagGroups[groupKey].push(pathKey);
+            }
+            else {
+                tags.forEach((tag) => {
+                    if (!tagGroups[tag])
+                        tagGroups[tag] = [];
+                    tagGroups[tag].push(pathKey);
+                });
+            }
+        }
+        const finalGroups = {};
+        const sortedTags = Object.keys(tagGroups).sort();
+        for (const tagName of sortedTags) {
+            const pathKeys = tagGroups[tagName].sort();
+            const totalMethods = pathKeys.reduce((sum, pk) => sum + this.getMethodCount(paths[pk]), 0);
+            if (totalMethods <= 8) {
+                const groupName = (0, string_utils_1.toPascalCase)([tagName]);
+                finalGroups[groupName] = {
+                    groupName,
+                    baseSegments: this.getCommonSegments(pathKeys),
+                    paths: pathKeys,
+                    baseUrl: (0, path_utils_1.findCommonBaseUrl)(pathKeys),
+                };
+            }
+            else {
+                // Find common segments of this tag group to start splitting from a meaningful depth
+                const commonSegs = this.getCommonSegments(pathKeys);
+                // But we want the group names to start with the TagName
+                this.splitRecursively(paths, pathKeys, commonSegs, options, finalGroups, commonSegs.length, tagName);
+            }
+        }
+        return finalGroups;
+    }
+    groupByPath(paths, options) {
+        const finalGroups = {};
+        const pathKeys = Object.keys(paths).filter((k) => !!paths[k]);
+        // 1. Initial primary grouping by the first non-ignored segment
+        const initialBuckets = {};
+        for (const pk of pathKeys) {
+            const normalized = this.getNormalizedSegments(pk, options);
+            const first = normalized.length > 0 ? normalized[0] : "Default";
+            if (!initialBuckets[first])
+                initialBuckets[first] = [];
+            initialBuckets[first].push(pk);
+        }
+        const sortedPrimaryKeys = Object.keys(initialBuckets).sort();
+        for (const primaryKey of sortedPrimaryKeys) {
+            const pathsInBucket = initialBuckets[primaryKey];
+            const prefix = primaryKey === "Default" ? [] : [primaryKey];
+            this.splitRecursively(paths, pathsInBucket, prefix, options, finalGroups, 0);
+        }
+        // Ensure the resulting groups are deterministic
+        const sortedResult = {};
+        const sortedGroupNames = Object.keys(finalGroups).sort();
+        for (const name of sortedGroupNames) {
+            sortedResult[name] = finalGroups[name];
+        }
+        return sortedResult;
+    }
+    /**
+     * Recursively splits a group of paths based on their segments if the method count threshold is exceeded.
+     */
+    splitRecursively(allPaths, currentPaths, currentPrefix, options, finalGroups, initialDepth, customNamePrefix) {
+        const totalMethods = currentPaths.reduce((sum, pk) => sum + this.getMethodCount(allPaths[pk]), 0);
+        const depth = currentPrefix.length;
+        // Condition 1: If small enough, keep as one group.
+        if (totalMethods <= 8) {
+            this.addToFinalGroups(currentPaths, currentPrefix, finalGroups, initialDepth, customNamePrefix);
+            return;
+        }
+        // Attempt to split.
+        const stayers = [];
+        const branchMap = {};
+        for (const pk of currentPaths) {
+            const normalized = this.getNormalizedSegments(pk, options);
+            if (normalized.length > depth) {
+                const next = normalized[depth];
+                if (!branchMap[next])
+                    branchMap[next] = [];
+                branchMap[next].push(pk);
+            }
+            else {
+                stayers.push(pk);
+            }
+        }
+        const nextSegs = Object.keys(branchMap);
+        // If no possible split (no more segments), stop.
+        if (nextSegs.length === 0) {
+            this.addToFinalGroups(currentPaths, currentPrefix, finalGroups, initialDepth, customNamePrefix);
+            return;
+        }
+        // Identify which branches can move.
+        // A path (or group of paths) can move ONLY if it has >= 2 methods.
+        const movingBranches = [];
+        const remainingToStay = [...stayers];
+        for (const seg of nextSegs) {
+            const paths = branchMap[seg];
+            const count = paths.reduce((sum, pk) => sum + this.getMethodCount(allPaths[pk]), 0);
+            if (count >= 2) {
+                movingBranches.push({ seg, paths });
+            }
+            else {
+                remainingToStay.push(...paths);
+            }
+        }
+        // If no branches can move according to the 2-method rule, stop and keep everything here.
+        if (movingBranches.length === 0) {
+            this.addToFinalGroups(currentPaths, currentPrefix, finalGroups, initialDepth, customNamePrefix);
+            return;
+        }
+        // Optimization: If only one branch can move and no stayers, zip prefix.
+        if (movingBranches.length === 1 && remainingToStay.length === 0) {
+            this.splitRecursively(allPaths, currentPaths, [...currentPrefix, movingBranches[0].seg], options, finalGroups, initialDepth, customNamePrefix);
+            return;
+        }
+        // Otherwise, split: remainingToStay form the group at current level, movingBranches recurse.
+        if (remainingToStay.length > 0) {
+            this.addToFinalGroups(remainingToStay, currentPrefix, finalGroups, initialDepth, customNamePrefix);
+        }
+        for (const branch of movingBranches.sort((a, b) => a.seg.localeCompare(b.seg))) {
+            this.splitRecursively(allPaths, branch.paths, [...currentPrefix, branch.seg], options, finalGroups, initialDepth, customNamePrefix);
+        }
+    }
+    addToFinalGroups(paths, prefix, finalGroups, initialDepth, customNamePrefix) {
+        let groupName;
+        if (customNamePrefix) {
+            const trailing = prefix.slice(initialDepth);
+            groupName = (0, string_utils_1.toPascalCase)([customNamePrefix, ...trailing]);
+        }
+        else {
+            groupName = prefix.length > 0 ? (0, string_utils_1.toPascalCase)(prefix) : "Default";
+        }
+        if (finalGroups[groupName]) {
+            const existing = finalGroups[groupName];
+            existing.paths = [...new Set([...existing.paths, ...paths])].sort();
+            existing.baseSegments = this.getCommonSegments(existing.paths);
+            existing.baseUrl = (0, path_utils_1.findCommonBaseUrl)(existing.paths);
+        }
+        else {
+            finalGroups[groupName] = {
+                groupName,
+                baseSegments: this.getCommonSegments(paths),
+                paths: paths.sort(),
+                baseUrl: (0, path_utils_1.findCommonBaseUrl)(paths),
+            };
+        }
+    }
+    getNormalizedSegments(path, options) {
+        const segments = path.split("/").filter((s) => s);
+        const result = [];
+        for (const segment of segments) {
+            if (options.segmentsToIgnore?.includes(segment))
+                continue;
+            if (options.ignoreVariables && (0, path_utils_1.isVariable)(segment))
+                continue;
+            result.push(segment);
+        }
+        return result;
+    }
+    getMethodCount(pathItem) {
+        const methods = [
+            "get",
+            "put",
+            "post",
+            "delete",
+            "options",
+            "head",
+            "patch",
+            "trace",
+        ];
+        let count = 0;
+        for (const method of methods) {
+            if (pathItem[method]) {
+                count++;
+            }
+        }
+        return count;
+    }
+    getCommonSegments(paths) {
+        if (paths.length === 0)
+            return [];
+        const pathSegments = paths.map((p) => p
+            .replace(/^\/+api\/+/, "")
+            .split("/")
+            .filter((s) => s));
+        const firstPath = pathSegments[0];
+        const common = [];
+        for (let i = 0; i < firstPath.length; i++) {
+            const segment = firstPath[i];
+            if (pathSegments.every((ps) => ps[i] === segment)) {
+                common.push(segment);
+            }
+            else {
+                break;
+            }
+        }
+        return common;
+    }
+}
+exports.swaggerStore = new SwaggerStore();

package/dist/templates/angular-template.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.angularServiceTemplate = void 0;
+const angularServiceTemplate = (params) => {
+    return `
+import { HttpClient } from "@angular/common/http";
+import { Observable } from "rxjs";
+import { inject, Injectable } from '@angular/core';
+import { ${params.imports} } from '../../models';
+import { HttpHelper } from '@umss/shared/utils';
+
+@Injectable({
+    providedIn: "root"
+})
+export class ${params.name}Service {    
+
+  private readonly baseUrl = "${params.baseUrl}";
+  private readonly http = inject(HttpClient);
+
+${params.methods}
+}`;
+};
+exports.angularServiceTemplate = angularServiceTemplate;

package/dist/templates/paged-request-template.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pagedRequestTemplate = void 0;
+exports.pagedRequestTemplate = `
+export interface PagedRequestDto {
+  /**
+   * format: int32
+   * maximum: 2147483647
+   * minimum: 1
+   */
+  pageNumber?: number;
+   /**
+   * format: int32
+   * maximum: 100
+   * minimum: 1
+   */
+  pageSize?: number;
+  searchTerm?: string | null;
+  sortBy?: string | null;
+  sortDescending?: boolean;
+}
+`;

package/dist/templates/paged-result-template.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pagedResultTemplate = void 0;
+exports.pagedResultTemplate = `
+export interface PagedResultDto<T> {
+  items: T[];
+  totalCount: number;
+  pageNumber: number;
+  pageSize: number;
+  totalPages: number;
+  hasPreviousPage: boolean;
+  hasNextPage: boolean;
+}`;

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

@@ -0,0 +1,15 @@
+export interface AngularServiceTemplate {
+    name: string;
+    baseUrl: string;
+    methods: string;
+    imports: string;
+    hasHttpParamsHandler: boolean;
+}
+export interface AngularServiceResult {
+    forTemplate: AngularServiceTemplate[];
+    parametersTypes: Record<string, {
+        method: string;
+        parameterType: string;
+    }>;
+}
+export declare const angularTemplate: (params: AngularServiceTemplate) => string;

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.angularTemplate = void 0;
+const http_params_handler_1 = require("./http-params-handler");
+const angularTemplate = (params) => {
+    return `
+import { HttpClient } from "@angular/common/http";
+import { Observable } from "rxjs";
+import { inject, Injectable } from '@angular/core';
+import { ${params.imports} } from '../../models';
+${params.hasHttpParamsHandler ? (0, http_params_handler_1.httpParamsHandlerImport)() : ''}
+
+@Injectable({
+    providedIn: "root"
+})
+export class ${params.name}Service {    
+
+  private readonly baseUrl = "${params.baseUrl}";
+  private readonly http = inject(HttpClient);
+
+${params.methods}
+}`;
+};
+exports.angularTemplate = angularTemplate;

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

@@ -0,0 +1,2 @@
+export declare function httpParamsHandler(params: any): string;
+export declare function httpParamsHandlerImport(): string;

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.httpParamsHandler = httpParamsHandler;
+exports.httpParamsHandlerImport = httpParamsHandlerImport;
+function httpParamsHandler(params) {
+    return `
+  const params = HttpHelper.toHttpParams(${params} || {})
+`;
+}
+function httpParamsHandlerImport() {
+    return `import { HttpHelper } from '@umss/shared/utils';`;
+}

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

@@ -0,0 +1,3 @@
+import { InterfaceData } from '../../types/interface-data';
+export declare const extendsFromTypes: InterfaceData[];
+export declare function computeExtendsFromType(newInterface: InterfaceData): InterfaceData;

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

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extendsFromTypes = void 0;
+exports.computeExtendsFromType = computeExtendsFromType;
+exports.extendsFromTypes = [
+    {
+        name: 'PagedRequestDto',
+        type: 'interface',
+        imports: [],
+        properties: [
+            {
+                name: 'pageNumber',
+                type: 'number',
+                optional: true,
+                comments: `/**
+*  maximum: 2147483647,
+*  minimum: 1, 
+*  format: "int32"
+*/`,
+            },
+            {
+                name: 'pageSize',
+                type: 'number',
+                optional: true,
+                comments: `/**
+*  maximum: 100,
+*  minimum: 1, 
+*  format: "int32"
+*/`,
+            },
+            {
+                name: 'searchTerm',
+                type: 'string',
+                optional: true,
+                comments: '',
+            },
+            {
+                name: 'sortBy',
+                type: 'string',
+                optional: true,
+                comments: '',
+            },
+            {
+                name: 'sortDescending',
+                type: 'boolean',
+                optional: true,
+                comments: '',
+            },
+        ],
+    },
+];
+function computeExtendsFromType(newInterface) {
+    for (const extendsFromType of exports.extendsFromTypes) {
+        const newinterfacePropertiesReq = newInterface.properties
+            .filter((p) => !p.optional)
+            .map((p) => p.name);
+        const extendsFromTypePropertiesReq = extendsFromType.properties
+            .filter((p) => !p.optional)
+            .map((p) => p.name);
+        if (extendsFromTypePropertiesReq.some((p) => !newinterfacePropertiesReq.includes(p))) {
+            continue;
+        }
+        const extensionProperties = extendsFromType.properties.map((p) => p.name.toLowerCase());
+        return {
+            ...newInterface,
+            properties: newInterface.properties.filter((p) => !extensionProperties.includes(p.name.toLowerCase())),
+            imports: [...newInterface.imports, extendsFromType.name],
+            extendsFrom: [...(newInterface.extendsFrom ?? []), extendsFromType.name],
+        };
+    }
+    return newInterface;
+}

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

@@ -0,0 +1,4 @@
+import { InterfaceData } from '../../types/interface-data';
+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

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.genericTypesData = void 0;
+exports.isGenericType = isGenericType;
+exports.computeGenericType = computeGenericType;
+exports.genericTypesData = [
+    {
+        name: 'PagedResultDto',
+        imports: [],
+        type: 'interface',
+        properties: [
+            {
+                name: 'items',
+                type: 'T[]',
+                optional: false,
+                comments: '',
+            },
+            {
+                name: 'totalCount',
+                type: 'number',
+                optional: false,
+                comments: '',
+            },
+            {
+                name: 'pageNumber',
+                type: 'number',
+                optional: false,
+                comments: '',
+            },
+            {
+                name: 'pageSize',
+                type: 'number',
+                optional: false,
+                comments: '',
+            },
+            {
+                name: 'totalPages',
+                type: 'number',
+                optional: false,
+                comments: '',
+            },
+            {
+                name: 'hasPreviousPage',
+                type: 'boolean',
+                optional: false,
+                comments: '',
+            },
+            {
+                name: 'hasNextPage',
+                type: 'boolean',
+                optional: false,
+                comments: '',
+            },
+        ],
+    },
+];
+function isGenericType(newInterface) {
+    for (const genericType of exports.genericTypesData) {
+        if (genericType.properties.length !== newInterface.properties.length)
+            continue;
+        const newinterfaceProperties = newInterface.properties.map((p) => p.name);
+        const genericTypeProperties = genericType.properties.map((p) => p.name);
+        if (genericTypeProperties.some((p) => !newinterfaceProperties.includes(p)))
+            continue;
+        return genericType;
+    }
+    return undefined;
+}
+function computeGenericType(newInterface, genericType) {
+    const newName = newInterface.name.replaceAll(genericType.name, '');
+    return `${genericType.name}<${newName}>`;
+}

package/dist/translators/add-import-to-interface.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addImportToInterface = addImportToInterface;
+function addImportToInterface(interfaceString, imports, commons, modelInPath) {
+    const commonImports = commons.filter((c) => imports.includes(c));
+    let commonImportString = "";
+    if (commonImports.length > 0) {
+        commonImportString = `import { ${commonImports.join(", ")} } from "../../common";`;
+    }
+    const dtosImports = [];
+    for (const [model, path] of Object.entries(modelInPath)) {
+        if (!path)
+            continue;
+        if (!imports.includes(model))
+            continue;
+        const [outerKey, innerKey] = path;
+        const modelName = innerKey.replace(".dto.ts", "");
+        dtosImports.push(`import { ${modelName} } from "../${outerKey}/${innerKey}";`);
+    }
+    return `${commonImportString.length > 0 ? commonImportString + "\n" : ""}${dtosImports.join("\n")}\n${interfaceString}`;
+}