openapi-sync 1.0.24 → 2.0.0

package/README.md

@@ -1,37 +1,138 @@
 # Openapi-sync
 
-**Openapi-sync** is 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. Whether you need real-time synchronization before commits or periodic updates, openapi-sync ensures your API structure is always current and consistent. With an easy-to-use CLI, this tool integrates seamlessly into your development workflow, making API maintenance simpler and more reliable.
+[![NPM Version](https://img.shields.io/npm/v/openapi-sync.svg)](https://www.npmjs.com/package/openapi-sync)
+[![License](https://img.shields.io/npm/l/openapi-sync.svg)](https://github.com/akintomiwa-fisayo/openapi-sync/blob/main/LICENSE)
+
+**Openapi-sync** is a powerful developer tool that automates the synchronization of your API documentation with your codebase using OpenAPI (formerly Swagger) specifications. It generates TypeScript types and endpoint definitions from your OpenAPI schema, ensuring your API documentation stays up-to-date with your code.
+
+## Features
+
+- 🔄 Real-time API Synchronization
+- 📝 Automatic Type Generation
+- 🔄 Periodic API Refetching
+- 📁 Configurable Output Directory
+- 🔄 Customizable Naming Conventions
+- 🔄 Endpoint URL Transformation
+- 🔄 Schema Validation
+- 🔄 CLI Integration
+- 🔄 TypeScript Support
+- 🔄 YAML and JSON Support
 
 ## Installation
 
-To install `openapi-sync`, run the following command:
+Install the package using npm:
 
 ```bash
 npm install openapi-sync
 ```
 
+Or use it directly via npx:
+
+```bash
+npx openapi-sync
+```
+
 ## Configuration
 
-Create an `openapi.sync.json` file at the root of your project to configure openapi-sync. You can use the provided [`openapi.sync.sample.json`](https://github.com/akintomiwa-fisayo/openapi-sync/blob/master/openapi.sync.sample.json) as reference.
+Create a `openapi.sync.json` file in your project root with the following structure:
+
+```json
+{
+  "refetchInterval": 5000, // milliseconds between API refetches
+  "folder": "/path/to/output", // output directory for generated files
+  "api": {
+    "example1": "https://api.example.com/openapi.json",
+    "example2": "https://api.example.com/openapi.yaml"
+  },
+  "naming": {
+    "replaceWords": [
+      {
+        "replace": "Api",
+        "with": "",
+        "type": "endpoint"
+      }
+    ]
+  },
+  "endpoints": {
+    "value": {
+      "replaceWords": [
+        {
+          "replace": "/api/v\\d/",
+          "with": ""
+        }
+      ]
+    }
+  }
+}
+```
 
 ## Usage
 
-To start using openapi-sync, simply run the following command in your terminal:
+### CLI Commands
 
 ```bash
+# Basic usage
 npx openapi-sync
+
+# With custom refetch interval
+npx openapi-sync --refreshinterval 30000
 ```
 
-You can also add it as a script in your package.json for easy access:
+### Programmatic Usage
 
-```json
-"scripts": {
-  "api-sync": "npx openapi-sync",
-}
+```typescript
+import { Init } from "openapi-sync";
+
+// Initialize with custom options
+await Init({
+  refetchInterval: 30000, // optional, defaults to config value
+});
 ```
 
-## Features
+## Output Generation
+
+The tool generates:
+
+1. TypeScript interfaces for API endpoints
+2. Type definitions for request/response bodies
+3. Shared component types
+4. Endpoint URL constants
+
+## Type Generation
+
+The tool supports:
+
+- Primitive types (string, number, boolean, etc.)
+- Complex types (objects, arrays)
+- Enums
+- Nullable types
+- Any types
+- Shared components
+- Request/response bodies
+
+## Error Handling
+
+The tool includes:
+
+- Network error retries
+- Schema validation
+- Type generation error handling
+- State persistence
+
+## API Documentation
+
+For detailed API documentation, please refer to the [OpenAPI specification](https://spec.openapis.org/oas/v3.0.3).
+
+## License
+
+This project is licensed under the ISC License - see the [LICENSE](LICENSE) file for details.
+
+## Support
+
+For support, please open an issue in the GitHub repository.
+
+## Acknowledgments
 
-- Automated Endpoint URI Generation: Effortlessly generate endpoint URIs from your OpenAPI schema.
-- Type Generation: Automatically create all types defined in your API schema, including shared types, for better code consistency.
+- Thanks to the OpenAPI Initiative for the OpenAPI specification
+- Thanks to all contributors and users of this package
 - Flexible CLI Commands: Sync your API at any point in the development process on app start, pre-commit, or via manual triggers.

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) => `IApi${(0, exports.capitalize)(componentName)}`;
-exports.getSharedComponentName = getSharedComponentName;
 const getEndpointDetails = (path, method) => {
     const pathParts = path.split("/");
     let name = `${(0, exports.capitalize)(method)}`;
@@ -105,114 +99,24 @@ const getEndpointDetails = (path, method) => {
     return { name, variables, pathParts };
 };
 exports.getEndpointDetails = getEndpointDetails;
-const parseSchemaToType = (apiDoc, schema, name, isRequired, options) => {
-    let typeName = name ? `\t"${name}"${isRequired ? "" : "?"}: ` : "";
-    let type = "";
-    if (schema) {
-        if (schema.$ref) {
-            if (schema.$ref[0] === "#") {
-                let pathToComponentParts = (schema.$ref || "").split("/");
-                pathToComponentParts.shift();
-                const pathToComponent = pathToComponentParts.join(".");
-                const component = lodash_1.default.get(apiDoc, pathToComponent, null);
-                if (component) {
-                    const 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("&")})`;
+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.items) {
-            type += `${(0, exports.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 += `${(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";
-    }
-    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,28 +213,84 @@ 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 = "";
     let typesFileContent = "";
-    let sharedTypesFileContent = "";
-    if (spec.components && spec.components.schemas) {
-        // Create components (shared) types
-        const components = spec.components.schemas;
-        const contentKeys = Object.keys(components);
-        // only need 1 schema so will us the first schema provided
-        contentKeys.forEach((key) => {
-            const typeCnt = `${(0, helpers_1.parseSchemaToType)(spec, components[key], "", true, {
-                noSharedImport: true,
-            })}`;
-            if (typeCnt) {
-                sharedTypesFileContent += `export type ${(0, helpers_1.getSharedComponentName)(key)} = ${typeCnt};\n`;
+    let sharedTypesFileContent = {};
+    if (spec.components) {
+        Object.keys(spec.components).forEach((key) => {
+            if ([
+                "schemas",
+                "responses",
+                "parameters",
+                "examples",
+                "requestBodies",
+                "headers",
+                "links",
+                "callbacks",
+            ].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;
+                    /*  const schema = (() => {
+                      switch (key) {
+                        case "parameters":
+                          return components[contentKey].schema;
+                        default:
+                          return components[contentKey];
+                      }
+                    })() as IOpenApSchemaSpec; */
+                    const schema = (((_a = components[contentKey]) === null || _a === void 0 ? void 0 : _a.schema)
+                        ? components[contentKey].schema
+                        : components[contentKey]);
+                    const typeCnt = `${parseSchemaToType(spec, schema, "", true, {
+                        noSharedImport: true,
+                        useComponentName: ["parameters"].includes(key),
+                    })}`;
+                    if (typeCnt) {
+                        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";
+                });
             }
         });
     }
@@ -92,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 || "");
             });
@@ -114,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) => {
@@ -145,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) => {
-                    if (param.in === "query" && param.name) {
-                        typeCnt += `${(0, helpers_1.parseSchemaToType)(spec, param.schema, param.name, param.required)}`;
+                parameters.forEach((param, i) => {
+                    if (param.$ref || (param.in === "query" && param.name)) {
+                        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`;
                     }
                 });
             }
@@ -187,21 +444,21 @@ const OpenapiSync = (apiUrl, apiName, refetchInterval) => __awaiter(void 0, void
     yield fs_1.default.promises.mkdir(path_1.default.dirname(endpointsFilePath), { recursive: true });
     // Create the file asynchronously
     yield fs_1.default.promises.writeFile(endpointsFilePath, endpointsFileContent);
-    if (sharedTypesFileContent.length > 0) {
+    if (Object.values(sharedTypesFileContent).length > 0) {
         // Create the necessary directories
         const sharedTypesFilePath = path_1.default.join(rootUsingCwd, folderPath, "types", "shared.ts");
         yield fs_1.default.promises.mkdir(path_1.default.dirname(sharedTypesFilePath), {
             recursive: true,
         });
         // Create the file asynchronously
-        yield fs_1.default.promises.writeFile(sharedTypesFilePath, sharedTypesFileContent);
+        yield fs_1.default.promises.writeFile(sharedTypesFilePath, Object.values(sharedTypesFileContent).join("\n"));
     }
     if (typesFileContent.length > 0) {
         // Create the necessary directories
         const typesFilePath = path_1.default.join(rootUsingCwd, folderPath, "types", "index.ts");
         yield fs_1.default.promises.mkdir(path_1.default.dirname(typesFilePath), { recursive: true });
         // Create the file asynchronously
-        yield fs_1.default.promises.writeFile(typesFilePath, `${sharedTypesFileContent.length > 0
+        yield fs_1.default.promises.writeFile(typesFilePath, `${Object.values(sharedTypesFileContent).length > 0
             ? `import * as  Shared from "./shared";\n\n`
             : ""}${typesFileContent}`);
     }

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.24",
+  "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;
+    };
+  };
+};