gg-express 1.0.75 → 1.0.81

package/.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+"editor.formatOnSave": true
+}

package/dist/GGExpress.js

@@ -24,11 +24,20 @@ class GGExpress {
         this.appName = appName;
     }
     rootMethod(method, url, options, ...middlewares) {
-        myExpressRouteList.push({
-            method: method,
-            url: url,
-            requireParams: options.requireParams,
-            responseStructure: options.responseStructure,
+        let tempURL;
+        if (Array.isArray(url)) {
+            tempURL = url;
+        }
+        else {
+            tempURL = [url];
+        }
+        tempURL.map((url) => {
+            myExpressRouteList.push({
+                method: method,
+                url: url,
+                requireParams: options.requireParams,
+                responseStructure: options.responseStructure,
+            });
         });
         return this.express[method](url, (req, res, next) => {
             return next();

package/dist/main.d.ts

@@ -0,0 +1,3 @@
+import GGExpress from "./GGExpress";
+import GGExpressV2 from "./v2/GGExpressV2";
+export { GGExpress, GGExpressV2 };

package/dist/main.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GGExpressV2 = exports.GGExpress = void 0;
+const GGExpress_1 = __importDefault(require("./GGExpress"));
+exports.GGExpress = GGExpress_1.default;
+const GGExpressV2_1 = __importDefault(require("./v2/GGExpressV2"));
+exports.GGExpressV2 = GGExpressV2_1.default;

package/dist/run.test.js

@@ -82,9 +82,7 @@ function run() {
             },
         });
     });
-    ggapp.get(["/api/seed/memo/id",
-        "/api/hotel/memo/id"
-    ], {
+    ggapp.get(["/api/seed/memo/id", "/api/hotel/memo/id"], {
         requireParams: {
             parameter: { files: "string[]" },
             dataType: "arrayObject",

package/dist/staticRouteInterface_hotel.d.ts

@@ -23,6 +23,52 @@ export interface staticRouteInterface_hotel {
                 }[];
             };
         };
+        "/api/seed/memo/id": {
+            requireParams: {
+                parameter: {
+                    files: string[];
+                };
+                data: {
+                    id: number;
+                    name: "A" | "B";
+                }[];
+            };
+            responseStructure: {
+                status: "SUCCESS" | "ERROR";
+                message: string;
+                parameter: {
+                    numberOfPeople: number;
+                    itemName: string;
+                };
+                data: {
+                    id: number;
+                    name: string;
+                }[];
+            };
+        };
+        "/api/hotel/memo/id": {
+            requireParams: {
+                parameter: {
+                    files: string[];
+                };
+                data: {
+                    id: number;
+                    name: "A" | "B";
+                }[];
+            };
+            responseStructure: {
+                status: "SUCCESS" | "ERROR";
+                message: string;
+                parameter: {
+                    numberOfPeople: number;
+                    itemName: string;
+                };
+                data: {
+                    id: number;
+                    name: string;
+                }[];
+            };
+        };
     };
     post: {
         "/api/hotel/item": {

package/dist/v2/GGExpressV2.d.ts

@@ -0,0 +1,38 @@
+import { NextFunction, Request, Response } from "express";
+import Express from "express-serve-static-core";
+import { convertRoot, InputParent } from "./typeResolver";
+export type Method = "get" | "post" | "put" | "delete";
+type ReqByMethod<M extends Method, RQ extends InputParent> = M extends "get" ? convertRoot<MyRequestQuery<RQ>> : convertRoot<MyRequestBody<RQ>>;
+type MyRequestQuery<T extends InputParent> = Request<{}, {}, {}, T, {}>;
+type MyRequestBody<T extends InputParent> = Request<{}, {}, T, {}, {}>;
+type MyResponse<T extends InputParent> = Response<{
+    status: "SUCCESS" | "ERROR" | "SERVER_ERROR";
+    message: string;
+    data: convertRoot<T>;
+}>;
+export default class GGExpressV2<appName extends string> {
+    express: Express.Express;
+    private outputPath;
+    appName: string;
+    constructor(app: Express.Express, appName: appName, outputPath: string[]);
+    private rootMethod;
+    get<RQ extends InputParent, RS extends InputParent>(url: `/api/${appName | "seed"}/${string}` | `/api/${appName | "seed"}/${string}`[], options: {
+        requireParams: RQ;
+        responseStructure: RS;
+    }, ...middlewares: Array<(req: ReqByMethod<"get", RQ>, res: MyResponse<RS>, next: NextFunction) => any>): Express.Express;
+    post<RQ extends InputParent, RS extends InputParent>(url: `/api/${appName | "seed"}/${string}` | `/api/${appName | "seed"}/${string}`[], options: {
+        requireParams: RQ;
+        responseStructure: RS;
+    }, ...middlewares: Array<(req: ReqByMethod<"post", RQ>, res: MyResponse<RS>, next: NextFunction) => any>): Express.Express;
+    put<RQ extends InputParent, RS extends InputParent>(url: `/api/${appName | "seed"}/${string}` | `/api/${appName | "seed"}/${string}`[], options: {
+        requireParams: RQ;
+        responseStructure: RS;
+    }, ...middlewares: Array<(req: ReqByMethod<"put", RQ>, res: MyResponse<RS>, next: NextFunction) => any>): Express.Express;
+    delete<RQ extends InputParent, RS extends InputParent>(url: `/api/${appName | "seed"}/${string}` | `/api/${appName | "seed"}/${string}`[], options: {
+        requireParams: RQ;
+        responseStructure: RS;
+    }, ...middlewares: Array<(req: ReqByMethod<"delete", RQ>, res: MyResponse<RS>, next: NextFunction) => any>): Express.Express;
+    generateAPIFiles(): Promise<void>;
+    private generateStaticRouteFile;
+}
+export {};

package/dist/v2/GGExpressV2.js

@@ -0,0 +1,76 @@
+"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 generateStaticRouteFileV2_1 = require("./generateStaticRouteFileV2");
+const path_1 = __importDefault(require("path"));
+const generateGGApi_v2_1 = require("./generateGGApi_v2");
+const myExpressRouteList = [];
+class GGExpressV2 {
+    constructor(app, appName, outputPath) {
+        this.express = app;
+        this.outputPath = outputPath;
+        this.appName = appName;
+    }
+    rootMethod(method, url, options, ...middlewares) {
+        let tempURL;
+        if (Array.isArray(url)) {
+            tempURL = url;
+        }
+        else {
+            tempURL = [url];
+        }
+        tempURL.map((url) => {
+            myExpressRouteList.push({
+                method: method,
+                url: url,
+                requireParams: options.requireParams,
+                responseStructure: Object.assign({}, options.responseStructure),
+            });
+        });
+        return this.express[method](url, 
+        // Express handler ต้องกว้าง
+        (req, res, next) => next(), 
+        // แต่ middleware ของคุณจะถูก wrap ทีละตัว
+        ...middlewares.map((mw) => ((req, res, next) => mw(req, res, next))));
+    }
+    get(url, options, ...middlewares) {
+        return this.rootMethod("get", url, options, ...middlewares);
+    }
+    post(url, options, ...middlewares) {
+        return this.rootMethod("post", url, options, ...middlewares);
+    }
+    put(url, options, ...middlewares) {
+        return this.rootMethod("put", url, options, ...middlewares);
+    }
+    delete(url, options, ...middlewares) {
+        return this.rootMethod("delete", url, options, ...middlewares);
+    }
+    generateAPIFiles() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.generateStaticRouteFile();
+            console.log(`GGExpressV2.ts : ${this.appName} - generate staticRoute done.`);
+        });
+    }
+    generateStaticRouteFile() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const staticRouteCode = (0, generateStaticRouteFileV2_1.generateStaticRouteFileV2)(this.appName, myExpressRouteList);
+            for (let row of this.outputPath) {
+                fs_1.default.writeFileSync(path_1.default.join(row, `staticRouteInterface_${this.appName}_v2.ts`), staticRouteCode);
+                yield (0, generateGGApi_v2_1.generateGGApi_v2)(this.appName, path_1.default.join(row, `apiConnector_${this.appName}_v2.ts`));
+            }
+        });
+    }
+}
+exports.default = GGExpressV2;

package/dist/v2/generateGGApi_v2.d.ts

@@ -0,0 +1 @@
+export declare function generateGGApi_v2(appName: string, filePathWithFileName: string): void;

package/dist/v2/generateGGApi_v2.js

@@ -0,0 +1,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateGGApi_v2 = generateGGApi_v2;
+const fs_1 = __importDefault(require("fs"));
+function generateGGApi_v2(appName, filePathWithFileName) {
+    const tempInterfaceName = `staticRouteInterface_${appName}_v2`;
+    const code = `
+import axios from "axios"
+import { ${tempInterfaceName} } from "./${tempInterfaceName}"
+
+export class GGApi_v2 {
+  constructor() {}
+
+  get<T extends keyof ${tempInterfaceName}["get"]>(
+    url: T,
+    requireParams: ${tempInterfaceName}["get"][T]["requireParams"]
+  ): Promise<${tempInterfaceName}["get"][T]["responseStructure"]> {
+    return new Promise((resolve, reject) => {
+      axios
+        .get(url as string, { params: { data: requireParams } })
+        .then((response) => {
+          resolve(response.data)
+        })
+        .catch((error) => {
+          reject(error)
+        })
+    })
+  }
+
+  post<T extends keyof ${tempInterfaceName}["post"]>(
+    url: T,
+    requireParams: ${tempInterfaceName}["post"][T]["requireParams"]
+  ): Promise<${tempInterfaceName}["post"][T]["responseStructure"]> {
+    return new Promise((resolve, reject) => {
+      axios
+        .post(url as string, { data: requireParams })
+        .then((response) => {
+          resolve(response.data)
+        })
+        .catch((error) => {
+          reject(error)
+        })
+    })
+  }
+  put<T extends keyof ${tempInterfaceName}["put"]>(
+    url: T,
+    requireParams: ${tempInterfaceName}["put"][T]["requireParams"]
+  ): Promise<${tempInterfaceName}["put"][T]["responseStructure"]> {
+    return new Promise((resolve, reject) => {
+      axios
+        .put(url as string, { data: requireParams })
+        .then((response) => {
+          resolve(response.data)
+        })
+        .catch((error) => {
+          reject(error)
+        })
+    })
+  }
+  delete<T extends keyof ${tempInterfaceName}["delete"]>(
+    url: T,
+    requireParams: ${tempInterfaceName}["delete"][T]["requireParams"]
+  ): Promise<${tempInterfaceName}["delete"][T]["responseStructure"]> {
+    return new Promise((resolve, reject) => {
+      axios
+        .delete(url as string, { data: { data: requireParams } })
+        .then((response) => {
+          resolve(response.data)
+        })
+        .catch((error) => {
+          reject(error)
+        })
+    })
+  }
+}
+`;
+    fs_1.default.writeFileSync(filePathWithFileName, code);
+}

package/dist/v2/generateStaticRouteFileV2.d.ts

@@ -0,0 +1,19 @@
+import { Method } from "./GGExpressV2";
+import { InputParent } from "./typeResolver";
+type routeList = {
+    method: Method;
+    url: string;
+    requireParams: InputParent;
+    responseStructure: InputParent;
+};
+type PrepareRouteStucture = {
+    [K in Method]: {
+        [key in string]: {
+            requireParams: string;
+            responseStructure: string;
+        };
+    };
+};
+export declare function prepareExportInterfaceData(data: routeList[]): PrepareRouteStucture;
+export declare function generateStaticRouteFileV2(appName: string, data: routeList[]): string;
+export {};

package/dist/v2/generateStaticRouteFileV2.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareExportInterfaceData = prepareExportInterfaceData;
+exports.generateStaticRouteFileV2 = generateStaticRouteFileV2;
+function prepareExportInterfaceData(data) {
+    let prepareRoute = {
+        get: {},
+        post: {},
+        put: {},
+        delete: {},
+    };
+    prepareRoute = extract(data, prepareRoute);
+    return prepareRoute;
+}
+function extract(allData, prepareRoute) {
+    for (const route of allData) {
+        prepareRoute[route.method][route.url] = {
+            requireParams: parentInputToCode(route.requireParams),
+            responseStructure: parentInputToCode(route.responseStructure),
+        };
+    }
+    return prepareRoute;
+}
+function parentInputToCode(data) {
+    const recursiveExtract = (target, parentKeyName) => {
+        let result = "";
+        // check nest pimitive -------------------
+        if (typeof target === "string") {
+            const isUndefinedAble = target.includes("?")
+                ? "undefined"
+                : "";
+            const isNullAble = target.includes("~") ? "null" : "";
+            const isArray = target.includes("[]") ? "[]" : "";
+            const varType = target.replace(/\[\]|\?|\~/g, "");
+            let result = [`${varType}`, isUndefinedAble, isNullAble]
+                .filter((row) => row !== "")
+                .join(" | ");
+            if (isArray)
+                result = `(${result})[]`;
+            else
+                result;
+            return `${parentKeyName} : ${result}`;
+        }
+        // check object ---------------------------
+        else if (typeof target === "object" && Array.isArray(target) === false) {
+            const keyList = Object.keys(target);
+            const tempResult = [];
+            for (const keyName of keyList) {
+                //@ts-ignore
+                const recusiveResult = recursiveExtract(target[keyName], keyName);
+                tempResult.push(recusiveResult);
+            }
+            result = `${result} \n ${parentKeyName} : { ${tempResult.join(",")} }`;
+        }
+        // check array ---------------------------
+        else if (Array.isArray(target)) {
+            // enum
+            if (typeof target[0] === "number" ||
+                typeof target[0] === "string" ||
+                target[0] === null ||
+                target[0] === undefined)
+                return `${parentKeyName} : [${target
+                    .map((word) => ` "${word}" `)
+                    .join(",")}] `;
+            // nest or input nest
+            else if (typeof target[0] === "object")
+                for (const row of target) {
+                    result = result + " " + recursiveExtract(row, parentKeyName) + "[] ";
+                }
+        }
+        return `${result}`;
+    };
+    const result = recursiveExtract(data, "data");
+    return `${result} `;
+}
+function generateStaticRouteFileV2(appName, data) {
+    const interfaceName = `staticRouteInterface_${appName}_v2`;
+    const generateEachUrl = (data) => {
+        const keyName = Object.keys(data);
+        return keyName
+            .map((keyName) => `
+            "${keyName}" : {
+            requireParams : { ${data[keyName].requireParams} },
+            responseStructure : { ${data[keyName].responseStructure},    
+            status: "SUCCESS" | "ERROR",
+            message: string } 
+      }`)
+            .join(", ");
+    };
+    const preparedData = prepareExportInterfaceData(data);
+    let code = `
+  export interface ${interfaceName}  {
+    get :  { ${generateEachUrl(preparedData.get)} },
+    post : { ${generateEachUrl(preparedData.post)}  },
+    put : { ${generateEachUrl(preparedData.put)}  },
+    delete : { ${generateEachUrl(preparedData.delete)}  },
+  }
+  `;
+    return code;
+}

package/dist/v2/output/apiConnector_hotel_v2.d.ts

@@ -0,0 +1,8 @@
+import { staticRouteInterface_hotel_v2 } from "./staticRouteInterface_hotel_v2";
+export declare class GGApi_v2 {
+    constructor();
+    get<T extends keyof staticRouteInterface_hotel_v2["get"]>(url: T, requireParams: staticRouteInterface_hotel_v2["get"][T]["requireParams"]): Promise<staticRouteInterface_hotel_v2["get"][T]["responseStructure"]>;
+    post<T extends keyof staticRouteInterface_hotel_v2["post"]>(url: T, requireParams: staticRouteInterface_hotel_v2["post"][T]["requireParams"]): Promise<staticRouteInterface_hotel_v2["post"][T]["responseStructure"]>;
+    put<T extends keyof staticRouteInterface_hotel_v2["put"]>(url: T, requireParams: staticRouteInterface_hotel_v2["put"][T]["requireParams"]): Promise<staticRouteInterface_hotel_v2["put"][T]["responseStructure"]>;
+    delete<T extends keyof staticRouteInterface_hotel_v2["delete"]>(url: T, requireParams: staticRouteInterface_hotel_v2["delete"][T]["requireParams"]): Promise<staticRouteInterface_hotel_v2["delete"][T]["responseStructure"]>;
+}

package/dist/v2/output/apiConnector_hotel_v2.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GGApi_v2 = void 0;
+const axios_1 = __importDefault(require("axios"));
+class GGApi_v2 {
+    constructor() { }
+    get(url, requireParams) {
+        return new Promise((resolve, reject) => {
+            axios_1.default
+                .get(url, { params: { data: requireParams } })
+                .then((response) => {
+                resolve(response.data);
+            })
+                .catch((error) => {
+                reject(error);
+            });
+        });
+    }
+    post(url, requireParams) {
+        return new Promise((resolve, reject) => {
+            axios_1.default
+                .post(url, { data: requireParams })
+                .then((response) => {
+                resolve(response.data);
+            })
+                .catch((error) => {
+                reject(error);
+            });
+        });
+    }
+    put(url, requireParams) {
+        return new Promise((resolve, reject) => {
+            axios_1.default
+                .put(url, { data: requireParams })
+                .then((response) => {
+                resolve(response.data);
+            })
+                .catch((error) => {
+                reject(error);
+            });
+        });
+    }
+    delete(url, requireParams) {
+        return new Promise((resolve, reject) => {
+            axios_1.default
+                .delete(url, { data: { data: requireParams } })
+                .then((response) => {
+                resolve(response.data);
+            })
+                .catch((error) => {
+                reject(error);
+            });
+        });
+    }
+}
+exports.GGApi_v2 = GGApi_v2;

package/dist/v2/output/staticRouteInterface_hotel_v2.d.ts

@@ -0,0 +1,42 @@
+export interface staticRouteInterface_hotel_v2 {
+    get: {
+        "/api/hotel/users/id": {
+            requireParams: {
+                data: {
+                    id: number;
+                };
+            };
+            responseStructure: {
+                data: {
+                    userData: {
+                        id: number;
+                        name: string;
+                    }[];
+                };
+                status: "SUCCESS" | "ERROR";
+                message: string;
+            };
+        };
+    };
+    post: {
+        "/api/hotel/booking/id": {
+            requireParams: {
+                data: {
+                    id: number;
+                };
+            };
+            responseStructure: {
+                data: {
+                    bookingData: {
+                        id: number;
+                        roomNumber: string;
+                    };
+                };
+                status: "SUCCESS" | "ERROR";
+                message: string;
+            };
+        };
+    };
+    put: {};
+    delete: {};
+}

package/dist/v2/output/staticRouteInterface_hotel_v2.js

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

package/dist/v2/run_v2.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/v2/run_v2.test.js

@@ -0,0 +1,78 @@
+"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 express_1 = __importDefault(require("express"));
+const GGExpressV2_1 = __importDefault(require("./GGExpressV2"));
+const typeResolver_1 = require("./typeResolver");
+const apiConnector_hotel_v2_1 = require("./output/apiConnector_hotel_v2");
+// import { GGApi_v2 } from "./output/apiConnector_hotel_v2"
+function run() {
+    const app = (0, express_1.default)();
+    const ggapp = new GGExpressV2_1.default(app, "hotel", ["./output"]);
+    ggapp.get("/api/hotel/users/id", {
+        requireParams: {
+            id: "number",
+        },
+        responseStructure: {
+            userData: (0, typeResolver_1.toArray)({
+                id: "number",
+                name: "string",
+            }),
+        },
+    }, (req, res, next) => {
+        console.log(req.query);
+        return res.json({
+            message: "",
+            status: "SUCCESS",
+            data: { userData: [] },
+        });
+    });
+    ggapp.post("/api/hotel/booking/id", {
+        requireParams: {
+            id: "number",
+        },
+        responseStructure: {
+            bookingData: {
+                id: "number",
+                roomNumber: "string",
+            },
+        },
+    }, (req, res, next) => {
+        console.log(req.query);
+        return res.json({
+            message: "",
+            status: "SUCCESS",
+            data: {
+                bookingData: {
+                    id: 2,
+                    roomNumber: "dd",
+                },
+            },
+        });
+    });
+    app.listen(3002, () => __awaiter(this, void 0, void 0, function* () {
+        yield ggapp.generateAPIFiles();
+        console.log("done");
+        process.exit(0);
+    }));
+}
+run();
+const x = new apiConnector_hotel_v2_1.GGApi_v2();
+x.post("/api/hotel/booking/id", {
+    data: { id: 1 },
+}).then((response) => {
+    response.status === "ERROR";
+    response.data.bookingData;
+    response.data.bookingData.roomNumber;
+});

package/dist/v2/typeResolver.d.ts

@@ -0,0 +1,23 @@
+type BaseType = "string" | "number" | "string[]" | "number[]";
+export type CustomType = BaseType | `${BaseType}?` | `${BaseType}~` | `${BaseType}?~`;
+export type InputNest = {
+    [key in string]: CustomType;
+};
+type InputEnum = string[] | number[];
+export type InputParent = {
+    [key in string]: CustomType | InputNest | InputNest[] | InputParent | InputParent[] | InputEnum;
+};
+type ResolveBase<T extends BaseType> = T extends "string" ? string : T extends "string[]" ? string[] : T extends "number" ? number : T extends "number[]" ? number[] : never;
+export declare const toArray: <T extends InputParent>(input: T) => T[];
+type ResolveType<T> = T extends `${infer B}?~` ? ResolveBase<B & BaseType> | null | undefined : T extends `${infer B}?` ? ResolveBase<B & BaseType> | undefined : T extends `${infer B}~` ? ResolveBase<B & BaseType> | null : ResolveBase<T & BaseType>;
+type convertNest<T> = ResolveType<T>;
+type checkEnum<T> = T extends InputEnum ? T[number] : convertNest<T>;
+type convertChildObjet<T> = {
+    [K in keyof T]: chooseType<T[K]>;
+};
+type convertObject<T> = T extends object ? convertChildObjet<T> : checkEnum<T>;
+type chooseType<T> = T extends InputEnum ? T[number] : convertObject<T>;
+export type convertRoot<T> = {
+    [K in keyof T]: chooseType<T[K]>;
+};
+export {};

package/dist/v2/typeResolver.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toArray = void 0;
+const toArray = (input) => {
+    return [input];
+};
+exports.toArray = toArray;
+// const data = {} as convertRoot<typeof req2>
+// data.booking.bookingStatus
+// data.status
+// const id = data.booking.id
+// const roomNumber = data.booking.bookingStatus === data.booking.bookingStatus
+// data.rooms.map((row) => row.status === "OFF")
+// data.data.level_1.level_2.id
+// data.booking.createTime