Fixes + error handling

docs/pages/api-docs/adapters.mdx

@@ -14,6 +14,7 @@ export interface IAdapter<T, Q = IParsedQueryParams> {
   create(data: any, query?: Q): Promise<T> // POST /api/modelName
   update(resourceId: string | number, data: any, query?: Q): Promise<T> // PUT/PATCH /api/modelName/:id
   delete(resourceId: string | number, query?: Q): Promise<T> // DELETE /api/modelName/:id
+  handleError?: (err: Error) => void // Used to throw a custom error of your own
 }
 ```
 

example/package.json

@@ -16,7 +16,7 @@
     "@prisma/client": "^2.11.0",
     "framer-motion": "^2.9.4",
     "next": "latest",
-    "@premieroctet/next-crud": "file:..",
+    "@premieroctet/next-crud": "latest",
     "react": "^16.12.0",
     "react-dom": "^16.12.0",
     "react-hook-form": "^6.11.5",

package.json

@@ -46,8 +46,6 @@
   "dependencies": {
     "lodash.isobject": "^3.0.2",
     "lodash.set": "^4.3.2",
-    "nextra": "^0.3.1",
-    "nextra-theme-docs": "^1.0.1",
     "path-to-regexp": "^6.2.0",
     "qs": "^6.9.4"
   }

src/adapters/prisma/index.ts

@@ -1,5 +1,12 @@
-// @ts-ignore
-import { PrismaClient, PrismaAction, PrismaClientOptions } from '@prisma/client'
+import {
+  PrismaClient,
+  PrismaAction,
+  PrismaClientOptions,
+  PrismaClientKnownRequestError,
+  PrismaClientValidationError,
+  // @ts-ignore
+} from '@prisma/client'
+import HttpError from '../../httpError'
 import { IAdapter, IParsedQueryParams } from '../../types'
 import { IPrismaParsedQueryParams } from './types'
 import { parsePrismaCursor } from './utils/parseCursor'
@@ -33,6 +40,24 @@ export default class PrismaAdapter<T>
     this.manyRelations = manyRelations
   }
 
+  handleError(err: Error) {
+    console.error(err.message)
+    if (
+      err instanceof PrismaClientKnownRequestError ||
+      err instanceof PrismaClientValidationError
+    ) {
+      throw new HttpError(
+        400,
+        'invalid request, check your server logs for more info'
+      )
+    } else {
+      throw new HttpError(
+        500,
+        'an unknown error occured, check your server logs for more info'
+      )
+    }
+  }
+
   parseQuery(query?: IParsedQueryParams) {
     const parsed: IPrismaParsedQueryParams = {}
 

src/handler.ts

@@ -8,6 +8,7 @@ import {
   getOneHandler,
   updateHandler,
 } from './handlers'
+import HttpError from './httpError'
 import { parseQuery } from './queryParser'
 import { IAdapter, IHandlerParams, RouteType, TMiddleware } from './types'
 import { getRouteType, formatResourceId as formatResourceIdUtil } from './utils'
@@ -120,35 +121,43 @@ function NextCrud<T, Q = any>({
       const resourceIdFormatted = formatResourceId(resourceId)
 
       const executeCrud = async () => {
-        switch (routeType) {
-          case RouteType.READ_ONE:
-            await getOneHandler({
-              ...params,
-              resourceId: resourceIdFormatted,
-            })
-            break
-          case RouteType.READ_ALL:
-            await getAllHandler<T, Q>(params)
-            break
-          case RouteType.CREATE:
-            await createHandler<T, Q>({ ...params, body })
-            break
-          case RouteType.UPDATE:
-            await updateHandler<T, Q>({
-              ...params,
-              resourceId: resourceIdFormatted,
-              body,
-            })
-            break
-          case RouteType.DELETE:
-            await deleteHandler<T, Q>({
-              ...params,
-              resourceId: resourceIdFormatted,
-            })
-            break
-          case null:
-            res.status(404)
-            break
+        try {
+          switch (routeType) {
+            case RouteType.READ_ONE:
+              await getOneHandler({
+                ...params,
+                resourceId: resourceIdFormatted,
+              })
+              break
+            case RouteType.READ_ALL:
+              await getAllHandler<T, Q>(params)
+              break
+            case RouteType.CREATE:
+              await createHandler<T, Q>({ ...params, body })
+              break
+            case RouteType.UPDATE:
+              await updateHandler<T, Q>({
+                ...params,
+                resourceId: resourceIdFormatted,
+                body,
+              })
+              break
+            case RouteType.DELETE:
+              await deleteHandler<T, Q>({
+                ...params,
+                resourceId: resourceIdFormatted,
+              })
+              break
+            case null:
+              res.status(404)
+              break
+          }
+        } catch (e) {
+          if (adapter.handleError && !(e instanceof HttpError)) {
+            adapter.handleError(e)
+          } else {
+            throw e
+          }
         }
       }
 
@@ -182,7 +191,11 @@ function NextCrud<T, Q = any>({
       await onSuccess?.(req, res)
     } catch (e) {
       await onError?.(req, res, e)
-      res.status(500).send(e.message)
+      if (e instanceof HttpError) {
+        res.status(e.statusCode).send(e.message)
+      } else {
+        res.status(500).send(e.message)
+      }
     } finally {
       await adapter.disconnect?.()
       res.end()

src/handlers/deleteHandler.ts

@@ -1,3 +1,4 @@
+import HttpError from '../httpError'
 import { IUniqueResourceHandlerParams } from '../types'
 import { executeMiddlewares } from '../utils'
 
@@ -11,20 +12,26 @@ async function deleteHandler<T, Q>({
   request,
   middlewares,
 }: IDeleteHandler<T, Q>): Promise<void> {
-  const deletedResource = await adapter.delete(resourceId, query)
-  await executeMiddlewares(
-    [
-      ...middlewares,
-      ({ result }) => {
-        response.send(result)
-      },
-    ],
-    {
-      req: request,
-      res: response,
-      result: deletedResource,
-    }
-  )
+  const resource = await adapter.getOne(resourceId, query)
+
+  if (resource) {
+    const deletedResource = await adapter.delete(resourceId, query)
+    await executeMiddlewares(
+      [
+        ...middlewares,
+        ({ result }) => {
+          response.send(result)
+        },
+      ],
+      {
+        req: request,
+        res: response,
+        result: deletedResource,
+      }
+    )
+  } else {
+    throw new HttpError(404, `resource ${resourceId} not found`)
+  }
 }
 
 export default deleteHandler

src/handlers/getOne.ts

@@ -1,3 +1,4 @@
+import HttpError from '../httpError'
 import { IUniqueResourceHandlerParams } from '../types'
 import { executeMiddlewares } from '../utils'
 
@@ -12,6 +13,11 @@ async function getOneHandler<T, Q>({
   request,
 }: IGetOneHandler<T, Q>): Promise<void> {
   const resource = await adapter.getOne(resourceId, query)
+
+  if (!resource) {
+    throw new HttpError(404, `resource ${resourceId} not found`)
+  }
+
   await executeMiddlewares(
     [
       ...middlewares,

src/handlers/updateHandler.ts

@@ -1,3 +1,4 @@
+import HttpError from '../httpError'
 import { IUniqueResourceHandlerParams } from '../types'
 import { executeMiddlewares } from '../utils'
 
@@ -14,20 +15,26 @@ async function updateHandler<T, Q>({
   middlewares,
   request,
 }: IUpdateHandler<T, Q>): Promise<void> {
-  const updatedResource = await adapter.update(resourceId, body, query)
-  await executeMiddlewares(
-    [
-      ...middlewares,
-      ({ result }) => {
-        response.send(result)
-      },
-    ],
-    {
-      req: request,
-      res: response,
-      result: updatedResource,
-    }
-  )
+  const resource = await adapter.getOne(resourceId, query)
+
+  if (resource) {
+    const updatedResource = await adapter.update(resourceId, body, query)
+    await executeMiddlewares(
+      [
+        ...middlewares,
+        ({ result }) => {
+          response.send(result)
+        },
+      ],
+      {
+        req: request,
+        res: response,
+        result: updatedResource,
+      }
+    )
+  } else {
+    throw new HttpError(404, `resource ${resourceId} not found`)
+  }
 }
 
 export default updateHandler

src/httpError.ts

@@ -0,0 +1,11 @@
+import * as http from 'http'
+
+export default class HttpError extends Error {
+  statusCode: number
+
+  constructor(code: number, message?: string) {
+    super(`${http.STATUS_CODES[code]}: ${message}`)
+    this.name = 'HttpError'
+    this.statusCode = code
+  }
+}

src/index.ts

@@ -1,3 +1,4 @@
 export { default } from './handler'
 export { default as PrismaAdapter } from './adapters/prisma'
 export * from './types'
+export { default as HttpError } from './httpError'

src/types.ts

@@ -30,6 +30,7 @@ export interface IAdapter<T, Q> {
   delete(resourceId: string | number, query?: Q): Promise<T>
   connect?: () => Promise<void>
   disconnect?: () => Promise<void>
+  handleError?: (err: Error) => void
 }
 
 export type TMiddlewareContext<T> = {