dn-react-router-toolkit 0.4.4 → 0.5.1

package/dist/api/index.mjs

@@ -21,7 +21,7 @@ var toResponse = (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()) => {
@@ -38,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);
         }
@@ -50,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);
@@ -97,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]) {
@@ -125,10 +117,13 @@ var createAPIHandler = ({
                 const provider = slug[2];
                 switch (method) {
                   case "POST": {
-                    return loginWithThirdPartyHandler(request, {
-                      provider,
-                      getThirdPartyAuth
-                    });
+                    return loginWithThirdPartyHandler(
+                      request,
+                      {
+                        provider,
+                        getThirdPartyAuth
+                      }
+                    );
                   }
                 }
               }
@@ -167,11 +162,14 @@ var createAPIHandler = ({
               default: {
                 switch (method) {
                   case "POST": {
-                    return signUpWithThirdpartyHandler(request, {
-                      authService,
-                      fileService,
-                      signupTokenManager
-                    });
+                    return signUpWithThirdpartyHandler(
+                      request,
+                      {
+                        authService,
+                        fileService,
+                        signupTokenManager
+                      }
+                    );
                   }
                 }
               }
@@ -195,7 +193,9 @@ var createAPIHandler = ({
             });
           }
           case "reset-password": {
-            return resetPasswordHandler(request, { passwordRecoveryService });
+            return resetPasswordHandler(request, {
+              passwordRecoveryService
+            });
           }
         }
       }
@@ -205,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,6 +1,5 @@
-export { WithAuthHandler, createWithAuthHandler, createWithTempAuthHandler } from './with_auth.mjs';
+export { WithAuthHandler, createWithAuthHandler, createWithStrictAuthHandler } from './with_auth.mjs';
 export { ReactRouterCookieManager } from './cookie_store.mjs';
-export { TempUserPayload } from './temp_user.mjs';
 import 'dn-react-toolkit/auth';
 import 'dn-react-toolkit/auth/server';
 import 'react-router';

package/dist/auth/index.d.ts

@@ -1,6 +1,5 @@
-export { WithAuthHandler, createWithAuthHandler, createWithTempAuthHandler } from './with_auth.js';
+export { WithAuthHandler, createWithAuthHandler, createWithStrictAuthHandler } from './with_auth.js';
 export { ReactRouterCookieManager } from './cookie_store.js';
-export { TempUserPayload } from './temp_user.js';
 import 'dn-react-toolkit/auth';
 import 'dn-react-toolkit/auth/server';
 import 'react-router';

package/dist/auth/index.js

@@ -22,7 +22,7 @@ var auth_exports = {};
 __export(auth_exports, {
   ReactRouterCookieManager: () => ReactRouterCookieManager,
   createWithAuthHandler: () => createWithAuthHandler,
-  createWithTempAuthHandler: () => createWithTempAuthHandler
+  createWithStrictAuthHandler: () => createWithStrictAuthHandler
 });
 module.exports = __toCommonJS(auth_exports);
 
@@ -34,7 +34,7 @@ var toResponse = (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()) => {
@@ -51,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);
         }
@@ -63,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);
@@ -90,13 +82,13 @@ function createWithAuthHandler({ authService }) {
     return handler;
   };
 }
-function createWithTempAuthHandler({
+function createWithAuthHandler({
   authService,
   tempUserTokenManager,
   tempUserCookieManager
 }) {
   return function(fn) {
-    const withAuthHandler = createWithAuthHandler({
+    const withAuthHandler = createWithStrictAuthHandler({
       authService
     });
     const handler = withAuthHandler((auth) => async (args) => {
@@ -113,7 +105,9 @@ function createWithTempAuthHandler({
         });
         return res;
       };
-      const tempUserToken = await tempUserCookieManager.parse(args.request);
+      const tempUserToken = await tempUserCookieManager.parse(
+        args.request
+      );
       if (tempUserToken) {
         const tempUserPayload = await tempUserTokenManager.verify(tempUserToken);
         if (tempUserPayload) {
@@ -131,9 +125,7 @@ function createWithTempAuthHandler({
         role: user.role
       });
       const headers = new Headers();
-      const setCookie = await tempUserCookieManager.serialize(
-        newTempUserToken
-      );
+      const setCookie = await tempUserCookieManager.serialize(newTempUserToken);
       headers.append("Set-Cookie", setCookie);
       const newTempUserPayload = tempUserTokenManager.decode(newTempUserToken);
       return respond(newTempUserPayload, headers);
@@ -174,5 +166,5 @@ var ReactRouterCookieManager = class {
 0 && (module.exports = {
   ReactRouterCookieManager,
   createWithAuthHandler,
-  createWithTempAuthHandler
+  createWithStrictAuthHandler
 });

package/dist/auth/index.mjs

@@ -6,7 +6,7 @@ var toResponse = (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()) => {
@@ -23,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);
         }
@@ -35,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);
@@ -62,13 +54,13 @@ function createWithAuthHandler({ authService }) {
     return handler;
   };
 }
-function createWithTempAuthHandler({
+function createWithAuthHandler({
   authService,
   tempUserTokenManager,
   tempUserCookieManager
 }) {
   return function(fn) {
-    const withAuthHandler = createWithAuthHandler({
+    const withAuthHandler = createWithStrictAuthHandler({
       authService
     });
     const handler = withAuthHandler((auth) => async (args) => {
@@ -85,7 +77,9 @@ function createWithTempAuthHandler({
         });
         return res;
       };
-      const tempUserToken = await tempUserCookieManager.parse(args.request);
+      const tempUserToken = await tempUserCookieManager.parse(
+        args.request
+      );
       if (tempUserToken) {
         const tempUserPayload = await tempUserTokenManager.verify(tempUserToken);
         if (tempUserPayload) {
@@ -103,9 +97,7 @@ function createWithTempAuthHandler({
         role: user.role
       });
       const headers = new Headers();
-      const setCookie = await tempUserCookieManager.serialize(
-        newTempUserToken
-      );
+      const setCookie = await tempUserCookieManager.serialize(newTempUserToken);
       headers.append("Set-Cookie", setCookie);
       const newTempUserPayload = tempUserTokenManager.decode(newTempUserToken);
       return respond(newTempUserPayload, headers);
@@ -145,5 +137,5 @@ var ReactRouterCookieManager = class {
 export {
   ReactRouterCookieManager,
   createWithAuthHandler,
-  createWithTempAuthHandler
+  createWithStrictAuthHandler
 };

package/dist/auth/with_auth.d.mts

@@ -5,13 +5,13 @@ 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 createWithTempAuthHandler<T extends LoaderFunctionArgs | ActionFunctionArgs>({ authService, tempUserTokenManager, tempUserCookieManager, }: {
+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, createWithTempAuthHandler };
+export { type WithAuthHandler, createWithAuthHandler, createWithStrictAuthHandler };

package/dist/auth/with_auth.d.ts

@@ -5,13 +5,13 @@ 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 createWithTempAuthHandler<T extends LoaderFunctionArgs | ActionFunctionArgs>({ authService, tempUserTokenManager, tempUserCookieManager, }: {
+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, createWithTempAuthHandler };
+export { type WithAuthHandler, createWithAuthHandler, createWithStrictAuthHandler };

package/dist/auth/with_auth.js

@@ -21,7 +21,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var with_auth_exports = {};
 __export(with_auth_exports, {
   createWithAuthHandler: () => createWithAuthHandler,
-  createWithTempAuthHandler: () => createWithTempAuthHandler
+  createWithStrictAuthHandler: () => createWithStrictAuthHandler
 });
 module.exports = __toCommonJS(with_auth_exports);
 var import_uuid = require("uuid");
@@ -31,7 +31,7 @@ var toResponse = (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()) => {
@@ -48,9 +48,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);
         }
@@ -60,23 +58,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);
@@ -87,13 +79,13 @@ function createWithAuthHandler({ authService }) {
     return handler;
   };
 }
-function createWithTempAuthHandler({
+function createWithAuthHandler({
   authService,
   tempUserTokenManager,
   tempUserCookieManager
 }) {
   return function(fn) {
-    const withAuthHandler = createWithAuthHandler({
+    const withAuthHandler = createWithStrictAuthHandler({
       authService
     });
     const handler = withAuthHandler((auth) => async (args) => {
@@ -110,7 +102,9 @@ function createWithTempAuthHandler({
         });
         return res;
       };
-      const tempUserToken = await tempUserCookieManager.parse(args.request);
+      const tempUserToken = await tempUserCookieManager.parse(
+        args.request
+      );
       if (tempUserToken) {
         const tempUserPayload = await tempUserTokenManager.verify(tempUserToken);
         if (tempUserPayload) {
@@ -128,9 +122,7 @@ function createWithTempAuthHandler({
         role: user.role
       });
       const headers = new Headers();
-      const setCookie = await tempUserCookieManager.serialize(
-        newTempUserToken
-      );
+      const setCookie = await tempUserCookieManager.serialize(newTempUserToken);
       headers.append("Set-Cookie", setCookie);
       const newTempUserPayload = tempUserTokenManager.decode(newTempUserToken);
       return respond(newTempUserPayload, headers);
@@ -141,5 +133,5 @@ function createWithTempAuthHandler({
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   createWithAuthHandler,
-  createWithTempAuthHandler
+  createWithStrictAuthHandler
 });

package/dist/auth/with_auth.mjs

@@ -6,7 +6,7 @@ var toResponse = (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()) => {
@@ -23,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);
         }
@@ -35,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);
@@ -62,13 +54,13 @@ function createWithAuthHandler({ authService }) {
     return handler;
   };
 }
-function createWithTempAuthHandler({
+function createWithAuthHandler({
   authService,
   tempUserTokenManager,
   tempUserCookieManager
 }) {
   return function(fn) {
-    const withAuthHandler = createWithAuthHandler({
+    const withAuthHandler = createWithStrictAuthHandler({
       authService
     });
     const handler = withAuthHandler((auth) => async (args) => {
@@ -85,7 +77,9 @@ function createWithTempAuthHandler({
         });
         return res;
       };
-      const tempUserToken = await tempUserCookieManager.parse(args.request);
+      const tempUserToken = await tempUserCookieManager.parse(
+        args.request
+      );
       if (tempUserToken) {
         const tempUserPayload = await tempUserTokenManager.verify(tempUserToken);
         if (tempUserPayload) {
@@ -103,9 +97,7 @@ function createWithTempAuthHandler({
         role: user.role
       });
       const headers = new Headers();
-      const setCookie = await tempUserCookieManager.serialize(
-        newTempUserToken
-      );
+      const setCookie = await tempUserCookieManager.serialize(newTempUserToken);
       headers.append("Set-Cookie", setCookie);
       const newTempUserPayload = tempUserTokenManager.decode(newTempUserToken);
       return respond(newTempUserPayload, headers);
@@ -115,5 +107,5 @@ function createWithTempAuthHandler({
 }
 export {
   createWithAuthHandler,
-  createWithTempAuthHandler
+  createWithStrictAuthHandler
 };