gg-express 1.0.79 → 1.0.83

package/src/v2/GGExpressV2.ts

@@ -0,0 +1,192 @@
+import { NextFunction, Request, Response } from "express"
+import Express from "express-serve-static-core"
+import fs from "fs"
+import { convertRoot, InputParent } from "./typeResolver"
+import { generateStaticRouteFileV2 } from "./generateStaticRouteFileV2"
+import path from "path"
+import { generateGGApi_v2 } from "./generateGGApi_v2"
+
+type Unarray<T> = T extends (infer U)[] ? U : T
+export type Method = "get" | "post" | "put" | "delete"
+
+type MyRequest<M extends Method, RQ extends InputParent> = M extends "get"
+  ? //get
+    convertRoot<MyRequestQuery<RQ>>
+  : // post, put, delete
+    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>
+}>
+
+const myExpressRouteList: {
+  method: "get" | "post" | "put" | "delete"
+  url: string
+  requireParams: InputParent
+  responseStructure: InputParent
+}[] = []
+
+export default class GGExpressV2<appName extends string> {
+  public express: Express.Express
+  private outputPath: string[]
+  appName: string
+  constructor(app: Express.Express, appName: appName, outputPath: string[]) {
+    this.express = app
+    this.outputPath = outputPath
+    this.appName = appName
+  }
+
+  private rootMethod<
+    M extends Method,
+    RQ extends InputParent,
+    RS extends InputParent
+  >(
+    method: M,
+    url: string | string[],
+    options: {
+      requireParams: RQ
+      responseStructure: RS
+    },
+    ...middlewares: Array<
+      (
+        req: MyRequest<M, RQ>,
+        res: MyResponse<RS>,
+        next: NextFunction
+      ) => void | Promise<void>
+    >
+  ): Express.Express {
+    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,
+      // Express handler ต้องกว้าง
+      (req: Request, res: Response, next: NextFunction) => next(),
+
+      // แต่ middleware ของคุณจะถูก wrap ทีละตัว
+      ...middlewares.map(
+        (mw) =>
+          ((req: Request, res: Response, next: NextFunction) =>
+            mw(
+              req as unknown as MyRequest<M, RQ>,
+              res as MyResponse<RS>,
+              next
+            )) as Express.RequestHandler
+      )
+    )
+  }
+  get<RQ extends InputParent, RS extends InputParent>(
+    url:
+      | `/api/${appName | "seed"}/${string}`
+      | `/api/${appName | "seed"}/${string}`[],
+    options: {
+      requireParams: RQ
+      responseStructure: RS
+    },
+    ...middlewares: Array<
+      (
+        req: MyRequest<"get", RQ>,
+        res: MyResponse<RS>,
+        next: NextFunction
+      ) => any
+    >
+  ) {
+    return this.rootMethod("get", url, options, ...middlewares)
+  }
+
+  post<RQ extends InputParent, RS extends InputParent>(
+    url:
+      | `/api/${appName | "seed"}/${string}`
+      | `/api/${appName | "seed"}/${string}`[],
+    options: {
+      requireParams: RQ
+      responseStructure: RS
+    },
+    ...middlewares: Array<
+      (
+        req: MyRequest<"post", RQ>,
+        res: MyResponse<RS>,
+        next: NextFunction
+      ) => any
+    >
+  ) {
+    return this.rootMethod("post", url, options, ...middlewares)
+  }
+  put<RQ extends InputParent, RS extends InputParent>(
+    url:
+      | `/api/${appName | "seed"}/${string}`
+      | `/api/${appName | "seed"}/${string}`[],
+    options: {
+      requireParams: RQ
+      responseStructure: RS
+    },
+    ...middlewares: Array<
+      (
+        req: MyRequest<"put", RQ>,
+        res: MyResponse<RS>,
+        next: NextFunction
+      ) => any
+    >
+  ) {
+    return this.rootMethod("put", url, options, ...middlewares)
+  }
+  delete<RQ extends InputParent, RS extends InputParent>(
+    url:
+      | `/api/${appName | "seed"}/${string}`
+      | `/api/${appName | "seed"}/${string}`[],
+    options: {
+      requireParams: RQ
+      responseStructure: RS
+    },
+    ...middlewares: Array<
+      (
+        req: MyRequest<"delete", RQ>,
+        res: MyResponse<RS>,
+        next: NextFunction
+      ) => any
+    >
+  ) {
+    return this.rootMethod("delete", url, options, ...middlewares)
+  }
+  public async generateAPIFiles() {
+    await this.generateStaticRouteFile()
+    console.log(`GGExpressV2.ts : ${this.appName} - generate staticRoute done.`)
+  }
+
+  private async generateStaticRouteFile() {
+    const staticRouteCode = generateStaticRouteFileV2(
+      this.appName,
+      myExpressRouteList
+    )
+
+    for (let row of this.outputPath) {
+      fs.writeFileSync(
+        path.join(row, `staticRouteInterface_${this.appName}_v2.ts`),
+        staticRouteCode
+      )
+      await generateGGApi_v2(
+        this.appName,
+        path.join(row, `apiConnector_${this.appName}_v2.ts`)
+      )
+    }
+  }
+}

package/src/v2/generateGGApi_v2.ts

@@ -0,0 +1,79 @@
+import fs from "fs"
+
+export function generateGGApi_v2(
+  appName: string,
+  filePathWithFileName: string
+) {
+  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: 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.writeFileSync(filePathWithFileName, code)
+}

package/src/v2/generateStaticRouteFileV2.ts

@@ -0,0 +1,127 @@
+import { Method } from "./GGExpressV2"
+import { CustomType, InputNest, InputParent, toArray } from "./typeResolver"
+import fs from "fs"
+type routeList = {
+  method: Method
+  url: string
+  requireParams: InputParent
+  responseStructure: InputParent
+}
+
+type PrepareRouteStucture = {
+  [K in Method]: {
+    [key in string]: {
+      requireParams: string
+      responseStructure: string
+    }
+  }
+}
+
+type MyResponse = {
+  [url in string]: {}
+}
+export function prepareExportInterfaceData(data: routeList[]) {
+  let prepareRoute: PrepareRouteStucture = {
+    get: {},
+    post: {},
+    put: {},
+    delete: {},
+  }
+  prepareRoute = extract(data, prepareRoute)
+  return prepareRoute
+}
+function extract(
+  allData: routeList[],
+  prepareRoute: PrepareRouteStucture
+): PrepareRouteStucture {
+  for (const route of allData) {
+    prepareRoute[route.method][route.url] = {
+      requireParams: parentInputToCode(route.requireParams),
+      responseStructure: parentInputToCode(route.responseStructure),
+    }
+  }
+
+  return prepareRoute
+}
+
+function parentInputToCode(data: InputParent) {
+  const recursiveExtract = (target: InputParent, parentKeyName: string) => {
+    let result = ""
+    // check nest pimitive -------------------
+    if (typeof target === "string") {
+      const isUndefinedAble = (target as string).includes("?")
+        ? "undefined"
+        : ""
+      const isNullAble = (target as string).includes("~") ? "null" : ""
+      const isArray = (target as string).includes("[]") ? "[]" : ""
+      const varType = (target as string).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 as string[])
+          .map((word) => ` "${word}" `)
+          .join(",")}] `
+      // nest or input nest
+      else if (typeof target[0] === "object")
+        for (const row of target as InputNest[] | InputParent[]) {
+          result = result + " " + recursiveExtract(row, parentKeyName) + "[] "
+        }
+    }
+    return `${result}`
+  }
+  const result = recursiveExtract(data, "data")
+  return `${result} `
+}
+export function generateStaticRouteFileV2(appName: string, data: routeList[]) {
+  const interfaceName = `staticRouteInterface_${appName}_v2`
+  const generateEachUrl = (data: PrepareRouteStucture[Method]) => {
+    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/src/v2/output/apiConnector_hotel_v2.ts

@@ -0,0 +1,68 @@
+import axios from "axios"
+import { staticRouteInterface_hotel_v2 } from "./staticRouteInterface_hotel_v2"
+
+export 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"]> {
+    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 staticRouteInterface_hotel_v2["post"]>(
+    url: T,
+    requireParams: staticRouteInterface_hotel_v2["post"][T]["requireParams"]
+  ): Promise<staticRouteInterface_hotel_v2["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 staticRouteInterface_hotel_v2["put"]>(
+    url: T,
+    requireParams: staticRouteInterface_hotel_v2["put"][T]["requireParams"]
+  ): Promise<staticRouteInterface_hotel_v2["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 staticRouteInterface_hotel_v2["delete"]>(
+    url: T,
+    requireParams: staticRouteInterface_hotel_v2["delete"][T]["requireParams"]
+  ): Promise<staticRouteInterface_hotel_v2["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)
+        })
+    })
+  }
+}

package/src/v2/output/staticRouteInterface_hotel_v2.ts

@@ -0,0 +1,32 @@
+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/src/v2/run_v2.test.ts

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

package/src/v2/typeResolver.ts

@@ -0,0 +1,110 @@
+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 const toArray = <T extends InputParent>(input: T) => {
+  return [input]
+}
+
+// let req2 = {
+//   booking: {
+//     id: "number",
+//     bookingGroupID: "number",
+//     checkInDate: "string",
+//     checkOutDate: "string",
+//     checkInTime: "string",
+//     checkOutTime: "string",
+//     roomRate: "number",
+//     extraBedRate: "number",
+//     roomNumber: "string",
+//     editTime: "string",
+//     createTime: "string",
+//     shiftDate: "string",
+//     shiftName: "string",
+//     userName: "string",
+//     bookingStatus: ["ACTIVE", "CLOSE", "CANCEL", "NO_SHOW"],
+//     is_specificRoom: "number",
+//     guestCount: "number",
+//     reasonToCancel: "string",
+//     note: "string",
+//   },
+//   status: ["ACTIVE", "DISABLE"],
+//   rooms: toArray({
+//     id: "number",
+//     status: ["ON", "OFF"],
+//     roomNumber: "string",
+//     log: toArray({
+//       time: "string",
+//       logger: [{ info: "string" }],
+//     }),
+//   }),
+
+//   data: {
+//     level_1: {
+//       title: "string",
+//       level_2: {
+//         id: "number",
+//         name: "string",
+//       },
+//     },
+//   },
+// } as const satisfies InputParent
+
+type ResolveType<T> =
+  // both null + undefined
+  T extends `${infer B}?~`
+    ? ResolveBase<B & BaseType> | null | undefined
+    : // undefined only
+    T extends `${infer B}?`
+    ? ResolveBase<B & BaseType> | undefined
+    : // null only
+    T extends `${infer B}~`
+    ? ResolveBase<B & BaseType> | null
+    : // plain primitive
+      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]>
+}
+
+// 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