create-fullstack-scaffold 0.1.1 → 0.2.0

package/template/src/server/module-order/routes/orders-mock-routes.ts

@@ -0,0 +1,67 @@
+import { createRoute } from '@hono/zod-openapi'
+import { OpenAPIHono } from '@hono/zod-openapi'
+import { successResponse } from '@server/utils/route-helpers'
+import { ECommerceOrderListSchema } from '@shared/schemas'
+
+const MOCK_ORDERS = [
+  {
+    id: 'ORD-2024-001',
+    date: '2024-12-10',
+    status: 'processing' as const,
+    products: [
+      { name: 'Wireless Headphones', color: '#374151' },
+      { name: 'USB-C Cable', color: '#6366f1' },
+    ],
+    total: 94.98,
+  },
+  {
+    id: 'ORD-2024-002',
+    date: '2024-12-08',
+    status: 'shipped' as const,
+    products: [
+      { name: 'Organic Cotton T-Shirt', color: '#6ee7b7' },
+      { name: 'Ceramic Travel Mug', color: '#f59e0b' },
+      { name: 'Linen Tote Bag', color: '#d4a574' },
+    ],
+    total: 79.97,
+  },
+  {
+    id: 'ORD-2024-003',
+    date: '2024-12-01',
+    status: 'delivered' as const,
+    products: [
+      { name: 'Bamboo Desk Organizer', color: '#a3e635' },
+      { name: 'Recycled Notebook', color: '#f472b6' },
+    ],
+    total: 45.98,
+  },
+  {
+    id: 'ORD-2024-004',
+    date: '2024-11-25',
+    status: 'delivered' as const,
+    products: [{ name: 'Beeswax Candle Set', color: '#fbbf24' }],
+    total: 29.99,
+  },
+  {
+    id: 'ORD-2024-005',
+    date: '2024-11-20',
+    status: 'cancelled' as const,
+    products: [
+      { name: 'Wooden Phone Stand', color: '#92400e' },
+      { name: 'Plant-Based Soap', color: '#86efac' },
+    ],
+    total: 39.98,
+  },
+]
+
+const getOrdersRoute = createRoute({
+  method: 'get',
+  path: '/orders-mock',
+  responses: {
+    200: successResponse(ECommerceOrderListSchema, 'List e-commerce orders'),
+  },
+})
+
+export const ordersMockRoutes = new OpenAPIHono().openapi(getOrdersRoute, async c => {
+  return c.json({ success: true as const, data: MOCK_ORDERS })
+})

package/template/src/server/module-order/services/order-service.ts

@@ -8,7 +8,7 @@ import { parseModuleId } from '@server/utils/id-helpers'
 
 export async function seedOrdersIfEmpty(): Promise<void> {
   const db = await getDb()
-  const existing = await db.select().from(orders).all()
+  const existing = await db.select().from(orders)
   if (existing.length === 0) {
     const STATUSES: OrderStatus[] = ['pending', 'processing', 'completed', 'cancelled', 'disputed']
     const CUSTOMERS = [

package/template/src/server/module-plugin/__tests__/plugin-query-service.test.ts

@@ -0,0 +1,203 @@
+import { describe, it, expect, beforeAll, afterAll, beforeEach, afterEach, vi } from 'vitest'
+import * as queryService from '../services/plugin-query-service'
+import { getRawClient, getDb } from '@server/db'
+import { setupTestDatabase, cleanupTestDatabase } from '@server/db/test-setup'
+import { NotFoundError } from '@server/utils/app-error'
+
+async function clearPluginTables() {
+  const client = await getRawClient()
+  if (client && 'execute' in client) {
+    await client.execute('DELETE FROM plugin_reviews')
+    await client.execute('DELETE FROM plugin_versions')
+    await client.execute('DELETE FROM plugin_category_mappings')
+    await client.execute('DELETE FROM plugins')
+    await client.execute('DELETE FROM plugin_categories')
+  }
+}
+
+async function insertPlugin(overrides: Record<string, unknown> = {}) {
+  const client = await getRawClient()
+  if (!client || !('execute' in client)) throw new Error('No DB client')
+
+  const id = (overrides.id ??
+    `plugin-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`) as string
+  const now = Date.now()
+  await client.execute({
+    sql: `INSERT INTO plugins (id, name, slug, description, author_id, author_name, version, status, download_count, view_count, featured, created_at, updated_at, tags)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    args: [
+      id as string,
+      (overrides.name ?? 'Test Plugin') as string,
+      (overrides.slug ?? id) as string,
+      (overrides.description ?? 'A test plugin') as string,
+      (overrides.authorId ?? 'user-1') as string,
+      (overrides.authorName ?? 'Test User') as string,
+      (overrides.version ?? '0.0.1') as string,
+      (overrides.status ?? 'approved') as string,
+      (overrides.downloadCount ?? 0) as number,
+      (overrides.viewCount ?? 0) as number,
+      (overrides.featured === true ? 1 : 0) as number,
+      (overrides.createdAt ?? now) as number,
+      (overrides.updatedAt ?? now) as number,
+      (overrides.tags ?? null) as string | null,
+    ],
+  })
+  return id
+}
+
+describe('Plugin Query Service', () => {
+  beforeAll(async () => {
+    await setupTestDatabase()
+    const db = await getDb()
+    expect(db).toBeDefined()
+  })
+
+  afterAll(async () => {
+    await cleanupTestDatabase()
+  })
+
+  beforeEach(async () => {
+    await clearPluginTables()
+  })
+
+  afterEach(async () => {
+    await clearPluginTables()
+    vi.clearAllMocks()
+  })
+
+  describe('listPlugins', () => {
+    it('should return empty list when no approved plugins exist', async () => {
+      const result = await queryService.listPlugins()
+      expect(result.plugins).toEqual([])
+      expect(result.total).toBe(0)
+    })
+
+    it('should return approved plugins with pagination', async () => {
+      await insertPlugin({ slug: 'plugin-a', status: 'approved' })
+      await insertPlugin({ slug: 'plugin-b', status: 'approved' })
+      await insertPlugin({ slug: 'plugin-c', status: 'pending' })
+
+      const result = await queryService.listPlugins({ page: 1, limit: 10 })
+
+      expect(result.plugins).toHaveLength(2)
+      expect(result.total).toBe(2)
+    })
+
+    it('should filter by status', async () => {
+      await insertPlugin({ slug: 'pending-1', status: 'pending' })
+      await insertPlugin({ slug: 'approved-1', status: 'approved' })
+
+      const result = await queryService.listPlugins({ status: 'pending' })
+
+      expect(result.plugins).toHaveLength(1)
+      expect(result.plugins[0].status).toBe('pending')
+    })
+
+    it('should filter by featured', async () => {
+      await insertPlugin({ slug: 'featured-1', status: 'approved', featured: true })
+      await insertPlugin({ slug: 'regular-1', status: 'approved', featured: false })
+
+      const result = await queryService.listPlugins({ featured: true })
+
+      expect(result.plugins).toHaveLength(1)
+      expect(result.plugins[0].featured).toBe(true)
+    })
+
+    it('should paginate correctly', async () => {
+      for (let i = 0; i < 5; i++) {
+        await insertPlugin({ slug: `page-plugin-${i}`, status: 'approved' })
+      }
+
+      const page1 = await queryService.listPlugins({ page: 1, limit: 2 })
+      const page2 = await queryService.listPlugins({ page: 2, limit: 2 })
+
+      expect(page1.plugins).toHaveLength(2)
+      expect(page1.page).toBe(1)
+      expect(page1.total).toBe(5)
+      expect(page2.plugins).toHaveLength(2)
+      expect(page2.page).toBe(2)
+    })
+  })
+
+  describe('searchPlugins', () => {
+    it('should search by name', async () => {
+      await insertPlugin({ name: 'React Utils', slug: 'react-utils', status: 'approved' })
+      await insertPlugin({ name: 'Vue Helper', slug: 'vue-helper', status: 'approved' })
+
+      const result = await queryService.searchPlugins('React')
+
+      expect(result.plugins).toHaveLength(1)
+      expect(result.plugins[0].name).toBe('React Utils')
+    })
+
+    it('should search by description', async () => {
+      await insertPlugin({
+        name: 'Tool',
+        slug: 'search-tool',
+        description: 'A React component library',
+        status: 'approved',
+      })
+
+      const result = await queryService.searchPlugins('component')
+
+      expect(result.plugins).toHaveLength(1)
+    })
+
+    it('should return empty for no matches', async () => {
+      await insertPlugin({ slug: 'existing-plugin', status: 'approved' })
+
+      const result = await queryService.searchPlugins('nonexistent-xyz')
+
+      expect(result.plugins).toHaveLength(0)
+      expect(result.total).toBe(0)
+    })
+  })
+
+  describe('getPluginBySlug', () => {
+    it('should return plugin and increment view count', async () => {
+      await insertPlugin({ slug: 'viewed-plugin', viewCount: 0 })
+
+      const plugin = await queryService.getPluginBySlug('viewed-plugin')
+
+      expect(plugin.slug).toBe('viewed-plugin')
+      expect(plugin.viewCount).toBe(0)
+
+      const plugin2 = await queryService.getPluginBySlug('viewed-plugin')
+      expect(plugin2.viewCount).toBe(1)
+    })
+
+    it('should throw NotFoundError for non-existent slug', async () => {
+      await expect(queryService.getPluginBySlug('non-existent')).rejects.toThrow(NotFoundError)
+    })
+  })
+
+  describe('getVersions', () => {
+    it('should return empty array for plugin with no versions', async () => {
+      const pluginId: string = await insertPlugin({ slug: 'no-versions' })
+
+      const versions = await queryService.getVersions(pluginId)
+
+      expect(versions).toEqual([])
+    })
+  })
+
+  describe('listCategories', () => {
+    it('should return empty when no categories exist', async () => {
+      const categories = await queryService.listCategories()
+      expect(categories).toEqual([])
+    })
+  })
+
+  describe('getStats', () => {
+    it('should return marketplace stats', async () => {
+      await insertPlugin({ slug: 'stats-1', status: 'approved', downloadCount: 10 })
+      await insertPlugin({ slug: 'stats-2', status: 'approved', downloadCount: 5 })
+
+      const stats = await queryService.getStats()
+
+      expect(stats.totalPlugins).toBe(2)
+      expect(stats.totalDownloads).toBe(15)
+      expect(stats.totalDevelopers).toBeGreaterThanOrEqual(1)
+    })
+  })
+})

package/template/src/server/module-plugin/__tests__/plugin-service.test.ts

@@ -0,0 +1,234 @@
+import { describe, it, expect, beforeAll, afterAll, beforeEach, afterEach, vi } from 'vitest'
+import * as pluginService from '../services/plugin-service'
+import { getRawClient, getDb } from '@server/db'
+import { setupTestDatabase, cleanupTestDatabase } from '@server/db/test-setup'
+import { NotFoundError, AuthorizationError, ConflictError } from '@server/utils/app-error'
+
+async function clearPluginTables() {
+  const client = await getRawClient()
+  if (client && 'execute' in client) {
+    await client.execute('DELETE FROM plugin_reviews')
+    await client.execute('DELETE FROM plugin_versions')
+    await client.execute('DELETE FROM plugin_category_mappings')
+    await client.execute('DELETE FROM plugins')
+  }
+}
+
+async function insertTestPlugin(overrides: Record<string, unknown> = {}) {
+  const client = await getRawClient()
+  if (!client || !('execute' in client)) throw new Error('No DB client')
+
+  const id = overrides.id ?? 'test-plugin-id'
+  const now = Date.now()
+  await client.execute({
+    sql: `INSERT INTO plugins (id, name, slug, description, author_id, author_name, version, status, download_count, view_count, featured, created_at, updated_at, tags, site_urls, commands)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    args: [
+      id as string,
+      (overrides.name ?? 'Test Plugin') as string,
+      (overrides.slug ?? 'test-plugin') as string,
+      (overrides.description ?? 'A test plugin') as string,
+      (overrides.authorId ?? 'user-1') as string,
+      (overrides.authorName ?? 'Test User') as string,
+      (overrides.version ?? '0.0.1') as string,
+      (overrides.status ?? 'pending') as string,
+      (overrides.downloadCount ?? 0) as number,
+      (overrides.viewCount ?? 0) as number,
+      (overrides.featured === true ? 1 : 0) as number,
+      (overrides.createdAt ?? now) as number,
+      (overrides.updatedAt ?? now) as number,
+      (overrides.tags ?? null) as string | null,
+      (overrides.siteUrls ?? null) as string | null,
+      (overrides.commands ?? null) as string | null,
+    ],
+  })
+  return id
+}
+
+describe('Plugin Service', () => {
+  beforeAll(async () => {
+    await setupTestDatabase()
+    const db = await getDb()
+    expect(db).toBeDefined()
+  })
+
+  afterAll(async () => {
+    await cleanupTestDatabase()
+  })
+
+  beforeEach(async () => {
+    await clearPluginTables()
+  })
+
+  afterEach(async () => {
+    await clearPluginTables()
+    vi.clearAllMocks()
+  })
+
+  describe('createPlugin', () => {
+    it('should create a plugin with status pending', async () => {
+      const result = await pluginService.createPlugin({
+        name: 'My Plugin',
+        slug: 'my-plugin',
+        description: 'A great plugin',
+        authorId: 'user-1',
+        authorName: 'Developer',
+      })
+
+      expect(result.id).toBeDefined()
+      expect(result.name).toBe('My Plugin')
+      expect(result.slug).toBe('my-plugin')
+      expect(result.status).toBe('pending')
+      expect(result.version).toBe('0.0.1')
+      expect(result.downloadCount).toBe(0)
+      expect(result.viewCount).toBe(0)
+      expect(result.featured).toBe(false)
+      expect(result.authorId).toBe('user-1')
+      expect(result.authorName).toBe('Developer')
+    })
+
+    it('should create a plugin with optional fields', async () => {
+      const result = await pluginService.createPlugin({
+        name: 'Full Plugin',
+        slug: 'full-plugin',
+        description: 'Plugin with all fields',
+        authorId: 'user-1',
+        authorName: 'Developer',
+        repositoryUrl: 'https://github.com/test/plugin',
+        homepageUrl: 'https://plugin.dev',
+        npmPackage: '@test/plugin',
+        license: 'MIT',
+        tags: ['utility', 'tools'],
+        siteUrls: ['https://example.com'],
+        commands: [{ name: 'init', description: 'Initialize' }],
+      })
+
+      expect(result.repositoryUrl).toBe('https://github.com/test/plugin')
+      expect(result.homepageUrl).toBe('https://plugin.dev')
+      expect(result.npmPackage).toBe('@test/plugin')
+      expect(result.license).toBe('MIT')
+      expect(result.tags).toEqual(['utility', 'tools'])
+      expect(result.siteUrls).toEqual(['https://example.com'])
+      expect(result.commands).toEqual([{ name: 'init', description: 'Initialize' }])
+    })
+
+    it('should throw ConflictError for duplicate slug', async () => {
+      await pluginService.createPlugin({
+        name: 'Plugin 1',
+        slug: 'duplicate-slug',
+        description: 'First',
+        authorId: 'user-1',
+        authorName: 'Dev',
+      })
+
+      await expect(
+        pluginService.createPlugin({
+          name: 'Plugin 2',
+          slug: 'duplicate-slug',
+          description: 'Second',
+          authorId: 'user-2',
+          authorName: 'Dev2',
+        })
+      ).rejects.toThrow(ConflictError)
+    })
+  })
+
+  describe('updatePlugin', () => {
+    it('should update plugin fields', async () => {
+      await insertTestPlugin({ slug: 'updatable-plugin', authorId: 'user-1' })
+
+      const result = await pluginService.updatePlugin(
+        'updatable-plugin',
+        {
+          name: 'Updated Name',
+          description: 'Updated desc',
+        },
+        'user-1'
+      )
+
+      expect(result.name).toBe('Updated Name')
+      expect(result.description).toBe('Updated desc')
+    })
+
+    it('should throw NotFoundError for non-existent slug', async () => {
+      await expect(
+        pluginService.updatePlugin('non-existent', { name: 'X' }, 'user-1')
+      ).rejects.toThrow(NotFoundError)
+    })
+
+    it('should throw AuthorizationError for non-author', async () => {
+      await insertTestPlugin({ slug: 'auth-plugin', authorId: 'user-1' })
+
+      await expect(
+        pluginService.updatePlugin('auth-plugin', { name: 'X' }, 'user-2')
+      ).rejects.toThrow(AuthorizationError)
+    })
+
+    it('should update JSON fields', async () => {
+      await insertTestPlugin({ slug: 'json-plugin', authorId: 'user-1' })
+
+      const result = await pluginService.updatePlugin(
+        'json-plugin',
+        {
+          tags: ['new-tag'],
+          siteUrls: ['https://new-site.com'],
+        },
+        'user-1'
+      )
+
+      expect(result.tags).toEqual(['new-tag'])
+      expect(result.siteUrls).toEqual(['https://new-site.com'])
+    })
+  })
+
+  describe('deletePlugin', () => {
+    it('should delete a plugin', async () => {
+      await insertTestPlugin({ slug: 'deletable-plugin', authorId: 'user-1' })
+
+      await pluginService.deletePlugin('deletable-plugin', 'user-1')
+
+      const client = await getRawClient()
+      if (client && 'execute' in client) {
+        const result = await client.execute('SELECT * FROM plugins WHERE slug = ?', [
+          'deletable-plugin',
+        ])
+        expect(result.rows.length).toBe(0)
+      }
+    })
+
+    it('should throw NotFoundError for non-existent slug', async () => {
+      await expect(pluginService.deletePlugin('non-existent', 'user-1')).rejects.toThrow(
+        NotFoundError
+      )
+    })
+
+    it('should throw AuthorizationError for non-author', async () => {
+      await insertTestPlugin({ slug: 'auth-delete-plugin', authorId: 'user-1' })
+
+      await expect(pluginService.deletePlugin('auth-delete-plugin', 'user-2')).rejects.toThrow(
+        AuthorizationError
+      )
+    })
+  })
+
+  describe('trackInstall', () => {
+    it('should increment download count', async () => {
+      await insertTestPlugin({ slug: 'install-plugin', downloadCount: 5 })
+
+      await pluginService.trackInstall('install-plugin')
+
+      const client = await getRawClient()
+      if (client && 'execute' in client) {
+        const result = await client.execute('SELECT download_count FROM plugins WHERE slug = ?', [
+          'install-plugin',
+        ])
+        const row = result.rows[0] as unknown as { download_count: number }
+        expect(row.download_count).toBe(6)
+      }
+    })
+
+    it('should throw NotFoundError for non-existent slug', async () => {
+      await expect(pluginService.trackInstall('non-existent')).rejects.toThrow(NotFoundError)
+    })
+  })
+})

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

@@ -0,0 +1,2 @@
+export { pluginRoutes } from './routes/plugin-routes'
+export { pluginAdminRoutes } from './routes/plugin-admin-routes'

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

@@ -0,0 +1,52 @@
+import type { ModuleManifest } from '@shared/core/module-manifest'
+
+const pluginManifest: ModuleManifest = {
+  name: 'plugin',
+  description:
+    'Plugin marketplace with CRUD, publishing, reviews, categories, and admin management',
+  category: 'business',
+  dependsOn: ['permission'],
+
+  routes: {
+    client: {
+      importPath: './routes/plugin-routes',
+      exportName: 'pluginRoutes',
+    },
+    admin: [
+      {
+        importPath: './routes/plugin-admin-routes',
+        exportName: 'pluginAdminRoutes',
+      },
+    ],
+  },
+
+  sharedSchemas: {
+    path: 'plugins',
+  },
+
+  clientPages: [
+    { name: 'PluginsPage', route: '/plugins' },
+    { name: 'PluginDetailPage', route: '/plugins/:slug' },
+    { name: 'CategoriesPage', route: '/categories' },
+    { name: 'SearchPage', route: '/search' },
+    { name: 'PublishPage', route: '/publish' },
+    { name: 'DeveloperDashboardPage', route: '/developer' },
+    { name: 'TopicsPage', route: '/topics' },
+  ],
+
+  adminPages: [
+    { name: 'PluginManagementPage', route: '/admin/plugins' },
+    { name: 'PluginReviewPage', route: '/admin/plugins/review' },
+    { name: 'CategoryManagementPage', route: '/admin/categories' },
+    { name: 'PluginDashboardPage', route: '/admin/plugins/dashboard' },
+  ],
+
+  clientStores: ['pluginStore'],
+
+  dbSchemas: {
+    files: ['plugins'],
+    hasSeed: true,
+  },
+}
+
+export default pluginManifest