dn-react-router-toolkit 0.4.2 → 0.5.0

package/dist/api/index.js

@@ -29,13 +29,14 @@ var import_http = require("dn-react-toolkit/http");
 var import_server = require("dn-react-toolkit/auth/server");
 
 // src/auth/with_auth.ts
+var import_uuid = require("uuid");
 var toResponse = (result) => {
   if (result instanceof Response) {
     return result;
   }
   return Response.json(result);
 };
-function createWithAuthHandler({ authService }) {
+function createWithStrictAuthHandler({ authService }) {
   return function(fn) {
     const handler = async function(arg) {
       const respond = async (auth, headers = new Headers()) => {
@@ -44,7 +45,7 @@ function createWithAuthHandler({ authService }) {
       };
       const setHeader = (res, headers) => {
         headers.forEach((value, key) => {
-          res.headers.set(key, value);
+          res.headers.append(key, value);
         });
         return res;
       };
@@ -52,9 +53,7 @@ function createWithAuthHandler({ authService }) {
         arg.request
       );
       if (accessToken) {
-        const payload = await authService.accessTokenManager.verify(
-          accessToken
-        );
+        const payload = await authService.accessTokenManager.verify(accessToken);
         if (payload) {
           return respond(payload);
         }
@@ -64,23 +63,17 @@ function createWithAuthHandler({ authService }) {
       );
       if (refreshToken) {
         try {
-          const newAccessToken = await authService.refreshAccessToken(
-            refreshToken
-          );
+          const newAccessToken = await authService.refreshAccessToken(refreshToken);
           const setCookieHeader = await authService.getAccessTokenSetCookie(
             newAccessToken
           );
           const headers = new Headers();
           headers.append("Set-Cookie", setCookieHeader);
-          const payload = authService.accessTokenManager.decode(
-            newAccessToken
-          );
+          const payload = authService.accessTokenManager.decode(newAccessToken);
           return respond(payload, headers);
         } catch (e) {
           console.log(e);
-          const setCookieHeader = await authService.getRefreshTokenSetCookie(
-            null
-          );
+          const setCookieHeader = await authService.getRefreshTokenSetCookie(null);
           const headers = new Headers();
           headers.append("Set-Cookie", setCookieHeader);
           return respond(void 0, headers);
@@ -108,7 +101,7 @@ var createAPIHandler = ({
     const { request, params } = args;
     const method = request.method.toUpperCase();
     const slug = params["*"] ? params["*"].split("/") : [];
-    const withAuth = createWithAuthHandler({ authService });
+    const withAuth = createWithStrictAuthHandler({ authService });
     switch (slug[0]) {
       case "auth": {
         switch (slug[1]) {
@@ -136,10 +129,13 @@ var createAPIHandler = ({
                 const provider = slug[2];
                 switch (method) {
                   case "POST": {
-                    return (0, import_server.loginWithThirdPartyHandler)(request, {
-                      provider,
-                      getThirdPartyAuth
-                    });
+                    return (0, import_server.loginWithThirdPartyHandler)(
+                      request,
+                      {
+                        provider,
+                        getThirdPartyAuth
+                      }
+                    );
                   }
                 }
               }
@@ -178,11 +174,14 @@ var createAPIHandler = ({
               default: {
                 switch (method) {
                   case "POST": {
-                    return (0, import_server.signUpWithThirdpartyHandler)(request, {
-                      authService,
-                      fileService,
-                      signupTokenManager
-                    });
+                    return (0, import_server.signUpWithThirdpartyHandler)(
+                      request,
+                      {
+                        authService,
+                        fileService,
+                        signupTokenManager
+                      }
+                    );
                   }
                 }
               }
@@ -206,7 +205,9 @@ var createAPIHandler = ({
             });
           }
           case "reset-password": {
-            return (0, import_server.resetPasswordHandler)(request, { passwordRecoveryService });
+            return (0, import_server.resetPasswordHandler)(request, {
+              passwordRecoveryService
+            });
           }
         }
       }
@@ -216,7 +217,9 @@ var createAPIHandler = ({
             switch (method) {
               case "POST": {
                 return withAuth(
-                  (auth) => ({ request: request2 }) => (0, import_server2.uploadFileHandler)({ fileService })(auth)(request2)
+                  (auth) => ({ request: request2 }) => (0, import_server2.uploadFileHandler)({ fileService })(
+                    auth
+                  )(request2)
                 )(args);
               }
             }

package/dist/api/index.mjs

@@ -14,13 +14,14 @@ import {
 } from "dn-react-toolkit/auth/server";
 
 // src/auth/with_auth.ts
+import { v4 } from "uuid";
 var toResponse = (result) => {
   if (result instanceof Response) {
     return result;
   }
   return Response.json(result);
 };
-function createWithAuthHandler({ authService }) {
+function createWithStrictAuthHandler({ authService }) {
   return function(fn) {
     const handler = async function(arg) {
       const respond = async (auth, headers = new Headers()) => {
@@ -29,7 +30,7 @@ function createWithAuthHandler({ authService }) {
       };
       const setHeader = (res, headers) => {
         headers.forEach((value, key) => {
-          res.headers.set(key, value);
+          res.headers.append(key, value);
         });
         return res;
       };
@@ -37,9 +38,7 @@ function createWithAuthHandler({ authService }) {
         arg.request
       );
       if (accessToken) {
-        const payload = await authService.accessTokenManager.verify(
-          accessToken
-        );
+        const payload = await authService.accessTokenManager.verify(accessToken);
         if (payload) {
           return respond(payload);
         }
@@ -49,23 +48,17 @@ function createWithAuthHandler({ authService }) {
       );
       if (refreshToken) {
         try {
-          const newAccessToken = await authService.refreshAccessToken(
-            refreshToken
-          );
+          const newAccessToken = await authService.refreshAccessToken(refreshToken);
           const setCookieHeader = await authService.getAccessTokenSetCookie(
             newAccessToken
           );
           const headers = new Headers();
           headers.append("Set-Cookie", setCookieHeader);
-          const payload = authService.accessTokenManager.decode(
-            newAccessToken
-          );
+          const payload = authService.accessTokenManager.decode(newAccessToken);
           return respond(payload, headers);
         } catch (e) {
           console.log(e);
-          const setCookieHeader = await authService.getRefreshTokenSetCookie(
-            null
-          );
+          const setCookieHeader = await authService.getRefreshTokenSetCookie(null);
           const headers = new Headers();
           headers.append("Set-Cookie", setCookieHeader);
           return respond(void 0, headers);
@@ -96,7 +89,7 @@ var createAPIHandler = ({
     const { request, params } = args;
     const method = request.method.toUpperCase();
     const slug = params["*"] ? params["*"].split("/") : [];
-    const withAuth = createWithAuthHandler({ authService });
+    const withAuth = createWithStrictAuthHandler({ authService });
     switch (slug[0]) {
       case "auth": {
         switch (slug[1]) {
@@ -124,10 +117,13 @@ var createAPIHandler = ({
                 const provider = slug[2];
                 switch (method) {
                   case "POST": {
-                    return loginWithThirdPartyHandler(request, {
-                      provider,
-                      getThirdPartyAuth
-                    });
+                    return loginWithThirdPartyHandler(
+                      request,
+                      {
+                        provider,
+                        getThirdPartyAuth
+                      }
+                    );
                   }
                 }
               }
@@ -166,11 +162,14 @@ var createAPIHandler = ({
               default: {
                 switch (method) {
                   case "POST": {
-                    return signUpWithThirdpartyHandler(request, {
-                      authService,
-                      fileService,
-                      signupTokenManager
-                    });
+                    return signUpWithThirdpartyHandler(
+                      request,
+                      {
+                        authService,
+                        fileService,
+                        signupTokenManager
+                      }
+                    );
                   }
                 }
               }
@@ -194,7 +193,9 @@ var createAPIHandler = ({
             });
           }
           case "reset-password": {
-            return resetPasswordHandler(request, { passwordRecoveryService });
+            return resetPasswordHandler(request, {
+              passwordRecoveryService
+            });
           }
         }
       }
@@ -204,7 +205,9 @@ var createAPIHandler = ({
             switch (method) {
               case "POST": {
                 return withAuth(
-                  (auth) => ({ request: request2 }) => uploadFileHandler({ fileService })(auth)(request2)
+                  (auth) => ({ request: request2 }) => uploadFileHandler({ fileService })(
+                    auth
+                  )(request2)
                 )(args);
               }
             }

package/dist/api/item_api_handler.d.mts

@@ -0,0 +1,18 @@
+import { Table } from 'drizzle-orm';
+import { LoaderFunctionArgs } from 'react-router';
+import { TableRepository } from '../table/repository.mjs';
+import { WithAuthHandler } from '../auth/with_auth.mjs';
+import 'drizzle-orm/pg-core';
+import 'dn-react-toolkit/auth';
+import 'dn-react-toolkit/auth/server';
+
+type ItemAPIHandlerOptions<T extends Table, TSelect> = {
+    withAuthAction: WithAuthHandler<LoaderFunctionArgs>;
+    repository: TableRepository<T, TSelect>;
+};
+declare function itemApiHandler<T extends Table, TSelect>({ withAuthAction, repository, }: ItemAPIHandlerOptions<T, TSelect>): {
+    loader: ({ request }: LoaderFunctionArgs) => Promise<{}>;
+    action: (arg: LoaderFunctionArgs<any>) => Promise<unknown> | unknown;
+};
+
+export { type ItemAPIHandlerOptions, itemApiHandler };

package/dist/api/item_api_handler.d.ts

@@ -0,0 +1,18 @@
+import { Table } from 'drizzle-orm';
+import { LoaderFunctionArgs } from 'react-router';
+import { TableRepository } from '../table/repository.js';
+import { WithAuthHandler } from '../auth/with_auth.js';
+import 'drizzle-orm/pg-core';
+import 'dn-react-toolkit/auth';
+import 'dn-react-toolkit/auth/server';
+
+type ItemAPIHandlerOptions<T extends Table, TSelect> = {
+    withAuthAction: WithAuthHandler<LoaderFunctionArgs>;
+    repository: TableRepository<T, TSelect>;
+};
+declare function itemApiHandler<T extends Table, TSelect>({ withAuthAction, repository, }: ItemAPIHandlerOptions<T, TSelect>): {
+    loader: ({ request }: LoaderFunctionArgs) => Promise<{}>;
+    action: (arg: LoaderFunctionArgs<any>) => Promise<unknown> | unknown;
+};
+
+export { type ItemAPIHandlerOptions, itemApiHandler };

package/dist/api/item_api_handler.js

@@ -0,0 +1,55 @@
+"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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/api/item_api_handler.ts
+var item_api_handler_exports = {};
+__export(item_api_handler_exports, {
+  itemApiHandler: () => itemApiHandler
+});
+module.exports = __toCommonJS(item_api_handler_exports);
+var import_http = require("dn-react-toolkit/http");
+var import_react_router = require("react-router");
+function itemApiHandler({
+  withAuthAction,
+  repository
+}) {
+  const loader = async ({ request }) => {
+    return {};
+  };
+  const action = withAuthAction((auth) => async ({ params, request }) => {
+    if (!auth || auth.role !== "admin") {
+      return (0, import_http.UNAUTHORIZED)();
+    }
+    switch (request.method) {
+      case "DELETE": {
+        const itemId = params.itemId;
+        await repository.delete(itemId);
+        return {};
+      }
+    }
+  });
+  return {
+    loader,
+    action
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  itemApiHandler
+});

package/dist/api/item_api_handler.mjs

@@ -0,0 +1,30 @@
+// src/api/item_api_handler.ts
+import { UNAUTHORIZED } from "dn-react-toolkit/http";
+import "react-router";
+function itemApiHandler({
+  withAuthAction,
+  repository
+}) {
+  const loader = async ({ request }) => {
+    return {};
+  };
+  const action = withAuthAction((auth) => async ({ params, request }) => {
+    if (!auth || auth.role !== "admin") {
+      return UNAUTHORIZED();
+    }
+    switch (request.method) {
+      case "DELETE": {
+        const itemId = params.itemId;
+        await repository.delete(itemId);
+        return {};
+      }
+    }
+  });
+  return {
+    loader,
+    action
+  };
+}
+export {
+  itemApiHandler
+};

package/dist/auth/index.d.mts

@@ -1,4 +1,4 @@
-export { WithAuthHandler, createWithAuthHandler } from './with_auth.mjs';
+export { WithAuthHandler, createWithAuthHandler, createWithStrictAuthHandler } from './with_auth.mjs';
 export { ReactRouterCookieManager } from './cookie_store.mjs';
 import 'dn-react-toolkit/auth';
 import 'dn-react-toolkit/auth/server';

package/dist/auth/index.d.ts

@@ -1,4 +1,4 @@
-export { WithAuthHandler, createWithAuthHandler } from './with_auth.js';
+export { WithAuthHandler, createWithAuthHandler, createWithStrictAuthHandler } from './with_auth.js';
 export { ReactRouterCookieManager } from './cookie_store.js';
 import 'dn-react-toolkit/auth';
 import 'dn-react-toolkit/auth/server';

package/dist/auth/index.js

@@ -21,18 +21,20 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var auth_exports = {};
 __export(auth_exports, {
   ReactRouterCookieManager: () => ReactRouterCookieManager,
-  createWithAuthHandler: () => createWithAuthHandler
+  createWithAuthHandler: () => createWithAuthHandler,
+  createWithStrictAuthHandler: () => createWithStrictAuthHandler
 });
 module.exports = __toCommonJS(auth_exports);
 
 // src/auth/with_auth.ts
+var import_uuid = require("uuid");
 var toResponse = (result) => {
   if (result instanceof Response) {
     return result;
   }
   return Response.json(result);
 };
-function createWithAuthHandler({ authService }) {
+function createWithStrictAuthHandler({ authService }) {
   return function(fn) {
     const handler = async function(arg) {
       const respond = async (auth, headers = new Headers()) => {
@@ -41,7 +43,7 @@ function createWithAuthHandler({ authService }) {
       };
       const setHeader = (res, headers) => {
         headers.forEach((value, key) => {
-          res.headers.set(key, value);
+          res.headers.append(key, value);
         });
         return res;
       };
@@ -49,9 +51,7 @@ function createWithAuthHandler({ authService }) {
         arg.request
       );
       if (accessToken) {
-        const payload = await authService.accessTokenManager.verify(
-          accessToken
-        );
+        const payload = await authService.accessTokenManager.verify(accessToken);
         if (payload) {
           return respond(payload);
         }
@@ -61,23 +61,17 @@ function createWithAuthHandler({ authService }) {
       );
       if (refreshToken) {
         try {
-          const newAccessToken = await authService.refreshAccessToken(
-            refreshToken
-          );
+          const newAccessToken = await authService.refreshAccessToken(refreshToken);
           const setCookieHeader = await authService.getAccessTokenSetCookie(
             newAccessToken
           );
           const headers = new Headers();
           headers.append("Set-Cookie", setCookieHeader);
-          const payload = authService.accessTokenManager.decode(
-            newAccessToken
-          );
+          const payload = authService.accessTokenManager.decode(newAccessToken);
           return respond(payload, headers);
         } catch (e) {
           console.log(e);
-          const setCookieHeader = await authService.getRefreshTokenSetCookie(
-            null
-          );
+          const setCookieHeader = await authService.getRefreshTokenSetCookie(null);
           const headers = new Headers();
           headers.append("Set-Cookie", setCookieHeader);
           return respond(void 0, headers);
@@ -88,6 +82,57 @@ function createWithAuthHandler({ authService }) {
     return handler;
   };
 }
+function createWithAuthHandler({
+  authService,
+  tempUserTokenManager,
+  tempUserCookieManager
+}) {
+  return function(fn) {
+    const withAuthHandler = createWithStrictAuthHandler({
+      authService
+    });
+    const handler = withAuthHandler((auth) => async (args) => {
+      if (auth) {
+        return fn(auth)(args);
+      }
+      const respond = async (auth2, headers2 = new Headers()) => {
+        const result = await fn(auth2)(args);
+        return setHeader(toResponse(result), headers2);
+      };
+      const setHeader = (res, headers2) => {
+        headers2.forEach((value, key) => {
+          res.headers.append(key, value);
+        });
+        return res;
+      };
+      const tempUserToken = await tempUserCookieManager.parse(
+        args.request
+      );
+      if (tempUserToken) {
+        const tempUserPayload = await tempUserTokenManager.verify(tempUserToken);
+        if (tempUserPayload) {
+          return respond(tempUserPayload);
+        }
+      }
+      const user = await authService.authRepository.createUser({
+        id: (0, import_uuid.v4)(),
+        role: "temp",
+        name: "\uC775\uBA85"
+      });
+      const newTempUserToken = await tempUserTokenManager.sign({
+        userId: user.id,
+        name: user.name,
+        role: user.role
+      });
+      const headers = new Headers();
+      const setCookie = await tempUserCookieManager.serialize(newTempUserToken);
+      headers.append("Set-Cookie", setCookie);
+      const newTempUserPayload = tempUserTokenManager.decode(newTempUserToken);
+      return respond(newTempUserPayload, headers);
+    });
+    return handler;
+  };
+}
 
 // src/auth/cookie_store.ts
 var import_react_router = require("react-router");
@@ -120,5 +165,6 @@ var ReactRouterCookieManager = class {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ReactRouterCookieManager,
-  createWithAuthHandler
+  createWithAuthHandler,
+  createWithStrictAuthHandler
 });

package/dist/auth/index.mjs

@@ -1,11 +1,12 @@
 // src/auth/with_auth.ts
+import { v4 } from "uuid";
 var toResponse = (result) => {
   if (result instanceof Response) {
     return result;
   }
   return Response.json(result);
 };
-function createWithAuthHandler({ authService }) {
+function createWithStrictAuthHandler({ authService }) {
   return function(fn) {
     const handler = async function(arg) {
       const respond = async (auth, headers = new Headers()) => {
@@ -14,7 +15,7 @@ function createWithAuthHandler({ authService }) {
       };
       const setHeader = (res, headers) => {
         headers.forEach((value, key) => {
-          res.headers.set(key, value);
+          res.headers.append(key, value);
         });
         return res;
       };
@@ -22,9 +23,7 @@ function createWithAuthHandler({ authService }) {
         arg.request
       );
       if (accessToken) {
-        const payload = await authService.accessTokenManager.verify(
-          accessToken
-        );
+        const payload = await authService.accessTokenManager.verify(accessToken);
         if (payload) {
           return respond(payload);
         }
@@ -34,23 +33,17 @@ function createWithAuthHandler({ authService }) {
       );
       if (refreshToken) {
         try {
-          const newAccessToken = await authService.refreshAccessToken(
-            refreshToken
-          );
+          const newAccessToken = await authService.refreshAccessToken(refreshToken);
           const setCookieHeader = await authService.getAccessTokenSetCookie(
             newAccessToken
           );
           const headers = new Headers();
           headers.append("Set-Cookie", setCookieHeader);
-          const payload = authService.accessTokenManager.decode(
-            newAccessToken
-          );
+          const payload = authService.accessTokenManager.decode(newAccessToken);
           return respond(payload, headers);
         } catch (e) {
           console.log(e);
-          const setCookieHeader = await authService.getRefreshTokenSetCookie(
-            null
-          );
+          const setCookieHeader = await authService.getRefreshTokenSetCookie(null);
           const headers = new Headers();
           headers.append("Set-Cookie", setCookieHeader);
           return respond(void 0, headers);
@@ -61,6 +54,57 @@ function createWithAuthHandler({ authService }) {
     return handler;
   };
 }
+function createWithAuthHandler({
+  authService,
+  tempUserTokenManager,
+  tempUserCookieManager
+}) {
+  return function(fn) {
+    const withAuthHandler = createWithStrictAuthHandler({
+      authService
+    });
+    const handler = withAuthHandler((auth) => async (args) => {
+      if (auth) {
+        return fn(auth)(args);
+      }
+      const respond = async (auth2, headers2 = new Headers()) => {
+        const result = await fn(auth2)(args);
+        return setHeader(toResponse(result), headers2);
+      };
+      const setHeader = (res, headers2) => {
+        headers2.forEach((value, key) => {
+          res.headers.append(key, value);
+        });
+        return res;
+      };
+      const tempUserToken = await tempUserCookieManager.parse(
+        args.request
+      );
+      if (tempUserToken) {
+        const tempUserPayload = await tempUserTokenManager.verify(tempUserToken);
+        if (tempUserPayload) {
+          return respond(tempUserPayload);
+        }
+      }
+      const user = await authService.authRepository.createUser({
+        id: v4(),
+        role: "temp",
+        name: "\uC775\uBA85"
+      });
+      const newTempUserToken = await tempUserTokenManager.sign({
+        userId: user.id,
+        name: user.name,
+        role: user.role
+      });
+      const headers = new Headers();
+      const setCookie = await tempUserCookieManager.serialize(newTempUserToken);
+      headers.append("Set-Cookie", setCookie);
+      const newTempUserPayload = tempUserTokenManager.decode(newTempUserToken);
+      return respond(newTempUserPayload, headers);
+    });
+    return handler;
+  };
+}
 
 // src/auth/cookie_store.ts
 import { createCookie } from "react-router";
@@ -92,5 +136,6 @@ var ReactRouterCookieManager = class {
 };
 export {
   ReactRouterCookieManager,
-  createWithAuthHandler
+  createWithAuthHandler,
+  createWithStrictAuthHandler
 };

package/dist/auth/with_auth.d.mts

@@ -1,12 +1,17 @@
 import { AccessTokenPayload } from 'dn-react-toolkit/auth';
-import { AuthService } from 'dn-react-toolkit/auth/server';
+import { AuthService, JWTManager, CookieManager } from 'dn-react-toolkit/auth/server';
 import { LoaderFunctionArgs, ActionFunctionArgs } from 'react-router';
 
 type Handler<T extends LoaderFunctionArgs | ActionFunctionArgs> = (arg: T) => Promise<unknown> | unknown;
 type InputFN = (auth?: AccessTokenPayload) => Handler<LoaderFunctionArgs> | Handler<ActionFunctionArgs>;
 type WithAuthHandler<T extends LoaderFunctionArgs | ActionFunctionArgs> = (fn: InputFN) => Handler<T>;
-declare function createWithAuthHandler<T extends LoaderFunctionArgs | ActionFunctionArgs>({ authService }: {
+declare function createWithStrictAuthHandler<T extends LoaderFunctionArgs | ActionFunctionArgs>({ authService }: {
     authService: AuthService;
 }): <THandler extends Handler<T>>(fn: (auth?: AccessTokenPayload) => THandler) => THandler;
+declare function createWithAuthHandler<T extends LoaderFunctionArgs | ActionFunctionArgs>({ authService, tempUserTokenManager, tempUserCookieManager, }: {
+    authService: AuthService;
+    tempUserTokenManager: JWTManager<AccessTokenPayload>;
+    tempUserCookieManager: CookieManager;
+}): <THandler extends Handler<T>>(fn: (auth: AccessTokenPayload) => THandler) => THandler;
 
-export { type WithAuthHandler, createWithAuthHandler };
+export { type WithAuthHandler, createWithAuthHandler, createWithStrictAuthHandler };