mcl-axios-kit 0.0.1

package/Readme.md

@@ -0,0 +1 @@
+# McL-Axios-Kit

package/dist/McAxios.d.ts

@@ -0,0 +1,7 @@
+import { type AxiosHeaders } from "axios";
+export default abstract class McAxios {
+    private _axios;
+    constructor();
+    protected abstract header(): AxiosHeaders | undefined;
+    private bindEndpoints;
+}

package/dist/McAxios.js

@@ -0,0 +1,68 @@
+import axios from "axios";
+import McRequest from "./McRequest";
+import { ERROR_HANDLER_KEY, METHOD_META_KEY, PATH_PARAMS_KEY, REQUEST_KEY, RESPONSE_TYPE_KEY, SUCCESS_HANDLER_KEY } from "./McAxiosAnnotations";
+export default class McAxios {
+    _axios;
+    constructor() {
+        this._axios = axios.create();
+        this.bindEndpoints();
+    }
+    bindEndpoints() {
+        const proto = Object.getPrototypeOf(this);
+        const names = Object.getOwnPropertyNames(proto);
+        // const names = Object.keys(this);
+        for (const name of names) {
+            const descriptor = Object.getOwnPropertyDescriptor(proto, name);
+            if (!descriptor || typeof descriptor.value !== "function")
+                continue;
+            const meta = Reflect.getMetadata(METHOD_META_KEY, proto, name);
+            if (!meta)
+                continue;
+            const { method, path } = meta;
+            const successHandler = Reflect.getMetadata(SUCCESS_HANDLER_KEY, proto, name);
+            const errorHandler = Reflect.getMetadata(ERROR_HANDLER_KEY, proto, name);
+            const requestBody = Reflect.getMetadata(REQUEST_KEY, proto, name);
+            const responseType = Reflect.getMetadata(RESPONSE_TYPE_KEY, proto, name);
+            const pathParams = Reflect.getMetadata(PATH_PARAMS_KEY, proto, name) || {};
+            Object.defineProperty(this, name, {
+                // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+                value: async (...args) => {
+                    let url = path;
+                    // Path param 치환
+                    for (const [key, index] of Object.entries(pathParams)) {
+                        const value = encodeURIComponent(args[index]);
+                        url = url.replace(`{${key}}`, value);
+                    }
+                    const request = requestBody !== undefined ? args[requestBody] : undefined;
+                    if (request !== undefined && request instanceof McRequest === false) {
+                        const err = new Error("Request 형식이 잘못 되었습니다.");
+                        errorHandler ? errorHandler(err) : err;
+                        throw err;
+                    }
+                    const data = request !== undefined ? request.toJson() : undefined;
+                    console.log(`param -> ${name} :: ${data}`);
+                    try {
+                        const response = await this._axios
+                            .request({
+                            method,
+                            url,
+                            data,
+                        })
+                            .catch((err) => {
+                            throw err;
+                        });
+                        if (successHandler)
+                            return successHandler(response);
+                        if (responseType)
+                            return new responseType(response);
+                        return response.data;
+                    }
+                    catch (reqErr) {
+                        const err = errorHandler ? errorHandler(reqErr) : reqErr;
+                        throw reqErr;
+                    }
+                },
+            });
+        }
+    }
+}

package/dist/McAxiosAnnotations.d.ts

@@ -0,0 +1,20 @@
+import "reflect-metadata";
+export declare const API_META_KEY: unique symbol;
+export declare const METHOD_META_KEY: unique symbol;
+export declare const REQUEST_KEY: unique symbol;
+export declare const RESPONSE_TYPE_KEY: unique symbol;
+export declare const PATH_PARAMS_KEY: unique symbol;
+export declare const SUCCESS_HANDLER_KEY: unique symbol;
+export declare const ERROR_HANDLER_KEY: unique symbol;
+declare const McAxiosAnnotations: {
+    GET: (url: string, type: new (res: any) => any) => (target: any, propertyKey: string) => void;
+    POST: (url: string, type: new (res: any) => any) => (target: any, propertyKey: string) => void;
+    PUT: (url: string, type: new (res: any) => any) => (target: any, propertyKey: string) => void;
+    DELETE: (url: string, type: new (res: any) => any) => (target: any, propertyKey: string) => void;
+    PATCH: (url: string, type: new (res: any) => any) => (target: any, propertyKey: string) => void;
+    Request: (target: Object, propertyKey: string | symbol, parameterIndex: number) => void;
+    Path: (name: string) => (target: Object, propertyKey: string | symbol, parameterIndex: number) => void;
+    Success: (fn: Function) => (target: any, propertyKey: string) => void;
+    Error: (fn: Function) => (target: any, propertyKey: string) => void;
+};
+export default McAxiosAnnotations;

package/dist/McAxiosAnnotations.js

@@ -0,0 +1,66 @@
+import "reflect-metadata";
+export const API_META_KEY = Symbol("mc:api");
+export const METHOD_META_KEY = Symbol("mc:method");
+export const REQUEST_KEY = Symbol("mc:requestBody");
+export const RESPONSE_TYPE_KEY = Symbol("mc:responseType");
+export const PATH_PARAMS_KEY = Symbol("mc:pathParams");
+export const SUCCESS_HANDLER_KEY = Symbol("mc:successHandler");
+export const ERROR_HANDLER_KEY = Symbol("mc:errorHandler");
+const McAxiosAnnotations = {
+    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+    GET: (url, type) => {
+        return createDecorator("GET", url, type);
+    },
+    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+    POST: (url, type) => {
+        return createDecorator("POST", url, type);
+    },
+    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+    PUT: (url, type) => {
+        return createDecorator("PUT", url, type);
+    },
+    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+    DELETE: (url, type) => {
+        return createDecorator("DELETE", url, type);
+    },
+    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+    PATCH: (url, type) => {
+        return createDecorator("PATCH", url, type);
+    },
+    // biome-ignore lint/complexity/noBannedTypes: <explanation>
+    Request: (target, propertyKey, parameterIndex) => {
+        Reflect.defineMetadata(REQUEST_KEY, parameterIndex, target, propertyKey);
+    },
+    Path: (name) => {
+        // biome-ignore lint/complexity/noBannedTypes: <explanation>
+        return (target, propertyKey, parameterIndex) => {
+            const existingParams = Reflect.getMetadata(PATH_PARAMS_KEY, target, propertyKey) || {};
+            existingParams[name] = parameterIndex;
+            Reflect.defineMetadata(PATH_PARAMS_KEY, existingParams, target, propertyKey);
+        };
+    },
+    // biome-ignore lint/complexity/noBannedTypes: <explanation>
+    Success: (fn) => {
+        // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+        return (target, propertyKey) => {
+            Reflect.defineMetadata(SUCCESS_HANDLER_KEY, fn, target, propertyKey);
+        };
+    },
+    // biome-ignore lint/complexity/noBannedTypes: <explanation>
+    // biome-ignore lint/suspicious/noShadowRestrictedNames: <explanation>
+    Error: (fn) => {
+        // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+        return (target, propertyKey) => {
+            Reflect.defineMetadata(ERROR_HANDLER_KEY, fn, target, propertyKey);
+        };
+    },
+};
+// biome-ignore lint/suspicious/noExplicitAny: <explanation>
+const createDecorator = (method, path, type) => {
+    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+    return (target, propertyKey) => {
+        Reflect.defineMetadata(METHOD_META_KEY, { method, path }, target, propertyKey);
+        Reflect.defineMetadata(RESPONSE_TYPE_KEY, type, target, propertyKey);
+    };
+};
+export default McAxiosAnnotations;

package/dist/McAxiosManager.d.ts

@@ -0,0 +1,10 @@
+import type McAxios from "./McAxios";
+export declare const createMcAxios: <T extends McAxios>(api: T) => T;
+export default class McAxiosManager {
+    private static _axios;
+    private constructor();
+    static set(servers: McAxios[]): void;
+    static add(axios: McAxios): void;
+    static get<T extends McAxios>(type: abstract new (...args: any[]) => T): T;
+    static clear(): void;
+}

package/dist/McAxiosManager.js

@@ -0,0 +1,29 @@
+export const createMcAxios = (api) => {
+    McAxiosManager.add(api);
+    return api;
+};
+export default class McAxiosManager {
+    static _axios = [];
+    constructor() { }
+    static set(servers) {
+        McAxiosManager.clear();
+        for (const axios of servers)
+            McAxiosManager.add(axios);
+    }
+    static add(axios) {
+        McAxiosManager._axios.push(axios);
+    }
+    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+    static get(type) {
+        const result = McAxiosManager._axios.find((axios) => axios instanceof type);
+        if (result)
+            return result;
+        throw new Error(`Axios is undefined : ${type.name}`);
+    }
+    // public static delete(type: object) {
+    // 	return McAxiosManager._axios.splice(type);
+    // }
+    static clear() {
+        McAxiosManager._axios = [];
+    }
+}

package/dist/McDataAnnotations.d.ts

@@ -0,0 +1,13 @@
+import "reflect-metadata";
+declare const McDataAnnotations: {
+    Entity: <T extends {
+        new (...args: any[]): {};
+    }>(constructor: T) => T;
+    Serialize: (jsonKey: string) => (target: any, propertyKey: string) => void;
+    Field: (type: any, path?: string, defaultValue?: any) => (target: any, propertyKey: string) => void;
+    ArrayField: (type: any, path?: string, defaultValue?: any) => (target: any, propertyKey: string) => void;
+};
+export declare abstract class McSerializable {
+    toJson(): Record<string, any>;
+}
+export default McDataAnnotations;

package/dist/McDataAnnotations.js

@@ -0,0 +1,172 @@
+import "reflect-metadata";
+import McResponse from "./McResponse";
+const ENTITY_FLAG = Symbol("mc:isEntity");
+const SERIALIZE_FLAG = Symbol("mc:serialize");
+const FIELD_TYPE = Symbol("mc:fieldType");
+const FIELD_IS_ARRAY = Symbol("mc:isArray");
+const FIELD_PATH = Symbol("mc:fieldPath");
+const FIELD_DEFAULT = Symbol("mc:fieldDefault");
+// biome-ignore lint/suspicious/noExplicitAny: <explanation>
+const isEntity = (type) => {
+    return !!Reflect.getMetadata(ENTITY_FLAG, type);
+};
+// biome-ignore lint/suspicious/noExplicitAny: <explanation>
+const findPath = (obj, path) => {
+    const keys = path.split(".");
+    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+    let result = obj;
+    for (const key of keys) {
+        result = result[key];
+    }
+    return result;
+};
+const McDataAnnotations = {
+    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+    // biome-ignore lint/suspicious/noShadowRestrictedNames: <explanation>
+    // biome-ignore lint/complexity/noBannedTypes: <explanation>
+    Entity: (constructor) => {
+        Reflect.defineMetadata(ENTITY_FLAG, true, constructor);
+        return class extends constructor {
+            // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+            constructor(...args) {
+                super(...args);
+                // const response = args[0];
+                let body = args[0];
+                if (this instanceof McResponse) {
+                    body = args[0]?.data?.body;
+                }
+                if (body === undefined)
+                    return;
+                console.log(`Dark Response > ${body.toString()}`);
+                const proto = Object.getPrototypeOf(this);
+                // 💡 메타데이터가 붙은 키들만 필터링
+                const names = Object.getOwnPropertyNames(this).filter((key) => Reflect.hasMetadata(FIELD_TYPE, proto, key));
+                for (const key of names) {
+                    if (typeof key !== "string")
+                        continue;
+                    const descriptor = Object.getOwnPropertyDescriptor(proto, key);
+                    const type = Reflect.getMetadata(FIELD_TYPE, proto, key);
+                    const isArray = Reflect.getMetadata(FIELD_IS_ARRAY, proto, key);
+                    const path = Reflect.getMetadata(FIELD_PATH, proto, key);
+                    const defaultValue = Reflect.getMetadata(FIELD_DEFAULT, proto, key) || {};
+                    if (!type)
+                        continue;
+                    const rawValue = path ? findPath(body, path) : body[key];
+                    // console.log(`Dartk > ${key.toString()} >> ${isArray} >>> ${Array.isArray(rawValue)}`);
+                    if (rawValue !== undefined && rawValue !== null) {
+                        if (isArray && Array.isArray(rawValue)) {
+                            let cnt = 0;
+                            // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+                            this[key] = rawValue.map((item) => {
+                                return isEntity(type) ? new type(item) : type(item);
+                            });
+                        }
+                        else if ([String, Number, Boolean].includes(type)) {
+                            // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+                            this[key] = type(rawValue);
+                        }
+                        else if (isEntity(type)) {
+                            // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+                            this[key] = new type(rawValue);
+                        }
+                        else {
+                            // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+                            this[key] = new type(rawValue);
+                        }
+                    }
+                    else {
+                        if (isArray && Array.isArray(rawValue)) {
+                            let cnt = 0;
+                            // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+                            this[key] = rawValue.map((item) => {
+                                return new type(defaultValue);
+                            });
+                        }
+                        else {
+                            // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+                            this[key] = defaultValue; // 또는 null, 또는 디폴트 값
+                        }
+                    }
+                }
+                // currentPrototype = Object.getPrototypeOf(currentPrototype);
+                // }
+            }
+        };
+    },
+    Serialize: (jsonKey) => {
+        // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+        return (target, propertyKey) => {
+            // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+            const properties = Reflect.getMetadata(SERIALIZE_FLAG, target) || [];
+            properties.push({
+                propertyKey: propertyKey,
+                jsonKey: jsonKey,
+            });
+            Reflect.defineMetadata(SERIALIZE_FLAG, properties, target);
+        };
+    },
+    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+    Field: (type, path, defaultValue = undefined) => {
+        // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+        return (target, propertyKey) => {
+            // const type = Reflect.getMetadata("design:type", target, propertyKey);
+            Reflect.defineMetadata(FIELD_TYPE, type, target, propertyKey);
+            Reflect.defineMetadata(FIELD_DEFAULT, defaultValue, target, propertyKey);
+            Reflect.defineMetadata(FIELD_PATH, path, target, propertyKey);
+        };
+    },
+    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+    ArrayField: (type, path, defaultValue = undefined) => {
+        // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+        return (target, propertyKey) => {
+            // const type = Reflect.getMetadata("design:type", target, propertyKey);
+            Reflect.defineMetadata(FIELD_TYPE, type, target, propertyKey);
+            Reflect.defineMetadata(FIELD_IS_ARRAY, true, target, propertyKey);
+            Reflect.defineMetadata(FIELD_PATH, path, target, propertyKey);
+        };
+    },
+    // Name: (originalKey: string) => {
+    // 	// biome-ignore lint/suspicious/noExplicitAny: <explanation>
+    // 	return (target: any, propertyKey: string) => {
+    // 		// const type = Reflect.getMetadata("design:type", target, propertyKey);
+    // 		Reflect.defineMetadata(FIELD_NAME, originalKey, target, propertyKey);
+    // 	};
+    // },
+};
+export class McSerializable {
+    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+    toJson() {
+        // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+        const result = {};
+        // 'this'는 런타임에 클래스의 인스턴스를 가리킵니다.
+        // 메타데이터는 프로토타입에 저장되어 있으므로 this.constructor.prototype 에서 찾습니다.
+        const properties = Reflect.getMetadata(SERIALIZE_FLAG, this.constructor.prototype);
+        if (!properties) {
+            return result;
+        }
+        for (const prop of properties) {
+            // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+            const value = this[prop.propertyKey];
+            // (this as any)를 통해 인스턴스의 프로퍼티 값에 접근합니다.
+            if (Array.isArray(value)) {
+                // 값이 배열일 경우, 각 항목을 재귀적으로 처리
+                result[prop.jsonKey] = value.map((item) => {
+                    if (item && typeof item.toJson === "function") {
+                        return item.toJson(); // 배열 안의 객체가 serializable이면 toJson() 호출
+                    }
+                    return item; // 아니면 값 그대로 반환
+                });
+            }
+            else if (value && typeof value.toJson === "function") {
+                // 값이 단일 serializable 객체일 경우
+                result[prop.jsonKey] = value.toJson(); // 해당 객체의 toJson() 호출
+            }
+            else {
+                // 값이 기본 타입이거나 non-serializable 객체일 경우
+                result[prop.jsonKey] = value;
+            }
+        }
+        return result;
+    }
+}
+export default McDataAnnotations;

package/dist/McRequest.d.ts

@@ -0,0 +1,3 @@
+import { McSerializable } from "./McDataAnnotations";
+export default abstract class McRequest extends McSerializable {
+}

package/dist/McRequest.js

@@ -0,0 +1,3 @@
+import { McSerializable } from "./McDataAnnotations";
+export default class McRequest extends McSerializable {
+}

package/dist/McResponse.d.ts

@@ -0,0 +1,7 @@
+import type { AxiosResponseHeaders, RawAxiosResponseHeaders } from "axios";
+import type { AxiosResponse } from "axios";
+export default abstract class McResponse {
+    private readonly _headers;
+    protected constructor(response: AxiosResponse);
+    get headers(): RawAxiosResponseHeaders | AxiosResponseHeaders;
+}

package/dist/McResponse.js

@@ -0,0 +1,9 @@
+export default class McResponse {
+    _headers;
+    constructor(response) {
+        this._headers = response.headers;
+    }
+    get headers() {
+        return this._headers;
+    }
+}

package/dist/McSerializable.js

@@ -0,0 +1 @@
+"use strict";

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "mcl-axios-kit",
+  "version": "0.0.1",
+  "description": "McL에서 Axios를 활용해 API를 보다 효율적이고 깔끔하게 활용할 수 있도록 구현된 Kit",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "rm -rf dist && tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "axios", "typescript", "mcl"
+  ],
+  "author": "IDEa Team",
+  "license": "Apache-2.0",
+  "dependencies": {
+    "reflect-metadata": "^0.2.2"
+  },
+  "peerDependencies": {
+    "axios": "^1.13.4"
+  },
+  "devDependencies": {
+    "axios": "^1.13.4",
+    "@types/node": "^25.2.0",
+    "typescript": "^5.9.3"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dark1004-k/mcl-axios-kit.git"
+  }
+}