dn-react-router-toolkit 0.1.0

package/dist/esm/file-kit/client/drop_file_input.d.ts

@@ -0,0 +1,31 @@
+import React from "react";
+import { type FileUploaderOptions } from "./file_uploader";
+export type FileInputProps = Omit<React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "defaultValue" | "onChange"> & {
+    container?: string;
+    accept?: string;
+    multiple?: boolean;
+    name?: string;
+    hideMessage?: boolean;
+    draggingClassName?: (value: boolean) => string;
+};
+export type FileItem<T> = {
+    key: string;
+    item?: T;
+};
+type Props<T> = {
+    defaultValue?: T | T[];
+    options?: FileUploaderOptions;
+    uploadFile?: (file: File, options?: FileUploaderOptions) => Promise<T>;
+    onFileInput?: (files: File[]) => void;
+    onFileUploaded?: (file: T) => Promise<void>;
+    onChange?: (files: FileItem<T>[]) => void;
+    limit?: number;
+};
+export declare function useDropFileInput<T>({ defaultValue, options, uploadFile, onFileInput, onFileUploaded, limit, }?: Props<T>): {
+    fileIds: string[];
+    files: FileItem<T>[];
+    setFiles: React.Dispatch<React.SetStateAction<FileItem<T>[]>>;
+    Component: ({ className, container, draggingClassName, name, hideMessage, children, ...props }: FileInputProps) => React.JSX.Element;
+};
+export declare function DropFileMessageBox(): React.JSX.Element;
+export default useDropFileInput;

package/dist/esm/file-kit/client/drop_file_input.js

@@ -0,0 +1,158 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import React, { useState, useCallback, useRef, useEffect, useMemo, } from "react";
+import { v4 } from "uuid";
+import { cn } from "../../cn";
+export function useDropFileInput({ defaultValue, options, uploadFile, onFileInput, onFileUploaded, limit, } = {}) {
+    const [files, setFiles] = useState(defaultValue
+        ? (Array.isArray(defaultValue) ? defaultValue : [defaultValue])
+            .map((v) => {
+            return {
+                key: v4(),
+                item: v,
+            };
+        })
+            .slice(0, limit ? limit : Infinity)
+        : []);
+    const fileRef = useRef([]);
+    useEffect(() => {
+        fileRef.current = files;
+    }, [files]);
+    const Component = useCallback(function Component(_a) {
+        var { className, container = "border border-dashed border-neutral-300 rounded flex items-center justify-center", draggingClassName, name, hideMessage = false, children } = _a, props = __rest(_a, ["className", "container", "draggingClassName", "name", "hideMessage", "children"]);
+        const [isDragging, setIsDragging] = useState(false);
+        const handleDragEnter = useCallback((e) => {
+            e.preventDefault();
+            e.stopPropagation();
+            setIsDragging(true);
+        }, []);
+        const handleDragLeave = useCallback((e) => {
+            e.preventDefault();
+            e.stopPropagation();
+            setIsDragging(false);
+        }, []);
+        const handleDragOver = useCallback((e) => {
+            e.preventDefault();
+            e.stopPropagation();
+        }, []);
+        const handleFiles = useCallback(async (files) => {
+            if (limit && fileRef.current.length >= limit) {
+                alert(`파일은 최대 ${limit}개 업로드할 수 있습니다.`);
+                return;
+            }
+            const filteredFiles = files.filter((file) => {
+                // if (!props.accept) {
+                //   return true;
+                // }
+                // const accepts = props.accept.split(",");
+                // for (const accept of accepts) {
+                //   if (file.type.startsWith(accept)) {
+                //     return true;
+                //   }
+                //   if (file.name.endsWith(accept)) {
+                //     return true;
+                //   }
+                // }
+                // return false;
+                return true;
+            });
+            if (files.length !== filteredFiles.length) {
+                alert(`${props.accept} 형식의 파일만 업로드할 수 있습니다.`);
+            }
+            const limitedFiles = filteredFiles.slice(0, limit ? limit - fileRef.current.length : Infinity);
+            if (limitedFiles.length === 0) {
+                return;
+            }
+            if (onFileInput) {
+                onFileInput(limitedFiles);
+            }
+            for (const file of limitedFiles) {
+                const fileItem = {
+                    key: v4(),
+                };
+                setFiles((prevFiles) => [...prevFiles, fileItem]);
+                uploadFile === null || uploadFile === void 0 ? void 0 : uploadFile(file, options).then(async (item) => {
+                    await (onFileUploaded === null || onFileUploaded === void 0 ? void 0 : onFileUploaded(item));
+                    setFiles((prevFiles) => prevFiles.map((f) => {
+                        if (f.key === fileItem.key) {
+                            return Object.assign(Object.assign({}, f), { item });
+                        }
+                        return f;
+                    }));
+                });
+            }
+        }, [props.accept]);
+        const handleDrop = useCallback((e) => {
+            e.preventDefault();
+            e.stopPropagation();
+            setIsDragging(false);
+            if (e.dataTransfer.files && e.dataTransfer.files.length > 0) {
+                handleFiles(Array.from(e.dataTransfer.files));
+                e.dataTransfer.clearData();
+            }
+        }, [handleFiles]);
+        const inputRef = useRef(null);
+        const handleClick = useCallback(() => {
+            var _a;
+            (_a = inputRef.current) === null || _a === void 0 ? void 0 : _a.click();
+        }, []);
+        const handleKeyDown = useCallback((e) => {
+            if (e.key === "Enter" || e.key === " ") {
+                handleClick();
+            }
+        }, [handleClick]);
+        const handleChange = useCallback((e) => {
+            if (e.target.files && e.target.files.length > 0) {
+                handleFiles(Array.from(e.target.files));
+                e.target.value = "";
+            }
+        }, [handleFiles]);
+        return (React.createElement("div", { className: cn(className, container, (draggingClassName === null || draggingClassName === void 0 ? void 0 : draggingClassName(isDragging)) ||
+                (isDragging ? "bg-neutral-300/25" : "hover:bg-neutral-300/25"), "transition-colors cursor-pointer"), onDragEnter: handleDragEnter, onDragLeave: handleDragLeave, onDragOver: handleDragOver, onDrop: handleDrop, onClick: handleClick, onChange: handleChange, onKeyDown: handleKeyDown, tabIndex: 0, role: "button" },
+            React.createElement("input", Object.assign({}, props, { defaultValue: "", type: "file", hidden: true, ref: inputRef })),
+            React.createElement("input", { name: name, hidden: true, readOnly: true, value: files
+                    .map((file) => {
+                    if (file.item &&
+                        typeof file.item === "object" &&
+                        "id" in file.item) {
+                        return file.item.id;
+                    }
+                    return null;
+                })
+                    .filter(Boolean)
+                    .join(",") }),
+            children ||
+                (!(hideMessage && !isDragging) && React.createElement(DropFileMessageBox, null))));
+    }, [limit, fileRef, files, options, uploadFile, onFileInput, onFileUploaded]);
+    const loadedFileIds = files
+        .map((file) => {
+        if (file.item && typeof file.item === "object" && "id" in file.item) {
+            return file.item.id;
+        }
+        return null;
+    })
+        .filter(Boolean);
+    const loadedFileIdsString = loadedFileIds.join(",");
+    const fileIds = useMemo(() => loadedFileIdsString.split(",").filter(Boolean), [loadedFileIdsString]);
+    return {
+        fileIds,
+        files,
+        setFiles,
+        Component,
+    };
+}
+export function DropFileMessageBox() {
+    return (React.createElement("div", { className: "text-sm pointer-events-none flex justify-center items-center" },
+        React.createElement("div", { className: "flex flex-col items-center" },
+            React.createElement("span", null, "\uD30C\uC77C\uC744 \uC5EC\uAE30\uB85C \uB04C\uC5B4\uB2E4 \uB193\uAC70\uB098 \uD074\uB9AD\uD574\uC11C \uC120\uD0DD\uD574 \uC8FC\uC138\uC694"))));
+}
+export default useDropFileInput;

package/dist/esm/file-kit/client/file_uploader.d.ts

@@ -0,0 +1,11 @@
+export type FileUploaderOptions = {
+    metadata?: Record<string, unknown>;
+};
+export declare class FileUploader {
+    endpoint: string;
+    constructor(endpoint?: string);
+    formatSize: (size: number) => string;
+    uploadFile(file: File, options?: FileUploaderOptions): Promise<any>;
+    uploadBlob(blob: Blob, name?: string, options?: FileUploaderOptions): Promise<any>;
+    deleteFile(fileId: string): Promise<boolean>;
+}

package/dist/esm/file-kit/client/file_uploader.js

@@ -0,0 +1,74 @@
+export class FileUploader {
+    constructor(endpoint = "/api/files") {
+        this.formatSize = (size) => {
+            if (size < 1024) {
+                return `${size} B`;
+            }
+            if (size < 1024 * 1024) {
+                return `${(size / 1024).toFixed(2)} KB`;
+            }
+            return `${(size / (1024 * 1024)).toFixed(2)} MB`;
+        };
+        this.endpoint = endpoint;
+    }
+    uploadFile(file, options = {}) {
+        return this.uploadBlob(file, file.name, options);
+    }
+    async uploadBlob(blob, name = "blob", options = {}) {
+        const { type, size } = blob;
+        const metadataForMedia = await new Promise((resolve, reject) => {
+            if (blob.type.startsWith("image/")) {
+                const img = new Image();
+                img.src = URL.createObjectURL(blob);
+                img.onload = () => {
+                    resolve(Object.assign(Object.assign({}, options.metadata), { width: img.width, height: img.height }));
+                };
+                img.onerror = reject;
+                return;
+            }
+            if (blob.type.startsWith("video/")) {
+                const video = document.createElement("video");
+                video.src = URL.createObjectURL(blob);
+                video.onloadedmetadata = () => {
+                    resolve(Object.assign(Object.assign({}, options.metadata), { width: video.videoWidth, height: video.videoHeight, duration: video.duration }));
+                };
+                video.onerror = reject;
+                return;
+            }
+            resolve(options.metadata || {});
+        });
+        const res1 = await fetch(this.endpoint, {
+            method: "POST",
+            body: JSON.stringify({
+                name: name.replace(/ /g, "_"),
+                type,
+                size,
+                metadata: metadataForMedia,
+            }),
+        });
+        if (!res1.ok) {
+            const message = await res1.json();
+            throw new Error(message);
+        }
+        const result = await res1.json();
+        const { signedUrl, file } = result;
+        const res2 = await fetch(signedUrl, {
+            method: "PUT",
+            body: blob,
+        });
+        if (!res2.ok) {
+            throw new Error(await res2.text());
+        }
+        return file;
+    }
+    async deleteFile(fileId) {
+        const res = await fetch(`${this.endpoint}/${fileId}`, {
+            method: "DELETE",
+        });
+        if (!res.ok) {
+            const { message } = await res.json();
+            throw new Error(message);
+        }
+        return true;
+    }
+}

package/dist/esm/file-kit/file_service.d.ts

@@ -0,0 +1,23 @@
+import { ObjectStorage } from "./object_storage";
+import { type FileRepository } from "./repository";
+type Params = {
+    userId?: string;
+    name: string;
+    type: string;
+    size: number;
+    metadata?: Record<string, any>;
+};
+export declare class FileService<TFile> {
+    prefix: string;
+    repository: FileRepository<TFile>;
+    OBJECT_STORAGE: ObjectStorage;
+    constructor(prefix: string | undefined, { repository, OBJECT_STORAGE, }: {
+        repository: FileRepository<TFile>;
+        OBJECT_STORAGE: ObjectStorage;
+    });
+    generateSignedUrl({ userId, name, type, size, metadata }: Params): Promise<{
+        file: Awaited<TFile>;
+        signedUrl: string;
+    }>;
+}
+export {};

package/dist/esm/file-kit/file_service.js

@@ -0,0 +1,25 @@
+import { v4 } from "uuid";
+export class FileService {
+    constructor(prefix = "user", { repository, OBJECT_STORAGE, }) {
+        this.prefix = prefix;
+        this.repository = repository;
+        this.OBJECT_STORAGE = OBJECT_STORAGE;
+    }
+    async generateSignedUrl({ userId, name, type, size, metadata = {} }) {
+        const id = v4();
+        const key = `${this.prefix}/${id}/${name}`;
+        const file = await this.repository.createFile({
+            id,
+            userId,
+            name,
+            type,
+            size,
+            metadata,
+            key,
+        });
+        const signedUrl = await this.OBJECT_STORAGE.generateSignedUrl(key, {
+            contentType: type,
+        });
+        return { file, signedUrl };
+    }
+}

package/dist/esm/file-kit/object_storage.d.ts

@@ -0,0 +1,13 @@
+export declare class ObjectStorage {
+    private client;
+    private bucketName;
+    constructor(bucketName: string);
+    generateSignedUrl(key: string, { contentType, expiresIn, }?: {
+        contentType?: string;
+        expiresIn?: number;
+    }): Promise<string>;
+    find(key: string): Promise<Uint8Array<ArrayBufferLike> | undefined>;
+    put(key: string, buffer: Buffer, { contentType }?: {
+        contentType?: string;
+    }): Promise<import("@aws-sdk/client-s3").PutObjectCommandOutput>;
+}

package/dist/esm/file-kit/object_storage.js

@@ -0,0 +1,46 @@
+import { GetObjectCommand, PutObjectCommand, S3Client, } from "@aws-sdk/client-s3";
+import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
+export class ObjectStorage {
+    constructor(bucketName) {
+        this.client = new S3Client({
+            region: "ap-northeast-2",
+        });
+        this.bucketName = bucketName;
+    }
+    async generateSignedUrl(key, { contentType, expiresIn = 3600, } = {}) {
+        const command = new PutObjectCommand({
+            Bucket: this.bucketName,
+            Key: key,
+            ContentType: contentType,
+        });
+        const signedUrl = await getSignedUrl(this.client, command, {
+            expiresIn,
+        });
+        return signedUrl;
+    }
+    async find(key) {
+        try {
+            const command = new GetObjectCommand({
+                Bucket: this.bucketName,
+                Key: key,
+            });
+            const { Body } = await this.client.send(command);
+            if (!Body) {
+                return;
+            }
+            return Body.transformToByteArray();
+        }
+        catch (error) {
+            return;
+        }
+    }
+    async put(key, buffer, { contentType } = {}) {
+        const command = new PutObjectCommand({
+            Bucket: this.bucketName,
+            Key: key,
+            ContentType: contentType,
+            Body: buffer,
+        });
+        return await this.client.send(command);
+    }
+}

package/dist/esm/file-kit/repository.d.ts

@@ -0,0 +1,14 @@
+export interface FileRepository<TFile> {
+    findFileById(fileId: string): Promise<TFile | undefined>;
+    hasPermission(file: TFile, userId?: string): boolean;
+    createFile(fileData: {
+        id: string;
+        userId?: string;
+        name: string;
+        type: string;
+        size: number;
+        metadata: Record<string, any>;
+        key: string;
+    }): Promise<TFile>;
+    deleteFile(fileId: string): Promise<void>;
+}

package/dist/esm/file-kit/repository.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/file-kit/responsive_image.d.ts

@@ -0,0 +1,17 @@
+import React from "react";
+export type ResponsiveImageProps = Omit<React.DetailedHTMLProps<React.ImgHTMLAttributes<HTMLImageElement>, HTMLImageElement>, "src" | "srcSet" | "alt"> & {
+    alt: string;
+    src?: string;
+    file?: {
+        key: string;
+    };
+    ratio?: number;
+};
+export declare const createResponsiveImage: (cdn: (key: string | undefined, options?: {
+    width?: number;
+}) => string | undefined) => React.FC<ResponsiveImageProps>;
+export default createResponsiveImage;
+export declare function generateSrcSet(image: HTMLImageElement | string, ratio?: number, props?: {
+    width?: string | number;
+    height?: string | number;
+}): string | undefined;

package/dist/esm/file-kit/responsive_image.js

@@ -0,0 +1,70 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import React from "react";
+const sizes = [
+    64, 128, 256, 320, 480, 640, 768, 1080, 1200, 1536, 1920, 2560, 3840,
+];
+export const createResponsiveImage = (cdn) => {
+    const Component = (_a) => {
+        var { alt, file, ratio } = _a, props = __rest(_a, ["alt", "file", "ratio"]);
+        const src = cdn(file === null || file === void 0 ? void 0 : file.key) || props.src || "#";
+        return (React.createElement("img", Object.assign({}, props, { src: src, alt: alt, srcSet: generateSrcSet(src, ratio, props) })));
+    };
+    return Component;
+};
+export default createResponsiveImage;
+const generateSrc = (src, width, height, ratio, image = {}) => {
+    const searchParams = new URLSearchParams();
+    if (image.width) {
+        searchParams.set("w", image.width.toString());
+    }
+    if (width) {
+        searchParams.set("w", width.toString());
+        if (ratio) {
+            searchParams.set("h", Math.round(width / ratio).toString());
+        }
+    }
+    if (image.height) {
+        searchParams.set("h", image.height.toString());
+    }
+    if (height) {
+        searchParams.set("h", height.toString());
+    }
+    const search = searchParams.toString() ? `?${searchParams.toString()}` : "";
+    const origin = process.env.NEXT_PUBLIC_CDN_ORIGIN || "";
+    if (!src.includes(origin)) {
+        return src;
+    }
+    return `${encodeURI(decodeURI(src))}${search}`;
+};
+export function generateSrcSet(image, ratio, props = {}) {
+    const src = typeof image === "string" ? image : image.src;
+    const isGif = src.endsWith(".gif");
+    if (isGif) {
+        return undefined;
+    }
+    if (props.width) {
+        return [1, 2, 3]
+            .map((scale) => {
+            const genWidth = Number(props.width) * scale;
+            return `${generateSrc(src, genWidth, props.height
+                ? Number(props.height) * scale
+                : ratio
+                    ? Math.round(genWidth / ratio)
+                    : undefined)} ${scale}x`;
+        })
+            .join(", ");
+    }
+    return sizes
+        .map((size) => `${generateSrc(src, size, undefined, ratio, props)} ${size}w`)
+        .join(", ");
+}

package/dist/esm/http-kit/index.d.ts

@@ -0,0 +1 @@
+export * from "./response";

package/dist/esm/http-kit/index.js

@@ -0,0 +1 @@
+export * from "./response";

package/dist/esm/http-kit/response.d.ts

@@ -0,0 +1,17 @@
+export declare const createJsonResponse: (status: number) => (data?: unknown, init?: ResponseInit) => Response;
+export declare const OK: (data?: unknown, init?: ResponseInit) => Response;
+export declare const CREATED: (data?: unknown, init?: ResponseInit) => Response;
+export declare const ACCEPTED: (data?: unknown, init?: ResponseInit) => Response;
+export declare const NO_CONTENT: (init?: ResponseInit) => Response;
+export declare const createException: (status: number, defaultMessage?: unknown) => (message?: unknown, init?: ResponseInit) => Response;
+export declare const BAD_REQUEST: (message?: unknown, init?: ResponseInit) => Response;
+export declare const UNAUTHORIZED: (message?: unknown, init?: ResponseInit) => Response;
+export declare const FORBIDDEN: (message?: unknown, init?: ResponseInit) => Response;
+export declare const NOT_FOUND: (message?: unknown, init?: ResponseInit) => Response;
+export declare const METHOD_NOT_ALLOWED: (message?: unknown, init?: ResponseInit) => Response;
+export declare const NOT_ACCEPTABLE: (message?: unknown, init?: ResponseInit) => Response;
+export declare const REQUEST_TIMEOUT: (message?: unknown, init?: ResponseInit) => Response;
+export declare const CONFLICT: (message?: unknown, init?: ResponseInit) => Response;
+export declare const UNPROCESSABLE_ENTITY: (message?: unknown, init?: ResponseInit) => Response;
+export declare const TOO_MANY_REQUESTS: (message?: unknown, init?: ResponseInit) => Response;
+export declare const INTERNAL_SERVER_ERROR: (message?: unknown, init?: ResponseInit) => Response;

package/dist/esm/http-kit/response.js

@@ -0,0 +1,28 @@
+export const createJsonResponse = (status) => {
+    return (data = {}, init) => {
+        return Response.json(data, Object.assign({ status }, init));
+    };
+};
+Response;
+export const OK = createJsonResponse(200);
+export const CREATED = createJsonResponse(201);
+export const ACCEPTED = createJsonResponse(202);
+export const NO_CONTENT = (init) => {
+    return new Response(null, Object.assign(Object.assign({}, init), { status: 204 }));
+};
+export const createException = (status, defaultMessage = "오류가 발생했습니다.") => {
+    return (message = defaultMessage, init) => {
+        return createJsonResponse(status)({ message }, init);
+    };
+};
+export const BAD_REQUEST = createException(400, "요청이 올바르지 않습니다.");
+export const UNAUTHORIZED = createException(401, "인증이 필요합니다.");
+export const FORBIDDEN = createException(403, "권한이 없습니다.");
+export const NOT_FOUND = createException(404, "요청한 리소스를 찾을 수 없습니다.");
+export const METHOD_NOT_ALLOWED = createException(405, "메서드를 사용할 수 없습니다.");
+export const NOT_ACCEPTABLE = createException(406, "요청한 형식을 사용할 수 없습니다.");
+export const REQUEST_TIMEOUT = createException(408, "요청 시간이 초과되었습니다.");
+export const CONFLICT = createException(409, "요청이 충돌했습니다.");
+export const UNPROCESSABLE_ENTITY = createException(422, "처리할 수 없는 엔티티입니다.");
+export const TOO_MANY_REQUESTS = createException(429, "요청이 너무 많습니다.");
+export const INTERNAL_SERVER_ERROR = createException(500, "예기치 못한 오류가 발생했습니다.");

package/dist/esm/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./cn";
+export * from "./date";
+export * from "./singleton";
+export * from "./slug";

package/dist/esm/index.js

@@ -0,0 +1,4 @@
+export * from "./cn";
+export * from "./date";
+export * from "./singleton";
+export * from "./slug";

package/dist/esm/route/api/auth/login/[provider]/route.d.ts

@@ -0,0 +1,10 @@
+import { GoogleAuth } from "../../../../../auth-kit/google_auth";
+import { AppleAuth } from "../../../../../auth-kit/apple_auth";
+import { KakaoAuth } from "../../../../../auth-kit/kakao_auth";
+export declare const loginThirdPartyHandler: (request: Request, { provider, }: {
+    provider: string;
+}, { GOOGLE_AUTH, APPLE_AUTH, KAKAO_AUTH, }: {
+    GOOGLE_AUTH: GoogleAuth;
+    APPLE_AUTH: AppleAuth;
+    KAKAO_AUTH: KakaoAuth;
+}) => Promise<Response>;

package/dist/esm/route/api/auth/login/[provider]/route.js

@@ -0,0 +1,32 @@
+import { BAD_REQUEST, CREATED, INTERNAL_SERVER_ERROR, } from "../../../../../http-kit";
+export const loginThirdPartyHandler = async (request, { provider, }, { GOOGLE_AUTH, APPLE_AUTH, KAKAO_AUTH, }) => {
+    const { code } = await request.json();
+    if (!code) {
+        return BAD_REQUEST("코드가 없습니다.");
+    }
+    const getThirdPartyAuth = (provider) => {
+        switch (provider) {
+            case "google":
+                return GOOGLE_AUTH;
+            case "apple":
+                return APPLE_AUTH;
+            case "kakao":
+                return KAKAO_AUTH;
+            default:
+                throw BAD_REQUEST("지원하지 않는 인증 제공자입니다.");
+        }
+    };
+    try {
+        const { accessToken, refreshToken } = await getThirdPartyAuth(provider).signIn(code);
+        return CREATED({
+            accessToken,
+            refreshToken,
+        });
+    }
+    catch (error) {
+        if (error instanceof Response) {
+            return error;
+        }
+        throw INTERNAL_SERVER_ERROR();
+    }
+};

package/dist/esm/route/api/auth/login/route.d.ts

@@ -0,0 +1,6 @@
+import { AuthService } from "../../../../auth-kit/auth_service";
+import { JWTManager } from "../../../../auth-kit/jwt";
+export declare const loginCredentialHandler: (request: Request, { AUTH, JWT_MANAGER, }: {
+    AUTH: AuthService;
+    JWT_MANAGER: JWTManager;
+}) => Promise<Response>;

package/dist/esm/route/api/auth/login/route.js

@@ -0,0 +1,31 @@
+import { CREATED, UNAUTHORIZED } from "../../../../http-kit";
+export const loginCredentialHandler = async (request, { AUTH, JWT_MANAGER, }) => {
+    const searchParams = new URL(request.url).searchParams;
+    const { id, password } = await request.json();
+    try {
+        const { accessToken, refreshToken } = await AUTH.signIn({
+            id,
+            password,
+        });
+        if (searchParams.get("type") === "json") {
+            return CREATED({ accessToken, refreshToken });
+        }
+        const [accessTokenSetCookie, refreshTokenSetCookie] = await Promise.all([
+            AUTH.getAccessTokenSetCookie(accessToken),
+            AUTH.getRefreshTokenSetCookie(refreshToken),
+        ]);
+        const payload = JWT_MANAGER.decode(accessToken);
+        const headers = new Headers();
+        headers.append("Set-Cookie", accessTokenSetCookie);
+        headers.append("Set-Cookie", refreshTokenSetCookie);
+        return CREATED(payload, {
+            headers,
+        });
+    }
+    catch (e) {
+        if (e instanceof Error) {
+            return UNAUTHORIZED(e.message);
+        }
+        throw e;
+    }
+};

package/dist/esm/route/api/auth/logout/route.d.ts

@@ -0,0 +1,6 @@
+import { AuthService } from "../../../../auth-kit/auth_service";
+import { type AuthRepository } from "../../../../auth-kit/repository";
+export declare const logoutHandler: (request: Request, { AUTH, repository }: {
+    AUTH: AuthService;
+    repository: AuthRepository;
+}) => Promise<Response>;