API Structure 재정비

server/apiStructure/defs.ts

@@ -5,61 +5,253 @@ export type RawArgType = Record<string, unknown> | Record<string, unknown>[] | u
 
 
 export interface BasicAPICallT<
-  ArgType extends RawArgType,
-  ResultType extends ValidResponse,
-  ErrorType extends InvalidResponse
+    ArgType extends RawArgType,
+    ResultType extends ValidResponse,
+    ErrorType extends InvalidResponse
 > {
-  (args: ArgType): Promise<ResultType>;
-  (args: ArgType, returnError: false): Promise<ResultType>;
-  (args: ArgType, returnError: true): Promise<ResultType | ErrorType>;
+    (args: ArgType): Promise<ResultType>;
+    (args: ArgType, returnError: false): Promise<ResultType>;
+    (args: ArgType, returnError: true): Promise<ResultType | ErrorType>;
+    readonly reqType: HttpMethod;
 }
 
+export type BasicGetAPICallT<
+    ArgType extends RawArgType,
+    ResultType extends ValidResponse,
+    ErrorType extends InvalidResponse
+> = BasicAPICallT<ArgType, ResultType, ErrorType> & { readonly reqType: 'get' };
+
+export type BasicPostAPICallT<
+    ArgType extends RawArgType,
+    ResultType extends ValidResponse,
+    ErrorType extends InvalidResponse
+> = BasicAPICallT<ArgType, ResultType, ErrorType> & { readonly reqType: 'post' };
+
+export type BasicPutAPICallT<
+    ArgType extends RawArgType,
+    ResultType extends ValidResponse,
+    ErrorType extends InvalidResponse
+> = BasicAPICallT<ArgType, ResultType, ErrorType> & { readonly reqType: 'put' };
+
+export type BasicDeleteAPICallT<
+    ArgType extends RawArgType,
+    ResultType extends ValidResponse,
+    ErrorType extends InvalidResponse
+> = BasicAPICallT<ArgType, ResultType, ErrorType> & { readonly reqType: 'delete' };
+
+export type BasicPatchAPICallT<
+    ArgType extends RawArgType,
+    ResultType extends ValidResponse,
+    ErrorType extends InvalidResponse
+> = BasicAPICallT<ArgType, ResultType, ErrorType> & { readonly reqType: 'patch' };
+
+export type BasicHeadAPICallT<
+    ArgType extends RawArgType,
+    ResultType extends ValidResponse,
+    ErrorType extends InvalidResponse
+> = BasicAPICallT<ArgType, ResultType, ErrorType> & { readonly reqType: 'head' };
+
 export interface EmptyAPICallT<ResultType extends ValidResponse, ErrorType extends InvalidResponse> {
-  (): Promise<ResultType>;
-  (args: undefined): Promise<ResultType>;
-  (args: undefined, returnError: false): Promise<ResultType>;
-  (args: undefined, returnError: true): Promise<ResultType | ErrorType>;
+    (): Promise<ResultType>;
+    (args?: undefined): Promise<ResultType>;
+    (args: undefined, returnError: false): Promise<ResultType>;
+    (args: undefined, returnError: true): Promise<ResultType | ErrorType>;
+    readonly reqType: HttpMethod;
 }
 
+export type EmptyGetAPICallT<
+    ResultType extends ValidResponse,
+    ErrorType extends InvalidResponse
+> = EmptyAPICallT<ResultType, ErrorType> & { readonly reqType: 'get' };
+
+export type EmptyPostAPICallT<
+    ResultType extends ValidResponse,
+    ErrorType extends InvalidResponse
+> = EmptyAPICallT<ResultType, ErrorType> & { readonly reqType: 'post' };
+
+export type EmptyPutAPICallT<
+    ResultType extends ValidResponse,
+    ErrorType extends InvalidResponse
+> = EmptyAPICallT<ResultType, ErrorType> & { readonly reqType: 'put' };
+
+export type EmptyDeleteAPICallT<
+    ResultType extends ValidResponse,
+    ErrorType extends InvalidResponse
+> = EmptyAPICallT<ResultType, ErrorType> & { readonly reqType: 'delete' };
+
+export type EmptyPatchAPICallT<
+    ResultType extends ValidResponse,
+    ErrorType extends InvalidResponse
+> = EmptyAPICallT<ResultType, ErrorType> & { readonly reqType: 'patch' };
+
+export type EmptyHeadAPICallT<
+    ResultType extends ValidResponse,
+    ErrorType extends InvalidResponse
+> = EmptyAPICallT<ResultType, ErrorType> & { readonly reqType: 'head' };
+
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export type ArgTypeOf<T> = T extends APICallT<infer A, any, any> ? A : never;
 
 
 export type APICallT<
-  ArgType extends RawArgType,
-  ResultType extends ValidResponse = ValidResponse,
-  ErrorType extends InvalidResponse = InvalidResponse
+    ArgType extends RawArgType,
+    ResultType extends ValidResponse = ValidResponse,
+    ErrorType extends InvalidResponse = InvalidResponse
 > = ArgType extends undefined ? EmptyAPICallT<ResultType, ErrorType> : BasicAPICallT<ArgType, ResultType, ErrorType>;
 
-export type APITail = typeof GET | typeof POST | typeof PUT | typeof PATCH | typeof HEAD | typeof DELETE;
+export type GetAPICallT<
+    ArgType extends RawArgType,
+    ResultType extends ValidResponse = ValidResponse,
+    ErrorType extends InvalidResponse = InvalidResponse
+> = ArgType extends undefined ? EmptyGetAPICallT<ResultType, ErrorType> : BasicGetAPICallT<ArgType, ResultType, ErrorType>;
 
-const httpMethodMap = new Map<APITail, HttpMethod>([
-    [GET, "get"],
-    [POST, "post"],
-    [PUT, "put"],
-    [PATCH, "patch"],
-    [HEAD, "head"],
-    [DELETE, "delete"],
-  ]);
+export type PostAPICallT<
+    ArgType extends RawArgType,
+    ResultType extends ValidResponse = ValidResponse,
+    ErrorType extends InvalidResponse = InvalidResponse
+> = ArgType extends undefined ? EmptyPostAPICallT<ResultType, ErrorType> : BasicPostAPICallT<ArgType, ResultType, ErrorType>;
 
-  export function extractHttpMethod(tail: APITail): HttpMethod {
-    return httpMethodMap.get(tail) ?? "post";
-  }
+export type PutAPICallT<
+    ArgType extends RawArgType,
+    ResultType extends ValidResponse = ValidResponse,
+    ErrorType extends InvalidResponse = InvalidResponse
+> = ArgType extends undefined ? EmptyPutAPICallT<ResultType, ErrorType> : BasicPutAPICallT<ArgType, ResultType, ErrorType>;
 
+export type DeleteAPICallT<
+    ArgType extends RawArgType,
+    ResultType extends ValidResponse = ValidResponse,
+    ErrorType extends InvalidResponse = InvalidResponse
+> = ArgType extends undefined ? EmptyDeleteAPICallT<ResultType, ErrorType> : BasicDeleteAPICallT<ArgType, ResultType, ErrorType>;
 
-export async function GET<ResultType extends ValidResponse, ArgType extends undefined = undefined>(
-    args?: ArgType
-): Promise<ResultType>;
-export async function GET<ResultType extends ValidResponse, ArgType extends undefined = undefined>(
-    args: ArgType | undefined,
-    returnError: false
-): Promise<ResultType>;
-export async function GET<
+export type PatchAPICallT<
+    ArgType extends RawArgType,
+    ResultType extends ValidResponse = ValidResponse,
+    ErrorType extends InvalidResponse = InvalidResponse
+> = ArgType extends undefined ? EmptyPatchAPICallT<ResultType, ErrorType> : BasicPatchAPICallT<ArgType, ResultType, ErrorType>;
+
+export type APITail = ReturnType<typeof GET> | ReturnType<typeof POST> | ReturnType<typeof PUT> | ReturnType<typeof DELETE> | ReturnType<typeof PATCH> | ReturnType<typeof HEAD>;
+
+export function GET<
     ResultType extends ValidResponse,
     ErrorType extends InvalidResponse,
-    ArgType extends undefined = undefined
->(args: ArgType | undefined, returnError: true): Promise<ResultType | ErrorType>;
-export async function GET<
+>(): EmptyGetAPICallT<ResultType, ErrorType>
+export function GET<
+    ArgType extends RawArgType,
+    ResultType extends ValidResponse,
+    ErrorType extends InvalidResponse,
+>(): BasicGetAPICallT<ArgType, ResultType, ErrorType>;
+export function GET<
+    ArgType extends RawArgType,
+    ResultType extends ValidResponse,
+    ErrorType extends InvalidResponse,
+>(): BasicGetAPICallT<ArgType, ResultType, ErrorType> | EmptyGetAPICallT<ResultType, ErrorType> {
+    return Object.assign(
+        fakeGET,
+        { reqType: 'get' } as const
+    )
+}
+
+export function POST<
+    ResultType extends ValidResponse,
+    ErrorType extends InvalidResponse,
+>(): EmptyPostAPICallT<ResultType, ErrorType>
+export function POST<
+    ArgType extends RawArgType,
+    ResultType extends ValidResponse,
+    ErrorType extends InvalidResponse,
+>(): BasicPostAPICallT<ArgType, ResultType, ErrorType>;
+export function POST<
+    ArgType extends RawArgType,
+    ResultType extends ValidResponse,
+    ErrorType extends InvalidResponse,
+>(): BasicPostAPICallT<ArgType, ResultType, ErrorType> | EmptyPostAPICallT<ResultType, ErrorType> {
+    return Object.assign(
+        fakePOST,
+        { reqType: 'post' } as const
+    )
+}
+
+export function PUT<
+    ResultType extends ValidResponse,
+    ErrorType extends InvalidResponse,
+>(): EmptyPutAPICallT<ResultType, ErrorType>
+export function PUT<
+    ArgType extends RawArgType,
+    ResultType extends ValidResponse,
+    ErrorType extends InvalidResponse,
+>(): BasicPutAPICallT<ArgType, ResultType, ErrorType>;
+export function PUT<
+    ArgType extends RawArgType,
+    ResultType extends ValidResponse,
+    ErrorType extends InvalidResponse,
+>(): BasicPutAPICallT<ArgType, ResultType, ErrorType> | EmptyPutAPICallT<ResultType, ErrorType> {
+    return Object.assign(
+        fakePUT,
+        { reqType: 'put' } as const
+    )
+}
+
+export function DELETE<
+    ResultType extends ValidResponse,
+    ErrorType extends InvalidResponse,
+>(): EmptyDeleteAPICallT<ResultType, ErrorType>
+export function DELETE<
+    ArgType extends RawArgType,
+    ResultType extends ValidResponse,
+    ErrorType extends InvalidResponse,
+>(): BasicDeleteAPICallT<ArgType, ResultType, ErrorType>;
+export function DELETE<
+    ArgType extends RawArgType,
+    ResultType extends ValidResponse,
+    ErrorType extends InvalidResponse,
+>(): BasicDeleteAPICallT<ArgType, ResultType, ErrorType> | EmptyDeleteAPICallT<ResultType, ErrorType> {
+    return Object.assign(
+        fakeDELETE,
+        { reqType: 'delete' } as const
+    )
+}
+
+export function PATCH<
+    ResultType extends ValidResponse,
+    ErrorType extends InvalidResponse,
+>(): EmptyPatchAPICallT<ResultType, ErrorType>
+export function PATCH<
+    ArgType extends RawArgType,
+    ResultType extends ValidResponse,
+    ErrorType extends InvalidResponse,
+>(): BasicPatchAPICallT<ArgType, ResultType, ErrorType>;
+export function PATCH<
+    ArgType extends RawArgType,
+    ResultType extends ValidResponse,
+    ErrorType extends InvalidResponse,
+>(): BasicPatchAPICallT<ArgType, ResultType, ErrorType> | EmptyPatchAPICallT<ResultType, ErrorType> {
+    return Object.assign(
+        fakePATCH,
+        { reqType: 'patch' } as const
+    )
+}
+
+export function HEAD<
+    ResultType extends ValidResponse,
+    ErrorType extends InvalidResponse,
+>(): EmptyHeadAPICallT<ResultType, ErrorType>
+export function HEAD<
+    ArgType extends RawArgType,
+    ResultType extends ValidResponse,
+    ErrorType extends InvalidResponse,
+>(): BasicHeadAPICallT<ArgType, ResultType, ErrorType>;
+export function HEAD<
+    ArgType extends RawArgType,
+    ResultType extends ValidResponse,
+    ErrorType extends InvalidResponse,
+>(): BasicHeadAPICallT<ArgType, ResultType, ErrorType> | EmptyHeadAPICallT<ResultType, ErrorType> {
+    return Object.assign(
+        fakeHEAD,
+        { reqType: 'head' } as const
+    )
+}
+
+export async function fakeGET<
     ResultType extends ValidResponse,
     ErrorType extends InvalidResponse,
     ArgType extends undefined = undefined
@@ -67,106 +259,45 @@ export async function GET<
     throw `Can't directly call GET. ${args}, ${returnError}. Use auto-generated path API.`
 }
 
-export async function POST<ResultType extends ValidResponse, ArgType extends RawArgType = RawArgType>(
-    args?: ArgType
-): Promise<ResultType>;
-export async function POST<ResultType extends ValidResponse, ArgType extends RawArgType = RawArgType>(
-    args: ArgType | undefined,
-    returnError: false
-): Promise<ResultType>;
-export async function POST<
+export async function fakePOST<
     ResultType extends ValidResponse,
     ErrorType extends InvalidResponse,
-    ArgType extends RawArgType = RawArgType
->(args: ArgType | undefined, returnError: true): Promise<ResultType | ErrorType>;
-export async function POST<
-    ResultType extends ValidResponse,
-    ErrorType extends InvalidResponse,
-    ArgType extends RawArgType = RawArgType
->(args?: ArgType, returnError = false): Promise<ResultType | ErrorType> {
+    ArgType extends RawArgType = undefined
+>(args: ArgType, returnError = false): Promise<ResultType | ErrorType> {
     throw `Can't directly call POST. ${args}, ${returnError}. Use auto-generated path API.`
 }
 
-export async function PUT<ResultType extends ValidResponse, ArgType extends RawArgType = RawArgType>(
-    args?: ArgType
-): Promise<ResultType>;
-export async function PUT<ResultType extends ValidResponse, ArgType extends RawArgType = RawArgType>(
-    args: ArgType | undefined,
-    returnError: false
-): Promise<ResultType>;
-export async function PUT<
+export async function fakePUT<
     ResultType extends ValidResponse,
     ErrorType extends InvalidResponse,
-    ArgType extends RawArgType = RawArgType
->(args: ArgType | undefined, returnError: true): Promise<ResultType | ErrorType>;
-export async function PUT<
-    ResultType extends ValidResponse,
-    ErrorType extends InvalidResponse,
-    ArgType extends RawArgType = RawArgType
->(args?: ArgType, returnError = false): Promise<ResultType | ErrorType> {
+    ArgType extends RawArgType = undefined
+>(args: ArgType, returnError = false): Promise<ResultType | ErrorType> {
     throw `Can't directly call PUT. ${args}, ${returnError}. Use auto-generated path API.`;
 }
 
-export async function PATCH<ResultType extends ValidResponse, ArgType extends RawArgType = RawArgType>(
-    args?: ArgType
-): Promise<ResultType>;
-export async function PATCH<ResultType extends ValidResponse, ArgType extends RawArgType = RawArgType>(
-    args: ArgType | undefined,
-    returnError: false
-): Promise<ResultType>;
-export async function PATCH<
+export async function fakeDELETE<
     ResultType extends ValidResponse,
     ErrorType extends InvalidResponse,
-    ArgType extends RawArgType = RawArgType
->(args: ArgType | undefined, returnError: true): Promise<ResultType | ErrorType>;
-export async function PATCH<
-    ResultType extends ValidResponse,
-    ErrorType extends InvalidResponse,
-    ArgType extends RawArgType = RawArgType
->(args?: ArgType, returnError = false): Promise<ResultType | ErrorType> {
-    throw `Can't directly call PATCH. ${args}, ${returnError}. Use auto-generated path API.`
-}
-
-export async function HEAD<ResultType extends ValidResponse, ArgType extends undefined = undefined>(
-    args?: ArgType
-): Promise<ResultType>;
-export async function HEAD<ResultType extends ValidResponse, ArgType extends undefined = undefined>(
-    args: ArgType | undefined,
-    returnError: false
-): Promise<ResultType>;
-export async function HEAD<
-    ResultType extends ValidResponse,
-    ErrorType extends InvalidResponse,
-    ArgType extends undefined = undefined
->(args: ArgType | undefined, returnError: true): Promise<ResultType | ErrorType>;
-export async function HEAD<
-    ResultType extends ValidResponse,
-    ErrorType extends InvalidResponse,
-    ArgType extends undefined = undefined
->(args?: ArgType, returnError = false): Promise<ResultType | ErrorType> {
-    throw `Can't directly call HEAD. ${args}, ${returnError}. Use auto-generated path API.`;
-}
-
-export async function DELETE<ResultType extends ValidResponse, ArgType extends RawArgType = RawArgType>(
-    args?: ArgType
-): Promise<ResultType>;
-export async function DELETE<ResultType extends ValidResponse, ArgType extends RawArgType = RawArgType>(
-    args: ArgType | undefined,
-    returnError: false
-): Promise<ResultType>;
-export async function DELETE<
-    ResultType extends ValidResponse,
-    ErrorType extends InvalidResponse,
-    ArgType extends RawArgType = RawArgType
->(args: ArgType | undefined, returnError: true): Promise<ResultType | ErrorType>;
-export async function DELETE<
-    ResultType extends ValidResponse,
-    ErrorType extends InvalidResponse,
-    ArgType extends RawArgType = RawArgType
->(args?: ArgType, returnError = false): Promise<ResultType | ErrorType> {
+    ArgType extends RawArgType = undefined
+>(args: ArgType, returnError = false): Promise<ResultType | ErrorType> {
     throw `Can't directly call DELETE. ${args}, ${returnError}. Use auto-generated path API.`;
 }
 
+export async function fakePATCH<
+    ResultType extends ValidResponse,
+    ErrorType extends InvalidResponse,
+    ArgType extends RawArgType = undefined
+>(args: ArgType, returnError = false): Promise<ResultType | ErrorType> {
+    throw `Can't directly call PATCH. ${args}, ${returnError}. Use auto-generated path API.`
+}
+
+export async function fakeHEAD<
+    ResultType extends ValidResponse,
+    ErrorType extends InvalidResponse,
+    ArgType extends RawArgType = undefined
+>(args?: ArgType, returnError = false): Promise<ResultType | ErrorType> {
+    throw `Can't directly call HEAD. ${args}, ${returnError}. Use auto-generated path API.`;
+}
 
 export interface ValidResponse {
     result: true;
@@ -182,7 +313,7 @@ export interface InvalidResponse {
 type ExtractValid<T> = T extends ValidResponse ? T : never;
 type ExtractInvalid<T> = T extends InvalidResponse ? T : never;
 
-export type Callable = (...args: any)=>any;
+export type Callable = (...args: any) => any;
 
 export type ExtractResponse<T extends Callable> = ExtractValid<Awaited<ReturnType<T>>>;
 export type ExtractError<T extends Callable> = ExtractInvalid<Awaited<ReturnType<T>>>;
@@ -190,12 +321,18 @@ export type ExtractQuery<T extends Callable> = Parameters<T>[0];
 
 export type DefAPINamespace = {
     [key: string]: DefAPINamespace
-    | typeof GET<any, any, any>
-    | typeof POST<any, any, any>
-    | typeof PUT<any, any, any>
-    | typeof DELETE<any, any, any>
-    | typeof PATCH<any, any, any>
-    | typeof HEAD<any, any, any>
+    | BasicGetAPICallT<any, any, any>
+    | BasicPostAPICallT<any, any, any>
+    | BasicPutAPICallT<any, any, any>
+    | BasicDeleteAPICallT<any, any, any>
+    | BasicPatchAPICallT<any, any, any>
+    | BasicHeadAPICallT<any, any, any>
+    | EmptyGetAPICallT<any, any>
+    | EmptyPostAPICallT<any, any>
+    | EmptyPutAPICallT<any, any>
+    | EmptyDeleteAPICallT<any, any>
+    | EmptyPatchAPICallT<any, any>
+    | EmptyHeadAPICallT<any, any>
     ;
 }
 

server/apiStructure/sammoRootAPI.ts

@@ -1,4 +1,4 @@
-import { type APICallT, GET, POST } from "./defs";
+import { DefAPINamespace, GET, POST } from "./defs";
 
 export type LoginResponse = {
     result: true,
@@ -32,14 +32,15 @@ export type AutoLoginFailed = {
 /** @internal */
 export const structure = {
     Login: {
-        LoginByID: POST as APICallT<{
+        LoginByID: POST<{
             username: string,
             password: string,
-        }, LoginResponse, LoginFailed>,
-        LoginByToken: POST as APICallT<{
+        }, LoginResponse, LoginFailed>(),
+        LoginByToken: POST<{
             hashedToken: string,
             token_id: number,
-        }, AutoLoginResponse, AutoLoginFailed>,
-        ReqNonce: GET as APICallT<undefined, AutoLoginNonceResponse, AutoLoginFailed>
+        }, AutoLoginResponse, AutoLoginFailed>(),
+        Test: POST<AutoLoginResponse, AutoLoginFailed>(),
+        ReqNonce: GET<AutoLoginNonceResponse, AutoLoginFailed>()
     },
-} as const;
+} satisfies DefAPINamespace;

server/clientAPI/sammoRootAPI.ts

@@ -1,11 +1,10 @@
 import { APIPathGen } from "./APIPathGen";
-import { extractHttpMethod } from "../apiStructure/defs";
 import type { APITail, RawArgType } from "../apiStructure/defs";
 import { structure } from "../apiStructure/sammoRootAPI";
 import { callClientAPI } from "./generator";
 
 export const SammoRootAPI = APIPathGen(structure, (path: string[], tail: APITail, pathParam) => {
-    const method = extractHttpMethod(tail);
+    const method = tail.reqType;
     return (args?: RawArgType, returnError?: boolean) => {
         if (returnError) {
             return callClientAPI(method, path.join('/'), args, pathParam, true);

server/index.ts

@@ -1,6 +1,5 @@
 import 'dotenv/config';
 import 'reflect-metadata';
-import { BasicQueryDTO } from './api/serverImpl.js';
 import { validate } from 'class-validator';
 import express, { type Request, type Response } from "express"
 import { AppDataSource } from "./data_source.js"
@@ -8,19 +7,12 @@ import session from "express-session";
 import path from 'node:path';
 import { LiteHashDRBG } from './util/LiteHashDRBG.js';
 import { simpleSerialize } from './util/simpleSerialize.js';
+import { SammoRootAPI } from './clientAPI/sammoRootAPI.js';
 
 export async function test() {
     console.log("Hello World!");
     console.log(process.env.GAME_DB_HOST);
 
-    const dto = new BasicQueryDTO();
-    dto.command = 'None';
-    dto.generalID = 1.1;
-
-    const result = await validate(dto);
-    console.log(result);
-    //must be integer가 나타나야함
-
     const abc= {
         a: 1,
         b: 2,