dn-react-router-toolkit 0.2.7 → 0.3.2

package/dist/api/index.js

@@ -0,0 +1,298 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/api/index.ts
+var api_exports = {};
+__export(api_exports, {
+  createAPIHandler: () => createAPIHandler
+});
+module.exports = __toCommonJS(api_exports);
+
+// src/http/index.ts
+var http_exports = {};
+__reExport(http_exports, require("dn-react-toolkit/http"));
+
+// src/api/create_handler.ts
+var import_server = require("dn-react-toolkit/auth/server");
+
+// src/auth/index.ts
+var auth_exports = {};
+__export(auth_exports, {
+  ReactRouterCookieStore: () => ReactRouterCookieStore,
+  createWithAuthHandler: () => createWithAuthHandler
+});
+__reExport(auth_exports, require("dn-react-toolkit/auth"));
+
+// src/auth/with_auth.ts
+function createWithAuthHandler({ authService }) {
+  return function(fn) {
+    const handler = async function(arg) {
+      const respond = async (auth) => {
+        const userAgent = arg.request.headers.get("User-Agent") || "";
+        const res = await fn(auth)(arg);
+        if (typeof res === "object" && res !== null && !Array.isArray(res)) {
+          if (res instanceof Response) {
+            if (res.status < 300 && res.headers.get("Content-Type")?.includes("application/json")) {
+              const data = await res.json();
+              return new Response(
+                JSON.stringify({
+                  AUTH: auth,
+                  userAgent,
+                  ...data
+                }),
+                {
+                  status: res.status,
+                  headers: res.headers
+                }
+              );
+            }
+            return res;
+          }
+          return {
+            AUTH: auth,
+            userAgent,
+            ...res
+          };
+        }
+        return res;
+      };
+      const accessToken = await authService.getAccessTokenFromRequest(
+        arg.request
+      );
+      if (accessToken) {
+        const payload = await authService.jwtManager.verifyAccessToken(
+          accessToken
+        );
+        if (payload) {
+          return respond(payload);
+        }
+      }
+      const refreshToken = await authService.getRefreshTokenFromCookies(
+        arg.request
+      );
+      if (refreshToken) {
+        try {
+          const newAccessToken = await authService.refreshAccessToken(
+            refreshToken
+          );
+          const setCookieHeader = await authService.getAccessTokenSetCookie(
+            newAccessToken
+          );
+          const headers = new Headers();
+          headers.append("Set-Cookie", setCookieHeader);
+          headers.append("Location", arg.request.url);
+          return new Response("Temporary Redirect", {
+            status: 307,
+            headers
+          });
+        } catch (e) {
+          if (e instanceof Error) {
+            console.log(e.message);
+          }
+          const setCookieHeader = await authService.getRefreshTokenSetCookie(
+            null
+          );
+          const headers = new Headers();
+          headers.append("Set-Cookie", setCookieHeader);
+          headers.append("Location", arg.request.url);
+          return new Response("Temporary Redirect", {
+            status: 307,
+            headers
+          });
+        }
+      }
+      return respond(void 0);
+    };
+    return handler;
+  };
+}
+
+// src/auth/cookie_store.ts
+var import_react_router = require("react-router");
+var ReactRouterCookieStore = class {
+  store;
+  constructor(key) {
+    this.store = (0, import_react_router.createCookie)(key, {
+      path: "/",
+      httpOnly: process.env.NODE_ENV === "production",
+      secure: process.env.NODE_ENV === "production",
+      sameSite: "strict"
+    });
+  }
+  parse(request) {
+    const cookieHeader = request.headers.get("cookie") || "";
+    return this.store.parse(cookieHeader);
+  }
+  serialize(value, options) {
+    return this.store.serialize(value, options);
+  }
+};
+
+// src/api/create_handler.ts
+var import_server2 = require("dn-react-toolkit/file/server");
+var createAPIHandler = ({
+  authService,
+  fileService,
+  passwordRecoveryService,
+  getThirdPartyAuth,
+  signupTokenSecret
+}) => {
+  const handler = async (args) => {
+    const { request, params } = args;
+    const method = request.method.toUpperCase();
+    const slug = params["*"] ? params["*"].split("/") : [];
+    const withAuth = createWithAuthHandler({ authService });
+    switch (slug[0]) {
+      case "auth": {
+        switch (slug[1]) {
+          case void 0: {
+            switch (method) {
+              case "GET": {
+                return withAuth(
+                  (auth) => ({ request: request2 }) => (0, import_server.findAuthHandler)(auth)(request2)
+                );
+              }
+            }
+          }
+          case "login": {
+            switch (slug[2]) {
+              case void 0: {
+                switch (method) {
+                  case "POST": {
+                    return (0, import_server.loginHandler)(request, {
+                      authService
+                    });
+                  }
+                }
+              }
+              default: {
+                const provider = slug[2];
+                switch (method) {
+                  case "POST": {
+                    return (0, import_server.loginWithThirdPartyHandler)(request, {
+                      provider,
+                      getThirdPartyAuth
+                    });
+                  }
+                }
+              }
+            }
+          }
+          case "logout": {
+            switch (method) {
+              case "POST": {
+                return withAuth(
+                  (auth) => async ({ request: request2 }) => (0, import_server.logoutHandler)({
+                    authService
+                  })(auth)(request2)
+                )(args);
+              }
+            }
+          }
+          case "refresh": {
+            switch (method) {
+              case "GET": {
+                return (0, import_server.refreshHandler)(request, { authService });
+              }
+            }
+          }
+          case "signup": {
+            switch (slug[2]) {
+              case void 0: {
+                switch (method) {
+                  case "POST": {
+                    return (0, import_server.signupHandler)(request, {
+                      authService,
+                      fileRepository: fileService.fileRepository
+                    });
+                  }
+                }
+              }
+              default: {
+                switch (method) {
+                  case "POST": {
+                    return (0, import_server.signUpWithThirdpartyHandler)(request, {
+                      authService,
+                      fileService,
+                      signupTokenSecret
+                    });
+                  }
+                }
+              }
+            }
+          }
+          case "callback": {
+            if (slug[2]) {
+              const provider = slug[2];
+              if (method === "GET") {
+                return (0, import_server.thirdpartyAuthCallbackHandler)(request, {
+                  provider,
+                  authService,
+                  getThirdPartyAuth
+                });
+              }
+            }
+          }
+          case "request-password-reset": {
+            return (0, import_server.requestPasswordResetHandler)(request, {
+              passwordRecoveryService
+            });
+          }
+          case "reset-password": {
+            return (0, import_server.resetPasswordHandler)(request, { passwordRecoveryService });
+          }
+        }
+      }
+      case "files": {
+        switch (slug[1]) {
+          case void 0: {
+            switch (method) {
+              case "POST": {
+                return withAuth(
+                  (auth) => ({ request: request2 }) => (0, import_server2.uploadFileHandler)({ fileService })(auth)(request2)
+                )(args);
+              }
+            }
+          }
+          default: {
+            switch (method) {
+              case "DELETE": {
+                const fileId = slug[1];
+                return withAuth(
+                  (auth) => () => (0, import_server2.deleteFileHandler)({
+                    fileRepository: fileService.fileRepository
+                  })({ fileId })(auth)()
+                );
+              }
+            }
+          }
+        }
+      }
+      default: {
+        return (0, http_exports.NOT_FOUND)();
+      }
+    }
+  };
+  return handler;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createAPIHandler
+});

package/dist/api/index.mjs

@@ -0,0 +1,304 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+
+// src/http/index.ts
+var http_exports = {};
+__reExport(http_exports, http_star);
+import * as http_star from "dn-react-toolkit/http";
+
+// src/api/create_handler.ts
+import {
+  findAuthHandler,
+  loginHandler,
+  loginWithThirdPartyHandler,
+  logoutHandler,
+  refreshHandler,
+  requestPasswordResetHandler,
+  resetPasswordHandler,
+  signupHandler,
+  signUpWithThirdpartyHandler,
+  thirdpartyAuthCallbackHandler
+} from "dn-react-toolkit/auth/server";
+
+// src/auth/index.ts
+var auth_exports = {};
+__export(auth_exports, {
+  ReactRouterCookieStore: () => ReactRouterCookieStore,
+  createWithAuthHandler: () => createWithAuthHandler
+});
+__reExport(auth_exports, auth_star);
+import * as auth_star from "dn-react-toolkit/auth";
+
+// src/auth/with_auth.ts
+function createWithAuthHandler({ authService }) {
+  return function(fn) {
+    const handler = async function(arg) {
+      const respond = async (auth) => {
+        const userAgent = arg.request.headers.get("User-Agent") || "";
+        const res = await fn(auth)(arg);
+        if (typeof res === "object" && res !== null && !Array.isArray(res)) {
+          if (res instanceof Response) {
+            if (res.status < 300 && res.headers.get("Content-Type")?.includes("application/json")) {
+              const data = await res.json();
+              return new Response(
+                JSON.stringify({
+                  AUTH: auth,
+                  userAgent,
+                  ...data
+                }),
+                {
+                  status: res.status,
+                  headers: res.headers
+                }
+              );
+            }
+            return res;
+          }
+          return {
+            AUTH: auth,
+            userAgent,
+            ...res
+          };
+        }
+        return res;
+      };
+      const accessToken = await authService.getAccessTokenFromRequest(
+        arg.request
+      );
+      if (accessToken) {
+        const payload = await authService.jwtManager.verifyAccessToken(
+          accessToken
+        );
+        if (payload) {
+          return respond(payload);
+        }
+      }
+      const refreshToken = await authService.getRefreshTokenFromCookies(
+        arg.request
+      );
+      if (refreshToken) {
+        try {
+          const newAccessToken = await authService.refreshAccessToken(
+            refreshToken
+          );
+          const setCookieHeader = await authService.getAccessTokenSetCookie(
+            newAccessToken
+          );
+          const headers = new Headers();
+          headers.append("Set-Cookie", setCookieHeader);
+          headers.append("Location", arg.request.url);
+          return new Response("Temporary Redirect", {
+            status: 307,
+            headers
+          });
+        } catch (e) {
+          if (e instanceof Error) {
+            console.log(e.message);
+          }
+          const setCookieHeader = await authService.getRefreshTokenSetCookie(
+            null
+          );
+          const headers = new Headers();
+          headers.append("Set-Cookie", setCookieHeader);
+          headers.append("Location", arg.request.url);
+          return new Response("Temporary Redirect", {
+            status: 307,
+            headers
+          });
+        }
+      }
+      return respond(void 0);
+    };
+    return handler;
+  };
+}
+
+// src/auth/cookie_store.ts
+import { createCookie } from "react-router";
+var ReactRouterCookieStore = class {
+  store;
+  constructor(key) {
+    this.store = createCookie(key, {
+      path: "/",
+      httpOnly: process.env.NODE_ENV === "production",
+      secure: process.env.NODE_ENV === "production",
+      sameSite: "strict"
+    });
+  }
+  parse(request) {
+    const cookieHeader = request.headers.get("cookie") || "";
+    return this.store.parse(cookieHeader);
+  }
+  serialize(value, options) {
+    return this.store.serialize(value, options);
+  }
+};
+
+// src/api/create_handler.ts
+import {
+  deleteFileHandler,
+  uploadFileHandler
+} from "dn-react-toolkit/file/server";
+var createAPIHandler = ({
+  authService,
+  fileService,
+  passwordRecoveryService,
+  getThirdPartyAuth,
+  signupTokenSecret
+}) => {
+  const handler = async (args) => {
+    const { request, params } = args;
+    const method = request.method.toUpperCase();
+    const slug = params["*"] ? params["*"].split("/") : [];
+    const withAuth = createWithAuthHandler({ authService });
+    switch (slug[0]) {
+      case "auth": {
+        switch (slug[1]) {
+          case void 0: {
+            switch (method) {
+              case "GET": {
+                return withAuth(
+                  (auth) => ({ request: request2 }) => findAuthHandler(auth)(request2)
+                );
+              }
+            }
+          }
+          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 withAuth(
+                  (auth) => async ({ request: request2 }) => logoutHandler({
+                    authService
+                  })(auth)(request2)
+                )(args);
+              }
+            }
+          }
+          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 });
+          }
+        }
+      }
+      case "files": {
+        switch (slug[1]) {
+          case void 0: {
+            switch (method) {
+              case "POST": {
+                return withAuth(
+                  (auth) => ({ request: request2 }) => uploadFileHandler({ fileService })(auth)(request2)
+                )(args);
+              }
+            }
+          }
+          default: {
+            switch (method) {
+              case "DELETE": {
+                const fileId = slug[1];
+                return withAuth(
+                  (auth) => () => deleteFileHandler({
+                    fileRepository: fileService.fileRepository
+                  })({ fileId })(auth)()
+                );
+              }
+            }
+          }
+        }
+      }
+      default: {
+        return (0, http_exports.NOT_FOUND)();
+      }
+    }
+  };
+  return handler;
+};
+export {
+  createAPIHandler
+};

package/dist/auth/client/index.d.mts

@@ -0,0 +1,3 @@
+export * from 'dn-react-toolkit/auth/client';
+export { RedirectPage } from './redirect_page.mjs';
+import 'react';

package/dist/auth/client/index.d.ts

@@ -0,0 +1,3 @@
+export * from 'dn-react-toolkit/auth/client';
+export { RedirectPage } from './redirect_page.js';
+import 'react';

package/dist/{date.js → auth/client/index.js}

@@ -17,6 +17,7 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 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-
@@ -27,39 +28,31 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/date.ts
-var date_exports = {};
-__export(date_exports, {
-  formatHumanDateTime: () => formatHumanDateTime,
-  moment: () => import_moment_timezone.default
+// src/auth/client/index.tsx
+var client_exports = {};
+__export(client_exports, {
+  RedirectPage: () => RedirectPage
 });
-module.exports = __toCommonJS(date_exports);
-var import_moment_timezone = __toESM(require("moment-timezone"));
-var formatHumanDateTime = (value) => {
-  const date = (0, import_moment_timezone.default)(value).tz("Asia/Seoul");
-  const now = (0, import_moment_timezone.default)().tz("Asia/Seoul");
-  if (date.isAfter(now.clone().subtract(1, "minute"))) {
-    return "\uBC29\uAE08 \uC804";
-  }
-  if (date.isAfter(now.clone().subtract(1, "hour"))) {
-    const diff = now.diff(date, "minute");
-    return `${diff}\uBD84 \uC804`;
-  }
-  if (date.isAfter(now.clone().subtract(6, "hours"))) {
-    const diff = now.diff(date, "hour");
-    return `${diff}\uC2DC\uAC04 \uC804`;
-  }
-  if (date.isAfter(now.clone().subtract(1, "week"))) {
-    const diff = now.diff(date, "day");
-    return `${diff}\uC77C \uC804`;
-  }
-  if (date.isSame(now, "year")) {
-    return date.format("M\uC6D4 D\uC77C");
-  }
-  return date.format("YYYY\uB144 M\uC6D4 D\uC77C");
-};
+module.exports = __toCommonJS(client_exports);
+__reExport(client_exports, require("dn-react-toolkit/auth/client"), module.exports);
+
+// src/auth/client/redirect_page.tsx
+var import_react = __toESM(require("react"));
+var import_react2 = require("react");
+var import_react_router = require("react-router");
+function RedirectPage() {
+  const navigate = (0, import_react_router.useNavigate)();
+  (0, import_react2.useEffect)(() => {
+    const searchParams = new URLSearchParams(window.location.search);
+    const redirectUrl = searchParams.get("redirectUrl") || new URL("/", window.location.origin).toString();
+    if (redirectUrl) {
+      navigate(redirectUrl);
+    }
+  }, [navigate]);
+  return /* @__PURE__ */ import_react.default.createElement(import_react.default.Fragment, null);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  formatHumanDateTime,
-  moment
+  RedirectPage,
+  ...require("dn-react-toolkit/auth/client")
 });

package/dist/auth/client/index.mjs

@@ -0,0 +1,21 @@
+// src/auth/client/index.tsx
+export * from "dn-react-toolkit/auth/client";
+
+// src/auth/client/redirect_page.tsx
+import React from "react";
+import { useEffect } from "react";
+import { useNavigate } from "react-router";
+function RedirectPage() {
+  const navigate = useNavigate();
+  useEffect(() => {
+    const searchParams = new URLSearchParams(window.location.search);
+    const redirectUrl = searchParams.get("redirectUrl") || new URL("/", window.location.origin).toString();
+    if (redirectUrl) {
+      navigate(redirectUrl);
+    }
+  }, [navigate]);
+  return /* @__PURE__ */ React.createElement(React.Fragment, null);
+}
+export {
+  RedirectPage
+};