swaggular 0.1.0

package/dist/parsers/swagger-parser.js

@@ -0,0 +1,53 @@
+"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.SwaggerParser = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const path_grouper_1 = require("./path-grouper");
+const swagger_state_1 = require("../core/state/swagger-state");
+class SwaggerParser {
+    static parse(filePath, options = { mode: 'tags' }) {
+        const absolutePath = path.resolve(filePath);
+        const content = fs.readFileSync(absolutePath, { encoding: 'utf8' });
+        const swagger = JSON.parse(content);
+        if (!swagger)
+            return;
+        const pathsGroupedByScope = path_grouper_1.PathGrouper.groupPaths(swagger.paths, options);
+        swagger_state_1.swaggerState.setSwagger(swagger);
+        swagger_state_1.swaggerState.setPathsGroupedByScope(pathsGroupedByScope);
+    }
+}
+exports.SwaggerParser = SwaggerParser;

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

@@ -0,0 +1,3 @@
+import { ServiceDataParameter } from '../types/service-data';
+export declare function generateInterfaceComments(param: any): string;
+export declare function generateServiceComments(summary: string, responseType?: string, parameters?: ServiceDataParameter[]): string;

package/dist/renderers/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) => `@param ${p.name} : ${p.type}`).join('\n')}`);
+    }
+    if (responseType) {
+        comments.push(`@returns Observable<${responseType}>`);
+    }
+    return `\t/**\n${comments.map((c) => `\t* ${c}\n`).join('')}\n */`;
+}

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

@@ -0,0 +1,12 @@
+import { OpenAPIV3 } from 'openapi-types';
+import { FileContent } from '../types/file-content';
+import { GroupedPath } from '../types/grouped-paths';
+import { InterfaceData, InterfaceDataProperty } from '../types/interface-data';
+export declare function parametersToIProperties(parameters: (OpenAPIV3.ParameterObject | OpenAPIV3.ReferenceObject)[]): InterfaceDataProperty[];
+export declare function propertiesToIProperties(properties: Record<string, OpenAPIV3.ReferenceObject | OpenAPIV3.SchemaObject>): InterfaceDataProperty[];
+export declare function generateInterfaces(): void;
+export declare function generateWithParameters(): void;
+export declare function computeParametersName(method: string, innerPath: string, groupedPath: GroupedPath): string;
+export declare function generateComponentsSchemas(): void;
+export declare function generateInterfacesFiles(locations?: Record<string, string[]>): FileContent[];
+export declare function generateContent(interfaceData: InterfaceData, deep?: number): string;

package/dist/renderers/generate-interface.js

@@ -0,0 +1,209 @@
+"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_state_1 = require("../core/state/interface-state");
+const swagger_state_1 = require("../core/state/swagger-state");
+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_state_1.swaggerState.getPaths();
+    const groupedPaths = swagger_state_1.swaggerState.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_state_1.interfaceState.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_state_1.swaggerState.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_state_1.interfaceState.addInterfaces(interfaces);
+}
+function generateInterfacesFiles(locations) {
+    const interfacesData = [
+        ...generic_types_1.genericTypesData,
+        ...extends_from_types_1.extendsFromTypes,
+        ...Array.from(Object.values(interface_state_1.interfaceState.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;
+}
+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 '';
+}

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

@@ -0,0 +1,9 @@
+import { FileContent } from '../types/file-content';
+import { GroupedPath } from '../types/grouped-paths';
+import { ServiceDataMethod } from '../types/service-data';
+/**
+ * Pick the paths grouped by scope and generate services for them.
+ */
+export declare function generateServices(): void;
+export declare function generateServiceFiles(locations?: Record<string, string[]>): FileContent[];
+export declare function buildMethods(groupedPath: GroupedPath): ServiceDataMethod[];

package/dist/renderers/generate-service.js

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateServices = generateServices;
+exports.generateServiceFiles = generateServiceFiles;
+exports.buildMethods = buildMethods;
+const service_state_1 = require("../core/state/service-state");
+const swagger_state_1 = require("../core/state/swagger-state");
+const angular_template_1 = require("../templates/services/angular-template");
+const build_types_1 = require("../utils/build-types");
+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");
+const object_utils_1 = require("../utils/object-utils");
+/**
+ * Pick the paths grouped by scope and generate services for them.
+ */
+function generateServices() {
+    const servicesData = [];
+    const groupedPaths = swagger_state_1.swaggerState.getPathsGroupedByScope();
+    const paths = swagger_state_1.swaggerState.getPaths();
+    if (!groupedPaths || !paths)
+        return;
+    for (const [key, value] of Object.entries(groupedPaths)) {
+        const serviceMethods = buildMethods(value);
+        const imports = new Set();
+        serviceMethods.forEach((method) => {
+            if (!(0, type_guard_1.isNativeType)(method.responseType)) {
+                imports.add(method.responseType);
+            }
+            method.parameters.forEach((param) => {
+                if (!(0, type_guard_1.isNativeType)(param.type)) {
+                    imports.add(param.type);
+                }
+            });
+        });
+        const serviceData = {
+            name: key,
+            imports: Array.from(imports),
+            baseUrl: value.baseUrl,
+            methods: serviceMethods,
+        };
+        servicesData.push(serviceData);
+    }
+    service_state_1.serviceState.addServices(servicesData);
+}
+function generateServiceFiles(locations) {
+    const services = Object.values(service_state_1.serviceState.services);
+    const filesContent = [];
+    for (const service of services) {
+        const location = ['services', ...(locations?.[service.name] ?? [])];
+        const methods = service.methods
+            .map((method) => {
+            return buildMethodTemplate(method);
+        })
+            .join('\n\n');
+        const templateParams = {
+            name: service.name,
+            baseUrl: service.baseUrl,
+            methods: methods,
+            imports: service.imports.join(', '),
+            hasHttpParamsHandler: service.methods.some((m) => m.parameters.some((p) => p.in === 'query')),
+        };
+        const content = (0, angular_template_1.angularTemplate)(templateParams);
+        filesContent.push({
+            location: location,
+            content,
+            extension: 'ts',
+            name: (0, string_utils_1.toKebabCase)(service.name) + '.service',
+        });
+    }
+    return filesContent;
+}
+function buildMethods(groupedPath) {
+    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 name = buildMethodName(method, path, groupedPath, usedNames);
+            usedNames.push(name);
+            const parameters = buildParameters(operation.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('')),
+                method: method,
+                parameters,
+                responseType,
+                comments: (0, generate_comments_1.generateServiceComments)(operation.summary ?? '', responseType, parameters),
+            });
+        }
+    }
+    return methods;
+}
+function pathItemToMethods(pathItem) {
+    return (0, object_utils_1.removeFalsyValues)({
+        get: pathItem.get,
+        post: pathItem.post,
+        put: pathItem.put,
+        delete: pathItem.delete,
+        patch: pathItem.patch,
+    });
+}
+function buildMethodName(method, path, groupedPath, usedNames) {
+    const dict = {
+        get: 'get',
+        post: 'create',
+        put: 'update',
+        delete: 'delete',
+        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('')));
+    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) {
+    const results = [];
+    for (const param of parameters) {
+        if ((0, type_guard_1.isReference)(param)) {
+            const ref = param.$ref.split('/').pop();
+            results.push({
+                name: (0, string_utils_1.lowerFirst)(ref),
+                in: 'query',
+                required: true,
+                type: ref,
+            });
+            continue;
+        }
+        results.push({
+            name: (0, string_utils_1.lowerFirst)(param.name),
+            in: param.in,
+            required: param.required ?? false,
+            type: (0, build_types_1.switchTypeJson)(param.schema),
+        });
+    }
+    // Check for body (simplified)
+    // In a real implementation we would look at requestBody
+    return results;
+}
+function buildResponseType(responses) {
+    const success = responses['200'] || responses['201'] || responses['default'];
+    if (!success)
+        return 'any';
+    if ((0, type_guard_1.isReference)(success))
+        return success.$ref.split('/').pop();
+    const content = success.content?.['application/json'];
+    if (!content || !content.schema)
+        return 'any';
+    return (0, build_types_1.switchTypeJson)(content.schema);
+}
+function buildMethodTemplate(method) {
+    const params = method.parameters
+        .map((p) => `${p.name}${p.required ? '' : '?'}: ${p.type}`)
+        .join(', ');
+    const path = method.path
+        .split('/')
+        .map((s) => ((0, path_utils_1.isVariable)(s) ? `\${${s.replace(/[{}]/g, '')}}` : s))
+        .join('/');
+    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})`;
+    return `${method.comments}
+  ${method.name}(${params}): Observable<${method.responseType}> {
+    return ${httpCall};
+  }`;
+}

package/dist/stores/interface-data-store.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.interfaceDataStore = void 0;
+class InterfaceDataStore {
+    genericInterfaces = {};
+    baseInterfaces = {};
+    generatedInterfaces = {};
+    generatedEnums = {};
+    componentsSchemas = {};
+    constructor() { }
+    setComponentsSchemas(componentsSchemas) {
+        this.componentsSchemas = componentsSchemas;
+    }
+    getComponentsSchema(name) {
+        return this.componentsSchemas[name];
+    }
+    exists(name) {
+        return (this.genericInterfaces[name] !== undefined ||
+            this.baseInterfaces[name] !== undefined ||
+            this.generatedInterfaces[name] !== undefined ||
+            this.generatedEnums[name] !== undefined);
+    }
+    addInterfaces(interfacesData) {
+        for (const inter of interfacesData) {
+            this.generatedInterfaces[inter.name] = inter;
+        }
+    }
+    computeExtendsFrom(properties) {
+        if (properties.length === 0)
+            return { extendsFrom: undefined, properties: [] };
+        const currentPropertiesNames = new Set(properties.map((p) => p.name));
+        for (const [name, schema] of Object.entries(this.baseInterfaces)) {
+            if (schema.properties.length !== properties.length)
+                continue;
+            const required = schema.properties
+                .filter((p) => !p.optional)
+                .map((p) => p.name);
+            if (required.some((r) => !currentPropertiesNames.has(r))) {
+                continue;
+            }
+            const optional = schema.properties
+                .filter((p) => p.optional)
+                .map((p) => p.name);
+            const remainingProperties = properties
+                .filter((p) => !required.includes(p.name))
+                .filter((p) => !optional.includes(p.name));
+            if (remainingProperties.length === 0 &&
+                schema.properties.some((p) => p.type === "generic")) {
+                return {
+                    extendsFrom: name,
+                    properties: [],
+                };
+            }
+            return {
+                extendsFrom: name,
+                properties: remainingProperties,
+            };
+        }
+        return { extendsFrom: undefined, properties };
+    }
+}
+exports.interfaceDataStore = new InterfaceDataStore();

package/dist/stores/services-store.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serviceStore = void 0;
+class ServiceStore {
+    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.serviceStore = new ServiceStore();