gg-express 1.0.1

package/dist/GGApi.d.ts

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

package/dist/GGApi.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 = void 0;
+const axios_1 = __importDefault(require("axios"));
+class GGApi {
+    constructor() { }
+    get(url, requireParams) {
+        return new Promise((resolve, reject) => {
+            axios_1.default
+                .get(url, { params: requireParams })
+                .then((response) => {
+                resolve(response.data);
+            })
+                .catch((error) => {
+                reject(error);
+            });
+        });
+    }
+    post(url, requireParams) {
+        return new Promise((resolve, reject) => {
+            axios_1.default
+                .post(url, requireParams)
+                .then((response) => {
+                resolve(response.data);
+            })
+                .catch((error) => {
+                reject(error);
+            });
+        });
+    }
+    put(url, requireParams) {
+        return new Promise((resolve, reject) => {
+            axios_1.default
+                .put(url, requireParams)
+                .then((response) => {
+                resolve(response.data);
+            })
+                .catch((error) => {
+                reject(error);
+            });
+        });
+    }
+    delete(url, requireParams) {
+        return new Promise((resolve, reject) => {
+            axios_1.default
+                .delete(url, requireParams)
+                .then((response) => {
+                resolve(response.data);
+            })
+                .catch((error) => {
+                reject(error);
+            });
+        });
+    }
+}
+exports.GGApi = GGApi;

package/dist/GGExpress.d.ts

@@ -0,0 +1,61 @@
+import { NextFunction, Request, Response } from "express";
+import Express from "express-serve-static-core";
+type Unarray<T> = T extends (infer U)[] ? U : T;
+type AsConstArray<T extends readonly any[]> = [...T];
+type paramType = "number" | "string" | AsConstArray<Array<string>> | AsConstArray<Array<number>>;
+interface responseStructure {
+    dataType: "singleObject" | "arrayObject";
+    structure: {
+        [key: string]: paramType;
+    };
+}
+interface requireParamsStructure {
+    dataType: "singleObject" | "arrayObject";
+    structure: {
+        [key: string]: paramType;
+    };
+}
+type numberOrString<T> = T extends "number" ? number : T extends "string" ? string : T extends string[] ? Unarray<T> : T extends number[] ? Unarray<T> : "error-type";
+type singleOrArrayObject<DT extends requireParamsStructure["dataType"], T extends requireParamsStructure["structure"], K extends keyof T> = DT extends "arrayObject" ? {
+    data: {
+        [Key in K]: numberOrString<T[Key]>;
+    }[];
+} : {
+    data: {
+        [Key in K]: numberOrString<T[Key]>;
+    };
+};
+type MyRequest<DT extends requireParamsStructure["dataType"], T extends requireParamsStructure["structure"], K extends keyof T> = Request<{}, {}, singleOrArrayObject<DT, T, K>, singleOrArrayObject<DT, T, K>, {}>;
+type MyResponse<DT extends responseStructure["dataType"], T extends responseStructure["structure"], K extends keyof T> = Response<{
+    status: "SUCCESS" | "ERROR";
+    message: string;
+    data: DT extends "arrayObject" ? Array<{
+        [key in K]: numberOrString<T[key]>;
+    }> : {
+        [key in K]: numberOrString<T[key]>;
+    };
+}>;
+export default class MyExpress {
+    express: Express.Express;
+    private outputPath;
+    constructor(app: Express.Express, outputPath: string[]);
+    private rootMethod;
+    get<M extends requireParamsStructure, T extends M["structure"], K extends keyof T, R extends responseStructure, RS extends R["structure"], KR extends keyof RS>(url: `/api/${string}`, options: {
+        requireParams: M;
+        responseStructure: R;
+    }, ...middlewares: Array<(req: MyRequest<M["dataType"], T, K>, res: MyResponse<R["dataType"], RS, KR>, next: NextFunction) => any>): Express.Express;
+    post<M extends requireParamsStructure, T extends M["structure"], K extends keyof T, R extends responseStructure, RS extends R["structure"], KR extends keyof RS>(url: `/api/${string}`, options: {
+        requireParams: M;
+        responseStructure: R;
+    }, ...middlewares: Array<(req: MyRequest<M["dataType"], T, K>, res: MyResponse<R["dataType"], RS, KR>, next: NextFunction) => any>): Express.Express;
+    put<M extends requireParamsStructure, T extends M["structure"], K extends keyof T, R extends responseStructure, RS extends R["structure"], KR extends keyof RS>(url: `/api/${string}`, options: {
+        requireParams: M;
+        responseStructure: R;
+    }, ...middlewares: Array<(req: MyRequest<M["dataType"], T, K>, res: MyResponse<R["dataType"], RS, KR>, next: NextFunction) => any>): Express.Express;
+    delete<M extends requireParamsStructure, T extends M["structure"], K extends keyof T, R extends responseStructure, RS extends R["structure"], KR extends keyof RS>(url: `/api/${string}`, options: {
+        requireParams: M;
+        responseStructure: R;
+    }, ...middlewares: Array<(req: MyRequest<M["dataType"], T, K>, res: MyResponse<R["dataType"], RS, KR>, next: NextFunction) => any>): Express.Express;
+    generateStaticRouteFile(): void;
+}
+export {};

package/dist/GGExpress.js

@@ -0,0 +1,117 @@
+"use strict";
+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 myExpressRouteList = [];
+class MyExpress {
+    constructor(app, outputPath) {
+        this.express = app;
+        this.outputPath = outputPath;
+    }
+    rootMethod(method, url, options, ...middlewares) {
+        myExpressRouteList.push({
+            method: method,
+            url: url,
+            requireParams: options.requireParams,
+            responseStructure: options.responseStructure,
+        });
+        return this.express[method](url, (req, res, next) => {
+            return next();
+        }, ...middlewares);
+    }
+    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);
+    }
+    generateStaticRouteFile() {
+        const genRequireParamCode = (data) => {
+            let result;
+            const resultArray = Object.entries(data["structure"]).map(([key, value]) => ({
+                name: key,
+                value: value,
+            }));
+            if (resultArray.length === 0)
+                return "";
+            result = resultArray
+                .map((row) => {
+                if (Array.isArray(row.value)) {
+                    return ` ${row.name} : ${row.value
+                        .map((vRow) => {
+                        if (typeof vRow === "string")
+                            return `"${vRow}"`;
+                        else if (typeof vRow === "number")
+                            return `${vRow}`;
+                    })
+                        .join(" | ")}`;
+                }
+                else
+                    return ` ${row.name} : ${row.value}`;
+            })
+                .join(",");
+            return result;
+        };
+        const isArray = (data) => {
+            if (Object.entries(data["structure"]).length === 0)
+                return "";
+            else if (data["dataType"] === "arrayObject")
+                return "[]";
+            else
+                return "";
+        };
+        const genInterfaceString = (data) => {
+            let rawString = ``;
+            if (data.length === 0)
+                return "";
+            rawString = data
+                .map((row) => {
+                return ` "${row.url}" : { 
+          requireParams : { ${genRequireParamCode(row.requireParams)} }${isArray(row.requireParams)},
+          responseStructure : { ${genRequireParamCode(row.responseStructure)} }${isArray(row.requireParams)},
+          responseModelInterfaceName : undefined
+        } `;
+            })
+                .join(",");
+            return rawString;
+        };
+        const getRoute = myExpressRouteList.filter((row) => row.method === "get");
+        const postRoute = myExpressRouteList.filter((row) => row.method === "post");
+        const putRoute = myExpressRouteList.filter((row) => row.method === "put");
+        const deleteDelete = myExpressRouteList.filter((row) => row.method === "delete");
+        let content = `export interface staticRouteInterface {
+        get : { ${genInterfaceString(getRoute)} },
+        post : { ${genInterfaceString(postRoute)} },
+        put : { ${genInterfaceString(putRoute)} },
+        delete : { ${genInterfaceString(deleteDelete)} },
+      }`;
+        for (let row of this.outputPath) {
+            fs_1.default.writeFileSync(row, content);
+        }
+        // const serverFilePath = path.join(
+        //   appRootPath.toString(),
+        //   "../",
+        //   "my-app",
+        //   "src",
+        //   "interfaces",
+        //   "staticRouteInterface.ts"
+        // )
+        // const myAppFilePath = path.join(
+        //   appRootPath.toString(),
+        //   "src",
+        //   "interfaces",
+        //   "staticRouteInterface.ts"
+        // )
+        // fs.writeFileSync(serverFilePath, content)
+        // fs.writeFileSync(myAppFilePath, content)
+    }
+}
+exports.default = MyExpress;

package/dist/dynamicRoute.js

@@ -0,0 +1,30 @@
+"use strict";
+// import hotel_INF from "../../interfaces/hotel_DBInstance"
+// import { hotel_model } from "../../myModel/hotel_model"
+// import MyExpress from "./MyExpress"
+// export function dynamicRoute(myApp: MyExpress, tableName: keyof hotel_INF) {
+//   const model = hotel_model.find((row) => row.tableName === tableName)
+//   if (model) {
+//     const data: { [key: string]: "number" | "string" } = {}
+//     for (const row of model.columns) {
+//       if (
+//         row.DATA_TYPE === "int" ||
+//         row.DATA_TYPE === "tinyint" ||
+//         row.DATA_TYPE === "float" ||
+//         row.DATA_TYPE === "double"
+//       )
+//         data[row.COLUMN_NAME] = "number"
+//       else data[row.COLUMN_NAME] = "string"
+//     }
+//     myApp.get(`/api/${tableName}`, {
+//       requireParams: {
+//         dataType: "singleObject",
+//         structure: {},
+//       },
+//       responseStructure: {
+//         dataType: "arrayObject",
+//         structure: data,
+//       },
+//     })
+//   }
+// }

package/dist/staticRouteInterface.d.ts

@@ -0,0 +1,16 @@
+export interface staticRouteInterface {
+    get: {
+        "/api/user": {
+            requireParams: {
+                date: string;
+            };
+            responseStructure: {
+                amount: number;
+            };
+            responseModelInterfaceName: undefined;
+        };
+    };
+    post: {};
+    put: {};
+    delete: {};
+}

package/dist/staticRouteInterface.js

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

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "gg-express",
+  "version": "1.0.1",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "build": "npm version patch && tsc",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@types/axios": "^0.14.0",
+    "app-root-path": "^3.1.0",
+    "axios": "^1.7.7",
+    "express": "^4.21.1",
+    "fs": "^0.0.1-security",
+    "path": "^0.12.7"
+  },
+  "devDependencies": {
+    "@types/express": "^5.0.0"
+  }
+}

package/src/GGApi.ts

@@ -0,0 +1,67 @@
+import { staticRouteInterface } from "./staticRouteInterface"
+import axios from "axios"
+export class GGApi {
+  constructor() {}
+
+  get<T extends keyof staticRouteInterface["get"]>(
+    url: T,
+    requireParams: staticRouteInterface["get"][T]["requireParams"]
+  ): Promise<staticRouteInterface["get"][T]["responseStructure"]> {
+    return new Promise((resolve, reject) => {
+      axios
+        .get(url, { params: requireParams })
+        .then((response) => {
+          resolve(response.data)
+        })
+        .catch((error) => {
+          reject(error)
+        })
+    })
+  }
+
+  post<T extends keyof staticRouteInterface["post"]>(
+    url: T,
+    requireParams: staticRouteInterface["post"][T]["requireParams"]
+  ): Promise<staticRouteInterface["post"][T]["responseStructure"]> {
+    return new Promise((resolve, reject) => {
+      axios
+        .post(url, requireParams)
+        .then((response) => {
+          resolve(response.data)
+        })
+        .catch((error) => {
+          reject(error)
+        })
+    })
+  }
+  put<T extends keyof staticRouteInterface["put"]>(
+    url: T,
+    requireParams: staticRouteInterface["put"][T]["requireParams"]
+  ): Promise<staticRouteInterface["put"][T]["responseStructure"]> {
+    return new Promise((resolve, reject) => {
+      axios
+        .put(url, requireParams)
+        .then((response) => {
+          resolve(response.data)
+        })
+        .catch((error) => {
+          reject(error)
+        })
+    })
+  }
+  delete<T extends keyof staticRouteInterface["delete"]>(
+    url: T,
+    requireParams: staticRouteInterface["delete"][T]["requireParams"]
+  ): Promise<staticRouteInterface["delete"][T]["responseStructure"]> {
+    return new Promise((resolve, reject) => {
+      axios
+        .delete(url, requireParams)
+        .then((response) => {
+          resolve(response.data)
+        })
+        .catch((error) => {
+          reject(error)
+        })
+    })
+  }
+}

package/src/GGExpress.ts

@@ -0,0 +1,302 @@
+import appRootPath from "app-root-path"
+import { NextFunction, Request, Response } from "express"
+import Express from "express-serve-static-core"
+import fs from "fs"
+import path from "path"
+type Unarray<T> = T extends (infer U)[] ? U : T;
+type AsConstArray<T extends readonly any[]> = [...T]
+type paramType =
+  | "number"
+  | "string"
+  | AsConstArray<Array<string>>
+  | AsConstArray<Array<number>>
+interface responseStructure {
+  dataType: "singleObject" | "arrayObject"
+  structure: {
+    [key: string]: paramType
+  }
+}
+
+interface requireParamsStructure {
+  dataType: "singleObject" | "arrayObject"
+  structure: {
+    [key: string]: paramType
+  }
+}
+type numberOrString<T> = T extends "number"
+  ? number
+  : T extends "string"
+  ? string
+  : T extends string[]
+  ? Unarray<T>
+  : T extends number[]
+  ? Unarray<T>
+  : "error-type"
+
+type singleOrArrayObject<
+  DT extends requireParamsStructure["dataType"],
+  T extends requireParamsStructure["structure"],
+  K extends keyof T
+> = DT extends "arrayObject"
+  ? { data: { [Key in K]: numberOrString<T[Key]> }[] }
+  : { data: { [Key in K]: numberOrString<T[Key]> } }
+
+type MyRequest<
+  DT extends requireParamsStructure["dataType"],
+  T extends requireParamsStructure["structure"],
+  K extends keyof T
+> = Request<
+  {},
+  {},
+  singleOrArrayObject<DT, T, K>,
+  singleOrArrayObject<DT, T, K>,
+  {}
+>
+
+type MyResponse<
+  DT extends responseStructure["dataType"],
+  T extends responseStructure["structure"],
+  K extends keyof T
+> = Response<{
+  status: "SUCCESS" | "ERROR"
+  message: string
+  data: DT extends "arrayObject"
+    ? Array<{ [key in K]: numberOrString<T[key]> }>
+    : { [key in K]: numberOrString<T[key]> }
+}>
+
+const myExpressRouteList: {
+  method: "get" | "post" | "put" | "delete"
+  url: string
+  requireParams: requireParamsStructure
+  responseStructure: responseStructure
+}[] = []
+
+export default class MyExpress {
+  public express: Express.Express
+  private outputPath: string[]
+  constructor(app: Express.Express, outputPath: string[]) {
+    this.express = app
+    this.outputPath = outputPath
+  }
+
+  private rootMethod<
+    M extends requireParamsStructure,
+    T extends M["structure"],
+    K extends keyof T,
+    R extends responseStructure,
+    RS extends R["structure"],
+    KR extends keyof RS
+  >(
+    method: "get" | "post" | "put" | "delete",
+    url: string,
+    options: {
+      requireParams: M
+      responseStructure: R
+    },
+    ...middlewares: Array<
+      (
+        req: MyRequest<M["dataType"], T, K>,
+        res: MyResponse<R["dataType"], RS, KR>,
+        next: NextFunction
+      ) => any
+    >
+  ) {
+    myExpressRouteList.push({
+      method: method,
+      url: url,
+      requireParams: options.requireParams,
+      responseStructure: options.responseStructure,
+    })
+
+    return this.express[method](
+      url,
+      (
+        req: MyRequest<M["dataType"], T, K>,
+        res: Response,
+        next: NextFunction
+      ) => {
+        return next()
+      },
+      ...middlewares
+    )
+  }
+  get<
+    M extends requireParamsStructure,
+    T extends M["structure"],
+    K extends keyof T,
+    R extends responseStructure,
+    RS extends R["structure"],
+    KR extends keyof RS
+  >(
+    url: `/api/${string}`,
+    options: {
+      requireParams: M
+      responseStructure: R
+    },
+    ...middlewares: Array<
+      (
+        req: MyRequest<M["dataType"], T, K>,
+        res: MyResponse<R["dataType"], RS, KR>,
+        next: NextFunction
+      ) => any
+    >
+  ) {
+    return this.rootMethod("get", url, options, ...middlewares)
+  }
+
+  post<
+    M extends requireParamsStructure,
+    T extends M["structure"],
+    K extends keyof T,
+    R extends responseStructure,
+    RS extends R["structure"],
+    KR extends keyof RS
+  >(
+    url: `/api/${string}`,
+    options: {
+      requireParams: M
+      responseStructure: R
+    },
+    ...middlewares: Array<
+      (
+        req: MyRequest<M["dataType"], T, K>,
+        res: MyResponse<R["dataType"], RS, KR>,
+        next: NextFunction
+      ) => any
+    >
+  ) {
+    return this.rootMethod("post", url, options, ...middlewares)
+  }
+  put<
+    M extends requireParamsStructure,
+    T extends M["structure"],
+    K extends keyof T,
+    R extends responseStructure,
+    RS extends R["structure"],
+    KR extends keyof RS
+  >(
+    url: `/api/${string}`,
+    options: {
+      requireParams: M
+      responseStructure: R
+    },
+    ...middlewares: Array<
+      (
+        req: MyRequest<M["dataType"], T, K>,
+        res: MyResponse<R["dataType"], RS, KR>,
+        next: NextFunction
+      ) => any
+    >
+  ) {
+    return this.rootMethod("put", url, options, ...middlewares)
+  }
+  delete<
+    M extends requireParamsStructure,
+    T extends M["structure"],
+    K extends keyof T,
+    R extends responseStructure,
+    RS extends R["structure"],
+    KR extends keyof RS
+  >(
+    url: `/api/${string}`,
+    options: {
+      requireParams: M
+      responseStructure: R
+    },
+    ...middlewares: Array<
+      (
+        req: MyRequest<M["dataType"], T, K>,
+        res: MyResponse<R["dataType"], RS, KR>,
+        next: NextFunction
+      ) => any
+    >
+  ) {
+    return this.rootMethod("delete", url, options, ...middlewares)
+  }
+  generateStaticRouteFile() {
+    const genRequireParamCode = (data: requireParamsStructure) => {
+      let result: string
+      const resultArray = Object.entries(data["structure"]).map(
+        ([key, value]) => ({
+          name: key,
+          value: value,
+        })
+      )
+      if (resultArray.length === 0) return ""
+
+      result = resultArray
+        .map((row) => {
+          if (Array.isArray(row.value)) {
+            return ` ${row.name} : ${row.value
+              .map((vRow) => {
+                if (typeof vRow === "string") return `"${vRow}"`
+                else if (typeof vRow === "number") return `${vRow}`
+              })
+              .join(" | ")}`
+          } else return ` ${row.name} : ${row.value}`
+        })
+        .join(",")
+
+      return result
+    }
+    const isArray = (data: requireParamsStructure) => {
+      if (Object.entries(data["structure"]).length === 0) return ""
+      else if (data["dataType"] === "arrayObject") return "[]"
+      else return ""
+    }
+    const genInterfaceString = (data: typeof myExpressRouteList) => {
+      let rawString = ``
+      if (data.length === 0) return ""
+      rawString = data
+        .map((row) => {
+          return ` "${row.url}" : { 
+          requireParams : { ${genRequireParamCode(
+            row.requireParams
+          )} }${isArray(row.requireParams)},
+          responseStructure : { ${genRequireParamCode(
+            row.responseStructure
+          )} }${isArray(row.requireParams)},
+          responseModelInterfaceName : undefined
+        } `
+        })
+        .join(",")
+      return rawString
+    }
+
+    const getRoute = myExpressRouteList.filter((row) => row.method === "get")
+    const postRoute = myExpressRouteList.filter((row) => row.method === "post")
+    const putRoute = myExpressRouteList.filter((row) => row.method === "put")
+    const deleteDelete = myExpressRouteList.filter(
+      (row) => row.method === "delete"
+    )
+    let content = `export interface staticRouteInterface {
+        get : { ${genInterfaceString(getRoute)} },
+        post : { ${genInterfaceString(postRoute)} },
+        put : { ${genInterfaceString(putRoute)} },
+        delete : { ${genInterfaceString(deleteDelete)} },
+      }`
+
+    for (let row of this.outputPath) {
+      fs.writeFileSync(row, content)
+    }
+
+    // const serverFilePath = path.join(
+    //   appRootPath.toString(),
+    //   "../",
+    //   "my-app",
+    //   "src",
+    //   "interfaces",
+    //   "staticRouteInterface.ts"
+    // )
+    // const myAppFilePath = path.join(
+    //   appRootPath.toString(),
+    //   "src",
+    //   "interfaces",
+    //   "staticRouteInterface.ts"
+    // )
+
+    // fs.writeFileSync(serverFilePath, content)
+    // fs.writeFileSync(myAppFilePath, content)
+  }
+}

package/src/dynamicRoute.ts

@@ -0,0 +1,32 @@
+// import hotel_INF from "../../interfaces/hotel_DBInstance"
+// import { hotel_model } from "../../myModel/hotel_model"
+// import MyExpress from "./MyExpress"
+
+// export function dynamicRoute(myApp: MyExpress, tableName: keyof hotel_INF) {
+//   const model = hotel_model.find((row) => row.tableName === tableName)
+//   if (model) {
+//     const data: { [key: string]: "number" | "string" } = {}
+
+//     for (const row of model.columns) {
+//       if (
+//         row.DATA_TYPE === "int" ||
+//         row.DATA_TYPE === "tinyint" ||
+//         row.DATA_TYPE === "float" ||
+//         row.DATA_TYPE === "double"
+//       )
+//         data[row.COLUMN_NAME] = "number"
+//       else data[row.COLUMN_NAME] = "string"
+//     }
+
+//     myApp.get(`/api/${tableName}`, {
+//       requireParams: {
+//         dataType: "singleObject",
+//         structure: {},
+//       },
+//       responseStructure: {
+//         dataType: "arrayObject",
+//         structure: data,
+//       },
+//     })
+//   }
+// }

package/src/staticRouteInterface.ts

@@ -0,0 +1,10 @@
+export interface staticRouteInterface {
+        get : {  "/api/user" : { 
+          requireParams : {  date : string },
+          responseStructure : {  amount : number },
+          responseModelInterfaceName : undefined
+        }  },
+        post : {  },
+        put : {  },
+        delete : {  },
+      }

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES6",                       // Specify ECMAScript target version
+    "module": "commonjs",                   // Use CommonJS module system for Node.js
+    "declaration": true,                    // Generates corresponding '.d.ts' files
+    "outDir": "./dist",                     // Redirect output structure to 'dist' folder
+    "strict": true,                         // Enable strict type-checking options
+    "esModuleInterop": true,                // Ensures ES6 module compatibility
+    "skipLibCheck": true,                   // Skips type checking of declaration files
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": ["src/**/*"],                  // Include all TypeScript files in 'src'
+  "exclude": ["node_modules", "dist"]
+}