@gt6/sdk 1.0.4 → 1.0.6

package/README.md

@@ -10,6 +10,42 @@ npm install @gt6/sdk
 
 ## 快速开始
 
+### 基础配置
+
+```typescript
+import { GT6SDK } from '@gt6/sdk';
+
+const sdk = new GT6SDK({
+  baseUrl: 'https://data.shopasb.io',
+  platformId: '1747558688',
+  // 文章相关配置
+  rootCategoryId: '969287034',  // 文章根分类ID
+  tagAlias: '002',              // 文章标签别名
+  // 产品相关配置
+  productRootCategoryId: '277233', // 产品根分类ID
+  productTagAlias: '01',           // 产品标签别名
+  // 缓存配置
+  cache: {
+    enabled: true,
+    ttl: 300000 // 5分钟
+  }
+});
+```
+
+### 配置选项
+
+| 字段 | 类型 | 必需 | 默认值 | 描述 |
+|------|------|------|--------|------|
+| `baseUrl` | string | ✅ | - | API 基础URL |
+| `platformId` | string \| number | ✅ | - | 平台ID |
+| `rootCategoryId` | string \| number | ❌ | '671920' | 文章根分类ID |
+| `tagAlias` | string | ❌ | '001' | 文章标签别名 |
+| `productRootCategoryId` | string \| number | ❌ | '277233' | 产品根分类ID |
+| `productTagAlias` | string | ❌ | '01' | 产品标签别名 |
+| `timeout` | number | ❌ | 10000 | 请求超时时间（毫秒） |
+| `cache.enabled` | boolean | ❌ | true | 是否启用缓存 |
+| `cache.ttl` | number | ❌ | 300000 | 缓存时间（毫秒） |
+
 ### 基本使用
 
 ```typescript
@@ -18,9 +54,15 @@ import { GT6SDK } from '@gt6/sdk';
 // 初始化SDK
 const sdk = new GT6SDK({
   baseUrl: 'https://data.shopasb.io',
-  platformId: '1750838492',
-  rootCategoryId: '671920', // 可选，默认为671920
-  tagAlias: '001' // 可选，默认为001
+  platformId: '1747558688',
+  rootCategoryId: '969287034', // 可选，默认为671920
+  tagAlias: '002', // 可选，默认为001
+  productRootCategoryId: '277233',
+  productTagAlias: '01',
+  cache: {
+    enabled: true,
+    ttl: 300000
+  }
 });
 
 // 获取文章详情
@@ -40,7 +82,7 @@ const categoryArticles = await sdk.getArticlesByCategory(782714);
 console.log(`分类文章总数: ${categoryArticles.total}`);
 
 // 根据标签获取文章
-const tagArticles = await sdk.getArticlesByTag(136424);
+const tagArticles = await sdk.getArticlesByTag(236656846);
 console.log(`标签文章总数: ${tagArticles.total}`);
 
 // 获取分类层级路径
@@ -59,7 +101,7 @@ console.log(`子分类数量: ${subCategories.total}`);
 const categoryArticles = await sdk.getArticlesByCategory(782714);
 
 // 按标签获取文章
-const tagArticles = await sdk.getArticlesByTag(136424);
+const tagArticles = await sdk.getArticlesByTag(236656846);
 
 // 获取分类层级路径（用于面包屑导航）
 const categoryPath = await sdk.getCategoryPath(782714);
@@ -92,7 +134,15 @@ import { GT6SDK } from '@gt6/sdk';
 
 const sdk = new GT6SDK({
   baseUrl: 'https://data.shopasb.io',
-  platformId: '1750838492'
+  platformId: '1747558688',
+  rootCategoryId: '969287034',
+  tagAlias: '002',
+  productRootCategoryId: '277233',
+  productTagAlias: '01',
+  cache: {
+    enabled: true,
+    ttl: 300000
+  }
 });
 
 const { id } = Astro.params;
@@ -118,21 +168,127 @@ const recommended = await sdk.articles.getRecommendedArticles(Number(id), 3);
 </html>
 ```
 
-### 面包屑导航使用示例
+## API 参考
 
-#### 基本面包屑导航
+### GT6SDK 类
+
+#### 构造函数
 
 ```typescript
-// 获取分类层级路径
-const categoryPath = await sdk.getCategoryPath(782714);
+new GT6SDK(config: GT6Config)
+```
+
+**配置参数:**
 
-// 输出面包屑数据
-console.log('当前分类:', categoryPath.currentCategory?.categoryName);
-console.log('完整路径:', categoryPath.path.map(cat => cat.categoryName).join(' > '));
+- `baseUrl` (string): API基础URL
+- `platformId` (string | number): 平台ID
+- `rootCategoryId` (string | number, 可选): 根分类ID，默认为'671920'
+- `tagAlias` (string, 可选): 标签别名，默认为'001'
+- `timeout` (number, 可选): 请求超时时间，默认为10000ms
+- `cache` (object, 可选): 缓存配置
+  - `enabled` (boolean): 是否启用缓存，默认为true
+  - `ttl` (number): 缓存时间，默认为300000ms (5分钟)
+
+#### 便捷方法
+
+- `getArticle(articleId: number | string): Promise<Article>`
+- `getCategories(rootCategoryId?: number | string): Promise<Category[]>`
+- `getTags(tagAlias?: string): Promise<Tag[]>`
+- `getArticlesByCategory(categoryId: number | number[], options?: ArticlesByCategoryOptions): Promise<{ articles: Article[]; total: number; page: number; limit: number }>`
+- `getArticlesByTag(tagId: number | number[], options?: ArticlesByTagOptions): Promise<{ articles: Article[]; total: number; page: number; limit: number }>`
+- `getCategoryPath(categoryId: number): Promise<{ path: Category[]; currentCategory: Category | null; breadcrumbs: Array<{ categoryId: number; categoryName: string; level: number }> }>`
+- `getSubCategories(categoryId: number, options?: { recursive?: boolean; includeCurrent?: boolean; maxDepth?: number }): Promise<{ subCategories: Category[]; currentCategory: Category | null; total: number; depth: number }>`
+
+#### 缓存管理
+
+- `clearCache(): void` - 清除所有缓存
+- `getCacheStats()` - 获取缓存统计信息
+
+### ArticlesAPI 类
+
+#### 文章相关方法
+
+- `getArticle(articleId: number | string): Promise<Article>`
+- `getArticles(params?: ArticleQueryParams): Promise<Article[]>`
+- `getArticleList(params?: ArticleQueryParams): Promise<ArticleListItem[]>`
+- `getArticlesByCategory(categoryId: number | number[], options?: ArticlesByCategoryOptions): Promise<{ articles: Article[]; total: number; page: number; limit: number }>`
+- `getArticlesByTag(tagId: number | number[], options?: ArticlesByTagOptions): Promise<{ articles: Article[]; total: number; page: number; limit: number }>`
+- `getCategoryPath(categoryId: number): Promise<{ path: Category[]; currentCategory: Category | null; breadcrumbs: Array<{ categoryId: number; categoryName: string; level: number }> }>`
+- `getSubCategories(categoryId: number, options?: { recursive?: boolean; includeCurrent?: boolean; maxDepth?: number }): Promise<{ subCategories: Category[]; currentCategory: Category | null; total: number; depth: number }>`
+- `getPublishedArticles(params?: Omit<ArticleQueryParams, 'status'>): Promise<Article[]>`
+- `searchArticles(query: string, params?: ArticleQueryParams): Promise<Article[]>`
+- `getRecommendedArticles(articleId: number, limit?: number): Promise<Article[]>`
+
+#### 分类和标签方法
+
+- `getCategories(rootCategoryId?: number | string): Promise<Category[]>`
+- `getTags(tagAlias?: string): Promise<Tag[]>`
+
+#### 统计方法
+
+- `getArticleStats(): Promise<ArticleStats>`
+
+## 使用示例
+
+### 根据分类获取文章
+
+```typescript
+// 获取单个分类的文章
+const result = await sdk.getArticlesByCategory(782714);
+console.log(`分类文章总数: ${result.total}`);
+console.log(`返回文章数: ${result.articles.length}`);
+
+// 获取多个分类的文章（去重）
+const multiResult = await sdk.getArticlesByCategory([782714, 821172]);
+console.log(`多分类文章总数: ${multiResult.total}`);
+
+// 使用分页和状态过滤
+const paginatedResult = await sdk.getArticlesByCategory(782714, {
+  page: 1,
+  limit: 10,
+  status: 'published'
+});
+```
+
+### 根据标签获取文章
+
+```typescript
+// 获取单个标签的文章
+const result = await sdk.getArticlesByTag(236656846);
+console.log(`标签文章总数: ${result.total}`);
+
+// 获取多个标签的文章（去重）
+const multiResult = await sdk.getArticlesByTag([236656846, 497329737]);
+console.log(`多标签文章总数: ${multiResult.total}`);
+
+// 使用分页和状态过滤
+const paginatedResult = await sdk.getArticlesByTag(236656846, {
+  page: 1,
+  limit: 10,
+  status: 'published'
+});
+
+// 指定标签别名获取文章
+const customTagResult = await sdk.getArticlesByTag(236656846, {
+  tagAlias: '002', // 使用自定义标签别名
+  limit: 10,
+  status: 'published'
+});
+```
+
+### 获取分类层级路径（面包屑导航）
+
+```typescript
+// 获取分类的完整层级路径
+const pathResult = await sdk.getCategoryPath(821172);
+
+// 输出面包屑导航数据
+console.log('当前分类:', pathResult.currentCategory?.categoryName);
+console.log('完整路径:', pathResult.path.map(cat => cat.categoryName).join(' > '));
 
 // 前端面包屑导航使用
-categoryPath.breadcrumbs.forEach((crumb, index) => {
-  if (index < categoryPath.breadcrumbs.length - 1) {
+pathResult.breadcrumbs.forEach((crumb, index) => {
+  if (index < pathResult.breadcrumbs.length - 1) {
     console.log(`<a href="/category/${crumb.categoryId}">${crumb.categoryName}</a> >`);
   } else {
     console.log(`<span>${crumb.categoryName}</span>`);
@@ -140,56 +296,37 @@ categoryPath.breadcrumbs.forEach((crumb, index) => {
 });
 ```
 
-#### 在Astro中使用面包屑导航
+### 获取子分类
 
-```astro
----
-// [categoryId]-[pageId].astro
-import { GT6SDK } from '@gt6/sdk';
+```typescript
+// 获取直接子分类
+const result = await sdk.getSubCategories(671920);
+console.log(`子分类数量: ${result.total}`);
+console.log(`递归深度: ${result.depth}`);
 
-const { categoryId, pageId } = Astro.params;
-const sdk = new GT6SDK({ 
-  baseUrl: 'https://data.shopasb.io', 
-  platformId: '1750838492' 
+// 递归获取所有层级的子分类
+const recursiveResult = await sdk.getSubCategories(671920, { 
+  recursive: true 
 });
+console.log(`所有子分类数量: ${recursiveResult.total}`);
 
-// 获取分类层级路径
-const categoryPath = await sdk.getCategoryPath(parseInt(categoryId));
-const currentCategory = categoryPath.currentCategory;
----
+// 包含当前分类
+const includeCurrentResult = await sdk.getSubCategories(671920, { 
+  includeCurrent: true 
+});
+console.log(`包含当前分类的总数量: ${includeCurrentResult.total}`);
 
-<html>
-  <head>
-    <title>{currentCategory?.categoryName} - GT6TRADE</title>
-  </head>
-  <body>
-    <!-- 面包屑导航 -->
-    <nav aria-label="面包屑导航" class="mb-3">
-      <ol class="breadcrumb justify-content-center">
-        <li class="breadcrumb-item">
-          <a href="/" class="text-decoration-none">首页</a>
-        </li>
-        {categoryPath.breadcrumbs.map((crumb, index) => (
-          <li class={`breadcrumb-item ${index === categoryPath.breadcrumbs.length - 1 ? 'active' : ''}`}>
-            {index === categoryPath.breadcrumbs.length - 1 ? (
-              <span>{crumb.categoryName}</span>
-            ) : (
-              <a href={`/postlist/${crumb.categoryId}-1`} class="text-decoration-none">
-                {crumb.categoryName}
-              </a>
-            )}
-          </li>
-        ))}
-      </ol>
-    </nav>
-    
-    <h1>{currentCategory?.categoryName}</h1>
-    <!-- 其他内容 -->
-  </body>
-</html>
+// 限制递归深度
+const limitedResult = await sdk.getSubCategories(671920, { 
+  recursive: true, 
+  maxDepth: 2 
+});
+console.log(`限制深度后的子分类数量: ${limitedResult.total}`);
 ```
 
-#### 面包屑导航组件
+## 在Astro中使用
+
+### 面包屑导航组件
 
 ```astro
 ---
@@ -202,7 +339,15 @@ export interface Props {
 const { categoryId, currentPage = 1 } = Astro.props;
 const sdk = new GT6SDK({ 
   baseUrl: 'https://data.shopasb.io', 
-  platformId: '1750838492' 
+  platformId: '1747558688', 
+  rootCategoryId: '969287034',
+  tagAlias: '002',
+  productRootCategoryId: '277233',
+  productTagAlias: '01',
+  cache: {
+    enabled: true,
+    ttl: 300000
+  }
 });
 const categoryPath = await sdk.getCategoryPath(categoryId);
 ---
@@ -251,7 +396,7 @@ const categoryPath = await sdk.getCategoryPath(categoryId);
 </style>
 ```
 
-#### 标签面包屑导航组件
+### 标签面包屑导航组件
 
 ```astro
 ---
@@ -269,13 +414,21 @@ const {
   currentPage = 1, 
   baseUrl = 'https://data.shopasb.io',
   platformId = '1747558688',
-  rootCategoryId = '969287034'
+  rootCategoryId = '969287034',
+  productRootCategoryId = '277233',
+  productTagAlias = '01'
 } = Astro.props;
 
 const sdk = new GT6SDK({ 
   baseUrl, 
   platformId, 
-  rootCategoryId 
+  rootCategoryId,
+  productRootCategoryId,
+  productTagAlias,
+  cache: {
+    enabled: true,
+    ttl: 300000
+  }
 });
 const tags = await sdk.getTags();
 const currentTag = tags.find(tag => tag.tagId === tagId);
@@ -336,44 +489,67 @@ const currentTag = tags.find(tag => tag.tagId === tagId);
 </style>
 ```
 
-#### 在文章详情页使用面包屑导航
+### 分类列表页面
 
 ```astro
 ---
-// [articleId].astro
+// [categoryId]-[pageId].astro
 import { GT6SDK } from '@gt6/sdk';
 import Breadcrumb from '../components/Breadcrumb.astro';
 
-const { articleId } = Astro.params;
+const { categoryId, pageId } = Astro.params;
 const sdk = new GT6SDK({ 
   baseUrl: 'https://data.shopasb.io', 
-  platformId: '1750838492' 
+  platformId: '1747558688', 
+  rootCategoryId: '969287034',
+  tagAlias: '002',
+  productRootCategoryId: '277233',
+  productTagAlias: '01',
+  cache: {
+    enabled: true,
+    ttl: 300000
+  }
 });
 
-const article = await sdk.getArticle(articleId);
-// 假设文章属于第一个分类
-const firstCategoryId = article.categories?.[0]?.categoryId;
-const categoryPath = firstCategoryId ? await sdk.getCategoryPath(firstCategoryId) : null;
+const currentPage = parseInt(pageId);
+const categoryArticles = await sdk.getArticlesByCategory(parseInt(categoryId), {
+  page: currentPage,
+  limit: 9,
+  status: 'published'
+});
+
+const categoryPath = await sdk.getCategoryPath(parseInt(categoryId));
+const currentCategory = categoryPath.currentCategory;
 ---
 
 <html>
   <head>
-    <title>{article.title} - GT6TRADE</title>
+    <title>{currentCategory?.categoryName} - GT6TRADE</title>
   </head>
   <body>
-    {categoryPath && (
-      <Breadcrumb categoryId={firstCategoryId} />
-    )}
+    <Breadcrumb 
+      categoryId={parseInt(categoryId)} 
+      currentPage={currentPage}
+    />
     
-    <article>
-      <h1>{article.title}</h1>
-      <div set:html={article.content}></div>
-    </article>
+    <section>
+      <h1>{currentCategory?.categoryName}</h1>
+      <p>共 {categoryArticles.total} 篇文章</p>
+      
+      <div class="articles">
+        {categoryArticles.articles.map(article => (
+          <article>
+            <h2><a href={`/post/${article.articleId}`}>{article.title}</a></h2>
+            <p>{article.content.substring(0, 200)}...</p>
+          </article>
+        ))}
+      </div>
+    </section>
   </body>
 </html>
 ```
 
-#### 在标签列表页使用面包屑导航
+### 标签列表页面
 
 ```astro
 ---
@@ -384,20 +560,32 @@ import TagBreadcrumb from '../components/TagBreadcrumb.astro';
 const { tagId, pageId } = Astro.params;
 const sdk = new GT6SDK({ 
   baseUrl: 'https://data.shopasb.io', 
-  platformId: '1750838492' 
+  platformId: '1747558688', 
+  rootCategoryId: '969287034',
+  tagAlias: '002',
+  productRootCategoryId: '277233',
+  productTagAlias: '01',
+  cache: {
+    enabled: true,
+    ttl: 300000
+  }
 });
 
 const currentPage = parseInt(pageId);
 const tagArticles = await sdk.getArticlesByTag(parseInt(tagId), {
   page: currentPage,
   limit: 9,
-  status: 'published'
+  status: 'published',
+  tagAlias: '002'
 });
+
+const tags = await sdk.getTags('002');
+const currentTag = tags.find(tag => tag.tagId === parseInt(tagId));
 ---
 
 <html>
   <head>
-    <title>标签文章 - GT6TRADE</title>
+    <title>{currentTag?.tagName} - GT6TRADE</title>
   </head>
   <body>
     <TagBreadcrumb 
@@ -406,7 +594,9 @@ const tagArticles = await sdk.getArticlesByTag(parseInt(tagId), {
     />
     
     <section>
-      <h1>标签文章列表</h1>
+      <h1>{currentTag?.tagName}</h1>
+      <p>共 {tagArticles.total} 篇文章</p>
+      
       <div class="articles">
         {tagArticles.articles.map(article => (
           <article>
@@ -420,219 +610,6 @@ const tagArticles = await sdk.getArticlesByTag(parseInt(tagId), {
 </html>
 ```
 
-### 新方法使用示例
-
-#### 根据分类获取文章
-
-```typescript
-// 获取单个分类的文章
-const result = await sdk.getArticlesByCategory(782714);
-console.log(`分类文章总数: ${result.total}`);
-console.log(`返回文章数: ${result.articles.length}`);
-
-// 获取多个分类的文章（去重）
-const multiResult = await sdk.getArticlesByCategory([782714, 821172]);
-console.log(`多分类文章总数: ${multiResult.total}`);
-
-// 使用分页和状态过滤
-const paginatedResult = await sdk.getArticlesByCategory(782714, {
-  offset: 0,
-  limit: 10,
-  status: 'published'
-});
-```
-
-#### 根据标签获取文章
-
-```typescript
-// 获取单个标签的文章
-const result = await sdk.getArticlesByTag(136424);
-console.log(`标签文章总数: ${result.total}`);
-
-// 获取多个标签的文章（去重）
-const multiResult = await sdk.getArticlesByTag([136424, 136425]);
-console.log(`多标签文章总数: ${multiResult.total}`);
-
-// 使用分页和状态过滤
-const paginatedResult = await sdk.getArticlesByTag(136424, {
-  offset: 0,
-  limit: 10,
-  status: 'published'
-});
-
-// 指定标签别名获取文章
-const customTagResult = await sdk.getArticlesByTag(136424, {
-  tagAlias: 'custom', // 使用自定义标签别名
-  limit: 10,
-  status: 'published'
-});
-```
-
-#### 获取分类层级路径（面包屑导航）
-
-```typescript
-// 获取分类的完整层级路径
-const pathResult = await sdk.getCategoryPath(821172);
-
-// 输出面包屑导航数据
-console.log('当前分类:', pathResult.currentCategory?.categoryName);
-console.log('完整路径:', pathResult.path.map(cat => cat.categoryName).join(' > '));
-
-// 前端面包屑导航使用
-pathResult.breadcrumbs.forEach((crumb, index) => {
-  if (index < pathResult.breadcrumbs.length - 1) {
-    console.log(`<a href="/category/${crumb.categoryId}">${crumb.categoryName}</a> >`);
-  } else {
-    console.log(`<span>${crumb.categoryName}</span>`);
-  }
-});
-```
-
-#### 获取子分类
-
-```typescript
-// 获取直接子分类
-const result = await sdk.getSubCategories(671920);
-console.log(`子分类数量: ${result.total}`);
-console.log(`递归深度: ${result.depth}`);
-
-// 递归获取所有层级的子分类
-const recursiveResult = await sdk.getSubCategories(671920, { 
-  recursive: true 
-});
-console.log(`所有子分类数量: ${recursiveResult.total}`);
-
-// 包含当前分类
-const includeCurrentResult = await sdk.getSubCategories(671920, { 
-  includeCurrent: true 
-});
-console.log(`包含当前分类的总数量: ${includeCurrentResult.total}`);
-
-// 限制递归深度
-const limitedResult = await sdk.getSubCategories(671920, { 
-  recursive: true, 
-  maxDepth: 2 
-});
-console.log(`限制深度后的子分类数量: ${limitedResult.total}`);
-```
-
-#### 在Astro中使用面包屑导航
-
-```astro
----
-// Breadcrumb.astro
-import { GT6SDK } from '@gt6/sdk';
-
-const { categoryId } = Astro.props;
-const sdk = new GT6SDK({ baseUrl: 'https://data.shopasb.io', platformId: '1750838492' });
-const pathResult = await sdk.articles.getCategoryPath(categoryId);
----
-
-<nav class="breadcrumb">
-  <ol>
-    <li><a href="/">首页</a></li>
-    {pathResult.breadcrumbs.map((crumb, index) => (
-      <li>
-        {index === pathResult.breadcrumbs.length - 1 ? (
-          <span>{crumb.categoryName}</span>
-        ) : (
-          <a href={`/category/${crumb.categoryId}`}>{crumb.categoryName}</a>
-        )}
-        {index < pathResult.breadcrumbs.length - 1 && <span> > </span>}
-      </li>
-    ))}
-  </ol>
-</nav>
-```
-
-#### 在Astro中使用分类树导航
-
-```astro
----
-// CategoryTree.astro
-import { GT6SDK } from '@gt6/sdk';
-
-const { categoryId, recursive = false, maxDepth = 3 } = Astro.props;
-const sdk = new GT6SDK({ baseUrl: 'https://data.shopasb.io', platformId: '1750838492' });
-const result = await sdk.articles.getSubCategories(categoryId, { recursive, maxDepth });
----
-
-<div class="category-tree">
-  <h3>{result.currentCategory?.categoryName}</h3>
-  <ul>
-    {result.subCategories.map(category => (
-      <li>
-        <a href={`/category/${category.categoryId}`}>
-          {category.categoryName} ({category.articleIds.length})
-        </a>
-      </li>
-    ))}
-  </ul>
-</div>
-```
-
-## API 参考
-
-### GT6SDK 类
-
-#### 构造函数
-
-```typescript
-new GT6SDK(config: GT6Config)
-```
-
-**配置参数:**
-
-- `baseUrl` (string): API基础URL
-- `platformId` (string | number): 平台ID
-- `rootCategoryId` (string | number, 可选): 根分类ID，默认为'671920'
-- `tagAlias` (string, 可选): 标签别名，默认为'001'
-- `timeout` (number, 可选): 请求超时时间，默认为10000ms
-- `cache` (object, 可选): 缓存配置
-  - `enabled` (boolean): 是否启用缓存，默认为true
-  - `ttl` (number): 缓存时间，默认为300000ms (5分钟)
-
-#### 方法
-
-##### 便捷方法
-
-- `getArticle(articleId: number | string): Promise<Article>`
-- `getCategories(rootCategoryId?: number | string): Promise<Category[]>`
-- `getTags(tagAlias?: string): Promise<Tag[]>`
-- `getArticlesByCategory(categoryId: number | number[], options?: { offset?: number; limit?: number; status?: string }): Promise<{ articles: Article[]; total: number; categoryIds: number[] }>`
-- `getArticlesByTag(tagId: number | number[], options?: { offset?: number; limit?: number; status?: string }): Promise<{ articles: Article[]; total: number; tagIds: number[] }>`
-- `getCategoryPath(categoryId: number): Promise<{ path: Category[]; currentCategory: Category | null; breadcrumbs: Array<{ categoryId: number; categoryName: string; level: number }> }>`
-- `getSubCategories(categoryId: number, options?: { recursive?: boolean; includeCurrent?: boolean; maxDepth?: number }): Promise<{ subCategories: Category[]; currentCategory: Category | null; total: number; depth: number }>`
-
-##### 缓存管理
-
-- `clearCache(): void` - 清除所有缓存
-- `getCacheStats()` - 获取缓存统计信息
-
-### ArticlesAPI 类
-
-#### 文章相关方法
-
-- `getArticle(articleId: number | string): Promise<Article>`
-- `getArticles(params?: ArticleQueryParams): Promise<Article[]>`
-- `getArticleList(params?: ArticleQueryParams): Promise<ArticleListItem[]>`
-- `getArticlesByCategory(categoryId: number | number[], options?: { offset?: number; limit?: number; status?: string }): Promise<{ articles: Article[]; total: number; categoryIds: number[] }>`
-- `getArticlesByTag(tagId: number | number[], options?: { offset?: number; limit?: number; status?: string }): Promise<{ articles: Article[]; total: number; tagIds: number[] }>`
-- `getCategoryPath(categoryId: number): Promise<{ path: Category[]; currentCategory: Category | null; breadcrumbs: Array<{ categoryId: number; categoryName: string; level: number }> }>`
-- `getSubCategories(categoryId: number, options?: { recursive?: boolean; includeCurrent?: boolean; maxDepth?: number }): Promise<{ subCategories: Category[]; currentCategory: Category | null; total: number; depth: number }>`
-- `getPublishedArticles(params?: Omit<ArticleQueryParams, 'status'>): Promise<Article[]>`
-- `searchArticles(query: string, params?: ArticleQueryParams): Promise<Article[]>`
-- `getRecommendedArticles(articleId: number, limit?: number): Promise<Article[]>`
-
-#### 分类和标签方法
-
-- `getCategories(rootCategoryId?: number | string): Promise<Category[]>`
-- `getTags(tagAlias?: string): Promise<Tag[]>`
-
-#### 统计方法
-
-- `getArticleStats(): Promise<ArticleStats>`
-
 ## 数据类型
 
 ### Article (文章)
@@ -692,6 +669,53 @@ interface Tag {
 }
 ```
 
+### 选项类型
+
+```typescript
+interface ArticlesByCategoryOptions {
+  page?: number;
+  limit?: number;
+  status?: 'published' | 'draft' | 'archived';
+}
+
+interface ArticlesByTagOptions {
+  page?: number;
+  limit?: number;
+  status?: 'published' | 'draft' | 'archived';
+  tagAlias?: string;
+}
+
+interface ProductsByCategoryOptions {
+  page?: number;
+  limit?: number;
+  status?: number;
+}
+
+interface ProductsByTagOptions {
+  page?: number;
+  limit?: number;
+  status?: number;
+  productTagAlias?: string;
+}
+```
+
+### 产品选项类型
+
+```typescript
+interface ProductsByCategoryOptions {
+  page?: number;
+  limit?: number;
+  status?: number;
+}
+
+interface ProductsByTagOptions {
+  page?: number;
+  limit?: number;
+  status?: number;
+  productTagAlias?: string;
+}
+```
+
 ## 错误处理
 
 SDK使用自定义的 `GT6Error` 类来处理错误：
@@ -716,7 +740,7 @@ SDK内置缓存机制，默认缓存5分钟：
 ```typescript
 const sdk = new GT6SDK({
   baseUrl: 'https://data.shopasb.io',
-  platformId: '1750838492',
+  platformId: '1747558688',
   cache: {
     enabled: true,
     ttl: 300000 // 5分钟
@@ -759,4 +783,360 @@ npm run type-check
 
 ## 许可证
 
-MIT 
+MIT 
+
+## 产品管理
+
+### 获取产品详情
+
+```typescript
+const product = await sdk.getProduct(424210);
+console.log(product.productName); // "极简不对称设计纯色短袖T恤"
+console.log(product.price); // "30.00"
+
+// 检查产品类型
+if (product.productType === 2) {
+  // 订阅产品
+  console.log(product.subscription?.billingCycleUnit); // "month"
+  console.log(product.subscription?.trialDays); // 5
+} else if (product.productType === 3) {
+  // 批发产品
+  console.log(product.wholesale?.minOrderQuantity); // 最小订购量
+  console.log(product.priceTiers?.length); // 价格层级数量
+} else if (product.productType === 4) {
+  // 众筹产品
+  console.log(product.crowdfunding?.targetAmount); // 目标金额
+  console.log(product.crowdfunding?.currentAmount); // 当前金额
+  console.log(product.rewards?.length); // 奖励数量
+} else if (product.productType === 5) {
+  // 简单理财产品
+  console.log(product.simpleFinance?.interestRate); // 年化收益率
+  console.log(product.simpleFinance?.minInvestment); // 最小投资金额
+  console.log(product.simpleFinance?.investmentPeriod); // 投资期限
+} else {
+  // 普通产品
+  console.log(product.variants.length); // 变体数量
+}
+
+// 税费和运费模板规则自动填充
+// SDK会自动为产品的税费模板和运费模板添加适用的规则
+if (product.taxTemplates && product.taxTemplates.length > 0) {
+  product.taxTemplates.forEach(template => {
+    console.log(`税费模板: ${template.templateName}`);
+    console.log(`默认税率: ${template.defaultTaxRate}%`);
+    if (template.rules && template.rules.length > 0) {
+      console.log(`适用规则数量: ${template.rules.length}`);
+      template.rules.forEach(rule => {
+        console.log(`  区域 ${rule.regionId}: ${rule.taxRate}%`);
+      });
+    }
+  });
+}
+
+if (product.shippingTemplates && product.shippingTemplates.length > 0) {
+  product.shippingTemplates.forEach(template => {
+    console.log(`运费模板: ${template.templateName}`);
+    console.log(`默认运费: ${template.defaultFee}`);
+    if (template.rules && template.rules.length > 0) {
+      console.log(`适用规则数量: ${template.rules.length}`);
+      template.rules.forEach(rule => {
+        console.log(`  区域 ${rule.regionId}: 首${rule.firstUnit}件${rule.firstFee}元，续${rule.additionalUnit}件${rule.additionalFee}元`);
+      });
+    }
+  });
+}
+```
+
+### 获取产品分类列表
+
+```typescript
+const categories = await sdk.getProductCategories();
+console.log(categories.length); // 分类数量
+
+// 或者指定产品根分类ID
+const categories = await sdk.getProductCategories('277233');
+```
+
+### 获取产品标签列表
+
+```typescript
+const tags = await sdk.getProductTags();
+console.log(tags.length); // 标签数量
+
+// 或者指定产品标签别名
+const tags = await sdk.getProductTags('01');
+```
+
+### 根据分类获取产品列表
+
+```typescript
+const result = await sdk.getProductsByCategory(367704, {
+  page: 1,
+  limit: 10,
+  status: 1
+});
+
+console.log(result.products.length); // 产品数量
+console.log(result.total); // 总产品数
+```
+
+### 根据标签获取产品列表
+
+```typescript
+const result = await sdk.getProductsByTag(567515, {
+  page: 1,
+  limit: 10,
+  status: 1,
+  productTagAlias: '01'
+});
+
+console.log(result.products.length); // 产品数量
+console.log(result.total); // 总产品数
+```
+
+### 获取产品分类路径（面包屑导航）
+
+```typescript
+const categoryPath = await sdk.getProductCategoryPath(categoryId);
+console.log(categoryPath.breadcrumbs);
+// [
+//   { categoryId: 277233, categoryName: "中文商品", level: 0 },
+//   { categoryId: 367704, categoryName: "女装", level: 1 },
+//   { categoryId: 907691, categoryName: "T恤", level: 2 }
+// ]
+```
+
+### 获取产品子分类
+
+```typescript
+const subCategories = await sdk.getProductSubCategories(367704, {
+  recursive: true,
+  includeCurrent: false,
+  maxDepth: 2
+});
+
+console.log(subCategories.subCategories.length); // 子分类数量
+```
+
+### 获取税费信息
+
+```typescript
+const taxInfo = await sdk.getTaxInfo();
+console.log('税费模板数量:', taxInfo.templates.length);
+
+taxInfo.templates.forEach(template => {
+  console.log(`模板 ${template.templateId}: ${template.templateName}`);
+  console.log(`  默认税率: ${template.defaultTaxRate}%`);
+  console.log(`  规则数量: ${template.rules.length}`);
+  
+  template.rules.forEach(rule => {
+    console.log(`    区域 ${rule.regionId}: ${rule.taxRate}%`);
+  });
+});
+```
+
+### 获取运费信息
+
+```typescript
+const shippingInfo = await sdk.getShippingInfo();
+console.log('运费模板数量:', shippingInfo.templates.length);
+
+shippingInfo.templates.forEach(template => {
+  console.log(`模板 ${template.templateId}: ${template.templateName}`);
+  console.log(`  默认运费: ${template.defaultFee}`);
+  console.log(`  免运费门槛: ${template.freeShippingLimit}`);
+  console.log(`  规则数量: ${template.rules.length}`);
+  
+  template.rules.forEach(rule => {
+    console.log(`    区域 ${rule.regionId}: 首${rule.firstUnit}件${rule.firstFee}元，续${rule.additionalUnit}件${rule.additionalFee}元`);
+  });
+});
+```
+
+### 获取区域信息
+
+```typescript
+const regionInfo = await sdk.getRegions();
+console.log('区域数量:', regionInfo.regions.length);
+
+// 递归显示区域层级结构
+const displayRegions = (regions: any[], level: number = 0) => {
+  regions.forEach(region => {
+    const indent = '  '.repeat(level);
+    console.log(`${indent}${region.regionName} (${region.regionCode}) - ${region.regionLevel}`);
+    
+    if (region.children && region.children.length > 0) {
+      displayRegions(region.children, level + 1);
+    }
+  });
+};
+
+displayRegions(regionInfo.regions);
+```
+
+### 税费和运费模板规则自动填充
+
+SDK在获取产品详情时会自动为税费模板和运费模板填充适用的规则：
+
+**触发条件：**
+- 产品有销售区域（`regions` 不为空）
+- 产品有税费模板（`taxTemplates` 不为空）或运费模板（`shippingTemplates` 不为空）
+
+**自动填充逻辑：**
+1. 获取平台的所有税费/运费模板和规则
+2. 根据产品的销售区域过滤出适用的规则
+3. 将适用规则添加到对应的模板中
+4. 如果获取模板信息失败，不影响产品详情返回
+
+**示例：**
+```typescript
+const product = await sdk.getProduct(424210);
+
+// 税费模板会自动包含适用区域的规则
+if (product.taxTemplates) {
+  product.taxTemplates.forEach(template => {
+    console.log(`模板: ${template.templateName}`);
+    console.log(`默认税率: ${template.defaultTaxRate}%`);
+    
+    // 自动填充的规则
+    if (template.rules) {
+      template.rules.forEach(rule => {
+        console.log(`区域 ${rule.regionId}: ${rule.taxRate}%`);
+      });
+    }
+  });
+}
+
+// 运费模板会自动包含适用区域的规则
+if (product.shippingTemplates) {
+  product.shippingTemplates.forEach(template => {
+    console.log(`模板: ${template.templateName}`);
+    console.log(`默认运费: ${template.defaultFee}`);
+    
+    // 自动填充的规则
+    if (template.rules) {
+      template.rules.forEach(rule => {
+        console.log(`区域 ${rule.regionId}: 首${rule.firstUnit}件${rule.firstFee}元`);
+      });
+    }
+  });
+}
+```
+
+**注意事项：**
+- 如果产品没有销售区域或模板，不会进行自动填充
+- 如果获取模板信息失败，产品详情仍会正常返回，只是模板中没有规则
+- 自动填充的规则只包含产品可销售区域的规则，确保数据的准确性
+
+### 产品类型说明
+
+- **productType: 1** - 普通产品（包含 variants、options 等）
+- **productType: 2** - 订阅产品（包含 subscription 信息）
+- **productType: 3** - 批发产品（包含 wholesale、priceTiers、variantPrices 信息）
+- **productType: 4** - 众筹产品（包含 crowdfunding、rewards、updates、faqs 信息）
+- **productType: 5** - 简单理财产品（包含 simpleFinance 信息）
+
+### 订阅产品示例
+
+```typescript
+const subscriptionProduct = await sdk.getProduct(305191);
+
+if (subscriptionProduct.subscription) {
+  console.log('订阅周期:', subscriptionProduct.subscription.billingCycleUnit);
+  console.log('试用天数:', subscriptionProduct.subscription.trialDays);
+  console.log('设置费用:', subscriptionProduct.subscription.setupFee);
+  console.log('续费折扣:', subscriptionProduct.subscription.renewalDiscount);
+  console.log('自动续费:', subscriptionProduct.subscription.autoRenew);
+}
+```
+
+### 批发产品示例
+
+```typescript
+const wholesaleProduct = await sdk.getProduct(369374);
+
+if (wholesaleProduct.wholesale) {
+  console.log('最小订购量:', wholesaleProduct.wholesale.minOrderQuantity);
+  console.log('最大订购量:', wholesaleProduct.wholesale.maxOrderQuantity);
+  console.log('允许混合变体:', wholesaleProduct.wholesale.allowMixedVariants);
+  console.log('显示零售价:', wholesaleProduct.wholesale.showRetailPrice);
+  console.log('批发描述:', wholesaleProduct.wholesale.wholesaleDescription);
+  console.log('付款条件:', wholesaleProduct.wholesale.paymentTerms);
+  console.log('运输条件:', wholesaleProduct.wholesale.shippingTerms);
+  
+  // 价格层级
+  console.log('价格层级数量:', wholesaleProduct.priceTiers?.length);
+  wholesaleProduct.priceTiers?.forEach(tier => {
+    console.log(`层级 ${tier.tierId}: ${tier.minQuantity}-${tier.maxQuantity}件, 价格调整: ${tier.priceValue}`);
+  });
+  
+  // 变体价格
+  console.log('变体价格数量:', wholesaleProduct.variantPrices?.length);
+}
+```
+
+### 众筹产品示例
+
+```typescript
+const crowdfundingProduct = await sdk.getProduct(803421);
+
+if (crowdfundingProduct.crowdfunding) {
+  console.log('目标金额:', crowdfundingProduct.crowdfunding.targetAmount);
+  console.log('当前金额:', crowdfundingProduct.crowdfunding.currentAmount);
+  console.log('支持者数量:', crowdfundingProduct.crowdfunding.supporterCount);
+  console.log('最小支持金额:', crowdfundingProduct.crowdfunding.minSupportAmount);
+  console.log('允许超额众筹:', crowdfundingProduct.crowdfunding.allowOverFunding);
+  console.log('超额限制:', crowdfundingProduct.crowdfunding.overFundingLimit);
+  
+  // 众筹进度
+  const progress = (parseFloat(crowdfundingProduct.crowdfunding.currentAmount) / parseFloat(crowdfundingProduct.crowdfunding.targetAmount)) * 100;
+  console.log(`众筹进度: ${progress.toFixed(2)}%`);
+  
+  // 奖励列表
+  console.log('奖励数量:', crowdfundingProduct.rewards?.length);
+  crowdfundingProduct.rewards?.forEach(reward => {
+    console.log(`奖励 ${reward.rewardId}: ${reward.rewardName} - ${reward.rewardAmount}`);
+    console.log(`  已认领: ${reward.rewardClaimed}/${reward.rewardLimit || '无限制'}`);
+  });
+  
+  // 项目更新
+  console.log('项目更新数量:', crowdfundingProduct.updates?.length);
+  crowdfundingProduct.updates?.forEach(update => {
+    console.log(`更新 ${update.updateId}: ${update.updateTitle} (${update.isPublic ? '公开' : '私密'})`);
+  });
+  
+  // FAQ
+  console.log('FAQ数量:', crowdfundingProduct.faqs?.length);
+  crowdfundingProduct.faqs?.forEach(faq => {
+    console.log(`FAQ ${faq.faqId}: ${faq.question}`);
+  });
+}
+```
+
+### 简单理财产品示例
+
+```typescript
+const financeProduct = await sdk.getProduct(249478);
+
+if (financeProduct.simpleFinance) {
+  console.log('年化收益率:', financeProduct.simpleFinance.interestRate + '%');
+  console.log('最小投资金额:', financeProduct.simpleFinance.minInvestment + ' ' + financeProduct.simpleFinance.minInvestmentUnit);
+  console.log('最大投资金额:', financeProduct.simpleFinance.maxInvestment + ' ' + financeProduct.simpleFinance.maxInvestmentUnit);
+  console.log('投资期限:', financeProduct.simpleFinance.investmentPeriod + ' ' + financeProduct.simpleFinance.investmentPeriodUnit);
+  console.log('计息周期:', financeProduct.simpleFinance.calculationPeriod + ' ' + financeProduct.simpleFinance.calculationPeriodUnit);
+  
+  // 计算投资收益示例
+  const investmentAmount = 5000; // 投资金额
+  const interestRate = parseFloat(financeProduct.simpleFinance.interestRate);
+  const investmentPeriod = financeProduct.simpleFinance.investmentPeriod;
+  
+  // 简单年化收益计算
+  const annualReturn = (investmentAmount * interestRate / 100);
+  const totalReturn = annualReturn * investmentPeriod;
+  
+  console.log(`投资 ${investmentAmount} ${financeProduct.simpleFinance.minInvestmentUnit} 的预期收益:`);
+  console.log(`  年化收益: ${annualReturn.toFixed(2)} ${financeProduct.simpleFinance.minInvestmentUnit}`);
+  console.log(`  总收益: ${totalReturn.toFixed(2)} ${financeProduct.simpleFinance.minInvestmentUnit}`);
+  console.log(`  到期金额: ${(investmentAmount + totalReturn).toFixed(2)} ${financeProduct.simpleFinance.minInvestmentUnit}`);
+}
+```