feat(api): complete refactor of openapi routes

apps/api/src/changelog/byId.ts

@@ -4,6 +4,10 @@ import { createRoute } from '@hono/zod-openapi'
 import { and, eq } from 'drizzle-orm'
 import { HTTPException } from 'hono/http-exception'
 
+import type { changelogApi } from '.'
+import { verifyAuthentication } from '../utils/authentication'
+import { openApiErrorResponses, openApiSecurity } from '../utils/openapi'
+
 export const route = createRoute({
   method: 'get',
   path: '/:id',
@@ -20,39 +24,35 @@ export const route = createRoute({
       },
       description: 'Return changelog by id',
     },
-    400: {
+    ...openApiErrorResponses,
-      description: 'Bad Request',
-    },
-    500: {
-      description: 'Internal Server Error',
-    },
   },
+  ...openApiSecurity,
 })
 
-export const func = async ({ userId, id }: { userId: string; id: string }) => {
+export const registerChangelogById = (api: typeof changelogApi) => {
-  const result = await db.query.changelog.findFirst({
+  return api.openapi(route, async (c) => {
-    where: and(eq(changelog.userId, userId), eq(changelog.id, id)),
+    const userId = await verifyAuthentication(c)
-    with: {
+    const { id } = c.req.valid('param')
-      pages: {
+
-        with: {
+    const result = await db.query.changelog.findFirst({
-          page: true,
+      where: and(eq(changelog.userId, userId), eq(changelog.id, id)),
+      with: {
+        pages: {
+          with: {
+            page: true,
+          },
+        },
+        versions: {
+          orderBy: (changelog_version, { desc }) => [
+            desc(changelog_version.createdAt),
+          ],
         },
       },
-      versions: {
+    })
-        orderBy: (changelog_version, { desc }) => [
+
-          desc(changelog_version.createdAt),
+    if (!result) {
-        ],
+      throw new HTTPException(404, { message: 'Not found' })
-      },
+    }
-    },
+    return c.json(ChangelogOutput.parse(result), 200)
   })
-
-  if (!result) {
-    throw new HTTPException(404, { message: 'Not found' })
-  }
-  return result
-}
-
-export default {
-  route,
-  func,
 }

apps/api/src/changelog/create.ts

@@ -5,6 +5,10 @@ import {
 } from '@boring.tools/schema'
 import { createRoute, type z } from '@hono/zod-openapi'
 
+import type { changelogApi } from '.'
+import { verifyAuthentication } from '../utils/authentication'
+import { openApiErrorResponses, openApiSecurity } from '../utils/openapi'
+
 export const route = createRoute({
   method: 'post',
   path: '/',
@@ -23,32 +27,24 @@ export const route = createRoute({
       },
       description: 'Return created changelog',
     },
-    400: {
+    ...openApiErrorResponses,
-      description: 'Bad Request',
-    },
-    500: {
-      description: 'Internal Server Error',
-    },
   },
+  ...openApiSecurity,
 })
 
-export const func = async ({
+export const registerChangelogCreate = (api: typeof changelogApi) => {
-  userId,
+  return api.openapi(route, async (c) => {
-  payload,
+    const userId = await verifyAuthentication(c)
-}: {
+    const payload: z.infer<typeof ChangelogCreateInput> = await c.req.json()
-  userId: string
-  payload: z.infer<typeof ChangelogCreateInput>
-}) => {
-  return await db
-    .insert(changelog)
-    .values({
-      ...payload,
-      userId: userId,
-    })
-    .returning()
-}
 
-export default {
+    const [result] = await db
-  route,
+      .insert(changelog)
-  func,
+      .values({
+        ...payload,
+        userId: userId,
+      })
+      .returning()
+
+    return c.json(ChangelogCreateOutput.parse(result), 201)
+  })
 }

apps/api/src/changelog/delete.ts

@@ -4,6 +4,10 @@ import { createRoute } from '@hono/zod-openapi'
 import { and, eq } from 'drizzle-orm'
 import { HTTPException } from 'hono/http-exception'
 
+import type { changelogApi } from '.'
+import { verifyAuthentication } from '../utils/authentication'
+import { openApiErrorResponses, openApiSecurity } from '../utils/openapi'
+
 export const route = createRoute({
   method: 'delete',
   path: '/:id',
@@ -17,29 +21,25 @@ export const route = createRoute({
       },
       description: 'Removes a changelog by id',
     },
-    400: {
+    ...openApiErrorResponses,
-      description: 'Bad Request',
-    },
-    500: {
-      description: 'Internal Server Error',
-    },
   },
+  ...openApiSecurity,
 })
 
-export const func = async ({ userId, id }: { userId: string; id: string }) => {
+export const registerChangelogDelete = async (api: typeof changelogApi) => {
-  const result = await db
+  return api.openapi(route, async (c) => {
-    .delete(changelog)
+    const userId = await verifyAuthentication(c)
-    .where(and(eq(changelog.userId, userId), eq(changelog.id, id)))
+    const id = c.req.param('id')
-    .returning()
 
-  if (!result) {
+    const [result] = await db
-    throw new HTTPException(404, { message: 'Not found' })
+      .delete(changelog)
-  }
+      .where(and(eq(changelog.userId, userId), eq(changelog.id, id)))
+      .returning()
 
-  return result
+    if (!result) {
-}
+      throw new HTTPException(404, { message: 'Not found' })
-
+    }
-export default {
+
-  route,
+    return c.json(GeneralOutput.parse(result), 200)
-  func,
+  })
 }

apps/api/src/changelog/index.ts

@@ -1,135 +1,28 @@
 import { OpenAPIHono } from '@hono/zod-openapi'
 import { cors } from 'hono/cors'
 import type { Variables } from '..'
-import { verifyAuthentication } from '../utils/authentication'
+import type { ContextModule } from '../utils/sentry'
-import { type ContextModule, captureSentry } from '../utils/sentry'
+import { registerChangelogById } from './byId'
-import ById from './byId'
 import { changelogCommitApi } from './commit'
-import Create from './create'
+import { registerChangelogCreate } from './create'
-import Delete from './delete'
+import { registerChangelogDelete } from './delete'
-import List from './list'
+import { registerChangelogList } from './list'
-import Update from './update'
+import { registerChangelogUpdate } from './update'
 import version from './version'
 
-const app = new OpenAPIHono<{ Variables: Variables }>()
+export const changelogApi = new OpenAPIHono<{ Variables: Variables }>()
 
 const module: ContextModule = {
   name: 'changelog',
 }
-app.use('*', cors())
+changelogApi.use('*', cors())
-app.route('/commit', changelogCommitApi)
+changelogApi.route('/commit', changelogCommitApi)
-app.route('/version', version)
+changelogApi.route('/version', version)
-app.openapi(ById.route, async (c) => {
-  const userId = await verifyAuthentication(c)
-  try {
-    const id = c.req.param('id')
-    const result = await ById.func({ userId, id })
-    return c.json(result, 200)
-  } catch (error) {
-    return captureSentry({
-      c,
-      error,
-      module,
-      user: {
-        id: userId,
-      },
-    })
-  }
-})
 
-app.openapi(List.route, async (c) => {
+registerChangelogById(changelogApi)
-  const userId = await verifyAuthentication(c)
+registerChangelogCreate(changelogApi)
-  try {
+registerChangelogDelete(changelogApi)
-    const result = await List.func({ userId })
+registerChangelogUpdate(changelogApi)
-    return c.json(result, 200)
+registerChangelogList(changelogApi)
-  } catch (error) {
-    return captureSentry({
-      c,
-      error,
-      module,
-      user: {
-        id: userId,
-      },
-    })
-  }
-})
 
-app.openapi(Create.route, async (c) => {
+export default changelogApi
-  const userId = await verifyAuthentication(c)
-
-  try {
-    const [result] = await Create.func({
-      userId,
-      payload: await c.req.json(),
-    })
-    return c.json(result, 201)
-  } catch (error) {
-    return captureSentry({
-      c,
-      error,
-      module,
-      user: {
-        id: userId,
-      },
-    })
-  }
-})
-
-app.openapi(Delete.route, async (c) => {
-  const userId = await verifyAuthentication(c)
-
-  try {
-    const id = c.req.param('id')
-    const result = await Delete.func({ userId, id })
-
-    if (result.length === 0) {
-      return c.json({ message: 'Changelog not found' }, 404)
-    }
-
-    return c.json({ message: 'Changelog removed' })
-  } catch (error) {
-    return captureSentry({
-      c,
-      error,
-      module,
-      user: {
-        id: userId,
-      },
-    })
-  }
-})
-
-app.openapi(Update.route, async (c) => {
-  const userId = await verifyAuthentication(c)
-
-  try {
-    const id = c.req.param('id')
-
-    if (!id) {
-      return c.json({ message: 'Changelog not found' }, 404)
-    }
-
-    const result = await Update.func({
-      userId,
-      payload: await c.req.json(),
-      id,
-    })
-
-    if (result.length === 0) {
-      return c.json({ message: 'Changelog not found' }, 404)
-    }
-
-    return c.json(result)
-  } catch (error) {
-    return captureSentry({
-      c,
-      error,
-      module,
-      user: {
-        id: userId,
-      },
-    })
-  }
-})
-
-export default app

apps/api/src/changelog/list.ts

@@ -3,6 +3,10 @@ import { ChangelogListOutput } from '@boring.tools/schema'
 import { createRoute } from '@hono/zod-openapi'
 import { eq } from 'drizzle-orm'
 
+import type { changelogApi } from '.'
+import { verifyAuthentication } from '../utils/authentication'
+import { openApiErrorResponses, openApiSecurity } from '../utils/openapi'
+
 export const route = createRoute({
   method: 'get',
   path: '/',
@@ -16,40 +20,37 @@ export const route = createRoute({
       },
       description: 'Return changelogs for current user',
     },
-    400: {
+    ...openApiErrorResponses,
-      description: 'Bad Request',
-    },
-    500: {
-      description: 'Internal Server Error',
-    },
   },
+  ...openApiSecurity,
 })
 
-export const func = async ({ userId }: { userId: string }) => {
+export const registerChangelogList = (api: typeof changelogApi) => {
-  const result = await db.query.changelog.findMany({
+  return api.openapi(route, async (c) => {
-    where: eq(changelog.userId, userId),
+    const userId = await verifyAuthentication(c)
-    with: {
-      versions: true,
-      commits: {
-        columns: { id: true },
-      },
-    },
-    orderBy: (changelog, { asc }) => [asc(changelog.createdAt)],
-  })
 
-  return result.map((changelog) => {
+    const result = await db.query.changelog.findMany({
-    const { versions, commits, ...rest } = changelog
+      where: eq(changelog.userId, userId),
-    return {
+      with: {
-      ...rest,
+        versions: true,
-      computed: {
+        commits: {
-        versionCount: versions.length,
+          columns: { id: true },
-        commitCount: commits.length,
+        },
       },
-    }
+      orderBy: (changelog, { asc }) => [asc(changelog.createdAt)],
+    })
+
+    const mappedData = result.map((changelog) => {
+      const { versions, commits, ...rest } = changelog
+      return {
+        ...rest,
+        computed: {
+          versionCount: versions.length,
+          commitCount: commits.length,
+        },
+      }
+    })
+
+    return c.json(ChangelogListOutput.parse(mappedData), 200)
   })
 }
-
-export default {
-  route,
-  func,
-}

apps/api/src/changelog/update.ts

@@ -6,6 +6,10 @@ import {
 import { createRoute, type z } from '@hono/zod-openapi'
 import { and, eq } from 'drizzle-orm'
 import { HTTPException } from 'hono/http-exception'
+
+import type { changelogApi } from '.'
+import { verifyAuthentication } from '../utils/authentication'
+import { openApiErrorResponses, openApiSecurity } from '../utils/openapi'
 import { redis } from '../utils/redis'
 
 export const route = createRoute({
@@ -26,43 +30,32 @@ export const route = createRoute({
       },
       description: 'Return updated changelog',
     },
-    400: {
+    ...openApiErrorResponses,
-      description: 'Bad Request',
-    },
-    500: {
-      description: 'Internal Server Error',
-    },
   },
+  ...openApiSecurity,
 })
 
-export const func = async ({
+export const registerChangelogUpdate = (api: typeof changelogApi) => {
-  userId,
+  return api.openapi(route, async (c) => {
-  payload,
+    const userId = await verifyAuthentication(c)
-  id,
+    const id = c.req.param('id')
-}: {
+    const payload: z.infer<typeof ChangelogUpdateInput> = await c.req.json()
-  userId: string
-  payload: z.infer<typeof ChangelogUpdateInput>
-  id: string
-}) => {
-  const [result] = await db
-    .update(changelog)
-    .set({
-      ...payload,
-    })
-    .where(and(eq(changelog.id, id), eq(changelog.userId, userId)))
-    .returning()
 
-  if (!result) {
+    const [result] = await db
-    throw new HTTPException(404, { message: 'Not found' })
+      .update(changelog)
-  }
+      .set({
+        ...payload,
+      })
+      .where(and(eq(changelog.id, id), eq(changelog.userId, userId)))
+      .returning()
 
-  if (result.pageId) {
+    if (!result) {
-    redis.del(result.pageId)
+      throw new HTTPException(404, { message: 'Not found' })
-  }
+    }
-  return result
+
-}
+    if (result.pageId) {
-
+      redis.del(result.pageId)
-export default {
+    }
-  route,
+    return c.json(ChangelogUpdateOutput.parse(result), 200)
-  func,
+  })
 }

packages/schema/src/changelog/base.ts

@@ -13,6 +13,12 @@ export const ChangelogOutput = z
       example: 'This is a changelog',
     }),
     versions: z.array(VersionOutput).optional(),
+    isSemver: z.boolean().openapi({
+      example: true,
+    }),
+    isConventional: z.boolean().openapi({
+      example: true,
+    }),
     computed: z
       .object({
         versionCount: z.number().openapi({