openapi-sync 1.0.0 → 1.0.1

package/Openapi-sync/components/helpers.ts

@@ -0,0 +1,150 @@
+import { IOpenApiSpec, IOpenApSchemaSpec } from "../types";
+import { variableNameChar } from "./regex";
+import propertyExpr from "property-expr";
+import * as yaml from "js-yaml";
+
+export const isJson = (value: any) => {
+  return ["object"].includes(typeof value) && !(value instanceof Blob);
+};
+export const isYamlString = (fileContent: string) => {
+  try {
+    yaml.load(fileContent);
+    return true;
+  } catch (en) {
+    const e = en as any;
+    if (e instanceof yaml.YAMLException) {
+      return false;
+    } else {
+      throw e;
+    }
+  }
+};
+
+export const yamlStringToJson = (fileContent: string) => {
+  if (isYamlString(fileContent)) {
+    const content = yaml.load(fileContent);
+
+    const jsonString = JSON.stringify(content, null, 2);
+    const json = JSON.parse(jsonString);
+    return json;
+  }
+};
+
+export const capitalize = (text: string) => {
+  const capitalizedWord =
+    text.substring(0, 1).toUpperCase() + text.substring(1);
+  return capitalizedWord;
+};
+
+export const getSharedComponentName = (componentName: string) =>
+  `IApi${capitalize(componentName)}`;
+
+export const getEndpointDetails = (path: string, method: string) => {
+  const pathParts = path.split("/");
+  let name = `${capitalize(method)}`;
+  const variables: string[] = [];
+  pathParts.forEach((part) => {
+    // check if part is a variable
+    if (part[0] === "{" && part[part.length - 1] === "}") {
+      const s = part.replace(/{/, "").replace(/}/, "");
+      variables.push(s);
+      part = `$${s}`;
+    }
+
+    // parse to variable name
+    let partVal = "";
+    part.split("").forEach((char) => {
+      let c = char;
+      if (!variableNameChar.test(char)) c = "/";
+      partVal += c;
+    });
+
+    partVal.split("/").forEach((val) => {
+      name += capitalize(val);
+    });
+  });
+
+  return { name, variables, pathParts };
+};
+
+export const parseSchemaToType = (
+  apiDoc: IOpenApiSpec,
+  schema: IOpenApSchemaSpec,
+  name: string,
+  isRequired?: boolean,
+  options?: {
+    noSharedImport?: boolean;
+  }
+) => {
+  let typeName = name ? `\t${name}${isRequired ? "" : "?"}: ` : "";
+  let type = "";
+  if (schema.$ref) {
+    if (schema.$ref[0] === "#") {
+      let pathToComponentParts = (schema.$ref || "").split("/");
+      pathToComponentParts.shift();
+      const pathToComponent = pathToComponentParts.join(".");
+      const component = propertyExpr.getter(pathToComponent)(
+        apiDoc
+      ) as IOpenApSchemaSpec;
+
+      if (component) {
+        const componentName =
+          pathToComponentParts[pathToComponentParts.length - 1];
+        // Reference component via import instead of parsing
+        type += `${
+          options?.noSharedImport ? "" : "Shared."
+        }${getSharedComponentName(componentName)}`;
+        // type += `${parseSchemaToType(apiDoc, component, "", isRequired)}`;
+      }
+    } else {
+      type += "";
+      //TODO $ref is a uri - use axios to fetch doc
+    }
+  } 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"].includes(schema.type)) {
+      if (schema.type === "string") {
+        type += `string`;
+      } else if (["integer", "number"].includes(schema.type)) {
+        type += `number`;
+      } else if (schema.type === "array") {
+        if (schema.items) {
+          type += `${parseSchemaToType(
+            apiDoc,
+            schema.items,
+            "",
+            false,
+            options
+          )}[]`;
+        } else {
+          type += "any[]";
+        }
+      }
+    } else if (schema.type === "object") {
+      if (schema.properties) {
+        //parse object key one at a time
+        const objKeys = Object.keys(schema.properties);
+        const requiredKeys = schema.required || [];
+        type += "{\n";
+        objKeys.forEach((key) => {
+          type += `${parseSchemaToType(
+            apiDoc,
+            schema.properties?.[key] as IOpenApSchemaSpec,
+            key,
+            requiredKeys.includes(key),
+            options
+          )}`;
+        });
+        type += "}";
+      }
+    }
+  }
+
+  return type.length > 0 ? `${typeName}${type}${name ? ";\n" : ""}` : "";
+};

package/Openapi-sync/components/regex.ts

@@ -0,0 +1,2 @@
+export const variableName = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+export const variableNameChar = /[A-Za-z0-9_$]/;

package/Openapi-sync/index.ts

@@ -0,0 +1,252 @@
+import fs from "fs";
+import path from "path";
+import {
+  getEndpointDetails,
+  getSharedComponentName,
+  isJson,
+  isYamlString,
+  parseSchemaToType,
+  yamlStringToJson,
+} from "./components/helpers";
+import {
+  IOpenApiMediaTypeSpec,
+  IOpenApiParameterSpec,
+  IOpenApiRequestBodySpec,
+  IOpenApiResponseSpec,
+  IOpenApiSpec,
+  IOpenApSchemaSpec,
+} from "./types";
+import { isEqual } from "lodash";
+import axios from "axios";
+import axiosRetry from "axios-retry";
+import { bundleFromString, createConfig } from "@redocly/openapi-core";
+import { getState, setState } from "./state";
+
+const rootUsingCwd = process.cwd();
+let fetchTimeout: null | NodeJS.Timeout = null;
+
+// Create an Axios instance
+const apiClient = axios.create({
+  timeout: 30000, // Timeout after 30 seconds
+});
+
+// Configure axios-retry
+axiosRetry(apiClient, {
+  retries: 20, // Number of retry attempts
+  retryCondition: (error) => {
+    // Retry on network error
+    return (
+      error.code === "ECONNABORTED" || error.message.includes("Network Error")
+    );
+  },
+  retryDelay: (retryCount) => {
+    return retryCount * 1000; // Exponential back-off: 1s, 2s, 3s, etc.
+  },
+});
+
+const OpenapiSync = async (apiUrl: string, apiName: string) => {
+  const specResponse = await apiClient.get(apiUrl);
+
+  const redoclyConfig = await createConfig({
+    extends: ["minimal"],
+  });
+
+  const source = JSON.stringify(
+    isJson(specResponse.data)
+      ? specResponse.data
+      : yamlStringToJson(specResponse.data)
+  );
+
+  const lintResults = await bundleFromString({
+    source,
+    config: redoclyConfig,
+  });
+
+  // Load config file
+  const config = require(path.join(rootUsingCwd, "openapi.sync.json"));
+  const folderPath = path.join(config.folder || "", apiName);
+
+  const spec: IOpenApiSpec = lintResults.bundle.parsed;
+  // auto update only on dev
+  if (
+    !(
+      process.env.NODE_ENV &&
+      ["production", "prod", "test", "staging"].includes(process.env.NODE_ENV)
+    )
+  ) {
+    // compare new spec with old spec, continuing only if spec it different
+    // auto sync at interval
+    if (fetchTimeout) clearTimeout(fetchTimeout);
+
+    if (!isNaN(config.refetchInterval) && config.refetchInterval) {
+      // use config interval or 1 hour
+      fetchTimeout = setTimeout(
+        () => OpenapiSync(apiUrl, apiName),
+        config.refetchInterval || 60000
+      );
+    }
+
+    const prevSpec = getState(apiName);
+    if (isEqual(prevSpec, spec)) return;
+
+    setState(apiName, spec);
+  }
+
+  let endpointsFileContent = "";
+  let typesFileContent = "";
+  let sharedTypesFileContent = "";
+
+  if (spec.components && spec.components.schemas) {
+    // Create components (shared) types
+    const components: Record<string, IOpenApiMediaTypeSpec> =
+      spec.components.schemas;
+    const contentKeys = Object.keys(components);
+    // only need 1 schema so will us the first schema provided
+    contentKeys.forEach((key) => {
+      const typeCnt = `${parseSchemaToType(
+        spec,
+        components[key] as IOpenApSchemaSpec,
+        "",
+        true,
+        {
+          noSharedImport: true,
+        }
+      )}`;
+      if (typeCnt) {
+        sharedTypesFileContent += `export type ${getSharedComponentName(
+          key
+        )} = ${typeCnt};\n`;
+      }
+    });
+  }
+
+  const getBodySchemaType = (requestBody: IOpenApiRequestBodySpec) => {
+    let typeCnt = "";
+    if (requestBody.content) {
+      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 += `${parseSchemaToType(
+          spec,
+          requestBody.content[contentKeys[0]].schema as IOpenApSchemaSpec,
+          ""
+        )}`;
+      }
+    }
+    return typeCnt;
+  };
+
+  Object.keys(spec.paths || {}).forEach((endpointPath) => {
+    const endpointSpec = spec.paths[endpointPath];
+    const endpointMethods = Object.keys(endpointSpec);
+    endpointMethods.forEach((method: string) => {
+      const endpoint = getEndpointDetails(endpointPath, method);
+
+      const endpointUrlTxt = endpoint.pathParts
+        .map((part) => {
+          // check if part is a variable
+          if (part[0] === "{" && part[part.length - 1] === "}") {
+            const s = part.replace(/{/, "").replace(/}/, "");
+            part = `\${${s}}`;
+          }
+          return part;
+        })
+        .join("/");
+
+      let endpointUrl = `"${endpointUrlTxt}"`;
+      if (endpoint.variables.length > 0) {
+        const params = endpoint.variables.map((v) => `${v}:string`).join(",");
+        endpointUrl = `(${params})=> \`${endpointUrlTxt}\``;
+      }
+      // Add the endpoint url
+      endpointsFileContent += `export const ${endpoint.name} = ${endpointUrl}; 
+`;
+
+      if (endpointSpec[method]?.parameters) {
+        // create query parameters types
+        const parameters: IOpenApiParameterSpec[] =
+          endpointSpec[method]?.parameters;
+        let typeCnt = "";
+        parameters.forEach((param) => {
+          if (param.in === "query" && param.name) {
+            typeCnt += `${parseSchemaToType(
+              spec,
+              param.schema as any,
+              param.name,
+              param.required
+            )}`;
+          }
+        });
+
+        if (typeCnt) {
+          typesFileContent += `export type I${endpoint.name}Query = {\n${typeCnt}};\n`;
+        }
+      }
+
+      if (endpointSpec[method]?.requestBody) {
+        //create requestBody types
+        const requestBody: IOpenApiRequestBodySpec =
+          endpointSpec[method]?.requestBody;
+
+        let typeCnt = getBodySchemaType(requestBody);
+        if (typeCnt) {
+          typesFileContent += `export type I${endpoint.name}DTO = ${typeCnt};\n`;
+        }
+      }
+
+      if (endpointSpec[method]?.responses) {
+        // create request response types
+        const responses: IOpenApiResponseSpec = endpointSpec[method]?.responses;
+        const resCodes = Object.keys(responses);
+        resCodes.forEach((code) => {
+          let typeCnt = getBodySchemaType(responses[code]);
+          if (typeCnt) {
+            typesFileContent += `export type I${endpoint.name}${code}Response = ${typeCnt};\n`;
+          }
+        });
+      }
+    });
+  });
+
+  // Create the necessary directories
+  const endpointsFilePath = path.join(rootUsingCwd, folderPath, "endpoints.ts");
+  await fs.promises.mkdir(path.dirname(endpointsFilePath), { recursive: true });
+  // Create the file asynchronously
+  await fs.promises.writeFile(endpointsFilePath, endpointsFileContent);
+
+  if (sharedTypesFileContent.length > 0) {
+    // Create the necessary directories
+    const sharedTypesFilePath = path.join(
+      rootUsingCwd,
+      folderPath,
+      "types",
+      "shared.ts"
+    );
+    await fs.promises.mkdir(path.dirname(sharedTypesFilePath), {
+      recursive: true,
+    });
+    // Create the file asynchronously
+    await fs.promises.writeFile(sharedTypesFilePath, sharedTypesFileContent);
+  }
+
+  if (typesFileContent.length > 0) {
+    // Create the necessary directories
+    const typesFilePath = path.join(
+      rootUsingCwd,
+      folderPath,
+      "types",
+      "index.ts"
+    );
+    await fs.promises.mkdir(path.dirname(typesFilePath), { recursive: true });
+    // Create the file asynchronously
+    await fs.promises.writeFile(
+      typesFilePath,
+      `${
+        sharedTypesFileContent.length > 0
+          ? `import * as  Shared from "./shared";\n\n`
+          : ""
+      }${typesFileContent}`
+    );
+  }
+};
+export default OpenapiSync;

package/Openapi-sync/state.ts

@@ -0,0 +1,15 @@
+import { IOpenApiSpec } from "./types";
+
+let state: Record<string, IOpenApiSpec> = {};
+
+export const setState = (key: string, value: IOpenApiSpec) => {
+  state[key] = value;
+};
+
+export const getState = (key: string): IOpenApiSpec | undefined => {
+  return state[key];
+};
+
+export const resetState = () => {
+  state = {};
+};

package/Openapi-sync/types.ts

@@ -0,0 +1,43 @@
+export type IOpenApiSpec = Record<"openapi", string> & Record<string, any>;
+
+export type IOpenApSchemaSpec = {
+  type: "string" | "integer" | "number" | "array" | "object";
+  example?: any;
+  enum?: string[];
+  format?: string;
+  items?: IOpenApSchemaSpec;
+  required?: string[];
+  $ref?: string;
+  properties?: Record<string, IOpenApSchemaSpec>;
+};
+
+export type IOpenApiParameterSpec = {
+  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>;

package/README.md

@@ -0,0 +1,14 @@
+## Install Openapi-sync
+
+`npm i openapi-sync`
+
+## Add a Openapi-sync config file
+
+Add a `openapi.sync.json` file at the root of your project (check out `openapi.sync.sample.json`)
+
+## import `openapi-sync`
+
+import openapi-sync anywhere in your project (preferably the entry point)  
+`import 'openapi-sync'`
+
+## Run your app

package/bin/cli

@@ -0,0 +1,4 @@
+#!/usr/bin/env sh
+
+
+npm run start

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

@@ -0,0 +1,159 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __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;
+const regex_1 = require("./regex");
+const property_expr_1 = __importDefault(require("property-expr"));
+const yaml = __importStar(require("js-yaml"));
+const isJson = (value) => {
+    return ["object"].includes(typeof value) && !(value instanceof Blob);
+};
+exports.isJson = isJson;
+const isYamlString = (fileContent) => {
+    try {
+        yaml.load(fileContent);
+        return true;
+    }
+    catch (en) {
+        const e = en;
+        if (e instanceof yaml.YAMLException) {
+            return false;
+        }
+        else {
+            throw e;
+        }
+    }
+};
+exports.isYamlString = isYamlString;
+const yamlStringToJson = (fileContent) => {
+    if ((0, exports.isYamlString)(fileContent)) {
+        const content = yaml.load(fileContent);
+        const jsonString = JSON.stringify(content, null, 2);
+        const json = JSON.parse(jsonString);
+        return json;
+    }
+};
+exports.yamlStringToJson = yamlStringToJson;
+const capitalize = (text) => {
+    const capitalizedWord = text.substring(0, 1).toUpperCase() + text.substring(1);
+    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)}`;
+    const variables = [];
+    pathParts.forEach((part) => {
+        // check if part is a variable
+        if (part[0] === "{" && part[part.length - 1] === "}") {
+            const s = part.replace(/{/, "").replace(/}/, "");
+            variables.push(s);
+            part = `$${s}`;
+        }
+        // parse to variable name
+        let partVal = "";
+        part.split("").forEach((char) => {
+            let c = char;
+            if (!regex_1.variableNameChar.test(char))
+                c = "/";
+            partVal += c;
+        });
+        partVal.split("/").forEach((val) => {
+            name += (0, exports.capitalize)(val);
+        });
+    });
+    return { name, variables, pathParts };
+};
+exports.getEndpointDetails = getEndpointDetails;
+const parseSchemaToType = (apiDoc, schema, name, isRequired, options) => {
+    let typeName = name ? `\t${name}${isRequired ? "" : "?"}: ` : "";
+    let type = "";
+    if (schema.$ref) {
+        if (schema.$ref[0] === "#") {
+            let pathToComponentParts = (schema.$ref || "").split("/");
+            pathToComponentParts.shift();
+            const pathToComponent = pathToComponentParts.join(".");
+            const component = property_expr_1.default.getter(pathToComponent)(apiDoc);
+            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.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"].includes(schema.type)) {
+            if (schema.type === "string") {
+                type += `string`;
+            }
+            else if (["integer", "number"].includes(schema.type)) {
+                type += `number`;
+            }
+            else if (schema.type === "array") {
+                if (schema.items) {
+                    type += `${(0, exports.parseSchemaToType)(apiDoc, schema.items, "", false, options)}[]`;
+                }
+                else {
+                    type += "any[]";
+                }
+            }
+        }
+        else if (schema.type === "object") {
+            if (schema.properties) {
+                //parse object key one at a time
+                const objKeys = Object.keys(schema.properties);
+                const requiredKeys = schema.required || [];
+                type += "{\n";
+                objKeys.forEach((key) => {
+                    var _a;
+                    type += `${(0, exports.parseSchemaToType)(apiDoc, (_a = schema.properties) === null || _a === void 0 ? void 0 : _a[key], key, requiredKeys.includes(key), options)}`;
+                });
+                type += "}";
+            }
+        }
+    }
+    return type.length > 0 ? `${typeName}${type}${name ? ";\n" : ""}` : "";
+};
+exports.parseSchemaToType = parseSchemaToType;

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

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.variableNameChar = exports.variableName = void 0;
+exports.variableName = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+exports.variableNameChar = /[A-Za-z0-9_$]/;

package/dist/Openapi-sync/index.js

@@ -0,0 +1,182 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const helpers_1 = require("./components/helpers");
+const lodash_1 = require("lodash");
+const axios_1 = __importDefault(require("axios"));
+const axios_retry_1 = __importDefault(require("axios-retry"));
+const openapi_core_1 = require("@redocly/openapi-core");
+const state_1 = require("./state");
+const rootUsingCwd = process.cwd();
+let fetchTimeout = null;
+// Create an Axios instance
+const apiClient = axios_1.default.create({
+    timeout: 30000, // Timeout after 30 seconds
+});
+// Configure axios-retry
+(0, axios_retry_1.default)(apiClient, {
+    retries: 20, // Number of retry attempts
+    retryCondition: (error) => {
+        // Retry on network error
+        return (error.code === "ECONNABORTED" || error.message.includes("Network Error"));
+    },
+    retryDelay: (retryCount) => {
+        return retryCount * 1000; // Exponential back-off: 1s, 2s, 3s, etc.
+    },
+});
+const OpenapiSync = (apiUrl, apiName) => __awaiter(void 0, void 0, void 0, function* () {
+    const specResponse = yield apiClient.get(apiUrl);
+    const redoclyConfig = yield (0, openapi_core_1.createConfig)({
+        extends: ["minimal"],
+    });
+    const source = JSON.stringify((0, helpers_1.isJson)(specResponse.data)
+        ? specResponse.data
+        : (0, helpers_1.yamlStringToJson)(specResponse.data));
+    const lintResults = yield (0, openapi_core_1.bundleFromString)({
+        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;
+    // auto update only on dev
+    if (!(process.env.NODE_ENV &&
+        ["production", "prod", "test", "staging"].includes(process.env.NODE_ENV))) {
+        // compare new spec with old spec, continuing only if spec it different
+        // auto sync at interval
+        if (fetchTimeout)
+            clearTimeout(fetchTimeout);
+        if (!isNaN(config.refetchInterval) && config.refetchInterval) {
+            // use config interval or 1 hour
+            fetchTimeout = setTimeout(() => OpenapiSync(apiUrl, apiName), config.refetchInterval || 60000);
+        }
+        const prevSpec = (0, state_1.getState)(apiName);
+        if ((0, lodash_1.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`;
+            }
+        });
+    }
+    const getBodySchemaType = (requestBody) => {
+        let typeCnt = "";
+        if (requestBody.content) {
+            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, "")}`;
+            }
+        }
+        return typeCnt;
+    };
+    Object.keys(spec.paths || {}).forEach((endpointPath) => {
+        const endpointSpec = spec.paths[endpointPath];
+        const endpointMethods = Object.keys(endpointSpec);
+        endpointMethods.forEach((method) => {
+            var _a, _b, _c, _d, _e, _f;
+            const endpoint = (0, helpers_1.getEndpointDetails)(endpointPath, method);
+            const endpointUrlTxt = endpoint.pathParts
+                .map((part) => {
+                // check if part is a variable
+                if (part[0] === "{" && part[part.length - 1] === "}") {
+                    const s = part.replace(/{/, "").replace(/}/, "");
+                    part = `\${${s}}`;
+                }
+                return part;
+            })
+                .join("/");
+            let endpointUrl = `"${endpointUrlTxt}"`;
+            if (endpoint.variables.length > 0) {
+                const params = endpoint.variables.map((v) => `${v}:string`).join(",");
+                endpointUrl = `(${params})=> \`${endpointUrlTxt}\``;
+            }
+            // Add the endpoint url
+            endpointsFileContent += `export const ${endpoint.name} = ${endpointUrl}; 
+`;
+            if ((_a = endpointSpec[method]) === null || _a === void 0 ? void 0 : _a.parameters) {
+                // create query parameters types
+                const parameters = (_b = endpointSpec[method]) === null || _b === void 0 ? void 0 : _b.parameters;
+                let typeCnt = "";
+                parameters.forEach((param) => {
+                    if (param.in === "query" && param.name) {
+                        typeCnt += `${(0, helpers_1.parseSchemaToType)(spec, param.schema, param.name, param.required)}`;
+                    }
+                });
+                if (typeCnt) {
+                    typesFileContent += `export type I${endpoint.name}Query = {\n${typeCnt}};\n`;
+                }
+            }
+            if ((_c = endpointSpec[method]) === null || _c === void 0 ? void 0 : _c.requestBody) {
+                //create requestBody types
+                const requestBody = (_d = endpointSpec[method]) === null || _d === void 0 ? void 0 : _d.requestBody;
+                let typeCnt = getBodySchemaType(requestBody);
+                if (typeCnt) {
+                    typesFileContent += `export type I${endpoint.name}DTO = ${typeCnt};\n`;
+                }
+            }
+            if ((_e = endpointSpec[method]) === null || _e === void 0 ? void 0 : _e.responses) {
+                // create request response types
+                const responses = (_f = endpointSpec[method]) === null || _f === void 0 ? void 0 : _f.responses;
+                const resCodes = Object.keys(responses);
+                resCodes.forEach((code) => {
+                    let typeCnt = getBodySchemaType(responses[code]);
+                    if (typeCnt) {
+                        typesFileContent += `export type I${endpoint.name}${code}Response = ${typeCnt};\n`;
+                    }
+                });
+            }
+        });
+    });
+    // Create the necessary directories
+    const endpointsFilePath = path_1.default.join(rootUsingCwd, folderPath, "endpoints.ts");
+    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) {
+        // 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);
+    }
+    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
+            ? `import * as  Shared from "./shared";\n\n`
+            : ""}${typesFileContent}`);
+    }
+});
+exports.default = OpenapiSync;

package/dist/Openapi-sync/state.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resetState = exports.getState = exports.setState = void 0;
+let state = {};
+const setState = (key, value) => {
+    state[key] = value;
+};
+exports.setState = setState;
+const getState = (key) => {
+    return state[key];
+};
+exports.getState = getState;
+const resetState = () => {
+    state = {};
+};
+exports.resetState = resetState;

package/dist/Openapi-sync/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/index.js

@@ -1,6 +1,32 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.add = add;
-function add(x, y) {
-    return x + y;
-}
+const Openapi_sync_1 = __importDefault(require("./Openapi-sync"));
+const dotenv_1 = __importDefault(require("dotenv"));
+const path_1 = __importDefault(require("path"));
+const state_1 = require("./Openapi-sync/state");
+dotenv_1.default.config();
+const rootUsingCwd = process.cwd();
+const Init = () => __awaiter(void 0, void 0, void 0, function* () {
+    // Load config file
+    const config = require(path_1.default.join(rootUsingCwd, "openapi.sync.json"));
+    const apiNames = Object.keys(config.api);
+    (0, state_1.resetState)();
+    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);
+    }
+});
+Init();

package/index.d.ts

@@ -0,0 +1 @@
+export * from "./Openapi-sync/types";

package/index.ts

@@ -1,3 +1,24 @@
-export function add(x: number, y: number): number {
-  return x + y;
-}
+import OpenapiSync from "./Openapi-sync";
+import dotenv from "dotenv";
+import path from "path";
+import { resetState } from "./Openapi-sync/state";
+
+dotenv.config();
+
+const rootUsingCwd = process.cwd();
+
+const Init = async () => {
+  // Load config file
+  const config = require(path.join(rootUsingCwd, "openapi.sync.json"));
+  const apiNames = Object.keys(config.api);
+
+  resetState();
+  for (let i = 0; i < apiNames.length; i += 1) {
+    const apiName = apiNames[i];
+    const apiUrl = config.api[apiName];
+
+    OpenapiSync(apiUrl, apiName);
+  }
+};
+
+Init();

package/openapi.sync.sample.json

@@ -0,0 +1,8 @@
+{
+  "refetchInterval": 5000,
+  "folder": "inputed/path",
+  "api": {
+    "example1": "https://raw.githubusercontent.com/OAI/OpenAPI-Specification/main/examples/v3.0/petstore.json",
+    "example2": "https://raw.githubusercontent.com/OAI/OpenAPI-Specification/main/examples/v3.0/petstore.yaml"
+  }
+}

package/package.json

@@ -1,17 +1,34 @@
 {
   "name": "openapi-sync",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "sync openapi variables",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "bin": {
+    "openapi-sync": "./bin/cli"
+  },
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
-    "build": "tsc"
+    "build": "tsc",
+    "publish": "npm run build && npm version patch && npm publish",
+    "start": "ts-node index.ts"
   },
   "author": "P-Technologies",
   "license": "ISC",
   "devDependencies": {
+    "@types/js-yaml": "^4.0.9",
+    "@types/lodash": "^4.17.7",
     "@types/node": "^22.1.0",
+    "ts-node": "^10.9.2",
     "typescript": "^5.5.4"
+  },
+  "dependencies": {
+    "@redocly/openapi-core": "^1.19.0",
+    "axios": "^1.7.3",
+    "axios-retry": "^4.5.0",
+    "dotenv": "^16.4.5",
+    "js-yaml": "^4.1.0",
+    "lodash": "^4.17.21",
+    "property-expr": "^2.0.6"
   }
 }

package/tsconfig.json

@@ -39,7 +39,7 @@
     // "resolvePackageJsonExports": true,                /* Use the package.json 'exports' field when resolving package imports. */
     // "resolvePackageJsonImports": true,                /* Use the package.json 'imports' field when resolving imports. */
     // "customConditions": [],                           /* Conditions to set in addition to the resolver-specific defaults when resolving imports. */
-    // "resolveJsonModule": true,                        /* Enable importing .json files. */
+    "resolveJsonModule": true,                           /* Enable importing .json files. */
     // "allowArbitraryExtensions": true,                 /* Enable importing files with any extension, provided a declaration file is present. */
     // "noResolve": true,                                /* Disallow 'import's, 'require's or '<reference>'s from expanding the number of files TypeScript should add to a project. */