create-fullstack-scaffold 0.1.1 → 0.2.0

package/template/src/server/module-plugin/routes/plugin-admin-routes.ts

@@ -0,0 +1,261 @@
+import { createRoute, z } from '@hono/zod-openapi'
+import { OpenAPIHono } from '@hono/zod-openapi'
+import type { AuthUser } from '@server/middleware/auth'
+import * as adminPluginService from '../services/admin-plugin-service'
+import * as adminCategoryService from '../services/admin-category-service'
+import * as adminStatsService from '../services/admin-stats-service'
+import {
+  PluginSchema,
+  CategorySchema,
+  AdminDashboardStatsSchema,
+  PluginListAdminSchema,
+  AdminListQuerySchema,
+  AdminListAllQuerySchema,
+  PluginSlugSchema,
+  RejectPluginBodySchema,
+  PluginDeleteResponseSchema,
+  BulkApproveBodySchema,
+  BulkRejectBodySchema,
+  BulkResponseSchema,
+  CreateCategoryBodySchema,
+  UpdateCategoryBodySchema,
+  CategoryIdParamsSchema,
+  CategoryIdResponseSchema,
+} from '@shared/schemas'
+import { successResponse, errorResponse, success, created } from '@server/utils/route-helpers'
+
+const getDashboardStatsRoute = createRoute({
+  method: 'get',
+  path: '/stats/dashboard',
+  tags: ['admin-plugins'],
+  responses: {
+    200: successResponse(AdminDashboardStatsSchema, 'Dashboard stats'),
+  },
+})
+
+const listPendingRoute = createRoute({
+  method: 'get',
+  path: '/plugins/pending',
+  tags: ['admin-plugins'],
+  request: {
+    query: AdminListQuerySchema,
+  },
+  responses: {
+    200: successResponse(PluginListAdminSchema, 'Pending plugins'),
+  },
+})
+
+const listAllPluginsRoute = createRoute({
+  method: 'get',
+  path: '/plugins',
+  tags: ['admin-plugins'],
+  request: {
+    query: AdminListAllQuerySchema,
+  },
+  responses: {
+    200: successResponse(PluginListAdminSchema, 'All plugins'),
+  },
+})
+
+const approvePluginRoute = createRoute({
+  method: 'put',
+  path: '/plugins/{slug}/approve',
+  tags: ['admin-plugins'],
+  request: { params: PluginSlugSchema },
+  responses: {
+    200: successResponse(PluginSchema, 'Plugin approved'),
+    404: errorResponse('Plugin not found'),
+  },
+})
+
+const rejectPluginRoute = createRoute({
+  method: 'put',
+  path: '/plugins/{slug}/reject',
+  tags: ['admin-plugins'],
+  request: {
+    params: PluginSlugSchema,
+    body: { content: { 'application/json': { schema: RejectPluginBodySchema } } },
+  },
+  responses: {
+    200: successResponse(PluginSchema, 'Plugin rejected'),
+    404: errorResponse('Plugin not found'),
+  },
+})
+
+const toggleFeaturedRoute = createRoute({
+  method: 'put',
+  path: '/plugins/{slug}/feature',
+  tags: ['admin-plugins'],
+  request: { params: PluginSlugSchema },
+  responses: {
+    200: successResponse(PluginSchema, 'Featured toggled'),
+    404: errorResponse('Plugin not found'),
+  },
+})
+
+const removePluginRoute = createRoute({
+  method: 'delete',
+  path: '/plugins/{slug}',
+  tags: ['admin-plugins'],
+  request: { params: PluginSlugSchema },
+  responses: {
+    200: successResponse(PluginDeleteResponseSchema, 'Plugin removed'),
+    404: errorResponse('Plugin not found'),
+  },
+})
+
+const bulkApproveRoute = createRoute({
+  method: 'post',
+  path: '/plugins/bulk-approve',
+  tags: ['admin-plugins'],
+  request: {
+    body: { content: { 'application/json': { schema: BulkApproveBodySchema } } },
+  },
+  responses: {
+    200: successResponse(BulkResponseSchema, 'Bulk approved'),
+  },
+})
+
+const bulkRejectRoute = createRoute({
+  method: 'post',
+  path: '/plugins/bulk-reject',
+  tags: ['admin-plugins'],
+  request: {
+    body: {
+      content: {
+        'application/json': {
+          schema: BulkRejectBodySchema,
+        },
+      },
+    },
+  },
+  responses: {
+    200: successResponse(BulkResponseSchema, 'Bulk rejected'),
+  },
+})
+
+const listCategoriesRoute = createRoute({
+  method: 'get',
+  path: '/categories',
+  tags: ['admin-plugins'],
+  responses: {
+    200: successResponse(z.array(CategorySchema), 'List categories'),
+  },
+})
+
+const createCategoryRoute = createRoute({
+  method: 'post',
+  path: '/categories',
+  tags: ['admin-plugins'],
+  request: {
+    body: {
+      content: {
+        'application/json': {
+          schema: CreateCategoryBodySchema,
+        },
+      },
+    },
+  },
+  responses: {
+    201: successResponse(CategorySchema, 'Category created'),
+    409: errorResponse('Category slug already exists'),
+  },
+})
+
+const updateCategoryRoute = createRoute({
+  method: 'put',
+  path: '/categories/{id}',
+  tags: ['admin-plugins'],
+  request: {
+    params: CategoryIdParamsSchema,
+    body: {
+      content: {
+        'application/json': {
+          schema: UpdateCategoryBodySchema,
+        },
+      },
+    },
+  },
+  responses: {
+    200: successResponse(CategorySchema, 'Category updated'),
+    404: errorResponse('Category not found'),
+  },
+})
+
+const deleteCategoryRoute = createRoute({
+  method: 'delete',
+  path: '/categories/{id}',
+  tags: ['admin-plugins'],
+  request: { params: CategoryIdParamsSchema },
+  responses: {
+    200: successResponse(CategoryIdResponseSchema, 'Category deleted'),
+    404: errorResponse('Category not found'),
+  },
+})
+
+export const pluginAdminRoutes = new OpenAPIHono<{ Variables: { authUser: AuthUser } }>()
+  .openapi(getDashboardStatsRoute, async c => {
+    const stats = await adminStatsService.getDashboardStats()
+    return c.json(success(stats), 200)
+  })
+  .openapi(listPendingRoute, async c => {
+    const { page, limit } = c.req.valid('query')
+    const result = await adminPluginService.listPending({ page, limit })
+    return c.json(success(result), 200)
+  })
+  .openapi(listAllPluginsRoute, async c => {
+    const { page, limit, status } = c.req.valid('query')
+    const result = await adminPluginService.listAllPlugins({ page, limit, status })
+    return c.json(success(result), 200)
+  })
+  .openapi(approvePluginRoute, async c => {
+    const { slug } = c.req.valid('param')
+    const plugin = await adminPluginService.approvePlugin(slug)
+    return c.json(success(plugin), 200)
+  })
+  .openapi(rejectPluginRoute, async c => {
+    const { slug } = c.req.valid('param')
+    const { reason } = c.req.valid('json')
+    const plugin = await adminPluginService.rejectPlugin(slug, reason)
+    return c.json(success(plugin), 200)
+  })
+  .openapi(toggleFeaturedRoute, async c => {
+    const { slug } = c.req.valid('param')
+    const plugin = await adminPluginService.toggleFeatured(slug)
+    return c.json(success(plugin), 200)
+  })
+  .openapi(removePluginRoute, async c => {
+    const { slug } = c.req.valid('param')
+    await adminPluginService.adminRemovePlugin(slug)
+    return c.json(success({ slug }), 200)
+  })
+  .openapi(bulkApproveRoute, async c => {
+    const { slugs } = c.req.valid('json')
+    const count = await adminPluginService.bulkApprove(slugs)
+    return c.json(success({ count }), 200)
+  })
+  .openapi(bulkRejectRoute, async c => {
+    const { slugs, reason } = c.req.valid('json')
+    const count = await adminPluginService.bulkReject(slugs, reason)
+    return c.json(success({ count }), 200)
+  })
+  .openapi(listCategoriesRoute, async c => {
+    const categories = await adminCategoryService.listAllCategories()
+    return c.json(success(categories), 200)
+  })
+  .openapi(createCategoryRoute, async c => {
+    const data = c.req.valid('json')
+    const category = await adminCategoryService.createCategory(data)
+    return c.json(created(category), 201)
+  })
+  .openapi(updateCategoryRoute, async c => {
+    const { id } = c.req.valid('param')
+    const data = c.req.valid('json')
+    const category = await adminCategoryService.updateCategory(id, data)
+    return c.json(success(category), 200)
+  })
+  .openapi(deleteCategoryRoute, async c => {
+    const { id } = c.req.valid('param')
+    await adminCategoryService.deleteCategory(id)
+    return c.json(success({ id }), 200)
+  })

package/template/src/server/module-plugin/routes/plugin-routes.ts

@@ -0,0 +1,354 @@
+import { createRoute, z } from '@hono/zod-openapi'
+import { OpenAPIHono } from '@hono/zod-openapi'
+import * as pluginService from '../services/plugin-service'
+import * as queryService from '../services/plugin-query-service'
+import * as reviewService from '../services/plugin-review-service'
+import {
+  PluginSchema,
+  CreatePluginSchema,
+  UpdatePluginSchema,
+  PluginSlugSchema,
+  ReviewSchema,
+  CreateReviewSchema,
+  MarketplaceStatsSchema,
+  CategorySchema,
+  VersionSchema,
+  PluginListResponseSchema,
+  PluginListQuerySchema,
+  PluginSearchQuerySchema,
+  PluginDeleteResponseSchema,
+  ReviewIdParamsSchema,
+  ReviewDeleteResponseSchema,
+  CategorySlugParamsSchema,
+  CategoryPluginsQuerySchema,
+} from '@shared/schemas'
+import { successResponse, errorResponse, success, created } from '@server/utils/route-helpers'
+import { getAuthUser } from '@server/utils/auth'
+
+const listRoute = createRoute({
+  method: 'get',
+  path: '/plugins',
+  tags: ['plugins'],
+  request: { query: PluginListQuerySchema },
+  responses: {
+    200: successResponse(PluginListResponseSchema, 'List plugins'),
+  },
+})
+
+const searchRoute = createRoute({
+  method: 'get',
+  path: '/plugins/search',
+  tags: ['plugins'],
+  request: {
+    query: PluginSearchQuerySchema,
+  },
+  responses: {
+    200: successResponse(PluginListResponseSchema, 'Search plugins'),
+  },
+})
+
+const getBySlugRoute = createRoute({
+  method: 'get',
+  path: '/plugins/{slug}',
+  tags: ['plugins'],
+  request: { params: PluginSlugSchema },
+  responses: {
+    200: successResponse(PluginSchema, 'Get plugin by slug'),
+    404: errorResponse('Plugin not found'),
+  },
+})
+
+const getVersionsRoute = createRoute({
+  method: 'get',
+  path: '/plugins/{slug}/versions',
+  tags: ['plugins'],
+  request: { params: PluginSlugSchema },
+  responses: {
+    200: successResponse(z.array(VersionSchema), 'List plugin versions'),
+    404: errorResponse('Plugin not found'),
+  },
+})
+
+const createRouteDef = createRoute({
+  method: 'post',
+  path: '/plugins',
+  tags: ['plugins'],
+  security: [{ Bearer: [] }],
+  request: {
+    body: { content: { 'application/json': { schema: CreatePluginSchema } } },
+  },
+  responses: {
+    201: successResponse(PluginSchema, 'Create plugin'),
+    400: errorResponse('Invalid input'),
+    409: errorResponse('Plugin slug already exists'),
+  },
+})
+
+const updateRoute = createRoute({
+  method: 'put',
+  path: '/plugins/{slug}',
+  tags: ['plugins'],
+  security: [{ Bearer: [] }],
+  request: {
+    params: PluginSlugSchema,
+    body: { content: { 'application/json': { schema: UpdatePluginSchema } } },
+  },
+  responses: {
+    200: successResponse(PluginSchema, 'Update plugin'),
+    404: errorResponse('Plugin not found'),
+    403: errorResponse('Forbidden'),
+  },
+})
+
+const deleteRoute = createRoute({
+  method: 'delete',
+  path: '/plugins/{slug}',
+  tags: ['plugins'],
+  security: [{ Bearer: [] }],
+  request: { params: PluginSlugSchema },
+  responses: {
+    200: successResponse(PluginDeleteResponseSchema, 'Delete plugin'),
+    404: errorResponse('Plugin not found'),
+    403: errorResponse('Forbidden'),
+  },
+})
+
+const submitReviewRoute = createRoute({
+  method: 'post',
+  path: '/plugins/{slug}/reviews',
+  tags: ['plugins'],
+  security: [{ Bearer: [] }],
+  request: {
+    params: PluginSlugSchema,
+    body: { content: { 'application/json': { schema: CreateReviewSchema } } },
+  },
+  responses: {
+    201: successResponse(ReviewSchema, 'Submit review'),
+    404: errorResponse('Plugin not found'),
+    409: errorResponse('Already reviewed'),
+  },
+})
+
+const getReviewsRoute = createRoute({
+  method: 'get',
+  path: '/plugins/{slug}/reviews',
+  tags: ['plugins'],
+  request: { params: PluginSlugSchema },
+  responses: {
+    200: successResponse(z.array(ReviewSchema), 'List reviews'),
+  },
+})
+
+const deleteReviewRoute = createRoute({
+  method: 'delete',
+  path: '/plugins/{slug}/reviews/{reviewId}',
+  tags: ['plugins'],
+  security: [{ Bearer: [] }],
+  request: {
+    params: ReviewIdParamsSchema,
+  },
+  responses: {
+    200: successResponse(ReviewDeleteResponseSchema, 'Review deleted'),
+    404: errorResponse('Review not found'),
+    403: errorResponse('Forbidden'),
+  },
+})
+
+const trackInstallRoute = createRoute({
+  method: 'post',
+  path: '/plugins/{slug}/install',
+  tags: ['plugins'],
+  request: { params: PluginSlugSchema },
+  responses: {
+    200: successResponse(PluginDeleteResponseSchema, 'Install tracked'),
+    404: errorResponse('Plugin not found'),
+  },
+})
+
+const listCategoriesRoute = createRoute({
+  method: 'get',
+  path: '/categories',
+  tags: ['plugins'],
+  responses: {
+    200: successResponse(z.array(CategorySchema), 'List categories'),
+  },
+})
+
+const getPluginsByCategoryRoute = createRoute({
+  method: 'get',
+  path: '/categories/{slug}/plugins',
+  tags: ['plugins'],
+  request: {
+    params: CategorySlugParamsSchema,
+    query: CategoryPluginsQuerySchema,
+  },
+  responses: {
+    200: successResponse(PluginListResponseSchema, 'Plugins by category'),
+    404: errorResponse('Category not found'),
+  },
+})
+
+const getStatsRoute = createRoute({
+  method: 'get',
+  path: '/stats',
+  tags: ['plugins'],
+  responses: {
+    200: successResponse(MarketplaceStatsSchema, 'Marketplace stats'),
+  },
+})
+
+const listMyPluginsRoute = createRoute({
+  method: 'get',
+  path: '/plugins/mine',
+  tags: ['plugins'],
+  security: [{ Bearer: [] }],
+  responses: {
+    200: successResponse(z.array(PluginSchema), 'My plugins'),
+  },
+})
+
+export const pluginRoutes = new OpenAPIHono()
+  .openapi(listMyPluginsRoute, async c => {
+    const user = getAuthUser(c)
+    if (!user) {
+      return c.json({ success: false as const, error: 'Unauthorized' }, 401)
+    }
+    try {
+      const plugins = await queryService.listMyPlugins(user.id)
+      return c.json(success(plugins), 200)
+    } catch {
+      return c.json(success([]), 200)
+    }
+  })
+  .openapi(listRoute, async c => {
+    const query = c.req.valid('query')
+    try {
+      const result = await queryService.listPlugins({
+        page: query.page,
+        limit: query.limit,
+        status: query.status,
+        sort: query.sort,
+        featured: query.featured,
+      })
+      return c.json(success(result), 200)
+    } catch {
+      return c.json(success({ plugins: [], total: 0, page: 1, limit: 20 }), 200)
+    }
+  })
+  .openapi(searchRoute, async c => {
+    const { q, page, limit, category } = c.req.valid('query')
+    try {
+      const result = await queryService.searchPlugins(q, { page, limit, category })
+      return c.json(success(result), 200)
+    } catch {
+      return c.json(success({ plugins: [], total: 0, page: 1, limit: 20 }), 200)
+    }
+  })
+  .openapi(getBySlugRoute, async c => {
+    const { slug } = c.req.valid('param')
+    try {
+      const plugin = await queryService.getPluginBySlug(slug)
+      return c.json(success(plugin), 200)
+    } catch {
+      return c.json({ success: false as const, error: 'Plugin not found' }, 404)
+    }
+  })
+  .openapi(getVersionsRoute, async c => {
+    const { slug } = c.req.valid('param')
+    try {
+      const plugin = await queryService.getPluginBySlug(slug)
+      const versions = await queryService.getVersions(plugin.id)
+      return c.json(success(versions), 200)
+    } catch {
+      return c.json(success([]), 200)
+    }
+  })
+  .openapi(createRouteDef, async c => {
+    const data = c.req.valid('json')
+    const user = getAuthUser(c)
+    const plugin = await pluginService.createPlugin({
+      ...data,
+      authorId: user.id,
+      authorName: user.username,
+    })
+    return c.json(created(plugin), 201)
+  })
+  .openapi(updateRoute, async c => {
+    const { slug } = c.req.valid('param')
+    const data = c.req.valid('json')
+    const user = getAuthUser(c)
+    const plugin = await pluginService.updatePlugin(slug, data, user.id)
+    return c.json(success(plugin), 200)
+  })
+  .openapi(deleteRoute, async c => {
+    const { slug } = c.req.valid('param')
+    const user = getAuthUser(c)
+    await pluginService.deletePlugin(slug, user.id)
+    return c.json(success({ slug }), 200)
+  })
+  .openapi(submitReviewRoute, async c => {
+    const { slug } = c.req.valid('param')
+    const data = c.req.valid('json')
+    const user = getAuthUser(c)
+    try {
+      const plugin = await queryService.getPluginBySlug(slug)
+      const review = await reviewService.submitReview({
+        pluginId: plugin.id,
+        userId: user.id,
+        userName: user.username,
+        rating: data.rating,
+        title: data.title,
+        content: data.content,
+      })
+      return c.json(created(review), 201)
+    } catch {
+      return c.json({ success: false as const, error: 'Plugin not found' }, 404)
+    }
+  })
+  .openapi(getReviewsRoute, async c => {
+    const { slug } = c.req.valid('param')
+    try {
+      const plugin = await queryService.getPluginBySlug(slug)
+      const reviews = await reviewService.getReviews(plugin.id)
+      return c.json(success(reviews), 200)
+    } catch {
+      return c.json(success([]), 200)
+    }
+  })
+  .openapi(deleteReviewRoute, async c => {
+    const { reviewId } = c.req.valid('param')
+    const user = getAuthUser(c)
+    await reviewService.deleteReview(reviewId, user.id)
+    return c.json(success({ id: reviewId }), 200)
+  })
+  .openapi(trackInstallRoute, async c => {
+    const { slug } = c.req.valid('param')
+    try {
+      await pluginService.trackInstall(slug)
+      return c.json(success({ slug }), 200)
+    } catch {
+      return c.json(success({ slug }), 200)
+    }
+  })
+  .openapi(listCategoriesRoute, async c => {
+    try {
+      const categories = await queryService.listCategories()
+      return c.json(success(categories), 200)
+    } catch {
+      return c.json(success([]), 200)
+    }
+  })
+  .openapi(getPluginsByCategoryRoute, async c => {
+    const { slug } = c.req.valid('param')
+    const { page, limit } = c.req.valid('query')
+    try {
+      const result = await queryService.getPluginsByCategory(slug, { page, limit })
+      return c.json(success(result), 200)
+    } catch {
+      return c.json(success({ plugins: [], total: 0, page: 1, limit: 20 }), 200)
+    }
+  })
+  .openapi(getStatsRoute, async c => {
+    const stats = await queryService.getStats()
+    return c.json(success(stats), 200)
+  })

package/template/src/server/module-plugin/services/admin-category-service.ts

@@ -0,0 +1,99 @@
+import { eq, asc } from 'drizzle-orm'
+import type { Category } from '@shared/schemas'
+import { getDb } from '@server/db'
+import { pluginCategories } from '@server/db/schema'
+import { generateUUID } from '@server/utils/uuid'
+import { NotFoundError, ConflictError } from '@server/utils/app-error'
+
+export interface CreateCategoryData {
+  name: string
+  slug: string
+  description?: string | null
+  icon?: string | null
+}
+
+export interface UpdateCategoryData {
+  name?: string | null
+  slug?: string | null
+  description?: string | null
+  icon?: string | null
+  sortOrder?: number | null
+}
+
+function mapCategoryRow(row: typeof pluginCategories.$inferSelect): Category {
+  return {
+    id: row.id,
+    name: row.name,
+    slug: row.slug,
+    description: row.description ?? undefined,
+    icon: row.icon ?? undefined,
+    sortOrder: row.sortOrder,
+  }
+}
+
+export async function createCategory(data: CreateCategoryData): Promise<Category> {
+  const db = await getDb()
+
+  const existing = await db
+    .select()
+    .from(pluginCategories)
+    .where(eq(pluginCategories.slug, data.slug))
+  if (existing.length > 0) {
+    throw new ConflictError(`Category with slug '${data.slug}' already exists`)
+  }
+
+  const id = generateUUID()
+  const result = await db
+    .insert(pluginCategories)
+    .values({
+      id,
+      name: data.name,
+      slug: data.slug,
+      description: data.description ?? null,
+      icon: data.icon ?? null,
+      sortOrder: 0,
+    })
+    .returning()
+
+  return mapCategoryRow(result[0])
+}
+
+export async function updateCategory(id: string, data: UpdateCategoryData): Promise<Category> {
+  const db = await getDb()
+
+  const rows = await db.select().from(pluginCategories).where(eq(pluginCategories.id, id))
+  if (rows.length === 0) {
+    throw new NotFoundError('Category', id)
+  }
+
+  const updateData: Partial<typeof pluginCategories.$inferInsert> = {}
+  if (data.name !== undefined && data.name !== null) updateData.name = data.name
+  if (data.slug !== undefined && data.slug !== null) updateData.slug = data.slug
+  if (data.description !== undefined) updateData.description = data.description
+  if (data.icon !== undefined) updateData.icon = data.icon
+  if (data.sortOrder !== undefined && data.sortOrder !== null) updateData.sortOrder = data.sortOrder
+
+  const result = await db
+    .update(pluginCategories)
+    .set(updateData)
+    .where(eq(pluginCategories.id, id))
+    .returning()
+  return mapCategoryRow(result[0])
+}
+
+export async function deleteCategory(id: string): Promise<void> {
+  const db = await getDb()
+
+  const rows = await db.select().from(pluginCategories).where(eq(pluginCategories.id, id))
+  if (rows.length === 0) {
+    throw new NotFoundError('Category', id)
+  }
+
+  await db.delete(pluginCategories).where(eq(pluginCategories.id, id))
+}
+
+export async function listAllCategories(): Promise<Category[]> {
+  const db = await getDb()
+  const rows = await db.select().from(pluginCategories).orderBy(asc(pluginCategories.sortOrder))
+  return rows.map(mapCategoryRow)
+}