gg-express 1.0.75 → 1.0.81

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "gg-express",
-  "version": "1.0.75",
+  "version": "1.0.81",
   "description": "",
-  "main": "dist/GGExpress.js",
+  "main": "dist/main.js",
   "scripts": {
     "build": "tsc && npm version patch --no-git-tag-version",
     "test": "echo \"Error: no test specified\" && exit 1"
@@ -24,7 +24,7 @@
   },
   "devDependencies": {
     "@types/express": "^5.0.0",
-    "typescript": "^5.8.3"
+    "typescript": "^5.9.3"
   },
   "keywords": [
     "express",

package/src/GGExpress.ts

@@ -107,7 +107,7 @@ type MyResponse<
 
 const myExpressRouteList: {
   method: "get" | "post" | "put" | "delete"
-  url: string | string[]
+  url: string
   requireParams: requireParamsStructure
   responseStructure: responseStructure
 }[] = []
@@ -148,11 +148,19 @@ export default class GGExpress<appName extends string> {
       ) => any
     >
   ) {
-    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](

package/src/main.ts

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

package/src/run.test.ts

@@ -88,10 +88,8 @@ 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[]" },

package/src/staticRouteInterface_hotel.ts

@@ -12,6 +12,30 @@ export interface staticRouteInterface_hotel {
         data: { id: number; name: string }[]
       }
     }
+    "/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/src/v2/GGExpressV2.ts

@@ -0,0 +1,190 @@
+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 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>
+}>
+
+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: ReqByMethod<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 ReqByMethod<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: ReqByMethod<"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: ReqByMethod<"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: ReqByMethod<"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: ReqByMethod<"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: { 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.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,69 @@
+
+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,26 @@
+
+  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)
+      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, 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
+})