dn-react-router-toolkit 0.9.0 → 0.9.2

package/dist/api/index.mjs

@@ -1,5 +1,4 @@
-// src/api/create_handler.ts
-import { NOT_FOUND } from "dn-react-toolkit/http";
+// src/api/default_api_handler.ts
 import {
   findAuthHandler,
   loginHandler,
@@ -11,7 +10,7 @@ import {
   signupHandler,
   signUpWithThirdpartyHandler,
   thirdpartyAuthCallbackHandler
-} from "dn-react-toolkit/auth/server";
+} from "gw-auth/server";
 
 // src/auth/with_auth.ts
 var toResponse = (result) => {
@@ -37,31 +36,31 @@ function createWithStrictAuthHandler({ authService }) {
         arg.request
       );
       if (accessToken) {
-        const payload = await authService.accessTokenManager.verify(accessToken);
-        if (payload) {
-          return respond(payload);
+        const verifyResult = await authService.accessTokenManager.verify(accessToken);
+        if (verifyResult.isOk) {
+          const payload = verifyResult.value;
+          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);
-          const payload = authService.accessTokenManager.decode(newAccessToken);
-          return respond(payload, headers);
-        } catch (e) {
-          console.log(e);
-          const setCookieHeader = await authService.getRefreshTokenSetCookie(void 0);
-          const headers = new Headers();
-          headers.append("Set-Cookie", setCookieHeader);
-          return respond(void 0, headers);
+        const refreshResult = await authService.refreshAccessToken(refreshToken);
+        if (refreshResult.isErr) {
+          const setCookieHeader2 = await authService.getRefreshTokenSetCookie(void 0);
+          const headers2 = new Headers();
+          headers2.append("Set-Cookie", setCookieHeader2);
+          return respond(void 0, headers2);
         }
+        const newAccessToken = refreshResult.value;
+        const setCookieHeader = await authService.getAccessTokenSetCookie(newAccessToken);
+        const headers = new Headers();
+        headers.append("Set-Cookie", setCookieHeader);
+        const payload = authService.accessTokenManager.decode(newAccessToken);
+        return respond(payload, headers);
       }
       return respond(void 0);
     };
@@ -72,16 +71,17 @@ function createWithStrictAuthHandler({ authService }) {
 // src/auth/cookie_manager.ts
 import { createCookie } from "react-router";
 
-// src/api/create_handler.ts
+// src/api/default_api_handler.ts
 import {
   deleteFileHandler,
   uploadFileHandler
-} from "dn-react-toolkit/file/server";
-var createAPIHandler = ({
+} from "gw-file/server";
+import { httpNotFound } from "gw-response";
+var defaultAPIHandler = ({
   authService,
   fileService,
   passwordRecoveryService,
-  getThirdPartyAuth,
+  authProviders,
   signupTokenManager
 }) => {
   const handler = async (args) => {
@@ -96,7 +96,7 @@ var createAPIHandler = ({
             switch (method) {
               case "GET": {
                 return withAuth(
-                  (auth) => ({ request: request2 }) => findAuthHandler(auth)(request2)
+                  (auth) => ({ request: request2 }) => findAuthHandler(auth)()
                 );
               }
             }
@@ -116,13 +116,10 @@ var createAPIHandler = ({
                 const provider = slug[2];
                 switch (method) {
                   case "POST": {
-                    return loginWithThirdPartyHandler(
-                      request,
-                      {
-                        provider,
-                        getThirdPartyAuth
-                      }
-                    );
+                    return loginWithThirdPartyHandler(request, {
+                      provider,
+                      authProviders
+                    });
                   }
                 }
               }
@@ -161,14 +158,11 @@ var createAPIHandler = ({
               default: {
                 switch (method) {
                   case "POST": {
-                    return signUpWithThirdpartyHandler(
-                      request,
-                      {
-                        authService,
-                        fileService,
-                        signupTokenManager
-                      }
-                    );
+                    return signUpWithThirdpartyHandler(request, {
+                      authService,
+                      fileService,
+                      signupTokenManager
+                    });
                   }
                 }
               }
@@ -181,7 +175,7 @@ var createAPIHandler = ({
                 return thirdpartyAuthCallbackHandler(request, {
                   provider,
                   authService,
-                  getThirdPartyAuth
+                  authProviders
                 });
               }
             }
@@ -204,9 +198,9 @@ var createAPIHandler = ({
             switch (method) {
               case "POST": {
                 return withAuth(
-                  (auth) => ({ request: request2 }) => uploadFileHandler({ fileService })(
-                    auth
-                  )(request2)
+                  (auth) => ({ request: request2 }) => uploadFileHandler({ fileService })(request2, {
+                    userId: auth?.userId
+                  })
                 )(args);
               }
             }
@@ -218,7 +212,7 @@ var createAPIHandler = ({
                 return withAuth(
                   (auth) => () => deleteFileHandler({
                     fileRepository: fileService.fileRepository
-                  })({ fileId })(auth)()
+                  })({ fileId, userId: auth?.userId })()
                 );
               }
             }
@@ -226,26 +220,41 @@ var createAPIHandler = ({
         }
       }
       default: {
-        return NOT_FOUND();
+        return httpNotFound({
+          code: "RESOURCE_NOT_FOUND",
+          message: "\uB9AC\uC18C\uC2A4\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4."
+        });
       }
     }
   };
   return handler;
 };
 
-// src/api/create_api_handler.ts
+// src/api/resource_handler.ts
 import {
-  BAD_REQUEST,
-  CONFLICT,
-  CREATED,
-  INTERNAL_SERVER_ERROR,
-  METHOD_NOT_ALLOWED,
-  UNAUTHORIZED
-} from "dn-react-toolkit/http";
+  httpForbidden as httpForbidden2,
+  httpMethodNotAllowed,
+  httpNoContent,
+  httpNotFound as httpNotFound3
+} from "gw-response";
+import { ok } from "gw-result";
+
+// src/api/put_resource_handler.ts
 import {
-  and
-} from "drizzle-orm";
-import { v4 } from "uuid";
+  httpBadRequest,
+  httpConflict,
+  httpCreated,
+  httpForbidden,
+  httpNotFound as httpNotFound2
+} from "gw-response";
+
+// src/crud/crud_form_provider.tsx
+import { useNavigate } from "react-router";
+import { useStore } from "react-store-input";
+import {
+  createContext,
+  useContext
+} from "react";
 
 // src/crud/serialize.ts
 function deserialize(data) {
@@ -284,119 +293,197 @@ function deserialize(data) {
   return void 0;
 }
 
-// src/api/create_api_handler.ts
-function apiHandler({
-  withAuthAction,
+// src/crud/crud_form_provider.tsx
+import { jsx } from "react/jsx-runtime";
+var FormContext = createContext({});
+
+// src/form/create_form_component.tsx
+import "react";
+
+// src/utils/cn.ts
+function cn(...classes) {
+  return classes.filter(Boolean).join(" ").trim();
+}
+
+// src/utils/date.ts
+import moment from "moment-timezone";
+
+// src/form/create_form_component.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+function createComponent(tag, options) {
+  return function FormComponent({ className, ...props }) {
+    const Tag = tag;
+    return /* @__PURE__ */ jsx2(Tag, { ...props, className: cn(options.className, className) });
+  };
+}
+
+// src/form/form_components.tsx
+var FormEntry = createComponent("div", {
+  className: "flex-1"
+});
+var FormRow = createComponent("div", {
+  className: "flex-1 flex gap-4 mb-6"
+});
+var FormLabel = createComponent("label", {
+  className: "flex-1 font-semibold mb-2.5 block"
+});
+
+// src/crud/crud_form.tsx
+import { useStoreComponent } from "react-store-input";
+
+// src/client/env_loader.tsx
+import { useRouteLoaderData } from "react-router";
+import { jsx as jsx3 } from "react/jsx-runtime";
+
+// src/client/file_input.tsx
+import {
+  useRef
+} from "react";
+import { Fragment, jsx as jsx4, jsxs } from "react/jsx-runtime";
+
+// src/client/use_user_agent.tsx
+import { useRouteLoaderData as useRouteLoaderData2 } from "react-router";
+
+// src/client/store_text_editor.tsx
+import {
+  TextEditor
+} from "dn-react-text-editor";
+import { useStoreController } from "react-store-input";
+import { useImperativeHandle, useRef as useRef2 } from "react";
+import { jsx as jsx5 } from "react/jsx-runtime";
+
+// src/client/editor.tsx
+import { generateMetadata } from "gw-file/client";
+
+// src/crud/crud_form.tsx
+import { Fragment as Fragment2, jsx as jsx6, jsxs as jsxs2 } from "react/jsx-runtime";
+
+// src/api/put_resource_handler.ts
+import {
+  and
+} from "drizzle-orm";
+import { v4 } from "uuid";
+function putResourceHandler({
   repository,
   validators,
   existingConditions,
   injectUserId,
-  roles
+  isOwnedBy
 }) {
-  const loader = async ({ request }) => {
-    return {};
-  };
-  const action = withAuthAction((auth) => async ({ request }) => {
-    if (roles && roles.length > 0 && (!auth || !roles.includes(auth.role))) {
-      throw UNAUTHORIZED();
+  return async (auth, request) => {
+    const serilaizedParams = await request.json();
+    const params = deserialize(serilaizedParams);
+    const itemId = params.id || v4();
+    if (params.id) {
+      const existing = await repository.find(itemId);
+      if (!existing) {
+        return httpNotFound2();
+      }
+      if (isOwnedBy && (!auth || !isOwnedBy(auth, existing))) {
+        return httpForbidden();
+      }
     }
-    switch (request.method) {
-      case "POST":
-      case "PUT": {
-        try {
-          const serilaizedParams = await request.json();
-          const params = deserialize(serilaizedParams);
-          if (validators) {
-            const paramsForValidation = Object.keys(validators).filter(
-              (key) => Object.prototype.hasOwnProperty.call(validators, key)
-            );
-            for (const paramKey of paramsForValidation) {
-              const value = params[paramKey];
-              const validator = validators[paramKey];
-              if (validator?.validate && !validator.validate(value)) {
-                throw BAD_REQUEST(
-                  validator.message ? validator.message(value) : void 0
-                );
-              }
-            }
-          }
-          const itemId = params.id || v4();
-          if (!params.id && existingConditions) {
-            const paramsForExistenceCheck = Object.keys(
-              existingConditions
-            ).filter(
-              (key) => Object.prototype.hasOwnProperty.call(params, key)
-            );
-            if (paramsForExistenceCheck.length > 0) {
-              const where = and(
-                ...paramsForExistenceCheck.reduce((acc, key) => {
-                  const condition = existingConditions[key];
-                  if (condition) {
-                    acc.push(condition(params[key]));
-                  }
-                  return acc;
-                }, [])
-              );
-              const existing = await repository.findAll({
-                limit: 1,
-                where
-              });
-              if (existing.length > 0) {
-                throw CONFLICT("\uC790\uB8CC\uAC00 \uC774\uBBF8 \uC874\uC7AC\uD569\uB2C8\uB2E4.");
-              }
+    if (validators) {
+      const paramsForValidation = Object.keys(validators).filter(
+        (key) => Object.prototype.hasOwnProperty.call(validators, key)
+      );
+      for (const paramKey of paramsForValidation) {
+        const value = params[paramKey];
+        const validator = validators[paramKey];
+        if (validator?.validate && !validator.validate(value)) {
+          return httpBadRequest({
+            code: "BAD_REQUEST",
+            message: validator.message ? validator.message(value) : "\uC798\uBABB\uB41C \uC694\uCCAD\uC785\uB2C8\uB2E4."
+          });
+        }
+      }
+    }
+    if (!params.id && existingConditions) {
+      const paramsForExistenceCheck = Object.keys(existingConditions).filter(
+        (key) => Object.prototype.hasOwnProperty.call(params, key)
+      );
+      if (paramsForExistenceCheck.length > 0) {
+        const where = and(
+          ...paramsForExistenceCheck.reduce((acc, key) => {
+            const condition = existingConditions[key];
+            if (condition) {
+              acc.push(condition(params[key]));
             }
-          }
-          const values = {
-            id: itemId,
-            userId: injectUserId ? auth?.userId : void 0,
-            ...params
-          };
-          const item = await repository.save(values);
-          return CREATED(item);
-        } catch (error) {
-          if (error instanceof Error) {
-            throw INTERNAL_SERVER_ERROR(error.message);
-          }
-          throw error;
+            return acc;
+          }, [])
+        );
+        const existing = await repository.findAll({
+          limit: 1,
+          where
+        });
+        if (existing.length > 0) {
+          return httpConflict();
         }
       }
-      default:
-        throw METHOD_NOT_ALLOWED();
     }
-  });
-  return {
-    loader,
-    action
+    const values = {
+      id: itemId,
+      userId: injectUserId ? auth?.userId : void 0,
+      ...params
+    };
+    const item = await repository.save(values);
+    return httpCreated(item);
   };
 }
 
-// src/api/item_api_handler.ts
-import { FORBIDDEN, NOT_FOUND as NOT_FOUND2, UNAUTHORIZED as UNAUTHORIZED2 } from "dn-react-toolkit/http";
-function itemApiHandler({
+// src/api/resource_handler.ts
+function resourceHandler({
   withAuthAction,
   repository,
-  isOwnedBy,
-  roles
+  validators,
+  existingConditions,
+  injectUserId,
+  roles,
+  isOwnedBy
 }) {
   const loader = async ({ request }) => {
-    return {};
+    return ok({});
   };
-  const action = withAuthAction((auth) => async ({ params, request }) => {
+  const action = withAuthAction((auth) => async ({ request, params }) => {
     if (roles && roles.length > 0 && (!auth || !roles.includes(auth.role))) {
-      throw UNAUTHORIZED2();
+      return httpForbidden2({
+        code: "FORBIDDEN",
+        message: "\uAD8C\uD55C\uC774 \uC5C6\uC2B5\uB2C8\uB2E4."
+      });
     }
     const itemId = params.itemId;
-    const existing = await repository.find(itemId);
-    if (!existing) {
-      throw NOT_FOUND2();
-    }
-    if (isOwnedBy && !isOwnedBy(existing, auth)) {
-      throw FORBIDDEN();
+    if (itemId) {
+      const existing = await repository.find(itemId);
+      if (!existing) {
+        return httpNotFound3();
+      }
+      if (isOwnedBy && (!auth || !isOwnedBy(auth, existing))) {
+        return httpForbidden2();
+      }
+      switch (request.method) {
+        case "DELETE": {
+          await repository.delete(itemId);
+          return httpNoContent();
+        }
+        default: {
+          return httpMethodNotAllowed();
+        }
+      }
     }
     switch (request.method) {
-      case "DELETE": {
-        await repository.delete(itemId);
-        return {};
+      case "POST":
+      case "PUT": {
+        const handler = putResourceHandler({
+          repository,
+          validators,
+          existingConditions,
+          injectUserId,
+          isOwnedBy
+        });
+        return handler(auth, request);
+      }
+      default: {
+        return httpMethodNotAllowed();
       }
     }
   });
@@ -406,7 +493,7 @@ function itemApiHandler({
   };
 }
 export {
-  apiHandler,
-  createAPIHandler,
-  itemApiHandler
+  defaultAPIHandler,
+  putResourceHandler,
+  resourceHandler
 };

package/dist/api/put_resource_handler.d.mts

@@ -0,0 +1,25 @@
+import { InferSelectModel, SQLWrapper } from 'drizzle-orm';
+import { AccessTokenPayload } from 'gw-auth';
+import { PgTableWithColumns } from 'drizzle-orm/pg-core';
+import { TableRepository } from '../table/repository.mjs';
+import 'drizzle-orm/node-postgres';
+
+type PutResourceValidators<T extends PgTableWithColumns<any>> = {
+    [K in keyof InferSelectModel<T>]?: {
+        validate?: (value?: InferSelectModel<T>[K]) => boolean;
+        message?: (value?: InferSelectModel<T>[K]) => string;
+    };
+};
+type PutResourceExistingConditions<T extends PgTableWithColumns<any>> = {
+    [K in keyof InferSelectModel<T>]?: (value: InferSelectModel<T>[K]) => SQLWrapper;
+};
+type PutResourceHandlerOptions<T extends PgTableWithColumns<any>, TSelect> = {
+    repository: TableRepository<T, TSelect>;
+    validators?: PutResourceValidators<T>;
+    existingConditions?: PutResourceExistingConditions<T>;
+    injectUserId?: boolean;
+    isOwnedBy?: (auth: AccessTokenPayload, item: TSelect) => boolean;
+};
+declare function putResourceHandler<T extends PgTableWithColumns<any>, TSelect>({ repository, validators, existingConditions, injectUserId, isOwnedBy, }: PutResourceHandlerOptions<T, TSelect>): (auth: AccessTokenPayload | undefined, request: Request) => Promise<Response>;
+
+export { type PutResourceExistingConditions, type PutResourceHandlerOptions, type PutResourceValidators, putResourceHandler };

package/dist/api/put_resource_handler.d.ts

@@ -0,0 +1,25 @@
+import { InferSelectModel, SQLWrapper } from 'drizzle-orm';
+import { AccessTokenPayload } from 'gw-auth';
+import { PgTableWithColumns } from 'drizzle-orm/pg-core';
+import { TableRepository } from '../table/repository.js';
+import 'drizzle-orm/node-postgres';
+
+type PutResourceValidators<T extends PgTableWithColumns<any>> = {
+    [K in keyof InferSelectModel<T>]?: {
+        validate?: (value?: InferSelectModel<T>[K]) => boolean;
+        message?: (value?: InferSelectModel<T>[K]) => string;
+    };
+};
+type PutResourceExistingConditions<T extends PgTableWithColumns<any>> = {
+    [K in keyof InferSelectModel<T>]?: (value: InferSelectModel<T>[K]) => SQLWrapper;
+};
+type PutResourceHandlerOptions<T extends PgTableWithColumns<any>, TSelect> = {
+    repository: TableRepository<T, TSelect>;
+    validators?: PutResourceValidators<T>;
+    existingConditions?: PutResourceExistingConditions<T>;
+    injectUserId?: boolean;
+    isOwnedBy?: (auth: AccessTokenPayload, item: TSelect) => boolean;
+};
+declare function putResourceHandler<T extends PgTableWithColumns<any>, TSelect>({ repository, validators, existingConditions, injectUserId, isOwnedBy, }: PutResourceHandlerOptions<T, TSelect>): (auth: AccessTokenPayload | undefined, request: Request) => Promise<Response>;
+
+export { type PutResourceExistingConditions, type PutResourceHandlerOptions, type PutResourceValidators, putResourceHandler };