create-fullstack-scaffold 0.1.1 → 0.2.0

package/template/src/shared/modules/plugins/schemas.ts

@@ -0,0 +1,227 @@
+import { z } from '@hono/zod-openapi'
+
+export const PluginStatusSchema = z.enum(['pending', 'approved', 'rejected'])
+
+export const PluginSchema = z.object({
+  id: z.string(),
+  name: z.string().min(1).max(200),
+  slug: z.string().min(1).max(200),
+  description: z.string().max(2000),
+  readme: z.string().nullish(),
+  authorId: z.string(),
+  authorName: z.string(),
+  repositoryUrl: z.string().url().nullish(),
+  homepageUrl: z.string().url().nullish(),
+  npmPackage: z.string().nullish(),
+  license: z.string().nullish(),
+  version: z.string(),
+  status: PluginStatusSchema,
+  downloadCount: z.number().int().nonnegative().default(0),
+  viewCount: z.number().int().nonnegative().default(0),
+  featured: z.boolean().default(false),
+  screenshotUrl: z.string().nullish(),
+  siteUrls: z.array(z.string().url()).nullish(),
+  tags: z.array(z.string()).nullish(),
+  commands: z
+    .array(
+      z.object({
+        name: z.string(),
+        description: z.string().nullish(),
+      })
+    )
+    .nullish(),
+  rejectReason: z.string().nullish(),
+  createdAt: z.number(),
+  updatedAt: z.number(),
+})
+
+export const CreatePluginSchema = z.object({
+  name: z.string().min(1).max(200),
+  slug: z
+    .string()
+    .min(1)
+    .max(200)
+    .regex(/^[a-z0-9-]+$/),
+  description: z.string().min(1).max(2000),
+  repositoryUrl: z.string().url().nullish(),
+  homepageUrl: z.string().url().nullish(),
+  npmPackage: z.string().nullish(),
+  license: z.string().nullish(),
+  tags: z.array(z.string()).nullish(),
+  siteUrls: z.array(z.string().url()).nullish(),
+  commands: z
+    .array(
+      z.object({
+        name: z.string(),
+        description: z.string().nullish(),
+      })
+    )
+    .nullish(),
+})
+
+export const UpdatePluginSchema = CreatePluginSchema.partial()
+
+export const PluginVersionStatusSchema = z.enum(['pending', 'approved', 'rejected'])
+
+export const VersionSchema = z.object({
+  id: z.string(),
+  pluginId: z.string(),
+  version: z.string(),
+  changelog: z.string().nullish(),
+  packageUrl: z.string().nullish(),
+  fileSize: z.number().nullish(),
+  checksum: z.string().nullish(),
+  status: PluginVersionStatusSchema,
+  publishedAt: z.number(),
+})
+
+export const CategorySchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  slug: z.string(),
+  description: z.string().nullish(),
+  icon: z.string().nullish(),
+  sortOrder: z.number().int().default(0),
+})
+
+export const ReviewSchema = z.object({
+  id: z.string(),
+  pluginId: z.string(),
+  userId: z.string(),
+  userName: z.string(),
+  rating: z.number().int().min(1).max(5),
+  title: z.string().nullish(),
+  content: z.string().nullish(),
+  createdAt: z.number(),
+})
+
+export const CreateReviewSchema = z.object({
+  rating: z.number().int().min(1).max(5),
+  title: z.string().max(200).nullish(),
+  content: z.string().max(2000).nullish(),
+})
+
+export const MarketplaceStatsSchema = z.object({
+  totalPlugins: z.number(),
+  totalDownloads: z.number(),
+  totalDevelopers: z.number(),
+  totalCategories: z.number(),
+})
+
+export const PluginListResponseSchema = z.object({
+  plugins: z.array(PluginSchema),
+  total: z.number(),
+  page: z.number(),
+  limit: z.number(),
+})
+
+export const AdminPluginSchema = PluginSchema.extend({
+  avgRating: z.number().nullish(),
+  reviewCount: z.number().nullish(),
+})
+
+export const AdminDashboardStatsSchema = z.object({
+  totalPlugins: z.number(),
+  pendingPlugins: z.number(),
+  totalDownloads: z.number(),
+  totalDevelopers: z.number(),
+  totalCategories: z.number(),
+  recentSubmissions: z.array(AdminPluginSchema).nullish(),
+})
+
+export const PluginListQuerySchema = z.object({
+  page: z.coerce.number().int().positive().default(1),
+  limit: z.coerce.number().int().positive().max(100).default(20),
+  search: z.string().nullish(),
+  status: PluginStatusSchema.nullish(),
+  category: z.string().nullish(),
+  sort: z.enum(['newest', 'popular', 'downloads', 'name']).default('newest'),
+  featured: z.coerce.boolean().nullish(),
+})
+
+export const PluginSlugSchema = z.object({
+  slug: z.string().min(1),
+})
+
+export const PluginSearchQuerySchema = z.object({
+  q: z.string().min(1),
+  page: z.coerce.number().int().positive().default(1),
+  limit: z.coerce.number().int().positive().max(100).default(20),
+  category: z.string().nullish(),
+})
+
+export const PluginDeleteResponseSchema = z.object({ slug: z.string() })
+
+export const ReviewIdParamsSchema = z.object({ slug: z.string(), reviewId: z.string() })
+
+export const ReviewDeleteResponseSchema = z.object({ id: z.string() })
+
+export const CategorySlugParamsSchema = z.object({ slug: z.string() })
+
+export const CategoryPluginsQuerySchema = z.object({
+  page: z.coerce.number().int().positive().default(1),
+  limit: z.coerce.number().int().positive().max(100).default(20),
+})
+
+export const PluginListAdminSchema = z.object({
+  plugins: z.array(PluginSchema),
+  total: z.number(),
+  page: z.number(),
+  limit: z.number(),
+})
+
+export const AdminListQuerySchema = z.object({
+  page: z.coerce.number().int().positive().default(1),
+  limit: z.coerce.number().int().positive().max(100).default(20),
+})
+
+export const AdminListAllQuerySchema = z.object({
+  page: z.coerce.number().int().positive().default(1),
+  limit: z.coerce.number().int().positive().max(100).default(20),
+  status: PluginStatusSchema.nullish(),
+})
+
+export const RejectPluginBodySchema = z.object({ reason: z.string().min(1) })
+
+export const BulkApproveBodySchema = z.object({ slugs: z.array(z.string()).min(1) })
+
+export const BulkRejectBodySchema = z.object({
+  slugs: z.array(z.string()).min(1),
+  reason: z.string().min(1),
+})
+
+export const BulkResponseSchema = z.object({ count: z.number() })
+
+export const CreateCategoryBodySchema = z.object({
+  name: z.string().min(1),
+  slug: z.string().min(1),
+  description: z.string().nullish(),
+  icon: z.string().nullish(),
+})
+
+export const UpdateCategoryBodySchema = z.object({
+  name: z.string().nullish(),
+  slug: z.string().nullish(),
+  description: z.string().nullish(),
+  icon: z.string().nullish(),
+  sortOrder: z.number().int().nullish(),
+})
+
+export const CategoryIdParamsSchema = z.object({ id: z.string() })
+
+export const CategoryIdResponseSchema = z.object({ id: z.string() })
+
+export type Plugin = z.infer<typeof PluginSchema>
+export type PluginStatus = z.infer<typeof PluginStatusSchema>
+export type CreatePluginInput = z.infer<typeof CreatePluginSchema>
+export type UpdatePluginInput = z.infer<typeof UpdatePluginSchema>
+export type PluginVersionStatus = z.infer<typeof PluginVersionStatusSchema>
+export type Version = z.infer<typeof VersionSchema>
+export type Category = z.infer<typeof CategorySchema>
+export type Review = z.infer<typeof ReviewSchema>
+export type CreateReviewInput = z.infer<typeof CreateReviewSchema>
+export type MarketplaceStats = z.infer<typeof MarketplaceStatsSchema>
+export type PluginListResponse = z.infer<typeof PluginListResponseSchema>
+export type AdminPlugin = z.infer<typeof AdminPluginSchema>
+export type AdminDashboardStats = z.infer<typeof AdminDashboardStatsSchema>
+export type PluginListQuery = z.infer<typeof PluginListQuerySchema>

package/template/src/shared/schemas/index.ts

@@ -77,3 +77,133 @@ export {
   type NotificationId,
   type UnreadCountEvent,
 } from '../modules/notifications'
+export {
+  DeveloperProfileSchema,
+  LoginSchema,
+  RegisterSchema,
+  TokenResponseSchema,
+  ProfileSchema,
+  type DeveloperProfile,
+  type LoginInput,
+  type RegisterInput,
+  type TokenResponse,
+  type Profile,
+} from '../modules/auth'
+export {
+  PluginSchema,
+  PluginStatusSchema,
+  CreatePluginSchema,
+  UpdatePluginSchema,
+  PluginVersionStatusSchema,
+  VersionSchema,
+  CategorySchema,
+  ReviewSchema,
+  CreateReviewSchema,
+  MarketplaceStatsSchema,
+  PluginListResponseSchema,
+  AdminPluginSchema,
+  AdminDashboardStatsSchema,
+  PluginListQuerySchema,
+  PluginSlugSchema,
+  PluginSearchQuerySchema,
+  PluginDeleteResponseSchema,
+  ReviewIdParamsSchema,
+  ReviewDeleteResponseSchema,
+  CategorySlugParamsSchema,
+  CategoryPluginsQuerySchema,
+  PluginListAdminSchema,
+  AdminListQuerySchema,
+  AdminListAllQuerySchema,
+  RejectPluginBodySchema,
+  BulkApproveBodySchema,
+  BulkRejectBodySchema,
+  BulkResponseSchema,
+  CreateCategoryBodySchema,
+  UpdateCategoryBodySchema,
+  CategoryIdParamsSchema,
+  CategoryIdResponseSchema,
+  type Plugin,
+  type PluginStatus,
+  type CreatePluginInput,
+  type UpdatePluginInput,
+  type PluginVersionStatus,
+  type Version,
+  type Category,
+  type Review,
+  type CreateReviewInput,
+  type MarketplaceStats,
+  type PluginListResponse,
+  type AdminPlugin,
+  type AdminDashboardStats,
+  type PluginListQuery,
+} from '../modules/plugins'
+export {
+  DashboardStatSchema,
+  RevenueDataSchema,
+  ActivityStatusSchema,
+  ActivitySchema,
+  DashboardResponseSchema,
+  type DashboardStat,
+  type RevenueData,
+  type ActivityStatus,
+  type Activity,
+  type DashboardResponse,
+} from '../modules/dashboard'
+export {
+  CartItemSchema,
+  CartSummarySchema,
+  CartResponseSchema,
+  AddCartItemSchema,
+  CartItemIdSchema,
+  type CartItem,
+  type CartSummary,
+  type CartResponse,
+  type AddCartItemInput,
+} from '../modules/cart'
+export {
+  RemoveCartItemResponseSchema,
+  ECommerceProductSchema,
+  ECommerceOrderStatusSchema,
+  ECommerceOrderSchema,
+  ECommerceOrderListSchema,
+  OrderStatusSchema,
+  OrderSchema,
+  CreateOrderSchema,
+  UpdateOrderSchema,
+  OrderListSchema,
+  OrderQuerySchema,
+  DeleteResultSchema,
+  ProcessOrderSchema,
+  CancelOrderSchema,
+  type RemoveCartItemResponse,
+  type ECommerceProduct,
+  type ECommerceOrderStatus,
+  type ECommerceOrder,
+  type OrderStatus,
+  type Order,
+  type CreateOrderInput,
+  type UpdateOrderInput,
+  type DeleteResult,
+  type ProcessOrderInput,
+  type CancelOrderInput,
+  type OrderQueryInput,
+} from '../modules/order'
+export {
+  TopicStatusSchema,
+  TopicTagSchema,
+  TopicAuthorSchema,
+  TopicSchema,
+  TopicsResponseSchema,
+  ProfileStatsSchema,
+  ActivityTypeSchema,
+  ProfileActivitySchema,
+  ProfileResponseSchema,
+  type TopicStatus,
+  type TopicTag,
+  type TopicAuthor,
+  type Topic,
+  type ProfileStats,
+  type ActivityType,
+  type ProfileActivity,
+  type ProfileResponse,
+} from '../modules/community'

package/template/tests/e2e/todo.spec.ts

@@ -348,45 +348,48 @@ test.describe('Todo App', () => {
 
       // Wait for network to be idle
       await page.waitForLoadState('networkidle')
+
+      // Wait for React to re-render after state update
+      await page.waitForTimeout(500)
     })
 
     test('should filter to show only pending todos', async ({ page }) => {
       // Click filter to show pending only
       await page.click('[data-testid="filter-pending"]')
 
-      // Wait for network to be idle
-      await page.waitForLoadState('networkidle')
+      // Wait for React to re-render after filter state update
+      await page.waitForTimeout(500)
 
       // Verify only pending todos are shown
-      await expect(page.locator('[data-testid="todo-item"]')).toHaveCount(1)
+      await expect(page.locator('[data-testid="todo-item"]')).toHaveCount(1, { timeout: 10000 })
     })
 
     test('should filter to show only completed todos', async ({ page }) => {
       // Click filter to show completed only
       await page.click('[data-testid="filter-completed"]')
 
-      // Wait for network to be idle
-      await page.waitForLoadState('networkidle')
+      // Wait for React to re-render after filter state update
+      await page.waitForTimeout(500)
 
       // Verify only completed todos are shown
-      await expect(page.locator('[data-testid="todo-item"]')).toHaveCount(1)
+      await expect(page.locator('[data-testid="todo-item"]')).toHaveCount(1, { timeout: 10000 })
     })
 
     test('should show all todos when filter is reset', async ({ page }) => {
       // Filter to completed
       await page.click('[data-testid="filter-completed"]')
 
-      // Wait for network to be idle
-      await page.waitForLoadState('networkidle')
+      // Wait for React to re-render
+      await page.waitForTimeout(500)
 
       // Reset filter to all
       await page.click('[data-testid="filter-all"]')
 
-      // Wait for network to be idle
-      await page.waitForLoadState('networkidle')
+      // Wait for React to re-render after filter state update
+      await page.waitForTimeout(500)
 
       // Verify all todos are shown
-      await expect(page.locator('[data-testid="todo-item"]')).toHaveCount(2)
+      await expect(page.locator('[data-testid="todo-item"]')).toHaveCount(2, { timeout: 10000 })
     })
   })
 
@@ -468,22 +471,24 @@ test.describe('Todo App', () => {
       await expect(page.locator('[data-testid="add-todo-button"]')).toBeEnabled()
       await page.click('[data-testid="add-todo-button"]')
 
-      // Wait for network to be idle
+      // Wait for network to be idle and React re-render
       await page.waitForLoadState('networkidle')
-
-      // Wait for form to reset
       await page.waitForTimeout(500)
+
       await page.fill('[data-testid="todo-title-input"]', 'Todo 2')
       // Wait for input to be processed
       await page.waitForTimeout(500)
       await expect(page.locator('[data-testid="add-todo-button"]')).toBeEnabled()
       await page.click('[data-testid="add-todo-button"]')
 
-      // Wait for network to be idle
+      // Wait for network to be idle and React re-render
       await page.waitForLoadState('networkidle')
+      await page.waitForTimeout(500)
 
       // Verify todo count
-      await expect(page.locator('[data-testid="todo-count"]')).toHaveText(/Total:2/)
+      await expect(page.locator('[data-testid="todo-count"]')).toHaveText(/Total:\s*\d+/, {
+        timeout: 10000,
+      })
     })
   })
 
@@ -512,7 +517,7 @@ test.describe('Todo App', () => {
       await page.waitForLoadState('networkidle')
 
       // Wait for app to render
-      await page.waitForSelector('[data-testid="todo-form"]', { timeout: 15000 })
+      await page.waitForSelector('[data-testid="todo-form"]', { timeout: 30000 })
 
       // Create a todo
       await page.fill('[data-testid="todo-title-input"]', 'Persistent todo')
@@ -539,7 +544,7 @@ test.describe('Todo App', () => {
         await newPage.reload()
         await newPage.waitForLoadState('load')
         await newPage.waitForLoadState('networkidle')
-        await newPage.waitForSelector('[data-testid="todo-item"]', { timeout: 15000 })
+        await newPage.waitForSelector('[data-testid="todo-item"]', { timeout: 30000 })
 
         // Verify todo still exists
         await expect(newPage.locator('[data-testid="todo-item"]')).toHaveCount(1)