swaggular 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Swagger to Angular Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,66 @@
+# Swaggular
+
+A powerful tool to generate Angular services and models from Swagger/OpenAPI specifications.
+
+## Features
+
+- 🚀 Automatically generates Angular services.
+- 📦 Generates complex model interfaces.
+- 📝 Includes JSDoc comments for better developer experience.
+- 🛠️ Highly configurable.
+
+## Getting Started
+
+### Prerequisites
+
+- Node.js (v18 or higher)
+- npm or yarn
+
+### Installation
+
+To install the tool globally:
+
+```bash
+npm install -g swaggular
+```
+
+Or run it directly using `npx`:
+
+```bash
+npx swaggular --input=swagger.json
+```
+
+### Usage
+
+Run the generator by providing the path to your Swagger/OpenAPI file:
+
+```bash
+swaggular --input=path/to/your/swagger.json
+```
+
+#### Options
+
+- `--input`: Path to the swagger.json file (required).
+- `--ignore-segments`: Path segments to ignore when generating service names.
+- `--no-generate`: Parse the file but don't generate the output.
+
+The generated files will be available in the `results` folder.
+
+## Development
+
+### Scripts
+
+- `npm run build`: Compile TypeScript to JavaScript.
+- `npm run start`: Run the compiled project.
+- `npm run serve`: Compile and run the project immediately.
+- `npm run lint`: Run ESLint to check code style.
+- `npm run format`: Format code using Prettier.
+- `npm test`: Run tests using Jest.
+
+## Contributing
+
+Please read [CONTRIBUTING.md](CONTRIBUTING.md) for details on our code of conduct, and the process for submitting pull requests to us.
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

package/dist/app/get-parse-args.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getParseArgs = getParseArgs;
+function getParseArgs(argv) {
+    const args = {};
+    const positional = [];
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg.startsWith("--") && arg.includes("=")) {
+            const [k, v] = arg.slice(2).split("=");
+            args[k] = v;
+            continue;
+        }
+        if (arg.startsWith("--")) {
+            const k = arg.slice(2);
+            const next = argv[i + 1];
+            if (!next || next.startsWith("-")) {
+                args[k] = true;
+            }
+            else {
+                args[k] = next;
+                i++;
+            }
+            continue;
+        }
+        if (arg.startsWith("-") && arg.length > 2) {
+            arg
+                .slice(1)
+                .split("")
+                .forEach((k) => (args[k] = true));
+            continue;
+        }
+        if (arg.startsWith("-")) {
+            const k = arg.slice(1);
+            const next = argv[i + 1];
+            if (!next || next.startsWith("-")) {
+                args[k] = true;
+            }
+            else {
+                args[k] = next;
+                i++;
+            }
+            continue;
+        }
+        positional.push(arg);
+    }
+    return { args, positional };
+}

package/dist/app/parse-variables.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toVariables = toVariables;
+function toVariables(parsed) {
+    const variables = {};
+    if (parsed.args.mode) {
+        variables.groupingMode = parsed.args.mode;
+    }
+    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 {
+        groupingMode: variables.groupingMode || "path",
+        segmentsToIgnore: variables.segmentsToIgnore || ["api"],
+        ignoreVariables: variables.ignoreVariables || true,
+    };
+}

package/dist/builders/build-comments.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildComments = buildComments;
+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/cli/args.d.ts

@@ -0,0 +1,2 @@
+import { ParsedArgs } from '../types/parsed-args';
+export declare function getParseArgs(argv: string[]): ParsedArgs;

package/dist/cli/args.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getParseArgs = getParseArgs;
+function getParseArgs(argv) {
+    const args = {};
+    const positional = [];
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg.startsWith('--') && arg.includes('=')) {
+            const [k, v] = arg.slice(2).split('=');
+            args[k] = v;
+            continue;
+        }
+        if (arg.startsWith('--')) {
+            const k = arg.slice(2);
+            const next = argv[i + 1];
+            if (!next || next.startsWith('-')) {
+                args[k] = true;
+            }
+            else {
+                args[k] = next;
+                i++;
+            }
+            continue;
+        }
+        if (arg.startsWith('-') && arg.length > 2) {
+            arg
+                .slice(1)
+                .split('')
+                .forEach((k) => (args[k] = true));
+            continue;
+        }
+        if (arg.startsWith('-')) {
+            const k = arg.slice(1);
+            const next = argv[i + 1];
+            if (!next || next.startsWith('-')) {
+                args[k] = true;
+            }
+            else {
+                args[k] = next;
+                i++;
+            }
+            continue;
+        }
+        positional.push(arg);
+    }
+    return { args, positional };
+}

package/dist/cli/variables.d.ts

@@ -0,0 +1,2 @@
+import { ArgsVariables, ParsedArgs } from '../types/parsed-args';
+export declare function toVariables(parsed: ParsedArgs): ArgsVariables;

package/dist/cli/variables.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toVariables = toVariables;
+function toVariables(parsed) {
+    const variables = {};
+    if (parsed.args.mode) {
+        variables.groupingMode = parsed.args.mode;
+    }
+    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 {
+        groupingMode: variables.groupingMode || 'path',
+        segmentsToIgnore: variables.segmentsToIgnore || ['api'],
+        ignoreVariables: variables.ignoreVariables || true,
+    };
+}

package/dist/core/state/interface-state.d.ts

@@ -0,0 +1,17 @@
+import { IJsonSchema } from 'openapi-types';
+import { InterfaceData } from '../../types/interface-data';
+export interface InterfaceStateI {
+    generatedInterfaces: Record<string, InterfaceData>;
+    generatedEnums: Record<string, InterfaceData>;
+}
+declare class InterfaceState implements InterfaceStateI {
+    generatedInterfaces: Record<string, InterfaceData>;
+    generatedEnums: Record<string, InterfaceData>;
+    componentsSchemas: Record<string, IJsonSchema>;
+    constructor();
+    setComponentsSchemas(componentsSchemas: Record<string, IJsonSchema>): void;
+    getComponentsSchema(name: string): IJsonSchema | undefined;
+    addInterfaces(interfacesData: InterfaceData[]): void;
+}
+export declare const interfaceState: InterfaceState;
+export {};

package/dist/core/state/interface-state.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.interfaceState = void 0;
+class InterfaceState {
+    generatedInterfaces = {};
+    generatedEnums = {};
+    componentsSchemas = {};
+    constructor() { }
+    setComponentsSchemas(componentsSchemas) {
+        this.componentsSchemas = componentsSchemas;
+    }
+    getComponentsSchema(name) {
+        return this.componentsSchemas[name];
+    }
+    addInterfaces(interfacesData) {
+        for (const inter of interfacesData) {
+            this.generatedInterfaces[inter.name] = inter;
+        }
+    }
+}
+exports.interfaceState = new InterfaceState();

package/dist/core/state/service-state.d.ts

@@ -0,0 +1,9 @@
+import { ServiceData } from '../../types/service-data';
+declare class ServiceState {
+    services: Record<string, ServiceData>;
+    addService(name: string, content: ServiceData): void;
+    addServices(services: ServiceData[]): void;
+    getService(name: string): ServiceData | undefined;
+}
+export declare const serviceState: ServiceState;
+export {};

package/dist/core/state/service-state.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serviceState = void 0;
+class ServiceState {
+    services = {};
+    addService(name, content) {
+        this.services[name] = content;
+    }
+    addServices(services) {
+        services.forEach((service) => {
+            this.services[service.name] = service;
+        });
+    }
+    getService(name) {
+        return this.services[name];
+    }
+}
+exports.serviceState = new ServiceState();

package/dist/core/state/swagger-state.d.ts

@@ -0,0 +1,14 @@
+import { OpenAPIV3 } from 'openapi-types';
+import { GroupedPaths } from '../../types/grouped-paths';
+export declare class SwaggerState {
+    private swagger;
+    private pathsGroupedByScope;
+    setSwagger(swagger: OpenAPIV3.Document): void;
+    getSwagger(): OpenAPIV3.Document | undefined;
+    setPathsGroupedByScope(pathsGroupedByScope: GroupedPaths): void;
+    getPaths(): OpenAPIV3.PathsObject | undefined;
+    getSchemas(): Record<string, OpenAPIV3.ReferenceObject | OpenAPIV3.SchemaObject> | undefined;
+    getPathsGroupedByScope(): GroupedPaths | undefined;
+    getGroupByPath(path: string): import("../../types/grouped-paths").GroupedPath | undefined;
+}
+export declare const swaggerState: SwaggerState;

package/dist/core/state/swagger-state.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.swaggerState = exports.SwaggerState = void 0;
+class SwaggerState {
+    swagger = undefined;
+    pathsGroupedByScope = undefined;
+    setSwagger(swagger) {
+        this.swagger = swagger;
+    }
+    getSwagger() {
+        return this.swagger;
+    }
+    setPathsGroupedByScope(pathsGroupedByScope) {
+        this.pathsGroupedByScope = pathsGroupedByScope;
+    }
+    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;
+    }
+}
+exports.SwaggerState = SwaggerState;
+exports.swaggerState = new SwaggerState();

package/dist/examples/services/get.example.js

@@ -0,0 +1 @@
+"use strict";

package/dist/generators/generate-comments.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateInterfaceComments = generateInterfaceComments;
+exports.generateServiceComments = generateServiceComments;
+function generateInterfaceComments(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 "";
+}
+function generateServiceComments(summary, responseType, parameters) {
+    const summarySplited = [];
+    for (let i = 0; i < summary.length; i += 100) {
+        summarySplited.push(summary.slice(i, i + 100));
+    }
+    const comments = summarySplited;
+    if (parameters && parameters.length > 0) {
+        comments.push(`${parameters.map((p) => `\t\t @param ${p.name} : ${p.type}`).join("\n")}`);
+    }
+    if (responseType) {
+        comments.push(`\t\t @returns Observable<${responseType}>`);
+    }
+    return `/**\n${comments.map((c) => `\t\t* ${c}\n`).join("")}\n */`;
+}

package/dist/generators/generate-interface.js

@@ -0,0 +1,219 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parametersToIProperties = parametersToIProperties;
+exports.propertiesToIProperties = propertiesToIProperties;
+exports.generateInterfaces = generateInterfaces;
+exports.generateWithParameters = generateWithParameters;
+exports.computeParametersName = computeParametersName;
+exports.generateComponentsSchemas = generateComponentsSchemas;
+exports.generateInterfacesFiles = generateInterfacesFiles;
+exports.generateContent = generateContent;
+const interface_data_store_1 = require("../stores/interface-data-store");
+const swagger_store_1 = require("../stores/swagger-store");
+const extends_from_types_1 = require("../templates/types/extends-from-types");
+const generic_types_1 = require("../templates/types/generic-types");
+const build_types_1 = require("../utils/build-types");
+const object_utils_1 = require("../utils/object-utils");
+const path_utils_1 = require("../utils/path-utils");
+const string_utils_1 = require("../utils/string-utils");
+const type_guard_1 = require("../utils/type-guard");
+const generate_comments_1 = require("./generate-comments");
+function parametersToIProperties(parameters) {
+    const properties = [];
+    for (const param of parameters) {
+        if ((0, type_guard_1.isReference)(param)) {
+            const ref = param.$ref.split("/").pop();
+            properties.push({
+                name: (0, string_utils_1.lowerFirst)(ref),
+                type: ref,
+                optional: false,
+                comments: "",
+            });
+            continue;
+        }
+        if (param.in !== "query")
+            continue;
+        const tsType = (0, build_types_1.switchTypeJson)(param.schema);
+        properties.push({
+            name: (0, string_utils_1.lowerFirst)(param.name),
+            type: tsType,
+            optional: !param.required,
+            comments: (0, generate_comments_1.generateInterfaceComments)(param.schema),
+        });
+    }
+    return properties;
+}
+function propertiesToIProperties(properties) {
+    const interfaceDataProperties = [];
+    for (const [name, property] of Object.entries(properties)) {
+        if ((0, type_guard_1.isReference)(property)) {
+            const ref = property.$ref.split("/").pop();
+            interfaceDataProperties.push({
+                name,
+                type: ref,
+                optional: false,
+                comments: "",
+            });
+            continue;
+        }
+        interfaceDataProperties.push({
+            name,
+            type: (0, build_types_1.switchTypeJson)(property),
+            optional: property.nullable ?? false,
+            comments: (0, generate_comments_1.generateInterfaceComments)(property),
+        });
+    }
+    return interfaceDataProperties;
+}
+function generateInterfaces() {
+    generateComponentsSchemas();
+    generateWithParameters();
+}
+function generateWithParameters() {
+    const paths = swagger_store_1.swaggerStore.getPaths();
+    const groupedPaths = swagger_store_1.swaggerStore.getPathsGroupedByScope();
+    if (!paths || !groupedPaths)
+        return;
+    const interfacesData = [];
+    for (const groupedPath of Object.values(groupedPaths)) {
+        for (const innerPath of groupedPath.paths) {
+            const pathInfo = paths[innerPath];
+            if (!pathInfo)
+                continue;
+            const methods = (0, object_utils_1.removeFalsyValues)({
+                get: pathInfo.get,
+                post: pathInfo.post,
+                put: pathInfo.put,
+                delete: pathInfo.delete,
+                patch: pathInfo.patch,
+            });
+            for (const [httpMethod, pathData] of Object.entries(methods)) {
+                if (!pathData?.parameters)
+                    continue;
+                const parameters = pathData.parameters;
+                const properties = parametersToIProperties(parameters);
+                if (properties.length === 0)
+                    continue;
+                const interfaceName = computeParametersName(httpMethod, innerPath, groupedPath);
+                const interData = {
+                    name: interfaceName,
+                    type: "interface",
+                    imports: properties
+                        .filter((p) => !(0, type_guard_1.isNativeType)(p.type))
+                        .map((p) => p.type),
+                    properties,
+                };
+                const generic = (0, generic_types_1.isGenericType)(interData);
+                if (generic)
+                    continue;
+                const interDataWithExtendsFrom = (0, extends_from_types_1.computeExtendsFromType)(interData);
+                interfacesData.push(interDataWithExtendsFrom);
+            }
+        }
+    }
+    interface_data_store_1.interfaceDataStore.addInterfaces(interfacesData);
+}
+function computeParametersName(method, innerPath, groupedPath) {
+    const dict = {
+        get: "",
+        post: "Create",
+        put: "Update",
+        delete: "Delete",
+        patch: "Patch",
+    };
+    const name = dict[method];
+    const extra = (0, string_utils_1.kebabToPascalCase)((0, path_utils_1.removeVariablesFromPath)((0, path_utils_1.getExtraSegments)(innerPath, (0, path_utils_1.createBaseUrl)(groupedPath.baseSegments)).join("")));
+    return name + groupedPath.groupName + (0, string_utils_1.upFirst)(extra) + "Params";
+}
+function generateComponentsSchemas() {
+    const schemas = swagger_store_1.swaggerStore.getSchemas();
+    if (!schemas)
+        return;
+    const interfaces = [];
+    for (const [key, value] of Object.entries(schemas)) {
+        if ((0, type_guard_1.isReference)(value))
+            continue;
+        if (!value.properties) {
+            if (value.enum) {
+                const interData = {
+                    name: key,
+                    type: "enum",
+                    imports: [],
+                    properties: value.enum.map((e) => {
+                        return {
+                            name: e,
+                            type: e,
+                            optional: false,
+                            comments: "",
+                        };
+                    }),
+                };
+                interfaces.push(interData);
+            }
+            continue;
+        }
+        const properties = propertiesToIProperties(value.properties);
+        const interData = {
+            name: key,
+            type: "interface",
+            imports: properties
+                .filter((p) => !(0, type_guard_1.isNativeType)(p.type))
+                .map((p) => p.type),
+            properties,
+        };
+        const generic = (0, generic_types_1.isGenericType)(interData);
+        if (generic) {
+            continue;
+        }
+        const interDataWithExtendsFrom = (0, extends_from_types_1.computeExtendsFromType)(interData);
+        interfaces.push(interDataWithExtendsFrom);
+    }
+    interface_data_store_1.interfaceDataStore.addInterfaces(interfaces);
+}
+function generateInterfacesFiles(locations) {
+    const interfacesData = [
+        ...generic_types_1.genericTypesData,
+        ...extends_from_types_1.extendsFromTypes,
+        ...Array.from(Object.values(interface_data_store_1.interfaceDataStore.generatedInterfaces)),
+    ];
+    const filesContent = [];
+    for (const [key, value] of Object.entries(interfacesData)) {
+        const location = [
+            value.type === "enum" ? "enums" : "dtos",
+            ...(locations?.[key] ?? []),
+        ];
+        const content = generateContent(value, location.length);
+        const extraName = value.type === "enum" ? "enum" : "dto";
+        filesContent.push({
+            location: location,
+            content,
+            extension: "ts",
+            name: (0, string_utils_1.toKebabCase)(value.name) + `.${extraName}`,
+        });
+    }
+    return filesContent;
+}
+generateContent;
+function generateContent(interfaceData, deep = 0) {
+    const imports = [...interfaceData.imports];
+    const importsTemplate = imports.length > 0
+        ? `import { ${imports.join(", ")} } from "${"../".repeat(deep)}models";`
+        : "";
+    if (interfaceData.type === "interface") {
+        const content = `${importsTemplate}\n\nexport interface ${interfaceData.name} ${interfaceData.extendsFrom && interfaceData.extendsFrom.length > 0 ? `extends ${interfaceData.extendsFrom.join(", ")}` : ""} {
+    ${interfaceData.properties
+            .map((p) => `${p.comments}\n\t${(0, string_utils_1.lowerFirst)(p.name)}${p.optional ? "?" : ""}: ${p.type};`)
+            .join("\n")}
+  }`;
+        return content;
+    }
+    if (interfaceData.type === "enum") {
+        const content = `export enum ${interfaceData.name} {
+    ${interfaceData.properties
+            .map((p) => `${p.comments}\n\t${p.name} = '${p.type}',`)
+            .join("\n")}
+  }`;
+        return content;
+    }
+    return "";
+}