dn-react-router-toolkit 0.1.0

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

@@ -0,0 +1,18 @@
+import { NO_CONTENT, UNAUTHORIZED } from "../../../../http-kit";
+export const logoutHandler = async (request, { AUTH, repository }) => {
+    const auth = await AUTH.verifyOrRefresh(request);
+    if (!auth) {
+        return UNAUTHORIZED();
+    }
+    await repository.updateUserRefreshToken(auth.userId, null);
+    const headers = new Headers();
+    const [accessTokenSetCookie, refreshTokenSetCookie] = await Promise.all([
+        AUTH.getAccessTokenSetCookie(null),
+        AUTH.getRefreshTokenSetCookie(null),
+    ]);
+    headers.append("Set-Cookie", accessTokenSetCookie);
+    headers.append("Set-Cookie", refreshTokenSetCookie);
+    return NO_CONTENT({
+        headers,
+    });
+};

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

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

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

@@ -0,0 +1,19 @@
+import { BAD_REQUEST, CREATED, UNAUTHORIZED } from "../../../../http-kit";
+export const authRefreshHandler = async (request, { AUTH, }) => {
+    var _a;
+    const refreshToken = ((_a = request === null || request === void 0 ? void 0 : request.headers.get("Authorization")) === null || _a === void 0 ? void 0 : _a.replace("Bearer ", "")) ||
+        (await AUTH.getRefreshTokenFromCookies(request));
+    if (!refreshToken) {
+        return BAD_REQUEST();
+    }
+    try {
+        const accessToken = await AUTH.refreshAccessToken(refreshToken);
+        return CREATED({ accessToken });
+    }
+    catch (e) {
+        if (e instanceof Error) {
+            return UNAUTHORIZED(e.message);
+        }
+        throw e;
+    }
+};

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

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

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

@@ -0,0 +1,8 @@
+import { OK, UNAUTHORIZED } from "../../../http-kit";
+export const getAuthHandler = async (request, { AUTH }) => {
+    const auth = await AUTH.verifyOrRefresh(request);
+    if (!auth) {
+        return UNAUTHORIZED();
+    }
+    return OK(auth);
+};

package/dist/esm/route/api/files/[fileId]/route.d.ts

@@ -0,0 +1,8 @@
+import { AuthService } from "../../../../auth-kit/auth_service";
+import { type FileRepository } from "../../../../file-kit/repository";
+export declare const fileDeleteHandler: <TFile>(request: Request, { fileId }: {
+    fileId: string;
+}, { AUTH, repository, }: {
+    AUTH: AuthService;
+    repository: FileRepository<TFile>;
+}) => Promise<Response>;

package/dist/esm/route/api/files/[fileId]/route.js

@@ -0,0 +1,16 @@
+import { FORBIDDEN, NO_CONTENT, NOT_FOUND } from "../../../../http-kit";
+export const fileDeleteHandler = async (request, { fileId }, { AUTH, repository, }) => {
+    const auth = await AUTH.verifyOrRefresh(request);
+    const file = await repository.findFileById(fileId);
+    const headers = {
+        "Access-Control-Allow-Origin": "*",
+    };
+    if (!file) {
+        return NOT_FOUND("파일을 찾을 수 없습니다.", { headers });
+    }
+    if (!repository.hasPermission(file, auth === null || auth === void 0 ? void 0 : auth.userId)) {
+        return FORBIDDEN("파일을 삭제할 권한이 없습니다.", { headers });
+    }
+    await repository.deleteFile(fileId);
+    return NO_CONTENT({ headers });
+};

package/dist/esm/route/api/files/route.d.ts

@@ -0,0 +1,6 @@
+import { AuthService } from "../../../auth-kit/auth_service";
+import { FileService } from "../../../file-kit/file_service";
+export declare const fileUploadHandler: <TFile>(request: Request, { AUTH, FILE_SERVICE, }: {
+    AUTH: AuthService;
+    FILE_SERVICE: FileService<TFile>;
+}) => Promise<Response>;

package/dist/esm/route/api/files/route.js

@@ -0,0 +1,30 @@
+import { BAD_REQUEST, CREATED, INTERNAL_SERVER_ERROR } from "../../../http-kit";
+export const fileUploadHandler = async (request, { AUTH, FILE_SERVICE, }) => {
+    const auth = await AUTH.verifyOrRefresh(request);
+    const { name, type, size, metadata } = await request.json();
+    const headers = {
+        "Access-Control-Allow-Origin": "*",
+    };
+    if (typeof name !== "string") {
+        return BAD_REQUEST("파일 이름이 필요해요.", { headers });
+    }
+    if (typeof type !== "string") {
+        return BAD_REQUEST("파일 타입이 필요해요.", { headers });
+    }
+    try {
+        const result = await FILE_SERVICE.generateSignedUrl({
+            userId: auth === null || auth === void 0 ? void 0 : auth.userId,
+            name,
+            type,
+            size,
+            metadata,
+        });
+        return CREATED(result, { headers });
+    }
+    catch (e) {
+        if (e instanceof Error) {
+            return INTERNAL_SERVER_ERROR(e.message, { headers });
+        }
+        return INTERNAL_SERVER_ERROR(e, { headers });
+    }
+};

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

@@ -0,0 +1,11 @@
+import { AuthService } from "../../../../auth-kit/auth_service";
+import { GoogleAuth } from "../../../../auth-kit/google_auth";
+import { AppleAuth } from "../../../../auth-kit/apple_auth";
+export declare const thirdPartyAuthCallbackHandler: (request: Request, { provider, }: {
+    provider: string;
+}, { AUTH, GOOGLE_AUTH, APPLE_AUTH, SITE_ORIGIN, }: {
+    AUTH: AuthService;
+    GOOGLE_AUTH: GoogleAuth;
+    APPLE_AUTH: AppleAuth;
+    SITE_ORIGIN: string;
+}) => Promise<Response>;

package/dist/esm/route/auth/callback/[provider]/route.js

@@ -0,0 +1,31 @@
+import { BAD_REQUEST } from "../../../../http-kit";
+export const thirdPartyAuthCallbackHandler = async (request, { provider, }, { AUTH, GOOGLE_AUTH, APPLE_AUTH, SITE_ORIGIN, }) => {
+    const url = new URL(request.url);
+    const code = url.searchParams.get("code");
+    if (!code) {
+        throw BAD_REQUEST("코드가 없습니다.");
+    }
+    const getThirdPartyAuth = (provider) => {
+        switch (provider) {
+            case "google":
+                return GOOGLE_AUTH;
+            case "apple":
+                return APPLE_AUTH;
+            default:
+                throw BAD_REQUEST("지원하지 않는 인증 제공자입니다.");
+        }
+    };
+    const { accessToken, refreshToken } = await getThirdPartyAuth(provider).signIn(code);
+    const [accessTokenSetCookie, refreshTokenSetCookie] = await Promise.all([
+        AUTH.getAccessTokenSetCookie(accessToken),
+        AUTH.getRefreshTokenSetCookie(refreshToken),
+    ]);
+    const headers = new Headers();
+    headers.append("Set-Cookie", accessTokenSetCookie);
+    headers.append("Set-Cookie", refreshTokenSetCookie);
+    const redirectUrl = url.searchParams.get("state") || SITE_ORIGIN;
+    return new Response("Temporary Redirect", {
+        status: 307,
+        headers: Object.assign(Object.assign({}, headers), { Location: new URL(`/r?redirectUrl=${encodeURIComponent(redirectUrl)}`, request.url).toString() }),
+    });
+};

package/dist/esm/route/index.d.ts

@@ -0,0 +1,22 @@
+import { AuthService } from "../auth-kit/auth_service";
+import { GoogleAuth } from "../auth-kit/google_auth";
+import { AppleAuth } from "../auth-kit/apple_auth";
+import { type FileRepository } from "../file-kit/repository";
+import { FileService } from "../file-kit/file_service";
+import { JWTManager } from "../auth-kit/jwt";
+import { type AuthRepository } from "../auth-kit/repository";
+import { KakaoAuth } from "../auth-kit/kakao_auth";
+export declare const createAuthAPIHandler: <TFile>({ AUTH, GOOGLE_AUTH, APPLE_AUTH, KAKAO_AUTH, JWT_MANAGER, FILE_SERVICE, SITE_ORIGIN, authRepository, fileRepository, }: {
+    SITE_ORIGIN: string;
+    JWT_MANAGER: JWTManager;
+    AUTH: AuthService;
+    GOOGLE_AUTH: GoogleAuth;
+    APPLE_AUTH: AppleAuth;
+    KAKAO_AUTH: KakaoAuth;
+    FILE_SERVICE: FileService<TFile>;
+    authRepository: AuthRepository;
+    fileRepository: FileRepository<TFile>;
+}) => ({ request, params, }: {
+    request: Request;
+    params: any;
+}) => Promise<Response>;

package/dist/esm/route/index.js

@@ -0,0 +1,76 @@
+import { thirdPartyAuthCallbackHandler } from "./auth/callback/[provider]/route";
+import { fileUploadHandler } from "./api/files/route";
+import { fileDeleteHandler } from "./api/files/[fileId]/route";
+import { getAuthHandler } from "./api/auth/route";
+import { loginThirdPartyHandler } from "./api/auth/login/[provider]/route";
+import { loginCredentialHandler } from "./api/auth/login/route";
+import { logoutHandler } from "./api/auth/logout/route";
+import { authRefreshHandler } from "./api/auth/refresh/route";
+export const createAuthAPIHandler = ({ AUTH, GOOGLE_AUTH, APPLE_AUTH, KAKAO_AUTH, JWT_MANAGER, FILE_SERVICE, SITE_ORIGIN, authRepository, fileRepository, }) => {
+    const handler = async ({ request, params, }) => {
+        const method = request.method.toUpperCase();
+        const slug = params["*"].split("/");
+        if (slug[0] === "auth") {
+            if (!slug[1]) {
+                if (method === "GET") {
+                    return getAuthHandler(request, { AUTH });
+                }
+            }
+            if (slug[1] === "login") {
+                if (slug[2]) {
+                    const provider = slug[2];
+                    if (method === "POST") {
+                        return loginThirdPartyHandler(request, { provider }, { GOOGLE_AUTH, KAKAO_AUTH, APPLE_AUTH });
+                    }
+                }
+                if (method === "POST") {
+                    return loginCredentialHandler(request, {
+                        AUTH,
+                        JWT_MANAGER,
+                    });
+                }
+            }
+            if (slug[1] === "logout") {
+                if (method === "POST") {
+                    return logoutHandler(request, {
+                        AUTH,
+                        repository: authRepository,
+                    });
+                }
+            }
+            if (slug[1] === "refresh") {
+                if (method === "GET") {
+                    return authRefreshHandler(request, { AUTH });
+                }
+            }
+            if (slug[1] === "callback") {
+                if (slug[2]) {
+                    const provider = slug[2];
+                    if (method === "GET") {
+                        return thirdPartyAuthCallbackHandler(request, { provider }, {
+                            AUTH,
+                            GOOGLE_AUTH,
+                            APPLE_AUTH,
+                            SITE_ORIGIN,
+                        });
+                    }
+                }
+            }
+        }
+        if (slug[0] === "files") {
+            if (!slug[1]) {
+                if (method === "POST") {
+                    return fileUploadHandler(request, { AUTH, FILE_SERVICE });
+                }
+            }
+            if (slug[1]) {
+                if (method === "DELETE") {
+                    const fileId = slug[1];
+                    return fileDeleteHandler(request, { fileId }, { AUTH, repository: fileRepository });
+                }
+            }
+        }
+        return new Response("Not Found", { status: 404 });
+    };
+    return handler;
+};

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

@@ -0,0 +1,3 @@
+export * from "./loader";
+export * from "./seo_loader";
+export * from "./seo";

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

@@ -0,0 +1,3 @@
+export * from "./loader";
+export * from "./seo_loader";
+export * from "./seo";

package/dist/esm/seo-kit/loader.d.ts

@@ -0,0 +1,5 @@
+export type LoaderFn<T, U> = (props: T) => U | Promise<U>;
+export declare function createLoader<T, U = void>(fn?: LoaderFn<T, U>): {
+    getData(): U;
+    wrap<V>(mapper: (props: U) => V | Promise<V>): (props: T) => Promise<V>;
+};

package/dist/esm/seo-kit/loader.js

@@ -0,0 +1,14 @@
+export function createLoader(fn = () => ({})) {
+    let loadedData;
+    return {
+        getData() {
+            return loadedData;
+        },
+        wrap(mapper) {
+            return async function Thing(props) {
+                loadedData = await fn(props);
+                return mapper(loadedData);
+            };
+        },
+    };
+}

package/dist/esm/seo-kit/seo.d.ts

@@ -0,0 +1,100 @@
+import * as Schema from "schema-dts";
+import React from "react";
+import type { MetaFunction } from "react-router";
+export type SEOImage = {
+    id?: string;
+    url: string;
+    alt?: string;
+    width?: number;
+    height?: number;
+};
+export type SEO = Awaited<ReturnType<ReturnType<typeof configSEO>["init"]>>;
+export declare function configSEO(config: {
+    origin: string;
+    siteName: string;
+    description: string;
+    keywords?: string[];
+    thumbnail?: SEOImage | (() => SEOImage | null | Promise<SEOImage | null>);
+    structedData?: Schema.Thing[] | (() => Schema.Thing[] | Promise<Schema.Thing[]>);
+    copyright?: string;
+}): {
+    config: {
+        origin: string;
+        siteName: string;
+        description: string;
+        keywords?: string[];
+        thumbnail?: SEOImage | (() => SEOImage | null | Promise<SEOImage | null>);
+        structedData?: Schema.Thing[] | (() => Schema.Thing[] | Promise<Schema.Thing[]>);
+        copyright?: string;
+    };
+    init(props?: {
+        title?: string;
+        description?: string;
+        keywords?: string[];
+        path?: string;
+        type?: string;
+        canonicalPath?: string;
+        breadcrumbs?: {
+            label: string;
+            href: string;
+        }[];
+        thumbnail?: SEOImage;
+        images?: SEOImage[];
+        updatedAt?: Date;
+        createdAt?: Date;
+        structedData?: Schema.Thing[] | (() => Schema.Thing[] | Promise<Schema.Thing[]>);
+        article?: boolean;
+        blogPosting?: boolean;
+        creativeWork?: boolean;
+        visualArtwork?: boolean;
+        collection?: {
+            title: string;
+            url: string;
+            description?: string;
+            thumbnail?: SEOImage;
+            updatedAt?: Date;
+            createdAt?: Date;
+        }[];
+    }): Promise<{
+        config: {
+            origin: string;
+            siteName: string;
+            description: string;
+            keywords?: string[];
+            thumbnail?: SEOImage | (() => SEOImage | null | Promise<SEOImage | null>);
+            structedData?: Schema.Thing[] | (() => Schema.Thing[] | Promise<Schema.Thing[]>);
+            copyright?: string;
+        };
+        props: {
+            title?: string;
+            description?: string;
+            keywords?: string[];
+            path?: string;
+            type?: string;
+            canonicalPath?: string;
+            breadcrumbs?: {
+                label: string;
+                href: string;
+            }[];
+            thumbnail?: SEOImage;
+            images?: SEOImage[];
+            updatedAt?: Date;
+            createdAt?: Date;
+            structedData?: Schema.Thing[] | (() => Schema.Thing[] | Promise<Schema.Thing[]>);
+            article?: boolean;
+            blogPosting?: boolean;
+            creativeWork?: boolean;
+            visualArtwork?: boolean;
+            collection?: {
+                title: string;
+                url: string;
+                description?: string;
+                thumbnail?: SEOImage;
+                updatedAt?: Date;
+                createdAt?: Date;
+            }[];
+        };
+        meta: MetaFunction<unknown, Record<string, unknown>>;
+        generateJSONLD: () => React.JSX.Element;
+    }>;
+};