create-fullstack-scaffold 0.4.9 → 0.4.10

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

@@ -0,0 +1,292 @@
+import { eq, desc, and } from 'drizzle-orm'
+import type {
+  Merchant,
+  MerchantLoginInput,
+  MerchantStats,
+  Product,
+  CreateProductInput,
+} from '@shared/schemas'
+import { getDb } from '@server/db'
+import { merchants, products } from '@server/db/schema'
+import { createModuleLoggerSync } from '../../utils/logger'
+import { AuthenticationError } from '../../utils/app-error'
+
+const log = createModuleLoggerSync('merchant-service')
+
+// ==================== Merchant Functions ====================
+
+export async function getMerchantByUserId(userId: string): Promise<Merchant | null> {
+  const db = await getDb()
+  const rows = await db.select().from(merchants).where(eq(merchants.userId, userId))
+
+  if (rows.length === 0) return null
+
+  const row = rows[0]
+
+  return {
+    id: row.id,
+    userId: row.userId,
+    tenantId: row.tenantId,
+    businessName: row.businessName,
+    businessType: row.businessType as 'retail' | 'wholesale' | 'service' | 'restaurant',
+    status: row.status as 'active' | 'inactive' | 'suspended',
+    description: row.description,
+    phone: row.phone,
+    email: row.email,
+    address: row.address,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt,
+  }
+}
+
+export async function getMerchantById(id: number): Promise<Merchant | null> {
+  const db = await getDb()
+  const rows = await db.select().from(merchants).where(eq(merchants.id, id))
+
+  if (rows.length === 0) return null
+
+  const row = rows[0]
+
+  return {
+    id: row.id,
+    userId: row.userId,
+    tenantId: row.tenantId,
+    businessName: row.businessName,
+    businessType: row.businessType as 'retail' | 'wholesale' | 'service' | 'restaurant',
+    status: row.status as 'active' | 'inactive' | 'suspended',
+    description: row.description,
+    phone: row.phone,
+    email: row.email,
+    address: row.address,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt,
+  }
+}
+
+export async function merchantLogin(
+  input: MerchantLoginInput
+): Promise<{ token: string; merchant: Merchant }> {
+  const db = await getDb()
+
+  // Find merchant by username
+  const rows = await db.select().from(merchants).where(eq(merchants.userId, input.username))
+
+  if (rows.length === 0) {
+    throw new AuthenticationError('Invalid credentials')
+  }
+
+  const merchant = rows[0]
+
+  // Check password (simplified for demo - use bcrypt in production)
+  if (merchant.password !== input.password) {
+    throw new AuthenticationError('Invalid credentials')
+  }
+
+  // Check merchant status
+  if (merchant.status === 'suspended') {
+    throw new AuthenticationError('Account is suspended')
+  }
+
+  if (merchant.status === 'inactive') {
+    throw new AuthenticationError('Account is inactive')
+  }
+
+  // Generate token (simplified for demo - use JWT in production)
+  const token = `merchant-token-${merchant.id}-${Date.now()}`
+
+  log.info({ merchantId: merchant.id }, 'Merchant logged in')
+
+  const merchantData: Merchant = {
+    id: merchant.id,
+    userId: merchant.userId,
+    tenantId: merchant.tenantId,
+    businessName: merchant.businessName,
+    businessType: merchant.businessType as 'retail' | 'wholesale' | 'service' | 'restaurant',
+    status: merchant.status as 'active' | 'inactive' | 'suspended',
+    description: merchant.description,
+    phone: merchant.phone,
+    email: merchant.email,
+    address: merchant.address,
+    createdAt: merchant.createdAt,
+    updatedAt: merchant.updatedAt,
+  }
+
+  return { token, merchant: merchantData }
+}
+
+export async function getMerchantStats(merchantId: number): Promise<MerchantStats> {
+  const db = await getDb()
+
+  // Get product counts
+  const allProducts = await db.select().from(products).where(eq(products.merchantId, merchantId))
+  const activeProducts = allProducts.filter(p => p.status === 'active').length
+
+  // Get order stats (simplified - in production, query orders table)
+  const totalOrders = 0 // TODO: Implement order stats
+  const totalRevenue = 0 // TODO: Implement revenue stats
+  const pendingOrders = 0 // TODO: Implement pending order count
+  const thisMonthRevenue = 0 // TODO: Implement monthly revenue
+
+  return {
+    totalOrders,
+    totalRevenue,
+    totalProducts: allProducts.length,
+    activeProducts,
+    pendingOrders,
+    thisMonthRevenue,
+  }
+}
+
+// ==================== Product Functions ====================
+
+export async function listProducts(
+  merchantId: number,
+  page = 1,
+  pageSize = 20,
+  status?: 'active' | 'inactive' | 'out_of_stock'
+): Promise<{ items: Product[]; total: number; page: number; pageSize: number }> {
+  const db = await getDb()
+  const offset = (page - 1) * pageSize
+
+  const whereConditions = [eq(products.merchantId, merchantId)]
+  if (status) {
+    whereConditions.push(eq(products.status, status))
+  }
+
+  const baseQuery = db
+    .select()
+    .from(products)
+    .where(and(...whereConditions))
+
+  const rows = await baseQuery.orderBy(desc(products.createdAt)).limit(pageSize).offset(offset)
+
+  const countRows = await baseQuery
+  const total = countRows.length
+
+  const items: Product[] = rows.map(row => ({
+    id: row.id,
+    name: row.name,
+    description: row.description || '',
+    price: row.price,
+    status: row.status as 'active' | 'inactive' | 'out_of_stock',
+    stock: row.stock,
+    imageUrl: row.imageUrl,
+    createdAt: row.createdAt.toISOString(),
+    updatedAt: row.updatedAt.toISOString(),
+  }))
+
+  return { items, total, page, pageSize }
+}
+
+export async function createProduct(
+  merchantId: number,
+  input: CreateProductInput
+): Promise<Product> {
+  const db = await getDb()
+
+  const now = new Date()
+  const productId = `product-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`
+
+  const result = await db
+    .insert(products)
+    .values({
+      id: productId,
+      merchantId,
+      name: input.name,
+      description: input.description || null,
+      price: input.price,
+      status: input.status || 'active',
+      stock: input.stock || 0,
+      imageUrl: input.imageUrl || null,
+      createdAt: now,
+      updatedAt: now,
+    })
+    .returning()
+
+  const row = result[0]
+
+  log.info({ productId, merchantId }, 'Product created')
+
+  return {
+    id: row.id,
+    name: row.name,
+    description: row.description || '',
+    price: row.price,
+    status: row.status as 'active' | 'inactive' | 'out_of_stock',
+    stock: row.stock,
+    imageUrl: row.imageUrl,
+    createdAt: row.createdAt.toISOString(),
+    updatedAt: row.updatedAt.toISOString(),
+  }
+}
+
+export async function getProductById(productId: string): Promise<Product | null> {
+  const db = await getDb()
+  const rows = await db.select().from(products).where(eq(products.id, productId))
+
+  if (rows.length === 0) return null
+
+  const row = rows[0]
+
+  return {
+    id: row.id,
+    name: row.name,
+    description: row.description || '',
+    price: row.price,
+    status: row.status as 'active' | 'inactive' | 'out_of_stock',
+    stock: row.stock,
+    imageUrl: row.imageUrl,
+    createdAt: row.createdAt.toISOString(),
+    updatedAt: row.updatedAt.toISOString(),
+  }
+}
+
+// ==================== Seed Functions ====================
+
+const seedMerchants = [
+  {
+    userId: 'merchant-1',
+    tenantId: 1,
+    businessName: 'Demo Store',
+    businessType: 'retail' as const,
+    status: 'active' as const,
+    description: 'A demo retail store',
+    phone: '13800138000',
+    email: 'merchant@example.com',
+    address: '123 Main St',
+    password: 'password123',
+  },
+  {
+    userId: 'merchant-2',
+    tenantId: 1,
+    businessName: 'Tech Shop',
+    businessType: 'service' as const,
+    status: 'active' as const,
+    description: null,
+    phone: null,
+    email: null,
+    address: null,
+    password: 'password123',
+  },
+]
+
+export async function seedMerchantsIfEmpty(): Promise<void> {
+  const db = await getDb()
+
+  const existing = await db.select().from(merchants).limit(1)
+  if (existing.length > 0) {
+    log.info({}, 'Merchants already seeded, skipping')
+    return
+  }
+
+  const now = new Date().toISOString()
+  for (const merchant of seedMerchants) {
+    await db.insert(merchants).values({
+      ...merchant,
+      createdAt: now,
+      updatedAt: now,
+    })
+  }
+
+  log.info({ count: seedMerchants.length }, 'Merchants seeded')
+}

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

@@ -0,0 +1,18 @@
+/**
+ * Notification Module Public API
+ *
+ * This is the public interface for the notification module.
+ * Other modules should import from here, not from internal service paths.
+ */
+export { notificationRoutes } from './routes/notification-routes'
+export {
+  listNotifications,
+  getNotification,
+  createNotification,
+  createNotificationAndBroadcast,
+  markAsRead,
+  markAllAsRead,
+  deleteNotification,
+  getUnreadCount,
+  clearAllNotifications,
+} from './services/notification-service'

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

@@ -27,6 +27,8 @@ const notificationManifest: ModuleManifest = {
   },
 
   hasSSE: true,
+
+  cliModule: { dir: 'notification', registerFunction: 'registerNotificationCommands' },
 }
 
 export default notificationManifest

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

@@ -39,6 +39,7 @@ const orderManifest: ModuleManifest = {
   dbSchemas: {
     files: ['orders'],
     hasSeed: true,
+    seed: { serviceFile: 'order-service', functionName: 'seedOrdersIfEmpty' },
   },
 }
 

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

@@ -10,7 +10,7 @@ import {
   CreateOrderSchema,
   UpdateOrderSchema,
   OrderListSchema,
-  DeleteResultSchema,
+  OrderDeleteResultSchema,
   OrderQuerySchema,
 } from '@shared/modules/order'
 
@@ -109,7 +109,7 @@ const deleteRoute = createRoute({
     params: OrderSchema.pick({ id: true }),
   },
   responses: {
-    200: successResponse(DeleteResultSchema, 'Order deleted'),
+    200: successResponse(OrderDeleteResultSchema, 'Order deleted'),
     401: errorResponse('Unauthorized'),
     403: errorResponse('Forbidden'),
     404: errorResponse('Order not found'),

package/template/src/server/module-permission/routes/role-routes.ts

@@ -11,7 +11,7 @@ import {
   CreateRoleSchema,
   UpdateRoleSchema,
   UpdateRolePermissionsSchema,
-  SuccessSchema,
+  RoleSuccessSchema,
 } from '@shared/modules/role/schemas'
 import { validatePermissionDependencies } from '@shared/modules/permission/permission-dependencies'
 
@@ -112,7 +112,7 @@ const deleteRoleRoute = createRoute({
     }),
   },
   responses: {
-    200: successResponse(SuccessSchema, 'Role deleted'),
+    200: successResponse(RoleSuccessSchema, 'Role deleted'),
     401: errorResponse('Unauthorized'),
     403: errorResponse('Forbidden'),
     400: errorResponse('Cannot delete system role'),
@@ -138,7 +138,7 @@ const updateRolePermissionsRoute = createRoute({
     },
   },
   responses: {
-    200: successResponse(SuccessSchema, 'Role permissions updated'),
+    200: successResponse(RoleSuccessSchema, 'Role permissions updated'),
     400: errorResponse('Permission dependency validation failed'),
     401: errorResponse('Unauthorized'),
     403: errorResponse('Forbidden'),

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

@@ -0,0 +1,181 @@
+import { describe, it, expect, beforeAll, afterAll, beforeEach, afterEach, vi } from 'vitest'
+import * as categoryService from '../services/admin-category-service'
+import { getRawClient, getDb } from '@server/db'
+import { setupTestDatabase, cleanupTestDatabase } from '@server/db/test-setup'
+import { NotFoundError, ConflictError } from '@server/utils/app-error'
+
+async function clearPluginTables() {
+  const client = await getRawClient()
+  if (client && 'execute' in client) {
+    await client.execute('DELETE FROM plugin_category_mappings')
+    await client.execute('DELETE FROM plugins')
+    await client.execute('DELETE FROM plugin_categories')
+  }
+}
+
+async function insertTestCategory(overrides: Record<string, unknown> = {}) {
+  const client = await getRawClient()
+  if (!client || !('execute' in client)) throw new Error('No DB client')
+
+  const id = (overrides.id ?? `cat-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`) as string
+  await client.execute({
+    sql: `INSERT INTO plugin_categories (id, name, slug, description, icon, sort_order)
+          VALUES (?, ?, ?, ?, ?, ?)`,
+    args: [
+      id,
+      (overrides.name ?? 'Test Category') as string,
+      (overrides.slug ?? id) as string,
+      (overrides.description ?? null) as string | null,
+      (overrides.icon ?? null) as string | null,
+      (overrides.sortOrder ?? 0) as number,
+    ],
+  })
+  return id
+}
+
+describe('Admin Category 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('createCategory', () => {
+    it('should create a category', async () => {
+      const category = await categoryService.createCategory({
+        name: 'UI & Design',
+        slug: 'ui-design',
+        description: 'Visual customization',
+        icon: 'palette',
+      })
+
+      expect(category.id).toBeDefined()
+      expect(category.name).toBe('UI & Design')
+      expect(category.slug).toBe('ui-design')
+      expect(category.description).toBe('Visual customization')
+      expect(category.icon).toBe('palette')
+      expect(category.sortOrder).toBe(0)
+    })
+
+    it('should create a category without optional fields', async () => {
+      const category = await categoryService.createCategory({
+        name: 'Basic',
+        slug: 'basic',
+      })
+
+      expect(category.name).toBe('Basic')
+      expect(category.description).toBeUndefined()
+      expect(category.icon).toBeUndefined()
+    })
+
+    it('should throw ConflictError for duplicate slug', async () => {
+      await categoryService.createCategory({ name: 'First', slug: 'dup-slug' })
+
+      await expect(
+        categoryService.createCategory({ name: 'Second', slug: 'dup-slug' })
+      ).rejects.toThrow(ConflictError)
+    })
+  })
+
+  describe('updateCategory', () => {
+    it('should update category name', async () => {
+      const catId = await insertTestCategory({ name: 'Old Name', slug: 'update-name' })
+
+      const updated = await categoryService.updateCategory(catId, { name: 'New Name' })
+
+      expect(updated.name).toBe('New Name')
+      expect(updated.slug).toBe('update-name')
+    })
+
+    it('should update category slug', async () => {
+      const catId = await insertTestCategory({ name: 'My Cat', slug: 'old-slug' })
+
+      const updated = await categoryService.updateCategory(catId, { slug: 'new-slug' })
+
+      expect(updated.slug).toBe('new-slug')
+    })
+
+    it('should update multiple fields at once', async () => {
+      const catId = await insertTestCategory({ name: 'Cat', slug: 'multi-update' })
+
+      const updated = await categoryService.updateCategory(catId, {
+        name: 'Updated Cat',
+        description: 'New description',
+        icon: 'new-icon',
+        sortOrder: 5,
+      })
+
+      expect(updated.name).toBe('Updated Cat')
+      expect(updated.description).toBe('New description')
+      expect(updated.icon).toBe('new-icon')
+      expect(updated.sortOrder).toBe(5)
+    })
+
+    it('should set description to null', async () => {
+      const catId = await insertTestCategory({
+        name: 'Desc Cat',
+        slug: 'desc-update',
+        description: 'Has description',
+      })
+
+      const updated = await categoryService.updateCategory(catId, { description: null })
+
+      expect(updated.description).toBeUndefined()
+    })
+
+    it('should throw NotFoundError for non-existent category', async () => {
+      await expect(
+        categoryService.updateCategory('non-existent', { name: 'X' })
+      ).rejects.toThrow(NotFoundError)
+    })
+  })
+
+  describe('deleteCategory', () => {
+    it('should delete a category', async () => {
+      const catId = await insertTestCategory({ name: 'Delete Me', slug: 'delete-cat' })
+
+      await categoryService.deleteCategory(catId)
+
+      const categories = await categoryService.listAllCategories()
+      expect(categories.find(c => c.id === catId)).toBeUndefined()
+    })
+
+    it('should throw NotFoundError for non-existent category', async () => {
+      await expect(categoryService.deleteCategory('non-existent')).rejects.toThrow(NotFoundError)
+    })
+  })
+
+  describe('listAllCategories', () => {
+    it('should return categories sorted by sortOrder', async () => {
+      await insertTestCategory({ name: 'Third', slug: 'third', sortOrder: 3 })
+      await insertTestCategory({ name: 'First', slug: 'first', sortOrder: 1 })
+      await insertTestCategory({ name: 'Second', slug: 'second', sortOrder: 2 })
+
+      const categories = await categoryService.listAllCategories()
+
+      expect(categories).toHaveLength(3)
+      expect(categories[0].name).toBe('First')
+      expect(categories[1].name).toBe('Second')
+      expect(categories[2].name).toBe('Third')
+    })
+
+    it('should return empty array when no categories', async () => {
+      const categories = await categoryService.listAllCategories()
+
+      expect(categories).toEqual([])
+    })
+  })
+})