dn-react-router-toolkit 0.1.12 → 0.2.1

package/dist/route/api.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,16 +17,24 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/route/api.ts
 var api_exports = {};
 __export(api_exports, {
-  createAuthAPIHandler: () => createAuthAPIHandler
+  createAPIHandler: () => createAPIHandler
 });
 module.exports = __toCommonJS(api_exports);
 
-// src/http-kit/response.ts
+// src/http/response.ts
 var createJsonResponse = (status) => {
   return (data = {}, init) => {
     return Response.json(data, { status, ...init });
@@ -74,59 +84,68 @@ var INTERNAL_SERVER_ERROR = createException(
   "\uC608\uAE30\uCE58 \uBABB\uD55C \uC624\uB958\uAC00 \uBC1C\uC0DD\uD588\uC2B5\uB2C8\uB2E4."
 );
 
-// src/route/auth/callback/[provider]/route.tsx
-var thirdPartyAuthCallbackHandler = async (request, {
-  provider
-}, {
-  AUTH,
-  GOOGLE_AUTH,
-  APPLE_AUTH,
-  SITE_ORIGIN
+// src/auth/handlers/thirdparty_auth_callback.tsx
+var thirdpartyAuthCallbackHandler = async (request, {
+  provider,
+  authService,
+  getThirdPartyAuth
 }) => {
   const url = new URL(request.url);
   const code = url.searchParams.get("code");
   if (!code) {
     throw BAD_REQUEST("\uCF54\uB4DC\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4.");
   }
-  const getThirdPartyAuth = (provider2) => {
-    switch (provider2) {
-      case "google":
-        return GOOGLE_AUTH;
-      case "apple":
-        return APPLE_AUTH;
-      default:
-        throw BAD_REQUEST("\uC9C0\uC6D0\uD558\uC9C0 \uC54A\uB294 \uC778\uC99D \uC81C\uACF5\uC790\uC785\uB2C8\uB2E4.");
-    }
-  };
-  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: {
-      ...headers,
-      Location: new URL(
-        `/r?redirectUrl=${encodeURIComponent(redirectUrl)}`,
-        request.url
-      ).toString()
+  try {
+    const { accessToken, refreshToken } = await getThirdPartyAuth(
+      provider
+    ).login(code);
+    const [accessTokenSetCookie, refreshTokenSetCookie] = await Promise.all([
+      authService.getAccessTokenSetCookie(accessToken),
+      authService.getRefreshTokenSetCookie(refreshToken)
+    ]);
+    const headers = new Headers();
+    headers.append("Set-Cookie", accessTokenSetCookie);
+    headers.append("Set-Cookie", refreshTokenSetCookie);
+    const redirectUrl = url.searchParams.get("state") || "/";
+    return new Response("Temporary Redirect", {
+      status: 307,
+      headers: {
+        ...headers,
+        Location: new URL(
+          `/r?redirectUrl=${encodeURIComponent(redirectUrl)}`,
+          request.url
+        ).toString()
+      }
+    });
+  } catch (error) {
+    if (error instanceof Response) {
+      if (error.status == 404) {
+        const body = await error.json();
+        const token = body.token;
+        return new Response(
+          "Temporary Redirect",
+          {
+            status: 307,
+            headers: {
+              Location: new URL(
+                `/signup?token=${token}`,
+                request.url
+              ).toString()
+            }
+          }
+        );
+      }
     }
-  });
+    throw error;
+  }
 };
 
-// src/route/api/files/route.ts
-var fileUploadHandler = async (request, {
-  AUTH,
-  FILE_SERVICE
+// src/file/handlers/upload_file.ts
+var uploadFileHandler = async (request, {
+  authService,
+  fileService
 }) => {
-  const auth = await AUTH.verifyOrRefresh(request);
+  const auth = await authService.verifyOrRefresh(request);
   const { name, type, size, metadata } = await request.json();
   const headers = {
     "Access-Control-Allow-Origin": "*"
@@ -138,7 +157,7 @@ var fileUploadHandler = async (request, {
     return BAD_REQUEST("\uD30C\uC77C \uD0C0\uC785\uC774 \uD544\uC694\uD574\uC694.", { headers });
   }
   try {
-    const result = await FILE_SERVICE.generateSignedUrl({
+    const result = await fileService.generateSignedUrl({
       userId: auth?.userId,
       name,
       type,
@@ -154,63 +173,48 @@ var fileUploadHandler = async (request, {
   }
 };
 
-// src/route/api/files/[fileId]/route.ts
-var fileDeleteHandler = async (request, { fileId }, {
-  AUTH,
-  repository
+// src/file/handlers/delete_file.ts
+var deleteFileHandler = async (request, { fileId }, {
+  authService,
+  fileRepository
 }) => {
-  const auth = await AUTH.verifyOrRefresh(request);
-  const file = await repository.findFileById(fileId);
+  const auth = await authService.verifyOrRefresh(request);
+  const file = await fileRepository.findFileById(fileId);
   const headers = {
     "Access-Control-Allow-Origin": "*"
   };
   if (!file) {
     return NOT_FOUND("\uD30C\uC77C\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.", { headers });
   }
-  if (!repository.hasPermission(file, auth?.userId)) {
+  if (!fileRepository.hasPermission(file, auth?.userId)) {
     return FORBIDDEN("\uD30C\uC77C\uC744 \uC0AD\uC81C\uD560 \uAD8C\uD55C\uC774 \uC5C6\uC2B5\uB2C8\uB2E4.", { headers });
   }
-  await repository.deleteFile(fileId);
+  await fileRepository.deleteFile(fileId);
   return NO_CONTENT({ headers });
 };
 
-// src/route/api/auth/route.ts
-var getAuthHandler = async (request, { AUTH }) => {
-  const auth = await AUTH.verifyOrRefresh(request);
+// src/auth/handlers/find_auth.ts
+var findAuthHandler = async (request, { authService }) => {
+  const auth = await authService.verifyOrRefresh(request);
   if (!auth) {
     return UNAUTHORIZED();
   }
   return OK(auth);
 };
 
-// src/route/api/auth/login/[provider]/route.ts
-var loginThirdPartyHandler = async (request, {
-  provider
-}, {
-  GOOGLE_AUTH,
-  APPLE_AUTH,
-  KAKAO_AUTH
+// src/auth/handlers/login_with_thirdparty.ts
+var loginWithThirdPartyHandler = async (request, {
+  provider,
+  getThirdPartyAuth
 }) => {
   const { code } = await request.json();
   if (!code) {
     return BAD_REQUEST("\uCF54\uB4DC\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4.");
   }
-  const getThirdPartyAuth = (provider2) => {
-    switch (provider2) {
-      case "google":
-        return GOOGLE_AUTH;
-      case "apple":
-        return APPLE_AUTH;
-      case "kakao":
-        return KAKAO_AUTH;
-      default:
-        throw BAD_REQUEST("\uC9C0\uC6D0\uD558\uC9C0 \uC54A\uB294 \uC778\uC99D \uC81C\uACF5\uC790\uC785\uB2C8\uB2E4.");
-    }
-  };
   try {
     const { accessToken, refreshToken } = await getThirdPartyAuth(
       provider
-    ).signIn(code);
+    ).login(code);
     return CREATED({
       accessToken,
       refreshToken
@@ -223,26 +227,26 @@ var loginThirdPartyHandler = async (request, {
   }
 };
 
-// src/route/api/auth/login/route.ts
-var loginCredentialHandler = async (request, {
-  AUTH,
-  JWT_MANAGER
+// src/auth/handlers/login.ts
+var loginHandler = async (request, {
+  authService
 }) => {
-  const searchParams = new URL(request.url).searchParams;
   const { id, password } = await request.json();
   try {
-    const { accessToken, refreshToken } = await AUTH.signIn({
+    const { accessToken, refreshToken } = await authService.login({
       id,
       password
     });
-    if (searchParams.get("type") === "json") {
+    const searchParams = new URL(request.url).searchParams;
+    const type = searchParams.get("type");
+    if (type === "json") {
       return CREATED({ accessToken, refreshToken });
     }
     const [accessTokenSetCookie, refreshTokenSetCookie] = await Promise.all([
-      AUTH.getAccessTokenSetCookie(accessToken),
-      AUTH.getRefreshTokenSetCookie(refreshToken)
+      authService.getAccessTokenSetCookie(accessToken),
+      authService.getRefreshTokenSetCookie(refreshToken)
     ]);
-    const payload = JWT_MANAGER.decode(accessToken);
+    const payload = authService.jwtManager.decode(accessToken);
     const headers = new Headers();
     headers.append("Set-Cookie", accessTokenSetCookie);
     headers.append("Set-Cookie", refreshTokenSetCookie);
@@ -257,17 +261,21 @@ var loginCredentialHandler = async (request, {
   }
 };
 
-// src/route/api/auth/logout/route.ts
-var logoutHandler = async (request, { AUTH, repository }) => {
-  const auth = await AUTH.verifyOrRefresh(request);
+// src/auth/handlers/logout.ts
+var logoutHandler = async (request, { authService }) => {
+  const auth = await authService.verifyOrRefresh(request);
   if (!auth) {
     return UNAUTHORIZED();
   }
-  await repository.updateUserRefreshToken(auth.userId, null);
+  await authService.authRepository.updateUserRefreshToken(auth.userId, null);
+  const type = new URL(request.url).searchParams.get("type");
+  if (type === "json") {
+    return NO_CONTENT();
+  }
   const headers = new Headers();
   const [accessTokenSetCookie, refreshTokenSetCookie] = await Promise.all([
-    AUTH.getAccessTokenSetCookie(null),
-    AUTH.getRefreshTokenSetCookie(null)
+    authService.getAccessTokenSetCookie(null),
+    authService.getRefreshTokenSetCookie(null)
   ]);
   headers.append("Set-Cookie", accessTokenSetCookie);
   headers.append("Set-Cookie", refreshTokenSetCookie);
@@ -276,16 +284,16 @@ var logoutHandler = async (request, { AUTH, repository }) => {
   });
 };
 
-// src/route/api/auth/refresh/route.ts
-var authRefreshHandler = async (request, {
-  AUTH
+// src/auth/handlers/refresh.ts
+var refreshHandler = async (request, {
+  authService
 }) => {
-  const refreshToken = request?.headers.get("Authorization")?.replace("Bearer ", "") || await AUTH.getRefreshTokenFromCookies(request);
+  const refreshToken = request?.headers.get("Authorization")?.replace("Bearer ", "") || await authService.getRefreshTokenFromCookies(request);
   if (!refreshToken) {
     return BAD_REQUEST();
   }
   try {
-    const accessToken = await AUTH.refreshAccessToken(refreshToken);
+    const accessToken = await authService.refreshAccessToken(refreshToken);
     return CREATED({ accessToken });
   } catch (e) {
     if (e instanceof Error) {
@@ -295,101 +303,282 @@ var authRefreshHandler = async (request, {
   }
 };
 
-// src/route/api.ts
-var createAuthAPIHandler = ({
-  AUTH,
-  GOOGLE_AUTH,
-  APPLE_AUTH,
-  KAKAO_AUTH,
-  JWT_MANAGER,
-  FILE_SERVICE,
-  SITE_ORIGIN,
-  authRepository,
+// src/auth/handlers/signup.ts
+var import_uuid = require("uuid");
+var bcrypt = __toESM(require("bcryptjs"));
+var signupHandler = async (request, {
+  authService,
   fileRepository
 }) => {
-  const handler = async ({
-    request,
-    params
-  }) => {
+  const body = await request.json();
+  const {
+    email,
+    password,
+    passwordConfirm,
+    name,
+    profileImageId
+  } = body;
+  if (!email) {
+    return BAD_REQUEST("\uC774\uBA54\uC77C\uC744 \uC785\uB825\uD574\uC8FC\uC138\uC694.");
+  }
+  if (!password) {
+    return BAD_REQUEST("\uBE44\uBC00\uBC88\uD638\uB97C \uC785\uB825\uD574\uC8FC\uC138\uC694.");
+  }
+  if (!passwordConfirm) {
+    return BAD_REQUEST("\uBE44\uBC00\uBC88\uD638 \uD655\uC778\uC744 \uC785\uB825\uD574\uC8FC\uC138\uC694.");
+  }
+  const existing = await authService.authRepository.findCredentialById(email);
+  if (existing) {
+    return CONFLICT("\uC774\uBBF8 \uAC00\uC785\uD55C \uC774\uBA54\uC77C\uC785\uB2C8\uB2E4.");
+  }
+  if (password !== passwordConfirm) {
+    return BAD_REQUEST("\uBE44\uBC00\uBC88\uD638\uAC00 \uC77C\uCE58\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.");
+  }
+  const profileImage = profileImageId ? await fileRepository.findFileById(profileImageId) : void 0;
+  const userId = (0, import_uuid.v5)(email, import_uuid.v5.DNS);
+  const user = await authService.authRepository.createUser({
+    id: userId,
+    name,
+    role: "user",
+    email,
+    profileImage
+  });
+  await authService.authRepository.createCredential({
+    id: email,
+    userId,
+    password: bcrypt.hashSync(password, 10)
+  });
+  const { accessToken, refreshToken } = await authService.issueTokenPair(user);
+  const searchParams = new URL(request.url).searchParams;
+  const type = searchParams.get("type");
+  if (type === "json") {
+    return CREATED({ accessToken, refreshToken });
+  }
+  const [accessTokenSetCookie, refreshTokenSetCookie] = await Promise.all([
+    authService.getAccessTokenSetCookie(accessToken),
+    authService.getRefreshTokenSetCookie(refreshToken)
+  ]);
+  const payload = authService.jwtManager.decode(accessToken);
+  const headers = new Headers();
+  headers.append("Set-Cookie", accessTokenSetCookie);
+  headers.append("Set-Cookie", refreshTokenSetCookie);
+  return CREATED(payload, {
+    headers
+  });
+};
+
+// src/auth/handlers/signup_with_thirdparty.ts
+var import_uuid2 = require("uuid");
+var signUpWithThirdpartyHandler = async (request, {
+  authService,
+  fileService,
+  signupTokenSecret
+}) => {
+  const body = await request.json();
+  const {
+    token
+  } = body;
+  const payload = await authService.jwtManager.verify(token, signupTokenSecret);
+  const { provider, id: thirdpartyId, email, name, picture } = payload;
+  const existing = await authService.authRepository.findThirdPartyAuth(
+    provider,
+    thirdpartyId
+  );
+  if (existing) {
+    return CONFLICT("\uC774\uBBF8 \uAC00\uC785\uB41C \uC81C3\uC790 \uC778\uC99D \uC815\uBCF4\uC785\uB2C8\uB2E4.");
+  }
+  const userId = (0, import_uuid2.v5)(thirdpartyId, import_uuid2.v5.DNS);
+  const profileImage = await (async () => {
+    if (!picture) {
+      return;
+    }
+    const arrayBuffer = await fetch(picture).then((res) => res.arrayBuffer());
+    const { file } = await fileService.putFile(Buffer.from(arrayBuffer), {
+      userId,
+      name: "profile.jpg",
+      type: "image/jpeg",
+      size: arrayBuffer.byteLength
+    });
+    return file;
+  })();
+  const user = await authService.authRepository.createUser({
+    id: userId,
+    name,
+    role: "user",
+    email,
+    profileImage
+  });
+  await authService.authRepository.createThirdPartyAuth({
+    id: thirdpartyId,
+    provider,
+    userId
+  });
+  const { accessToken, refreshToken } = await authService.issueTokenPair(user);
+  return CREATED({ accessToken, refreshToken });
+};
+
+// src/auth/handlers/request_password_reset.ts
+var requestPasswordResetHandler = async (request, {
+  passwordRecoveryService
+}) => {
+  const { email } = await request.json();
+  try {
+    await passwordRecoveryService.requestPasswordReset(email);
+    return CREATED({ message: "\uBE44\uBC00\uBC88\uD638 \uC7AC\uC124\uC815 \uC774\uBA54\uC77C\uC744 \uC804\uC1A1\uD588\uC2B5\uB2C8\uB2E4." });
+  } catch (error) {
+    console.error(error);
+    return INTERNAL_SERVER_ERROR("\uC774\uBA54\uC77C \uC804\uC1A1\uC5D0 \uC2E4\uD328\uD588\uC2B5\uB2C8\uB2E4.");
+  }
+};
+
+// src/auth/handlers/reset_password.ts
+var resetPasswordHandler = async (request, {
+  passwordRecoveryService
+}) => {
+  const { token, password, passwordConfirm } = await request.json();
+  await passwordRecoveryService.resetPassword(token, password, passwordConfirm);
+  return NO_CONTENT();
+};
+
+// src/route/api.ts
+var createAPIHandler = ({
+  authService,
+  fileService,
+  passwordRecoveryService,
+  getThirdPartyAuth,
+  signupTokenSecret
+}) => {
+  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 }
-            );
+    const slug = params["*"] ? params["*"].split("/") : [];
+    switch (slug[0]) {
+      case "auth": {
+        switch (slug[1]) {
+          case void 0: {
+            switch (method) {
+              case "GET": {
+                return findAuthHandler(request, { authService });
+              }
+            }
           }
-        }
-        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
+          case "login": {
+            switch (slug[2]) {
+              case void 0: {
+                switch (method) {
+                  case "POST": {
+                    return loginHandler(request, {
+                      authService
+                    });
+                  }
+                }
+              }
+              default: {
+                const provider = slug[2];
+                switch (method) {
+                  case "POST": {
+                    return loginWithThirdPartyHandler(
+                      request,
+                      { provider, getThirdPartyAuth }
+                    );
+                  }
+                }
               }
-            );
+            }
+          }
+          case "logout": {
+            switch (method) {
+              case "POST": {
+                return logoutHandler(request, {
+                  authService
+                });
+              }
+            }
+          }
+          case "refresh": {
+            switch (method) {
+              case "GET": {
+                return refreshHandler(request, { authService });
+              }
+            }
+          }
+          case "signup": {
+            switch (slug[2]) {
+              case void 0: {
+                switch (method) {
+                  case "POST": {
+                    return signupHandler(request, {
+                      authService,
+                      fileRepository: fileService.fileRepository
+                    });
+                  }
+                }
+              }
+              default: {
+                switch (method) {
+                  case "POST": {
+                    return signUpWithThirdpartyHandler(
+                      request,
+                      { authService, fileService, signupTokenSecret }
+                    );
+                  }
+                }
+              }
+            }
+          }
+          case "callback": {
+            if (slug[2]) {
+              const provider = slug[2];
+              if (method === "GET") {
+                return thirdpartyAuthCallbackHandler(
+                  request,
+                  {
+                    provider,
+                    authService,
+                    getThirdPartyAuth
+                  }
+                );
+              }
+            }
+          }
+          case "request-password-reset": {
+            return requestPasswordResetHandler(request, { passwordRecoveryService });
+          }
+          case "reset-password": {
+            return resetPasswordHandler(request, { passwordRecoveryService });
           }
         }
       }
-    }
-    if (slug[0] === "files") {
-      if (!slug[1]) {
-        if (method === "POST") {
-          return fileUploadHandler(request, { AUTH, FILE_SERVICE });
+      case "files": {
+        switch (slug[1]) {
+          case void 0: {
+            switch (method) {
+              case "POST": {
+                return uploadFileHandler(request, { authService, fileService });
+              }
+            }
+          }
+          default: {
+            switch (method) {
+              case "DELETE": {
+                const fileId = slug[1];
+                return deleteFileHandler(
+                  request,
+                  { fileId },
+                  { authService, fileRepository: fileService.fileRepository }
+                );
+              }
+            }
+          }
         }
       }
-      if (slug[1]) {
-        if (method === "DELETE") {
-          const fileId = slug[1];
-          return fileDeleteHandler(
-            request,
-            { fileId },
-            { AUTH, repository: fileRepository }
-          );
-        }
+      default: {
+        return NOT_FOUND();
       }
     }
-    return new Response("Not Found", { status: 404 });
   };
   return handler;
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  createAuthAPIHandler
+  createAPIHandler
 });