@gravito/satellite-catalog 0.1.1

package/src/Interface/Http/Controllers/AdminProductController.ts

@@ -0,0 +1,38 @@
+import type { PlanetCore } from '@gravito/core'
+import type { AdminListProducts } from '../../../Application/UseCases/AdminListProducts'
+
+export class AdminProductController {
+  constructor(private core: PlanetCore) {}
+
+  /**
+   * GET /api/admin/v1/catalog/products
+   */
+  async index(ctx: any) {
+    try {
+      const useCase = this.core.container.make<AdminListProducts>(
+        'catalog.usecase.adminListProducts'
+      )
+      const products = await useCase.execute()
+
+      return ctx.json(
+        products.map((p: any) => ({
+          id: p.id,
+          name: p.name,
+          price: (p as any).props.price,
+          stock: (p as any).props.stock,
+          status: (p as any).props.status || 'active',
+        }))
+      )
+    } catch (error: any) {
+      return ctx.json({ message: error.message }, 500)
+    }
+  }
+
+  /**
+   * PATCH /api/admin/v1/catalog/products/:id
+   */
+  async update(ctx: any) {
+    // 實作略，預留接口
+    return ctx.json({ success: true })
+  }
+}

package/src/Interface/Http/Controllers/CategoryController.ts

@@ -0,0 +1,20 @@
+import type { GravitoContext } from '@gravito/core'
+import { CategoryMapper } from '../../../Application/DTOs/CategoryDTO'
+import type { ICategoryRepository } from '../../../Domain/Contracts/ICatalogRepository'
+
+export class CategoryController {
+  /**
+   * Get the category tree
+   */
+  async index(c: GravitoContext) {
+    const core = c.get('core' as any) as any
+    const repo = core.container.make('catalog.repo.category') as ICategoryRepository
+
+    const categories = await repo.findAll()
+    const dtos = categories.map((cat) => CategoryMapper.toDTO(cat))
+
+    return c.json({
+      data: CategoryMapper.buildTree(dtos),
+    })
+  }
+}

package/src/Interface/Http/Controllers/ProductController.ts

@@ -0,0 +1,56 @@
+import type { GravitoContext } from '@gravito/core'
+import { ProductMapper } from '../../../Application/DTOs/ProductDTO'
+import type { CreateProduct } from '../../../Application/UseCases/CreateProduct'
+import type { IProductRepository } from '../../../Domain/Contracts/ICatalogRepository'
+
+export class ProductController {
+  /**
+   * List all products
+   */
+  async index(c: GravitoContext) {
+    const core = c.get('core' as any) as any
+    const repo = core.container.make('catalog.repo.product') as IProductRepository
+
+    const products = await repo.findAll()
+    return c.json({
+      data: products.map((p) => ProductMapper.toDTO(p)),
+    })
+  }
+
+  /**
+   * Get a single product details
+   */
+  async show(c: GravitoContext) {
+    const id = c.req.param('id') as string
+    const core = c.get('core' as any) as any
+    const repo = core.container.make('catalog.repo.product') as IProductRepository
+
+    const product = await repo.findById(id)
+    if (!product) {
+      return c.json({ error: 'Product not found' }, 404)
+    }
+
+    return c.json({
+      data: ProductMapper.toDTO(product),
+    })
+  }
+
+  /**
+   * Create a new product (Admin Only)
+   */
+  async store(c: GravitoContext) {
+    const core = c.get('core' as any) as any
+    const useCase = core.container.make('catalog.create-product') as CreateProduct
+
+    const body = (await c.req.json()) as any
+    const productDTO = await useCase.execute(body)
+
+    return c.json(
+      {
+        message: 'Product created successfully',
+        data: productDTO,
+      },
+      201
+    )
+  }
+}

package/src/index.ts

@@ -0,0 +1,62 @@
+import { type Container, ServiceProvider } from '@gravito/core'
+import { AdminListProducts } from './Application/UseCases/AdminListProducts'
+import { RecoverStock } from './Application/UseCases/RecoverStock'
+import { AtlasProductRepository } from './Infrastructure/Persistence/AtlasProductRepository'
+import { AdminProductController } from './Interface/Http/Controllers/AdminProductController'
+
+export class CatalogServiceProvider extends ServiceProvider {
+  register(container: Container): void {
+    container.singleton('catalog.repository.product', () => new AtlasProductRepository())
+    container.singleton('catalog.stock.recover', () => new RecoverStock())
+    container.bind(
+      'catalog.usecase.adminListProducts',
+      () => new AdminListProducts(container.make('catalog.repository.product'))
+    )
+    container.singleton(
+      'catalog.controller.adminProduct',
+      () => new AdminProductController(this.core!)
+    )
+  }
+
+  override boot(): void {
+    const core = this.core
+    if (!core) {
+      return
+    }
+
+    core.logger.info('🛰️ Satellite Catalog is operational')
+
+    const adminProductCtrl = core.container.make<AdminProductController>(
+      'catalog.controller.adminProduct'
+    )
+
+    // 管理端 API
+    core.router.prefix('/api/admin/v1/catalog').group((router) => {
+      router.get('/products', (ctx) => adminProductCtrl.index(ctx))
+      router.patch('/products/:id', (ctx) => adminProductCtrl.update(ctx))
+    })
+
+    /**
+     * GASS 聯動：監聽退款成功，自動恢復庫存
+     */
+    core.hooks.addAction(
+      'payment:refund:succeeded',
+      async (payload: { orderId: string; items: any[] }) => {
+        const recoverStock = core.container.make<RecoverStock>('catalog.stock.recover')
+
+        try {
+          // payload.items 應包含變體 ID 與數量
+          for (const item of payload.items) {
+            await recoverStock.execute({
+              variantId: item.variantId,
+              quantity: item.quantity,
+            })
+          }
+          core.logger.info(`[Catalog] Inventory closure completed for order: ${payload.orderId}`)
+        } catch (error: any) {
+          core.logger.error(`[Catalog] Failed to recover stock: ${error.message}`)
+        }
+      }
+    )
+  }
+}

package/src/manifest.json

@@ -0,0 +1,15 @@
+{
+  "name": "catalog",
+  "id": "catalog",
+  "version": "0.1.0",
+  "description": "A Gravito Satellite",
+  "capabilities": [
+    "create-catalog"
+  ],
+  "requirements": [
+    "cache"
+  ],
+  "hooks": [
+    "catalog:created"
+  ]
+}

package/tests/entities.test.ts

@@ -0,0 +1,71 @@
+import { describe, expect, it } from 'bun:test'
+import { CategoryMapper } from '../src/Application/DTOs/CategoryDTO'
+import { Category } from '../src/Domain/Entities/Category'
+import { Product, Variant } from '../src/Domain/Entities/Product'
+
+describe('Catalog Domain Entities', () => {
+  describe('Category Tree Logic', () => {
+    it('應該能正確計算分類路徑', () => {
+      const root = Category.create('c1', { zh: '男裝' }, 'men')
+      root.updatePath(null)
+      expect(root.path).toBe('men')
+
+      const sub = Category.create('c2', { zh: '上衣' }, 'tops', root.id)
+      sub.updatePath(root.path)
+      expect(sub.path).toBe('men/tops')
+
+      const leaf = Category.create('c3', { zh: '襯衫' }, 'shirts', sub.id)
+      leaf.updatePath(sub.path)
+      expect(leaf.path).toBe('men/tops/shirts')
+    })
+
+    it('CategoryMapper 應該能將扁平數據轉換為樹狀結構', () => {
+      const flatCategories = [
+        { id: '1', parentId: null, path: 'a', name: { zh: 'A' }, slug: 'a', sortOrder: 1 },
+        { id: '2', parentId: '1', path: 'a/b', name: { zh: 'B' }, slug: 'b', sortOrder: 1 },
+        { id: '3', parentId: '2', path: 'a/b/c', name: { zh: 'C' }, slug: 'c', sortOrder: 1 },
+        { id: '4', parentId: null, path: 'd', name: { zh: 'D' }, slug: 'd', sortOrder: 2 },
+      ]
+
+      const tree = CategoryMapper.buildTree(flatCategories as any)
+
+      expect(tree.length).toBe(2) // A 和 D
+      expect(tree[0].id).toBe('1')
+      expect(tree[0].children?.length).toBe(1) // B
+      expect(tree[0].children?.[0].children?.length).toBe(1) // C
+      expect(tree[1].id).toBe('4')
+    })
+  })
+
+  describe('Product & Variant Logic', () => {
+    it('變體應該能正確扣減庫存', () => {
+      const variant = new Variant('v1', {
+        productId: 'p1',
+        sku: 'TSHIRT-RED-L',
+        name: '紅色 L 號',
+        price: 500,
+        compareAtPrice: 600,
+        stock: 10,
+        options: { color: 'Red', size: 'L' },
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      })
+
+      variant.reduceStock(3)
+      expect(variant.stock).toBe(7)
+
+      expect(() => variant.reduceStock(10)).toThrow('Insufficient stock')
+    })
+
+    it('商品應該能正確管理變體與分類', () => {
+      const product = Product.create('p1', { zh: '極簡 T-Shirt' }, 'minimal-tshirt')
+
+      product.assignToCategory('c1')
+      expect(product.categoryIds).toContain('c1')
+
+      const variant = new Variant('v1', { productId: product.id } as any)
+      product.addVariant(variant)
+      expect(product.variants.length).toBe(1)
+    })
+  })
+})

package/tests/grand-review.ts

@@ -0,0 +1,129 @@
+import { expect } from 'bun:test'
+import { DB } from '@gravito/atlas'
+import { PlanetCore, setApp } from '@gravito/core'
+import { CategoryMapper } from '../src/Application/DTOs/CategoryDTO'
+import type { CreateProduct } from '../src/Application/UseCases/CreateProduct'
+import type { UpdateCategory } from '../src/Application/UseCases/UpdateCategory'
+import { CatalogServiceProvider } from '../src/index'
+
+/**
+ * 🛰️ Gravito Catalog "Grand Review"
+ */
+async function grandReview() {
+  console.log('\n🚀 [Grand Review] 啟動 Catalog 全系統校閱流程...')
+
+  // 1. 初始化核心
+  const core = await PlanetCore.boot({
+    config: {
+      APP_NAME: 'Catalog Review',
+      'database.default': 'sqlite',
+      'database.connections.sqlite': {
+        driver: 'sqlite',
+        database: ':memory:',
+      },
+    },
+  })
+
+  setApp(core)
+
+  // 2. 初始化 Atlas 與 資料表
+  DB.addConnection('default', { driver: 'sqlite', database: ':memory:' })
+
+  console.log('📦 [Database] 正在建立資料表...')
+  const migration = await import(
+    '../src/Infrastructure/Persistence/Migrations/20250101_create_catalog_tables'
+  )
+  await migration.default.up()
+
+  // 3. 註冊與啟動插件
+  await core.use(new CatalogServiceProvider())
+  await core.bootstrap()
+
+  const categoryRepo = core.container.make<any>('catalog.repo.category')
+  const createProduct = core.container.make<CreateProduct>('catalog.create-product')
+  const updateCategory = core.container.make<UpdateCategory>('catalog.update-category')
+
+  // --- 測試案例 A: 建立分類樹 ---
+  console.log('\n🧪 [Test A] 建立階層式分類...')
+  const { Category } = await import('../src/Domain/Entities/Category')
+
+  const men = Category.create('c1', { zh: '男裝' }, 'men')
+  men.updatePath(null)
+  await categoryRepo.save(men)
+
+  const tops = Category.create('c2', { zh: '上衣' }, 'tops', men.id)
+  tops.updatePath(men.path)
+  await categoryRepo.save(tops)
+
+  console.log(`✅ 分類已建立: ${tops.path}`) // 預期 men/tops
+
+  // --- 測試案例 B: 建立商品與多個 SKU ---
+  console.log('\n🧪 [Test B] 原子化建立商品與 SKU...')
+  const product = await createProduct.execute({
+    name: { zh: '經典棉質 T-Shirt' },
+    slug: 'classic-cotton-tshirt',
+    brand: 'Gravito Wear',
+    categoryIds: [tops.id],
+    variants: [
+      {
+        sku: 'TS-WHT-M',
+        name: '白色 / M',
+        price: 590,
+        stock: 100,
+        options: { color: 'White', size: 'M' },
+      },
+      {
+        sku: 'TS-BLK-L',
+        name: '黑色 / L',
+        price: 650,
+        stock: 50,
+        options: { color: 'Black', size: 'L' },
+      },
+    ],
+  })
+
+  console.log(`✅ 商品已建立: ${product.name.zh}, SKU 數量: ${product.variants.length}`)
+  console.log(`💰 SKU 1 價格: ${product.variants[0].price}, 庫存: ${product.variants[0].stock}`)
+
+  // --- 測試案例 C: 分類移動與路徑同步 (最難的部分) ---
+  console.log('\n🧪 [Test C] 測試分類移動與子孫路徑同步...')
+  // 建立一個新根分類 "特價"
+  const sale = Category.create('c4', { zh: '特價區' }, 'sale')
+  sale.updatePath(null)
+  await categoryRepo.save(sale)
+
+  // 將 "男裝" (men) 移動到 "特價區" (sale) 下面
+  await updateCategory.execute({
+    id: men.id,
+    parentId: sale.id,
+  })
+
+  // 驗證 "上衣" (tops) 的路徑是否自動更新為 sale/men/tops
+  const updatedTops = await categoryRepo.findById(tops.id)
+  console.log(`🔄 移動後 "上衣" 的新路徑: \x1b[32m${updatedTops.path}\x1b[0m`)
+
+  if (updatedTops.path === 'sale/men/tops') {
+    console.log('✅ [Pass] 路徑自動同步成功！')
+  } else {
+    throw new Error(`[Fail] 路徑同步失敗，收到: ${updatedTops.path}`)
+  }
+
+  // --- 測試案例 D: 樹狀結構輸出 ---
+  console.log('\n🧪 [Test D] 驗證樹狀結構輸出...')
+  const allFlat = await categoryRepo.findAll()
+  const tree = CategoryMapper.buildTree(allFlat.map((c: any) => CategoryMapper.toDTO(c)))
+  console.log(
+    '🌲 分類樹頂層節點:',
+    tree.map((t) => t.slug)
+  )
+  expect(tree[0].slug).toBe('sale')
+  expect(tree[0].children?.[0].slug).toBe('men')
+
+  console.log('\n🏁 [Grand Review] Catalog 校閱完成！')
+  process.exit(0)
+}
+
+grandReview().catch((err) => {
+  console.error('💥 校閱失敗:', err)
+  process.exit(1)
+})

package/tests/unit.test.ts

@@ -0,0 +1,7 @@
+import { describe, expect, it } from 'bun:test'
+
+describe('Catalog', () => {
+  it('should work', () => {
+    expect(true).toBe(true)
+  })
+})

package/tsconfig.json

@@ -0,0 +1,26 @@
+{
+    "extends": "../../tsconfig.json",
+    "compilerOptions": {
+        "outDir": "./dist",
+        "baseUrl": ".",
+        "paths": {
+            "@gravito/core": [
+                "../../packages/core/src/index.ts"
+            ],
+            "@gravito/*": [
+                "../../packages/*/src/index.ts"
+            ]
+        },
+        "types": [
+            "bun-types"
+        ]
+    },
+    "include": [
+        "src/**/*"
+    ],
+    "exclude": [
+        "node_modules",
+        "dist",
+        "**/*.test.ts"
+    ]
+}