openapi-sync 2.1.1 → 2.1.3

package/dist/Openapi-sync/index.js

@@ -118,16 +118,19 @@ const OpenapiSync = (apiUrl, apiName, config, refetchInterval) => __awaiter(void
             else if (schema.anyOf) {
                 type += `(${schema.anyOf
                     .map((v) => parseSchemaToType(apiDoc, v, "", isRequired, options))
+                    .filter((v) => !!v)
                     .join("|")})`;
             }
             else if (schema.oneOf) {
                 type += `(${schema.oneOf
                     .map((v) => parseSchemaToType(apiDoc, v, "", isRequired, options))
+                    .filter((v) => !!v)
                     .join("|")})`;
             }
             else if (schema.allOf) {
                 type += `(${schema.allOf
                     .map((v) => parseSchemaToType(apiDoc, v, "", isRequired, options))
+                    .filter((v) => !!v)
                     .join("&")})`;
             }
             else if (schema.items) {
@@ -161,47 +164,71 @@ const OpenapiSync = (apiUrl, apiName, config, refetchInterval) => __awaiter(void
             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}`;
+                schema.enum
+                    .map((v) => JSON.stringify(v))
+                    .filter((v) => !!v)
+                    .forEach((v, i) => {
+                    type += `${i === 0 ? "" : "|"}${v}`;
                 });
                 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;
+                const handleType = (_type) => {
+                    let typeCnt = "";
+                    if (typeof _type === "string") {
+                        if ([
+                            "string",
+                            "integer",
+                            "number",
+                            "array",
+                            "boolean",
+                            "null",
+                        ].includes(_type)) {
+                            if (["integer", "number"].includes(_type)) {
+                                typeCnt += `number`;
+                            }
+                            else if (_type === "array") {
+                                //Since we would have already parsed the arrays keys above "schema.items" if it exists
+                                typeCnt += "any[]";
+                                /* if (schema.items) {
+                              typeCnt += `${parseSchemaToType(
+                                apiDoc,
+                                schema.items,
+                                "",
+                                false,
+                                options
+                              )}[]`;
+                            } else {
+                              typeCnt += "any[]";
+                            } */
+                            }
+                            else {
+                                typeCnt += _type;
+                            }
+                        }
+                        else if (_type === "object") {
+                            //Since we would have already parsed the object keys above "schema.properties" if it exists
+                            if (schema.additionalProperties) {
+                                typeCnt += `{[k: string]: ${parseSchemaToType(apiDoc, schema.additionalProperties, "", true, options) || "any"}}`;
+                            }
+                            else {
+                                typeCnt += "{[k: string]: any}";
+                            }
+                        }
                     }
-                }
-                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 if (Array.isArray(_type)) {
+                        const arrType = _type.map((v) => handleType(v));
+                        arrType.filter((v) => v !== "");
+                        if (arrType.length > 1)
+                            typeCnt += "(" + arrType.join("|") + ")";
                     }
                     else {
-                        type += "{[k: string]: any}";
+                        typeCnt += "any";
                     }
-                }
+                    return typeCnt;
+                };
+                type = handleType(schema.type);
             }
         }
         else {
@@ -281,25 +308,51 @@ const OpenapiSync = (apiUrl, apiName, config, refetchInterval) => __awaiter(void
                     type += JSON.stringify(schema.example);
                 }
                 else {
-                    if (["string", "integer", "number", "array", "boolean"].includes(schema.type)) {
-                        if (["integer", "number"].includes(schema.type)) {
-                            type += `123`;
-                        }
-                        else if (schema.type === "array") {
-                            //Since we would have already parsed the arrays keys above "schema.items" if it exists
-                            type += "[]";
+                    const handleType = (_type) => {
+                        let typeCnt = "";
+                        if (typeof _type === "string") {
+                            if ([
+                                "string",
+                                "integer",
+                                "number",
+                                "array",
+                                "boolean",
+                                "null",
+                            ].includes(_type)) {
+                                if (["integer", "number"].includes(_type)) {
+                                    typeCnt += `123`;
+                                }
+                                else if (_type === "array") {
+                                    //Since we would have already parsed the arrays keys above "schema.items" if it exists
+                                    typeCnt += "[]";
+                                }
+                                else if (_type === "boolean") {
+                                    typeCnt += `true`;
+                                }
+                                else if (_type === "null") {
+                                    typeCnt += `null`;
+                                }
+                                else {
+                                    typeCnt += `"${_type}"`;
+                                }
+                            }
+                            else if (_type === "object") {
+                                //Since we would have already parsed the object keys above "schema.properties" if it exists
+                                typeCnt += "{}";
+                            }
                         }
-                        else if (schema.type === "boolean") {
-                            type += `true`;
+                        else if (Array.isArray(_type)) {
+                            const arrType = _type.map((v) => handleType(v));
+                            arrType.filter((v) => v !== "");
+                            if (arrType.length > 1)
+                                typeCnt += arrType.join("|");
                         }
                         else {
-                            type += `"${schema.type}"`;
+                            typeCnt += "any";
                         }
-                    }
-                    else if (schema.type === "object") {
-                        //Since we would have already parsed the object keys above "schema.properties" if it exists
-                        type += "{}";
-                    }
+                        return typeCnt;
+                    };
+                    type = handleType(schema.type);
                 }
             }
         }

package/dist/index.js

@@ -16,12 +16,13 @@ exports.Init = void 0;
 const Openapi_sync_1 = __importDefault(require("./Openapi-sync"));
 const dotenv_1 = __importDefault(require("dotenv"));
 const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
 const state_1 = require("./Openapi-sync/state");
 dotenv_1.default.config();
 const rootUsingCwd = process.cwd();
 const Init = (options) => __awaiter(void 0, void 0, void 0, function* () {
     // Load config file
-    let configJS, configJson;
+    let configJS, configJson, configTS;
     try {
         configJS = require(path_1.default.join(rootUsingCwd, "openapi.sync.js"));
     }
@@ -34,7 +35,23 @@ const Init = (options) => __awaiter(void 0, void 0, void 0, function* () {
     catch (e) {
         // console.log(e);
     }
-    const config = configJS || configJson;
+    try {
+        // Check if TypeScript config file exists first
+        const tsConfigPath = path_1.default.join(rootUsingCwd, "openapi.sync.ts");
+        if (fs_1.default.existsSync(tsConfigPath)) {
+            // Register TypeScript loader before requiring the file
+            try {
+                require("esbuild-register");
+            }
+            catch (registerError) {
+                throw registerError;
+            }
+            // Now try to load TypeScript config
+            configTS = require(tsConfigPath);
+        }
+    }
+    catch (e) { }
+    const config = configTS || configJS || configJson;
     const apiNames = Object.keys(config.api);
     const refetchInterval = options &&
         "refetchInterval" in options &&

package/dist/openapi.sync.sample.js

@@ -0,0 +1,60 @@
+"use strict";
+// TypeScript config file for openapi-sync
+// To use this file, install a TypeScript loader:
+// npm install --save-dev esbuild-register  (recommended - fastest & lightest)
+// or: npm install --save-dev tsx
+// or: npm install --save-dev @swc/register
+Object.defineProperty(exports, "__esModule", { value: true });
+const config = {
+    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",
+    },
+    server: 0,
+    types: {
+        name: {
+            prefix: "",
+            format: (source, data) => {
+                if (source === "shared") {
+                    return `${data.name}`;
+                }
+                else if (source === "endpoint") {
+                    return `${data.method.toLowerCase()}${data
+                        .path.replace(/\//g, "_")
+                        .replace(/{|}/g, "")}${data.code}${data.type}`;
+                }
+            },
+        },
+        doc: {
+            disable: true,
+        },
+    },
+    endpoints: {
+        value: {
+            replaceWords: [
+                {
+                    replace: "/api/v\\d/",
+                    with: "",
+                },
+            ],
+            includeServer: true,
+            type: "object",
+        },
+        name: {
+            prefix: "",
+            useOperationId: true,
+            format: ({ method, path, summary, operationId }) => {
+                if (path === "/")
+                    return "root";
+                return path.replace(/\//g, "_").replace(/{|}/g, "");
+            },
+        },
+        doc: {
+            disable: false,
+            showCurl: true,
+        },
+    },
+};
+module.exports = config;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openapi-sync",
-  "version": "2.1.1",
+  "version": "2.1.3",
   "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",
@@ -41,6 +41,7 @@
     "@types/js-yaml": "^4.0.9",
     "@types/lodash": "^4.17.7",
     "@types/node": "^22.1.0",
+    "esbuild-register": "^3.6.0",
     "typescript": "^5.5.4"
   },
   "dependencies": {

package/types.ts

@@ -4,7 +4,15 @@ export type IOpenApiSpec = Record<"openapi", string> & Record<string, any>;
 
 export type IOpenApSchemaSpec = {
   nullable?: boolean;
-  type: "string" | "integer" | "number" | "array" | "object" | "boolean";
+  type:
+    | "string"
+    | "integer"
+    | "number"
+    | "array"
+    | "object"
+    | "boolean"
+    | "null"
+    | any[];
   example?: any;
   enum?: string[];
   format?: string;
@@ -84,7 +92,7 @@ export type IConfig = {
         }
       ) => string | null | undefined;
     };
-    doc: IConfigDoc;
+    doc?: IConfigDoc;
   };
   endpoints?: {
     value?: {
@@ -102,7 +110,7 @@ export type IConfig = {
       prefix?: string;
       useOperationId?: boolean;
     };
-    doc: IConfigDoc;
+    doc?: IConfigDoc;
   };
 };