openapi-sync 1.0.25 → 2.0.0

package/dist/Openapi-sync/components/helpers.js

@@ -22,14 +22,10 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseSchemaToType = exports.getEndpointDetails = exports.getSharedComponentName = exports.capitalize = exports.yamlStringToJson = exports.isYamlString = exports.isJson = void 0;
+exports.JSONStringify = exports.getEndpointDetails = exports.capitalize = exports.yamlStringToJson = exports.isYamlString = exports.isJson = void 0;
 const regex_1 = require("./regex");
 const yaml = __importStar(require("js-yaml"));
-const lodash_1 = __importDefault(require("lodash"));
 const isJson = (value) => {
     return ["object"].includes(typeof value) && !(value instanceof Blob);
 };
@@ -64,8 +60,6 @@ const capitalize = (text) => {
     return capitalizedWord;
 };
 exports.capitalize = capitalize;
-const getSharedComponentName = (componentName, componentType) => `IApi${(0, exports.capitalize)(componentName)}`;
-exports.getSharedComponentName = getSharedComponentName;
 const getEndpointDetails = (path, method) => {
     const pathParts = path.split("/");
     let name = `${(0, exports.capitalize)(method)}`;
@@ -105,125 +99,24 @@ const getEndpointDetails = (path, method) => {
     return { name, variables, pathParts };
 };
 exports.getEndpointDetails = getEndpointDetails;
-const parseSchemaToType = (apiDoc, schema, name, isRequired, options) => {
-    let overrideName = "";
-    let componentName = "";
-    let type = "";
-    if (schema) {
-        if (schema.$ref) {
-            // console.log("Type schema 2");
-            if (schema.$ref[0] === "#") {
-                let pathToComponentParts = (schema.$ref || "").split("/");
-                pathToComponentParts.shift();
-                const pathToComponent = pathToComponentParts.join(".");
-                const component = lodash_1.default.get(apiDoc, pathToComponent, null);
-                // console.log("Type schema 3", pathToComponentParts);
-                if (component) {
-                    if (component === null || component === void 0 ? void 0 : component.name) {
-                        overrideName = component.name;
-                    }
-                    componentName = pathToComponentParts[pathToComponentParts.length - 1];
-                    // Reference component via import instead of parsing
-                    type += `${(options === null || options === void 0 ? void 0 : options.noSharedImport) ? "" : "Shared."}${(0, exports.getSharedComponentName)(componentName)}`;
-                    // type += `${parseSchemaToType(apiDoc, component, "", isRequired)}`;
-                }
-            }
-            else {
-                type += "";
-                //TODO $ref is a uri - use axios to fetch doc
-            }
-        }
-        else if (schema.anyOf) {
-            type += `(${schema.anyOf
-                .map((v) => (0, exports.parseSchemaToType)(apiDoc, v, "", isRequired, options))
-                .join("|")})`;
-        }
-        else if (schema.oneOf) {
-            type += `(${schema.oneOf
-                .map((v) => (0, exports.parseSchemaToType)(apiDoc, v, "", isRequired, options))
-                .join("|")})`;
-        }
-        else if (schema.allOf) {
-            type += `(${schema.allOf
-                .map((v) => (0, exports.parseSchemaToType)(apiDoc, v, "", isRequired, options))
-                .join("&")})`;
-        }
-        else if (schema.items) {
-            type += `${(0, exports.parseSchemaToType)(apiDoc, schema.items, "", false, options)}[]`;
+const JSONStringify = (obj) => {
+    let result = "{";
+    const keys = Object.keys(obj);
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        const value = obj[key];
+        result += key + ": ";
+        if (typeof value === "object" && value !== null) {
+            result += (0, exports.JSONStringify)(value);
         }
-        else if (schema.properties) {
-            //parse object key one at a time
-            const objKeys = Object.keys(schema.properties);
-            const requiredKeys = schema.required || [];
-            let typeCnt = "";
-            objKeys.forEach((key) => {
-                var _a;
-                typeCnt += `${(0, exports.parseSchemaToType)(apiDoc, (_a = schema.properties) === null || _a === void 0 ? void 0 : _a[key], key, requiredKeys.includes(key), options)}`;
-            });
-            if (typeCnt.length > 0) {
-                type += `{\n${typeCnt}}`;
-            }
-            else {
-                type += "{[k: string]: any}";
-            }
+        else {
+            result += value;
         }
-        else if (schema.type) {
-            if (schema.enum && schema.enum.length > 0) {
-                if (schema.enum.length > 1)
-                    type += "(";
-                type += schema.enum
-                    .map((v) => `"${v}"`)
-                    .join("|")
-                    .toString();
-                if (schema.enum.length > 1)
-                    type += ")";
-            }
-            else if (["string", "integer", "number", "array", "boolean"].includes(schema.type)) {
-                if (["integer", "number"].includes(schema.type)) {
-                    type += `number`;
-                }
-                else if (schema.type === "array") {
-                    //Since we would have already parsed the arrays keys above "schema.items" if it exists
-                    type += "any[]";
-                    /* if (schema.items) {
-                      type += `${parseSchemaToType(
-                        apiDoc,
-                        schema.items,
-                        "",
-                        false,
-                        options
-                      )}[]`;
-                    } else {
-                      type += "any[]";
-                    } */
-                }
-                else {
-                    type += schema.type;
-                }
-            }
-            else if (schema.type === "object") {
-                //Since we would have already parsed the object keys above "schema.properties" if it exists
-                if (schema.additionalProperties) {
-                    type += `{[k: string]: ${(0, exports.parseSchemaToType)(apiDoc, schema.additionalProperties, "", true, options) || "any"}}`;
-                }
-                else {
-                    type += "{[k: string]: any}";
-                }
-            }
+        if (i < keys.length - 1) {
+            result += ", ";
         }
     }
-    else {
-        //Default type to string if no schema provided
-        type = "string";
-    }
-    let _name = overrideName || name;
-    if ((options === null || options === void 0 ? void 0 : options.useComponentName) && !_name) {
-        _name = componentName;
-    }
-    let typeName = _name ? `\t"${_name}"${isRequired ? "" : "?"}: ` : "";
-    const nullable = (schema === null || schema === void 0 ? void 0 : schema.nullable) ? " | null" : "";
-    return type.length > 0
-        ? `${typeName}${type}${nullable}${_name ? ";\n" : ""}`
-        : "";
+    result += "}";
+    return result;
 };
-exports.parseSchemaToType = parseSchemaToType;
+exports.JSONStringify = JSONStringify;

package/dist/Openapi-sync/index.js

@@ -14,8 +14,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
+const lodash_1 = __importDefault(require("lodash"));
 const helpers_1 = require("./components/helpers");
-const lodash_1 = require("lodash");
+const lodash_2 = require("lodash");
 const axios_1 = __importDefault(require("axios"));
 const axios_retry_1 = __importDefault(require("axios-retry"));
 const openapi_core_1 = require("@redocly/openapi-core");
@@ -37,7 +38,8 @@ const apiClient = axios_1.default.create({
         return retryCount * 1000; // Exponential back-off: 1s, 2s, 3s, etc.
     },
 });
-const OpenapiSync = (apiUrl, apiName, refetchInterval) => __awaiter(void 0, void 0, void 0, function* () {
+const OpenapiSync = (apiUrl, apiName, config, refetchInterval) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b, _c, _d;
     const specResponse = yield apiClient.get(apiUrl);
     const redoclyConfig = yield (0, openapi_core_1.createConfig)({
         extends: ["minimal"],
@@ -49,10 +51,160 @@ const OpenapiSync = (apiUrl, apiName, refetchInterval) => __awaiter(void 0, void
         source,
         config: redoclyConfig,
     });
-    // Load config file
-    const config = require(path_1.default.join(rootUsingCwd, "openapi.sync.json"));
     const folderPath = path_1.default.join(config.folder || "", apiName);
     const spec = lintResults.bundle.parsed;
+    const typePrefix = typeof ((_b = (_a = config === null || config === void 0 ? void 0 : config.types) === null || _a === void 0 ? void 0 : _a.name) === null || _b === void 0 ? void 0 : _b.prefix) === "string"
+        ? config.types.name.prefix
+        : "I";
+    const endpointPrefix = typeof ((_d = (_c = config === null || config === void 0 ? void 0 : config.endpoints) === null || _c === void 0 ? void 0 : _c.name) === null || _d === void 0 ? void 0 : _d.prefix) === "string"
+        ? config.endpoints.name.prefix
+        : "";
+    const getSharedComponentName = (componentName, componentType) => {
+        var _a, _b;
+        if ((_b = (_a = config === null || config === void 0 ? void 0 : config.types) === null || _a === void 0 ? void 0 : _a.name) === null || _b === void 0 ? void 0 : _b.format) {
+            const formattedName = config.types.name.format("shared", {
+                name: componentName,
+            });
+            if (formattedName)
+                return `${typePrefix}${formattedName}`;
+        }
+        return `${typePrefix}${(0, helpers_1.capitalize)(componentName)}`;
+    };
+    const parseSchemaToType = (apiDoc, schema, name, isRequired, options) => {
+        let overrideName = "";
+        let componentName = "";
+        let type = "";
+        if (schema) {
+            if (schema.$ref) {
+                if (schema.$ref[0] === "#") {
+                    let pathToComponentParts = (schema.$ref || "").split("/");
+                    pathToComponentParts.shift();
+                    const partsClone = [...pathToComponentParts];
+                    partsClone.pop();
+                    const pathToComponent = pathToComponentParts;
+                    const component = lodash_1.default.get(apiDoc, pathToComponent, null);
+                    if (component) {
+                        if (component === null || component === void 0 ? void 0 : component.name) {
+                            overrideName = component.name;
+                        }
+                        componentName =
+                            pathToComponentParts[pathToComponentParts.length - 1];
+                        let name = getSharedComponentName(componentName);
+                        if (name.includes(".")) {
+                            const nameParts = name.split(".");
+                            name = nameParts
+                                .map((part, i) => {
+                                if (i === 0) {
+                                    return part;
+                                }
+                                return `["${part}"]`;
+                            })
+                                .join("");
+                        }
+                        // Reference component via import instead of parsing
+                        type += `${(options === null || options === void 0 ? void 0 : options.noSharedImport) ? "" : "Shared."}${name}`;
+                        // type += `${parseSchemaToType(apiDoc, component, "", isRequired)}`;
+                    }
+                }
+                else {
+                    type += "";
+                    //TODO $ref is a uri - use axios to fetch doc
+                }
+            }
+            else if (schema.anyOf) {
+                type += `(${schema.anyOf
+                    .map((v) => parseSchemaToType(apiDoc, v, "", isRequired, options))
+                    .join("|")})`;
+            }
+            else if (schema.oneOf) {
+                type += `(${schema.oneOf
+                    .map((v) => parseSchemaToType(apiDoc, v, "", isRequired, options))
+                    .join("|")})`;
+            }
+            else if (schema.allOf) {
+                type += `(${schema.allOf
+                    .map((v) => parseSchemaToType(apiDoc, v, "", isRequired, options))
+                    .join("&")})`;
+            }
+            else if (schema.items) {
+                type += `${parseSchemaToType(apiDoc, schema.items, "", false, options)}[]`;
+            }
+            else if (schema.properties) {
+                //parse object key one at a time
+                const objKeys = Object.keys(schema.properties);
+                const requiredKeys = schema.required || [];
+                let typeCnt = "";
+                objKeys.forEach((key) => {
+                    var _a;
+                    typeCnt += `${parseSchemaToType(apiDoc, (_a = schema.properties) === null || _a === void 0 ? void 0 : _a[key], key, requiredKeys.includes(key), options)}`;
+                });
+                if (typeCnt.length > 0) {
+                    type += `{\n${typeCnt}}`;
+                }
+                else {
+                    type += "{[k: string]: any}";
+                }
+            }
+            else if (schema.enum && schema.enum.length > 0) {
+                if (schema.enum.length > 1)
+                    type += "(";
+                schema.enum.forEach((v) => {
+                    let val = JSON.stringify(v);
+                    if (val)
+                        type += `|${val}`;
+                });
+                if (schema.enum.length > 1)
+                    type += ")";
+            }
+            else if (schema.type) {
+                if (["string", "integer", "number", "array", "boolean"].includes(schema.type)) {
+                    if (["integer", "number"].includes(schema.type)) {
+                        type += `number`;
+                    }
+                    else if (schema.type === "array") {
+                        //Since we would have already parsed the arrays keys above "schema.items" if it exists
+                        type += "any[]";
+                        /* if (schema.items) {
+                          type += `${parseSchemaToType(
+                            apiDoc,
+                            schema.items,
+                            "",
+                            false,
+                            options
+                          )}[]`;
+                        } else {
+                          type += "any[]";
+                        } */
+                    }
+                    else {
+                        type += schema.type;
+                    }
+                }
+                else if (schema.type === "object") {
+                    //Since we would have already parsed the object keys above "schema.properties" if it exists
+                    if (schema.additionalProperties) {
+                        type += `{[k: string]: ${parseSchemaToType(apiDoc, schema.additionalProperties, "", true, options) || "any"}}`;
+                    }
+                    else {
+                        type += "{[k: string]: any}";
+                    }
+                }
+            }
+        }
+        else {
+            //Default type to string if no schema provided
+            type = "string";
+        }
+        let _name = overrideName || name;
+        if ((options === null || options === void 0 ? void 0 : options.useComponentName) && !_name) {
+            _name = componentName;
+        }
+        let typeName = _name ? `\t"${_name}"${isRequired ? "" : "?"}: ` : "";
+        const nullable = (schema === null || schema === void 0 ? void 0 : schema.nullable) ? " | null" : "";
+        return type.length > 0
+            ? `${typeName}${type}${nullable}${_name ? ";\n" : ""}`
+            : "";
+    };
     // auto update only on dev
     if (refetchInterval && !isNaN(refetchInterval) && refetchInterval > 0) {
         if (!(process.env.NODE_ENV &&
@@ -61,12 +213,12 @@ const OpenapiSync = (apiUrl, apiName, refetchInterval) => __awaiter(void 0, void
             if (fetchTimeout[apiName])
                 clearTimeout(fetchTimeout[apiName]);
             // set next request timeout
-            fetchTimeout[apiName] = setTimeout(() => OpenapiSync(apiUrl, apiName, refetchInterval), refetchInterval);
+            fetchTimeout[apiName] = setTimeout(() => OpenapiSync(apiUrl, apiName, config, refetchInterval), refetchInterval);
         }
     }
     // compare new spec with old spec, continuing only if spec it different
     const prevSpec = (0, state_1.getState)(apiName);
-    if ((0, lodash_1.isEqual)(prevSpec, spec))
+    if ((0, lodash_2.isEqual)(prevSpec, spec))
         return;
     (0, state_1.setState)(apiName, spec);
     let endpointsFileContent = "";
@@ -86,10 +238,11 @@ const OpenapiSync = (apiUrl, apiName, refetchInterval) => __awaiter(void 0, void
             ].includes(key)) {
                 // Create components (shared) types
                 const components = spec.components[key];
+                const componentInterfaces = {};
                 const contentKeys = Object.keys(components);
                 // only need 1 schema so will us the first schema provided
                 contentKeys.forEach((contentKey) => {
-                    var _a, _b;
+                    var _a;
                     /*  const schema = (() => {
                       switch (key) {
                         case "parameters":
@@ -101,16 +254,43 @@ const OpenapiSync = (apiUrl, apiName, refetchInterval) => __awaiter(void 0, void
                     const schema = (((_a = components[contentKey]) === null || _a === void 0 ? void 0 : _a.schema)
                         ? components[contentKey].schema
                         : components[contentKey]);
-                    const typeCnt = `${(0, helpers_1.parseSchemaToType)(spec, schema, "", true, {
+                    const typeCnt = `${parseSchemaToType(spec, schema, "", true, {
                         noSharedImport: true,
                         useComponentName: ["parameters"].includes(key),
                     })}`;
                     if (typeCnt) {
-                        sharedTypesFileContent[key] =
-                            ((_b = sharedTypesFileContent[key]) !== null && _b !== void 0 ? _b : "") +
-                                `export type ${(0, helpers_1.getSharedComponentName)(contentKey)} = ${typeCnt};\n`;
+                        const parts = contentKey.split(".");
+                        let currentLevel = componentInterfaces;
+                        // Navigate or create the nested structure
+                        for (let i = 0; i < parts.length; i++) {
+                            const part = parts[i];
+                            if (i < parts.length - 1) {
+                                // If it's not the last part, create a nested object if it doesn't exist
+                                if (!(part in currentLevel)) {
+                                    currentLevel[part] = {}; //<== This rely on js ability to assign value to origianl object by reference, so this assignment will be reflected in componentInterfaces
+                                }
+                                currentLevel = currentLevel[part]; //<== This rely on js ability to assign value to origianl object by reference, so this assignment will be reflected in componentInterfaces
+                            }
+                            else {
+                                // This is the last part, assign the original schema value
+                                currentLevel[part] = typeCnt; //<== This rely on js ability to assign value to origianl object by reference, so this assignment will be reflected in componentInterfaces
+                            }
+                        }
                     }
                 });
+                // Generate TypeScript interfaces for each component
+                Object.keys(componentInterfaces).forEach((key) => {
+                    var _a;
+                    const name = getSharedComponentName(key);
+                    const cnt = componentInterfaces[key];
+                    sharedTypesFileContent[key] =
+                        ((_a = sharedTypesFileContent[key]) !== null && _a !== void 0 ? _a : "") +
+                            "export type " +
+                            name +
+                            " = " +
+                            (typeof cnt === "string" ? cnt : (0, helpers_1.JSONStringify)(cnt)) +
+                            ";\n";
+                });
             }
         });
     }
@@ -120,17 +300,17 @@ const OpenapiSync = (apiUrl, apiName, refetchInterval) => __awaiter(void 0, void
             const contentKeys = Object.keys(requestBody.content);
             // only need 1 schema so will us the first schema provided
             if (contentKeys[0] && requestBody.content[contentKeys[0]].schema) {
-                typeCnt += `${(0, helpers_1.parseSchemaToType)(spec, requestBody.content[contentKeys[0]].schema, "")}`;
+                typeCnt += `${parseSchemaToType(spec, requestBody.content[contentKeys[0]].schema, "")}`;
             }
         }
         return typeCnt;
     };
     const treatEndpointUrl = (endpointUrl) => {
-        var _a, _b;
+        var _a, _b, _c, _d, _e;
         if (((_b = (_a = config === null || config === void 0 ? void 0 : config.endpoints) === null || _a === void 0 ? void 0 : _a.value) === null || _b === void 0 ? void 0 : _b.replaceWords) &&
             Array.isArray(config.endpoints.value.replaceWords)) {
             let newEndpointUrl = endpointUrl;
-            config.endpoints.value.replaceWords.forEach((replaceWord, indx) => {
+            (_e = (_d = (_c = config === null || config === void 0 ? void 0 : config.endpoints) === null || _c === void 0 ? void 0 : _c.value) === null || _d === void 0 ? void 0 : _d.replaceWords) === null || _e === void 0 ? void 0 : _e.forEach((replaceWord, indx) => {
                 const regexp = new RegExp(replaceWord.replace, "g");
                 newEndpointUrl = newEndpointUrl.replace(regexp, replaceWord.with || "");
             });
@@ -142,9 +322,11 @@ const OpenapiSync = (apiUrl, apiName, refetchInterval) => __awaiter(void 0, void
     };
     Object.keys(spec.paths || {}).forEach((endpointPath) => {
         const endpointSpec = spec.paths[endpointPath];
+        // console.log("Endpoint Path:", { endpointPath, endpointSpec });
         const endpointMethods = Object.keys(endpointSpec);
-        endpointMethods.forEach((method) => {
-            var _a, _b, _c, _d, _e, _f;
+        endpointMethods.forEach((_method) => {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
+            const method = _method;
             const endpoint = (0, helpers_1.getEndpointDetails)(endpointPath, method);
             const endpointUrlTxt = endpoint.pathParts
                 .map((part) => {
@@ -173,38 +355,85 @@ const OpenapiSync = (apiUrl, apiName, refetchInterval) => __awaiter(void 0, void
             }
             //treat endpoint url
             endpointUrl = treatEndpointUrl(endpointUrl);
+            let name = `${endpoint.name}`;
+            if ((_b = (_a = config === null || config === void 0 ? void 0 : config.endpoints) === null || _a === void 0 ? void 0 : _a.name) === null || _b === void 0 ? void 0 : _b.format) {
+                const formattedName = config.endpoints.name.format({
+                    method,
+                    path: endpointPath,
+                    summary: (_c = endpointSpec[method]) === null || _c === void 0 ? void 0 : _c.summary,
+                });
+                if (formattedName)
+                    name = formattedName;
+            }
             // Add the endpoint url
-            endpointsFileContent += `export const ${endpoint.name} = ${endpointUrl}; 
+            endpointsFileContent += `export const ${endpointPrefix}${name} = ${endpointUrl}; 
 `;
-            if ((_a = endpointSpec[method]) === null || _a === void 0 ? void 0 : _a.parameters) {
+            if ((_d = endpointSpec[method]) === null || _d === void 0 ? void 0 : _d.parameters) {
                 // create query parameters types
-                const parameters = (_b = endpointSpec[method]) === null || _b === void 0 ? void 0 : _b.parameters;
+                const parameters = (_e = endpointSpec[method]) === null || _e === void 0 ? void 0 : _e.parameters;
                 let typeCnt = "";
                 parameters.forEach((param, i) => {
                     if (param.$ref || (param.in === "query" && param.name)) {
-                        typeCnt += `${(0, helpers_1.parseSchemaToType)(spec, param.$ref ? param : param.schema, param.name || "", param.required)}`;
+                        typeCnt += `${parseSchemaToType(spec, param.$ref ? param : param.schema, param.name || "", param.required)}`;
                     }
                 });
                 if (typeCnt) {
-                    typesFileContent += `export type I${endpoint.name}Query = {\n${typeCnt}};\n`;
+                    let name = `${endpoint.name}Query`;
+                    if ((_g = (_f = config === null || config === void 0 ? void 0 : config.types) === null || _f === void 0 ? void 0 : _f.name) === null || _g === void 0 ? void 0 : _g.format) {
+                        const formattedName = config.types.name.format("endpoint", {
+                            code: "",
+                            type: "query",
+                            method,
+                            path: endpointPath,
+                            summary: (_h = endpointSpec[method]) === null || _h === void 0 ? void 0 : _h.summary,
+                        });
+                        if (formattedName)
+                            name = formattedName;
+                    }
+                    typesFileContent += `export type ${typePrefix}${name} = {\n${typeCnt}};\n`;
                 }
             }
-            if ((_c = endpointSpec[method]) === null || _c === void 0 ? void 0 : _c.requestBody) {
+            if ((_j = endpointSpec[method]) === null || _j === void 0 ? void 0 : _j.requestBody) {
                 //create requestBody types
-                const requestBody = (_d = endpointSpec[method]) === null || _d === void 0 ? void 0 : _d.requestBody;
+                const requestBody = (_k = endpointSpec[method]) === null || _k === void 0 ? void 0 : _k.requestBody;
                 let typeCnt = getBodySchemaType(requestBody);
                 if (typeCnt) {
-                    typesFileContent += `export type I${endpoint.name}DTO = ${typeCnt};\n`;
+                    let name = `${endpoint.name}DTO`;
+                    if ((_m = (_l = config === null || config === void 0 ? void 0 : config.types) === null || _l === void 0 ? void 0 : _l.name) === null || _m === void 0 ? void 0 : _m.format) {
+                        const formattedName = config.types.name.format("endpoint", {
+                            code: "",
+                            type: "dto",
+                            method,
+                            path: endpointPath,
+                            summary: (_o = endpointSpec[method]) === null || _o === void 0 ? void 0 : _o.summary,
+                        });
+                        if (formattedName)
+                            name = formattedName;
+                    }
+                    typesFileContent += `export type ${typePrefix}${name} = ${typeCnt};\n`;
                 }
             }
-            if ((_e = endpointSpec[method]) === null || _e === void 0 ? void 0 : _e.responses) {
+            if ((_p = endpointSpec[method]) === null || _p === void 0 ? void 0 : _p.responses) {
                 // create request response types
-                const responses = (_f = endpointSpec[method]) === null || _f === void 0 ? void 0 : _f.responses;
+                const responses = (_q = endpointSpec[method]) === null || _q === void 0 ? void 0 : _q.responses;
                 const resCodes = Object.keys(responses);
                 resCodes.forEach((code) => {
+                    var _a, _b, _c;
                     let typeCnt = getBodySchemaType(responses[code]);
                     if (typeCnt) {
-                        typesFileContent += `export type I${endpoint.name}${code}Response = ${typeCnt};\n`;
+                        let name = `${endpoint.name}${code}Response`;
+                        if ((_b = (_a = config === null || config === void 0 ? void 0 : config.types) === null || _a === void 0 ? void 0 : _a.name) === null || _b === void 0 ? void 0 : _b.format) {
+                            const formattedName = config.types.name.format("endpoint", {
+                                code,
+                                type: "response",
+                                method,
+                                path: endpointPath,
+                                summary: (_c = endpointSpec[method]) === null || _c === void 0 ? void 0 : _c.summary,
+                            });
+                            if (formattedName)
+                                name = formattedName;
+                        }
+                        typesFileContent += `export type ${typePrefix}${name} = ${typeCnt};\n`;
                     }
                 });
             }

package/dist/index.js

@@ -21,7 +21,20 @@ dotenv_1.default.config();
 const rootUsingCwd = process.cwd();
 const Init = (options) => __awaiter(void 0, void 0, void 0, function* () {
     // Load config file
-    const config = require(path_1.default.join(rootUsingCwd, "openapi.sync.json"));
+    let configJS, configJson;
+    try {
+        configJS = require(path_1.default.join(rootUsingCwd, "openapi.sync.js"));
+    }
+    catch (e) {
+        // console.log(e);
+    }
+    try {
+        configJson = require(path_1.default.join(rootUsingCwd, "openapi.sync.json"));
+    }
+    catch (e) {
+        // console.log(e);
+    }
+    const config = configJS || configJson;
     const apiNames = Object.keys(config.api);
     const refetchInterval = options &&
         "refetchInterval" in options &&
@@ -32,7 +45,7 @@ const Init = (options) => __awaiter(void 0, void 0, void 0, function* () {
     for (let i = 0; i < apiNames.length; i += 1) {
         const apiName = apiNames[i];
         const apiUrl = config.api[apiName];
-        (0, Openapi_sync_1.default)(apiUrl, apiName, refetchInterval);
+        (0, Openapi_sync_1.default)(apiUrl, apiName, config, refetchInterval);
     }
 });
 exports.Init = Init;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openapi-sync",
-  "version": "1.0.25",
+  "version": "2.0.0",
   "description": "A developer-friendly tool designed to keep your API up-to-date by leveraging OpenAPI schemas. It automates the generation of endpoint URIs and type definitions, including shared types, directly from your OpenAPI specification.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -24,6 +24,7 @@
     "bin",
     "dist",
     "db.json",
+    "types.ts",
     "LICENSE",
     "README.md",
     "package.json"
@@ -31,7 +32,7 @@
   "scripts": {
     "test": "echo \"Error: no test specified\"",
     "build": "tsc",
-    "publish-package": "npm run build && npm version patch &&  npm publish",
+    "publish-package": "npm run build && npm version major &&  npm publish",
     "start": "npm run build && openapi-sync"
   },
   "author": "P-Technologies",

package/types.ts

@@ -0,0 +1,93 @@
+import { Method } from "axios";
+
+export type IOpenApiSpec = Record<"openapi", string> & Record<string, any>;
+
+export type IOpenApSchemaSpec = {
+  nullable?: boolean;
+  type: "string" | "integer" | "number" | "array" | "object" | "boolean";
+  example?: any;
+  enum?: string[];
+  format?: string;
+  items?: IOpenApSchemaSpec;
+  required?: string[];
+  $ref?: string;
+  properties?: Record<string, IOpenApSchemaSpec>;
+  additionalProperties?: IOpenApSchemaSpec;
+  anyOf?: IOpenApSchemaSpec[];
+  oneOf?: IOpenApSchemaSpec[];
+  allOf?: IOpenApSchemaSpec[];
+};
+
+export type IOpenApiParameterSpec = {
+  $ref?: string;
+  name: string;
+  in: string;
+  enum?: string[];
+  description?: string;
+  required?: boolean;
+  deprecated?: boolean;
+  allowEmptyValue?: boolean;
+  style?: string;
+  explode?: boolean;
+  allowReserved?: boolean;
+  schema?: IOpenApSchemaSpec;
+  example?: any;
+  examples?: any[];
+};
+
+export type IOpenApiMediaTypeSpec = {
+  schema?: IOpenApSchemaSpec;
+  example?: any;
+  examples?: any[];
+  encoding?: any;
+};
+
+export type IOpenApiRequestBodySpec = {
+  description?: string;
+  required?: boolean;
+  content: Record<string, IOpenApiMediaTypeSpec>;
+};
+
+export type IOpenApiResponseSpec = Record<string, IOpenApiRequestBodySpec>;
+
+export type IConfigReplaceWord = {
+  /**  string and regular expression as a string*/
+  replace: string;
+  with: string;
+  type?: "endpoint" | "type";
+};
+
+export type IConfig = {
+  refetchInterval?: number;
+  folder?: string;
+  api: Record<string, string>;
+  types?: {
+    name?: {
+      prefix?: string;
+      format?: (
+        source: "shared" | "endpoint",
+        data: {
+          name?: string;
+          type?: "response" | "dto" | "query";
+          code?: string;
+          method?: Method;
+          path?: string;
+          summary?: string;
+        }
+      ) => string | null | undefined;
+    };
+  };
+  endpoints?: {
+    value?: {
+      replaceWords?: IConfigReplaceWord[];
+    };
+    name?: {
+      format?: (data: {
+        method: Method;
+        path: string;
+        summary: string;
+      }) => string | null;
+      prefix?: string;
+    };
+  };
+};