Add before hooks, rename from createApi to createService

Author: flaviouk

README.md

@@ -10,7 +10,7 @@ Hooks are just middlewares that run before each of the handlers.
 ```ts
 import getConfig from 'next/config'
 import * as mongoose from 'mongoose'
-import { createApi, hook, NotFoundError } from 'api-next'
+import { createService, hook, NotFoundError } from 'api-next'
 
 export interface PostAttrs {
   title: string
@@ -51,24 +51,26 @@ const config = getConfig()
 
 // Concept from Feathersjs: https://feathersjs.com/
 const hooks = {
-  all: [
-    hook.connectToDatabase({
-      name: 'posts-db',
-      connect: () =>
-        mongoose.connect(config.serverRuntimeConfig.MONGO_URI, {
-          useNewUrlParser: true,
-          useUnifiedTopology: true,
-          useCreateIndex: true,
-        }),
-    }),
-  ],
-  create: [validateBody],
-  update: [validateBody],
+  before: {
+    all: [
+      hook.connectToDatabase({
+        name: 'posts-db',
+        connect: () =>
+          mongoose.connect(config.serverRuntimeConfig.MONGO_URI, {
+            useNewUrlParser: true,
+            useUnifiedTopology: true,
+            useCreateIndex: true,
+          }),
+      }),
+    ],
+    create: [validateBody],
+    update: [validateBody],
+  },
 }
 
 // All the keys are optional
 // Pick what you need
-export default createApi({
+export default createService({
   hooks,
   find: async () => Post.find(),
   create: async (body: PostAttrs) => Post.build(body),
@@ -93,11 +95,11 @@ export default createApi({
 ### Alternative
 
 ```ts
-import { createMongooseApi } from 'api-next'
+import { createMongooseService } from 'api-next'
 
-const { find, create, get, update, remove } = createMongooseApi(Post)
+const { find, create, get, update, remove } = createMongooseService(Post)
 
-export default createApi({
+export default createService({
   hooks,
   find,
   create,

package.json

@@ -1,6 +1,6 @@
 {
   "name": "api-next",
-  "version": "1.0.0-beta.2",
+  "version": "1.0.0",
   "repository": "https://github.com/imflavio/api-next",
   "author": "Flávio Carvalho <hey@flavio.uk>",
   "license": "MIT",

src/api.ts

@@ -1,7 +1,7 @@
 import * as hook from './hooks'
 export { hook }
 
-export * from './api'
+export * from 'services.ts'
 export * from './mongoose'
 export * from './types'
 export { BadRequestError } from './errors/bad-request-error'

src/index.ts

@@ -1,26 +1,26 @@
 import * as mongoose from 'mongoose'
 
-import { Services } from './types'
+import { ServiceMethods } from './types'
 import { NotFoundError } from './errors/not-found-error'
 
-export const createMongooseApi = (
+export const createMongooseService = (
   Model: ReturnType<typeof mongoose.model>,
-): Services => ({
+): ServiceMethods => ({
   find: async () => Model.find(),
   create: async (body) => Model.create(body),
   get: async (pk) => Model.findById(pk),
   update: async (pk, body) => {
-    const post = await Model.findById(pk)
-    if (!post) throw new NotFoundError()
+    const data = await Model.findById(pk)
+    if (!data) throw new NotFoundError()
 
-    post.set(body)
-    await post.save()
-    return post
+    data.set(body)
+    await data.save()
+    return data
   },
   remove: async (pk) => {
-    const post = await Model.findById(pk)
-    if (!post) throw new NotFoundError()
-    await post.remove()
-    return { success: true }
+    const data = await Model.findById(pk)
+    if (!data) throw new NotFoundError()
+    await data.remove()
+    return { success: true, data }
   },
 })

src/mongoose.ts

@@ -0,0 +1,145 @@
+import { NextApiRequest, NextApiResponse } from 'next'
+import morgan from 'morgan'
+import { Method, Status } from 'simple-http-status'
+
+import { CustomError } from './errors/custom-error'
+import { NotFoundError } from './errors/not-found-error'
+import { Hook, ServiceMethods } from './types'
+
+interface Pk {
+  name?: string
+  cast?: (pk: string) => string
+}
+
+interface Hooks {
+  all?: Hook[]
+  find?: Hook[]
+  create?: Hook[]
+  get?: Hook[]
+  update?: Hook[]
+  patch?: Hook[]
+  remove?: Hook[]
+}
+
+interface ServiceOptions extends ServiceMethods {
+  pk?: Pk
+  hooks?: {
+    before?: Hooks
+    after?: Hooks
+  }
+}
+
+const logger = morgan(
+  ':method :url :status :res[content-length] - :response-time ms',
+)
+
+const getPk = (pk: Pk = {}, query: NextApiRequest['query']): string | null => {
+  const queryValue = pk?.name ? query[pk?.name] : query?.id || query?.pk
+  const [value] = Array.isArray(queryValue) ? queryValue : [queryValue]
+  return pk?.cast && value ? pk.cast(value!) : value
+}
+
+const getStatusCode = (type: keyof ServiceMethods) => {
+  switch (type) {
+    case 'create':
+      return Status.HTTP_201_CREATED
+    default:
+      return Status.HTTP_200_OK
+  }
+}
+
+const runHandler = async (
+  type: keyof ServiceMethods,
+  options: ServiceOptions,
+  req: NextApiRequest,
+  pk: string,
+) => {
+  switch (type) {
+    case 'find':
+      return options.find!(req.query)
+    case 'create':
+      return options.create!(req.body)
+    case 'get':
+      return options.get!(pk, req.query)
+    case 'update':
+      return options.update!(pk, req.body, req.query)
+    case 'patch':
+      return options.patch!(pk, req.body, req.query)
+    case 'remove':
+      return options.remove!(pk)
+  }
+}
+
+const handleService = async (
+  type: keyof ServiceMethods,
+  options: ServiceOptions,
+  req: NextApiRequest,
+  res: NextApiResponse,
+) => {
+  const pk = getPk(options.pk, req.query)
+
+  const runHooks = async (hooks: Hook[]) => {
+    for (let index = 0; index < hooks.length; index++) {
+      await hooks[index](req, res, () => {})
+    }
+  }
+
+  const allBeforeHooks = options.hooks?.before?.all ?? []
+  const beforeHooks = options.hooks?.before?.[type] ?? []
+  await runHooks([...allBeforeHooks, ...beforeHooks])
+
+  const result = await runHandler(type, options, req, pk!)
+
+  const allAfterHooks = options.hooks?.after?.all ?? []
+  const afterHooks = options.hooks?.after?.[type] ?? []
+  await runHooks([...allAfterHooks, ...afterHooks])
+
+  const statusCode = getStatusCode(type)
+
+  return res.status(statusCode).json(result)
+}
+
+export const createService = (options: ServiceOptions) => async (
+  req: NextApiRequest,
+  res: NextApiResponse,
+) => {
+  logger(req, res, () => {})
+
+  try {
+    const pk = getPk(options.pk, req.query)
+    const { method } = req
+
+    switch (true) {
+      case options.get && pk && method === Method.GET:
+        return handleService('get', options, req, res)
+
+      case options.update && pk && method === Method.PUT:
+        return handleService('update', options, req, res)
+
+      case options.patch && pk && method === Method.PATCH:
+        return handleService('patch', options, req, res)
+
+      case options.remove && pk && method === Method.DELETE:
+        return handleService('remove', options, req, res)
+
+      case options.find && !pk && method === Method.GET:
+        return handleService('find', options, req, res)
+
+      case options.create && !pk && method === Method.POST:
+        return handleService('create', options, req, res)
+
+      default:
+        throw new NotFoundError()
+    }
+  } catch (err) {
+    if (err instanceof CustomError) {
+      return res.status(err.statusCode).json({
+        errors: err.serializeErrors(),
+      })
+    }
+
+    return res.status(Status.HTTP_500_INTERNAL_SERVER_ERROR).json({
+      errors: [{ message: 'Something went wrong' }],
+    })
+  }
+}

src/services.ts

@@ -8,7 +8,7 @@ export interface DatabaseConnection {
 export type ApiNextQuery = NextApiRequest['query']
 export type ApiNextBody = NextApiRequest['body']
 
-export interface Services {
+export interface ServiceMethods {
   find?(query: ApiNextQuery): Promise<any>
   create?: (body: ApiNextBody) => Promise<any>
   get?: (pk: string, query: ApiNextQuery) => Promise<any>