api 구성 준비

server/api/base.ts

@@ -0,0 +1,80 @@
+
+import type { Request, Response } from 'express';
+
+export interface ValidResponse {
+    result: true;
+}
+
+export type recoveryMethod = 'refreshEntirePage' | 'retryAPI' | 'gameLogin' | 'gatewayLogin' | 'gatewayPIN';
+
+export interface InvalidResponse {
+    result: false;
+    reason: string;
+    recovery?: recoveryMethod;
+}
+
+export const treatedSpecial = Symbol('treatedSpecial');
+export type HttpMethod = 'get' | 'post' | 'put' | 'delete' | 'patch' | 'head';
+export type RawArgType = Record<string, unknown> | Record<string, unknown>[] | undefined;
+
+export type APINamespace = {
+    [key: string]: APINamespace
+    | GET<any, any, any>
+    | POST<any, any, any>
+    | PUT<any, any, any>
+    | DELETE<any, any, any>
+    | PATCH<any, any, any>
+    | HEAD<any, any, any>
+    ;
+}
+
+export abstract class APIExecuter<Q extends object, R extends ValidResponse, E extends InvalidResponse>{
+    readonly reqType: HttpMethod | HttpMethod[];
+    protected abstract parseQuery(expressReq: Request): Promise<Q>;
+    protected abstract api(query: Q, expressReq: Request, expressRes: Response): Promise<R | E | typeof treatedSpecial>;
+    public async run(expressReq: Request, expressRes: Response): Promise<void> {
+        const query = await this.parseQuery(expressReq);
+        //TODO: middleware (인증, 요구사항, 아마도 decorator)
+        const result = await this.api(query, expressReq, expressRes);
+        if (result === treatedSpecial) {
+            return;
+        }
+        expressRes.json(result);
+    }
+}
+
+export abstract class APIBodyParseExecuter<Q extends object, R extends ValidResponse, E extends InvalidResponse> extends APIExecuter<Q, R, E>{
+    protected async parseQuery(expressReq: Request): Promise<Q> {
+        throw new Error('Not implemented');
+        return expressReq.body;
+    }
+}
+
+export abstract class GET<Q extends object, R extends ValidResponse, E extends InvalidResponse> extends APIExecuter<Q, R, E>{
+    readonly reqType = 'get';
+    protected async parseQuery(expressReq: Request): Promise<Q> {
+        expressReq.query;
+        throw new Error('Not implemented');
+        return expressReq.query as unknown as Q;
+    }
+}
+
+export abstract class POST<Q extends object, R extends ValidResponse, E extends InvalidResponse> extends APIBodyParseExecuter<Q, R, E>{
+    readonly reqType = 'post';
+}
+
+export abstract class PUT<Q extends object, R extends ValidResponse, E extends InvalidResponse> extends APIBodyParseExecuter<Q, R, E>{
+    readonly reqType = 'put';
+}
+
+export abstract class DELETE<Q extends object, R extends ValidResponse, E extends InvalidResponse> extends APIBodyParseExecuter<Q, R, E>{
+    readonly reqType = 'delete';
+}
+
+export abstract class PATCH<Q extends object, R extends ValidResponse, E extends InvalidResponse> extends APIBodyParseExecuter<Q, R, E>{
+    readonly reqType = 'patch';
+}
+
+export abstract class HEAD<Q extends object, R extends ValidResponse, E extends InvalidResponse> extends APIBodyParseExecuter<Q, R, E>{
+    readonly reqType = 'head';
+}

server/api/clientAPI.ts

@@ -0,0 +1,211 @@
+import ky from 'ky';
+import type { APIExecuter, APINamespace, HttpMethod, InvalidResponse, RawArgType, ValidResponse } from './base.js';
+import isArray from 'lodash-es/isArray.js';
+import isEmpty from 'lodash-es/isEmpty.js';
+
+const apiPath = process.env.API_ROOT_PATH ?? process.env.VITE_API_ROOT_PATH ?? '/api';
+
+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<
+    ResultType extends ValidResponse,
+    ErrorType extends InvalidResponse,
+    ArgType extends undefined = undefined
+>(args: ArgType | undefined, returnError: true): Promise<ResultType | ErrorType>;
+export async function GET<
+    ResultType extends ValidResponse,
+    ErrorType extends InvalidResponse,
+    ArgType extends undefined = undefined
+>(args?: ArgType, returnError = false): Promise<ResultType | ErrorType> {
+    console.error(`Can't directly call GET. ${args}, ${returnError}. Use auto-generated path API.`);
+    return callClientAPI<ResultType, ErrorType>("get", [], args, undefined, true);
+}
+
+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<
+    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> {
+    console.error(`Can't directly call POST. ${args}, ${returnError}. Use auto-generated path API.`);
+    return callClientAPI<ResultType, ErrorType>("post", [], args, undefined, true);
+}
+
+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<
+    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> {
+    console.error(`Can't directly call PUT. ${args}, ${returnError}. Use auto-generated path API.`);
+    return callClientAPI<ResultType, ErrorType>("put", [], args, undefined, true);
+}
+
+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<
+    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> {
+    console.error(`Can't directly call PATCH. ${args}, ${returnError}. Use auto-generated path API.`);
+    return callClientAPI<ResultType, ErrorType>("patch", [], args, undefined, true);
+}
+
+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> {
+    console.error(`Can't directly call HEAD. ${args}, ${returnError}. Use auto-generated path API.`);
+    return callClientAPI<ResultType, ErrorType>("head", [], args, undefined, true);
+}
+
+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> {
+    console.error(`Can't directly call DELETE. ${args}, ${returnError}. Use auto-generated path API.`);
+    return callClientAPI<ResultType, ErrorType>("patch", [], args, undefined, true);
+}
+
+
+export async function callClientAPI<ResultType extends ValidResponse>(
+    method: HttpMethod,
+    path: string | string[],
+    args: RawArgType,
+    paramArgs: Record<string, string | number> | undefined
+): Promise<ResultType>;
+export async function callClientAPI<ResultType extends ValidResponse>(
+    method: HttpMethod,
+    path: string | string[],
+    args: RawArgType,
+    paramArgs: Record<string, string | number> | undefined,
+    returnError: false
+): Promise<ResultType>;
+export async function callClientAPI<ResultType extends ValidResponse, ErrorType extends InvalidResponse>(
+    method: HttpMethod,
+    path: string | string[],
+    args: RawArgType,
+    paramArgs: Record<string, string | number> | undefined,
+    returnError: true
+): Promise<ResultType | ErrorType>;
+export async function callClientAPI<ResultType extends ValidResponse, ErrorType extends InvalidResponse>(
+    method: HttpMethod,
+    path: string | string[],
+    args: RawArgType,
+    paramArgs: Record<string, string | number> | undefined,
+    returnError = false
+): Promise<ResultType | ErrorType> {
+    if (isArray(path)) {
+        path = path.join("/");
+    }
+
+    if (args && isEmpty(args)) {
+        args = undefined;
+    }
+
+    const result = (await (() => {
+        if (method == "get") {
+            return ky(apiPath, {
+                searchParams: {
+                    ...paramArgs,
+                    ...(args as typeof paramArgs),
+                    path,
+                },
+                method,
+                headers: {
+                    "content-type": "application/json",
+                },
+                timeout: 30000,
+                retry: 0,
+            });
+        }
+        return ky(apiPath, {
+            searchParams: {
+                ...paramArgs,
+                path,
+            },
+            method,
+            json: args,
+            headers: {
+                "content-type": "application/json",
+            },
+            timeout: 30000,
+            retry: 0,
+        });
+    })().json()) as ErrorType | ResultType;
+
+    if (!result.result) {
+        if (returnError) {
+            return result;
+        }
+        throw result.reason;
+    }
+    return result;
+}
+
+//TODO: type이 하나 만들어져야 함. 이것은 typescript의 type system으로.
+//TODO: const로 실제 구조가 하나 더 만들어 져야 함. 이것은 위의 type을 satisfy하여야 함.

server/api/serverAPI.ts

@@ -0,0 +1,28 @@
+import { Router } from 'express';
+import type { APIExecuter, APINamespace } from './base.js';
+
+export function buildAPISystem<N extends APINamespace, Q extends APIExecuter<any, any, any>>(api: N | Q): Router {
+    const router = Router();
+    for (const [key, value] of Object.entries(api)) {
+        if (typeof value === 'function') {
+            const executer = new value() as Q;
+            if(!executer.reqType){
+                throw new Error('APIExecuter.reqType is not defined');
+            }
+            if(!Array.isArray(executer.reqType)){
+                router[executer.reqType](key, async (req, res) => {
+                    await executer.run(req, res);
+                });
+                continue;
+            }
+            for(const type of new Set(executer.reqType)){
+                router[type](key, async (req, res) => {
+                    await executer.run(req, res);
+                });
+            }
+        } else {
+            router.use(key, buildAPISystem(value));
+        }
+    }
+    return router;
+}

server/dotenv.d.ts

@@ -8,5 +8,8 @@ declare namespace NodeJS {
         GAME_DB_PASSWORD: string;
         SERVER_PORT: string; //숫자
         SESSION_SECRET: string; //길게
+
+        API_ROOT_PATH?: string;
+        VITE_API_ROOT_PATH?: string;
     }
 }