@svton/cli 1.2.1 → 1.2.2

package/templates/apps/mobile/project.config.json.tpl

@@ -0,0 +1,17 @@
+{
+  "miniprogramRoot": "dist/",
+  "projectname": "{{PROJECT_NAME}}",
+  "description": "{{PROJECT_NAME}} 小程序",
+  "appid": "",
+  "setting": {
+    "urlCheck": true,
+    "es6": false,
+    "enhance": false,
+    "compileHotReLoad": false,
+    "postcss": false,
+    "minified": false,
+    "bundle": false,
+    "nodeModules": false
+  },
+  "compileType": "miniprogram"
+}

package/templates/apps/mobile/src/app.config.ts

@@ -0,0 +1,9 @@
+export default defineAppConfig({
+  pages: ['pages/index/index'],
+  window: {
+    backgroundTextStyle: 'light',
+    navigationBarBackgroundColor: '#fff',
+    navigationBarTitleText: '首页',
+    navigationBarTextStyle: 'black',
+  },
+});

package/templates/apps/mobile/src/app.scss

@@ -0,0 +1,4 @@
+page {
+  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
+  background-color: #f5f5f5;
+}

package/templates/apps/mobile/src/app.ts

@@ -0,0 +1,8 @@
+import { PropsWithChildren } from 'react';
+import './app.scss';
+
+function App({ children }: PropsWithChildren) {
+  return children;
+}
+
+export default App;

package/templates/apps/mobile/src/hooks/useAPI.ts

@@ -0,0 +1,285 @@
+/**
+ * Mobile 端 useAPI Hook
+ * 适配 Taro 的 React Hook
+ * 
+ * 类型定义通过 {{ORG_NAME}}/types 扩展 @svton/api-client 的全局类型
+ */
+
+import { useDidShow } from '@tarojs/taro';
+import { useState, useEffect, useRef } from 'react';
+import { usePersistFn } from '@svton/hooks';
+import type { ApiName, ApiParams, ApiResponse } from '@svton/api-client';
+import { apiAsync } from '../services/api';
+// 引入类型定义以启用模块增强
+import '{{ORG_NAME}}/types';
+
+/**
+ * useAPI Hook 配置
+ */
+interface UseAPIConfig {
+  /**
+   * 是否立即加载
+   */
+  immediate?: boolean;
+  /**
+   * 页面显示时是否重新加载
+   */
+  refreshOnShow?: boolean;
+  /**
+   * 成功回调
+   */
+  onSuccess?: (data: any) => void;
+  /**
+   * 错误回调
+   */
+  onError?: (error: Error) => void;
+}
+
+/**
+ * useAPI 返回类型
+ */
+interface UseAPIReturn<K extends ApiName> {
+  data: ApiResponse<K> | null;
+  loading: boolean;
+  error: Error | null;
+  refresh: () => Promise<void>;
+}
+
+export function useAPI<K extends ApiName>(
+  apiName: K,
+  params?: ApiParams<K>,
+  config: UseAPIConfig = {},
+): UseAPIReturn<K> {
+  const { immediate = true, refreshOnShow = false, onSuccess, onError } = config;
+
+  const [data, setData] = useState<ApiResponse<K> | null>(null);
+  const [loading, setLoading] = useState(immediate);
+  const [error, setError] = useState<Error | null>(null);
+  const mountedRef = useRef(true);
+
+  const fetchData = usePersistFn(async () => {
+    if (!mountedRef.current) return;
+
+    setLoading(true);
+    setError(null);
+
+    try {
+      const result = (
+        params !== undefined
+          ? await (apiAsync as any)(apiName, params)
+          : await (apiAsync as any)(apiName)
+      ) as ApiResponse<K>;
+
+      if (mountedRef.current) {
+        setData(result);
+        onSuccess?.(result);
+      }
+    } catch (err: unknown) {
+      if (mountedRef.current) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        setError(error);
+        onError?.(error);
+      }
+    } finally {
+      if (mountedRef.current) {
+        setLoading(false);
+      }
+    }
+  });
+
+  useEffect(() => {
+    if (immediate || params !== undefined) {
+      fetchData();
+    }
+
+    return () => {
+      mountedRef.current = false;
+    };
+  }, [apiName, JSON.stringify(params), fetchData, immediate, params]);
+
+  useDidShow(() => {
+    if (refreshOnShow && data) {
+      fetchData();
+    }
+  });
+
+  return {
+    data,
+    loading,
+    error,
+    refresh: fetchData,
+  };
+}
+
+interface UseMutationReturn<K extends ApiName> {
+  trigger: (params?: ApiParams<K>) => Promise<ApiResponse<K>>;
+  loading: boolean;
+  error: Error | null;
+  data: ApiResponse<K> | null;
+  reset: () => void;
+}
+
+export function useMutation<K extends ApiName>(apiName: K): UseMutationReturn<K> {
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+  const [data, setData] = useState<ApiResponse<K> | null>(null);
+
+  const trigger = async (params?: ApiParams<K>): Promise<ApiResponse<K>> => {
+    setLoading(true);
+    setError(null);
+
+    try {
+      const result = (
+        params !== undefined
+          ? await (apiAsync as any)(apiName, params)
+          : await (apiAsync as any)(apiName)
+      ) as ApiResponse<K>;
+      setData(result);
+      return result;
+    } catch (err: unknown) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      setError(error);
+      throw error;
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  const reset = () => {
+    setLoading(false);
+    setError(null);
+    setData(null);
+  };
+
+  return {
+    trigger,
+    loading,
+    error,
+    data,
+    reset,
+  };
+}
+
+ type ExtractItemType<T> = T extends { items: (infer Item)[] }
+  ? Item
+  : T extends { data: (infer Item)[] }
+    ? Item
+    : T extends Array<infer Item>
+      ? Item
+      : unknown;
+
+ type PaginationParams<T> = T extends void
+  ? { pageSize?: number }
+  : Omit<T, 'page'> & { pageSize?: number };
+
+ interface UsePaginationReturn<TItem> {
+  data: TItem[];
+  loading: boolean;
+  error: Error | null;
+  page: number;
+  hasMore: boolean;
+  loadMore: () => Promise<void>;
+  refresh: () => Promise<void>;
+ }
+
+ export function usePagination<K extends ApiName>(
+  apiName: K,
+  initialParams?: PaginationParams<ApiParams<K>>,
+ ): UsePaginationReturn<ExtractItemType<ApiResponse<K>>> {
+  type ItemType = ExtractItemType<ApiResponse<K>>;
+
+  const [data, setData] = useState<ItemType[]>([]);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+  const [page, setPage] = useState(1);
+  const [hasMore, setHasMore] = useState(true);
+  const pageSize = initialParams?.pageSize || 10;
+
+  const paramsRef = useRef(initialParams);
+  paramsRef.current = initialParams;
+
+  const isFirstRenderRef = useRef(true);
+  const isRefreshingRef = useRef(false);
+
+  const loadMore = usePersistFn(async () => {
+    if (loading || !hasMore) return;
+
+    setLoading(true);
+    setError(null);
+
+    try {
+      const currentPage = isRefreshingRef.current ? 1 : page;
+
+      const paginationParams = {
+        ...(paramsRef.current || {}),
+        page: currentPage,
+        pageSize,
+      };
+
+      const result = await (apiAsync as any)(apiName, paginationParams);
+
+      let newItems: ItemType[] = [];
+      if (result && typeof result === 'object') {
+        if ('items' in result && Array.isArray((result as any).items)) {
+          newItems = (result as any).items as ItemType[];
+        } else if ('data' in result && Array.isArray((result as any).data)) {
+          newItems = (result as any).data as ItemType[];
+        } else if ('items' in (result as any)?.data && Array.isArray((result as any).data?.items)) {
+          newItems = (result as any).data.items as ItemType[];
+        } else if (Array.isArray(result)) {
+          newItems = result as ItemType[];
+        }
+      }
+
+      if (isRefreshingRef.current) {
+        setData(newItems);
+        setPage(2);
+        isRefreshingRef.current = false;
+      } else {
+        setData((prev: ItemType[]) => [...prev, ...newItems]);
+        setPage((p: number) => p + 1);
+      }
+
+      if (newItems.length < pageSize) {
+        setHasMore(false);
+      }
+    } catch (err: unknown) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      setError(error);
+    } finally {
+      setLoading(false);
+    }
+  });
+
+  const refresh = usePersistFn(async () => {
+    isRefreshingRef.current = true;
+    setData([]);
+    setHasMore(true);
+    await loadMore();
+  });
+
+  useEffect(() => {
+    loadMore();
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+
+  useEffect(() => {
+    if (isFirstRenderRef.current) {
+      isFirstRenderRef.current = false;
+      return;
+    }
+
+    refresh();
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [JSON.stringify(initialParams)]);
+
+  return {
+    data,
+    loading,
+    error,
+    page,
+    hasMore,
+    loadMore,
+    refresh,
+  };
+ }

package/templates/apps/mobile/src/pages/index/index.scss

@@ -0,0 +1,7 @@
+.index {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  min-height: 100vh;
+}

package/templates/apps/mobile/src/pages/index/index.tsx

@@ -0,0 +1,49 @@
+import { View } from '@tarojs/components';
+import { useState } from 'react';
+import { usePersistFn, useMount } from '@svton/hooks';
+import { NavBar, StatusBar, Loading, Empty } from '@svton/taro-ui';
+import type { ContentVo } from '{{ORG_NAME}}/types';
+import './index.scss';
+
+export default function Index() {
+  const [loading, setLoading] = useState(true);
+  const [contents, setContents] = useState<ContentVo[]>([]);
+
+  const fetchContents = usePersistFn(async () => {
+    try {
+      setLoading(true);
+      // 这里应该使用 @svton/api-client 的 API
+      // const response = await apiClient.contents.list({ page: 1, pageSize: 10 });
+      // setContents(response.data.list);
+      
+      // 模拟数据
+      await new Promise((resolve) => setTimeout(resolve, 1000));
+      setContents([]);
+    } catch (error) {
+      console.error('获取内容列表失败', error);
+    } finally {
+      setLoading(false);
+    }
+  });
+
+  useMount(() => {
+    fetchContents();
+  });
+
+  return (
+    <View className="index">
+      <StatusBar />
+      <NavBar title="首页" />
+      
+      <View className="content">
+        {loading && <Loading text="加载中..." />}
+        {!loading && contents.length === 0 && <Empty text="暂无内容" />}
+        {!loading && contents.length > 0 && (
+          <View className="content-list">
+            {/* 内容列表 */}
+          </View>
+        )}
+      </View>
+    </View>
+  );
+}

package/templates/apps/mobile/src/services/api.ts

@@ -0,0 +1,155 @@
+/**
+ * Mobile 端 API Client
+ * 使用 @svton/api-client 系统
+ */
+
+import Taro from '@tarojs/taro';
+import { createApiClient, createTokenInterceptor } from '@svton/api-client';
+// 引入类型定义以启用模块增强
+import '{{ORG_NAME}}/types';
+
+// API 基础 URL（从 Taro 配置文件的 defineConstants 中注入）
+// 注意：API_BASE_URL 是一个全局常量，在编译时由 Taro 配置文件注入
+declare const API_BASE_URL: string;
+
+/**
+ * Taro 适配器
+ */
+const taroAdapter = {
+  async request(config: any) {
+    const response = await Taro.request({
+      url: config.url,
+      method: config.method as any,
+      data: config.method === 'GET' ? config.params : config.data,
+      header: config.headers,
+    });
+
+    const result = response.data;
+
+    // 后端统一包装格式：{ code: 200, message: 'success', data: T, ... }
+    if (result && typeof result === 'object' && 'code' in result) {
+      if ((result as any).code !== 200) {
+        const error: any = new Error((result as any).message || 'Request failed');
+        error.code = (result as any).code;
+        error.response = {
+          status: (result as any).code,
+          data: result,
+        };
+        throw error;
+      }
+      return (result as any).data;
+    }
+
+    // 兼容未包装响应
+    return result;
+  },
+};
+
+/**
+ * 刷新 Token
+ */
+let isRefreshing = false;
+let refreshSubscribers: Array<(token: string) => void> = [];
+
+const subscribeTokenRefresh = (cb: (token: string) => void) => {
+  refreshSubscribers.push(cb);
+};
+
+const onRefreshed = (token: string) => {
+  refreshSubscribers.forEach((cb) => cb(token));
+  refreshSubscribers = [];
+};
+
+const refreshAccessToken = async (): Promise<string | null> => {
+  const refreshToken = Taro.getStorageSync('refreshToken');
+  if (!refreshToken) {
+    return null;
+  }
+
+  try {
+    const response = await Taro.request({
+      url: `${API_BASE_URL}/auth/refresh`,
+      method: 'POST',
+      data: { refreshToken },
+      header: {
+        'Content-Type': 'application/json',
+      },
+    });
+
+    const result = response.data as any;
+
+    if (result && result.code === 200 && result.data && result.data.accessToken) {
+      const newToken = result.data.accessToken as string;
+      const newRefreshToken = result.data.refreshToken as string | undefined;
+
+      Taro.setStorageSync('token', newToken);
+      if (newRefreshToken) {
+        Taro.setStorageSync('refreshToken', newRefreshToken);
+      }
+
+      return newToken;
+    }
+
+    return null;
+  } catch {
+    return null;
+  }
+};
+
+/**
+ * Token 刷新拦截器（错误处理）
+ */
+const createTokenRefreshInterceptor = () => {
+  return async (error: any): Promise<void> => {
+    if (error.code === 401 || error.code === '401') {
+      const token = Taro.getStorageSync('token');
+      const refreshToken = Taro.getStorageSync('refreshToken');
+
+      if (!token || !refreshToken) {
+        throw error;
+      }
+
+      if (!isRefreshing) {
+        isRefreshing = true;
+        const newToken = await refreshAccessToken();
+        isRefreshing = false;
+
+        if (newToken) {
+          onRefreshed(newToken);
+          return;
+        }
+
+        throw error;
+      }
+
+      return new Promise((resolve) => {
+        subscribeTokenRefresh(() => {
+          resolve();
+        });
+      });
+    }
+
+    throw error;
+  };
+};
+
+/**
+ * 创建 API 客户端实例
+ */
+const { api, apiAsync, runGenerator } = createApiClient(taroAdapter, {
+  baseURL: API_BASE_URL,
+  interceptors: {
+    request: [
+      createTokenInterceptor(() => {
+        try {
+          return Taro.getStorageSync('token');
+        } catch {
+          return null;
+        }
+      }),
+    ],
+    error: [createTokenRefreshInterceptor()],
+  },
+});
+
+export { api, apiAsync, runGenerator };

package/templates/apps/mobile/src/services/upload.service.ts

@@ -0,0 +1,41 @@
+import Taro from '@tarojs/taro';
+
+// API 基础 URL（从 Taro 配置文件注入）
+declare const API_BASE_URL: string;
+
+export interface UploadResult {
+  url: string;
+}
+
+export async function uploadImage(filePath: string): Promise<UploadResult> {
+  const token = Taro.getStorageSync('token');
+
+  const res = await Taro.uploadFile({
+    url: `${API_BASE_URL}/upload/image`,
+    filePath,
+    name: 'file',
+    header: {
+      Authorization: token ? `Bearer ${token}` : '',
+    },
+  });
+
+  if (res.statusCode !== 200 && res.statusCode !== 201) {
+    throw new Error(`上传失败: ${res.statusCode}`);
+  }
+
+  let parsed: any;
+  try {
+    parsed = JSON.parse(res.data);
+  } catch {
+    parsed = res.data;
+  }
+
+  if (parsed && typeof parsed === 'object' && 'code' in parsed) {
+    if (parsed.code !== 200) {
+      throw new Error(parsed.message || '上传失败');
+    }
+    return { url: parsed.data?.url };
+  }
+
+  return { url: parsed?.url };
+}

package/templates/apps/mobile/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ES2017",
+    "module": "CommonJS",
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+    "strict": true,
+    "jsx": "react-jsx",
+    "allowSyntheticDefaultImports": true,
+    "resolveJsonModule": true,
+    "typeRoots": ["node_modules/@types"],
+    "noEmit": true,
+    "skipLibCheck": true,
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  },
+  "include": ["src/**/*", "types/**/*", "config/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/templates/configs/authz.config.ts

@@ -0,0 +1,10 @@
+import { ConfigService } from '@nestjs/config';
+import { AuthzModuleOptions } from '@svton/nestjs-authz';
+
+export const useAuthzConfig = (
+  configService: ConfigService,
+): AuthzModuleOptions => ({
+  // 权限配置
+  roles: ['admin', 'user', 'guest'],
+  defaultRole: 'guest',
+});

package/templates/configs/cache.config.ts

@@ -0,0 +1,14 @@
+import { ConfigService } from '@nestjs/config';
+import { CacheModuleOptions } from '@svton/nestjs-cache';
+
+export const useCacheConfig = (
+  configService: ConfigService,
+): CacheModuleOptions => ({
+  ttl: 3600, // 默认缓存时间 1 小时
+  prefix: 'cache', // 缓存 key 前缀
+  redis: {
+    host: configService.get('REDIS_HOST', 'localhost'),
+    port: parseInt(configService.get('REDIS_PORT', '6379'), 10),
+    password: configService.get('REDIS_PASSWORD'),
+  },
+});

package/templates/configs/oauth.config.ts

@@ -0,0 +1,20 @@
+import { ConfigService } from '@nestjs/config';
+import { OAuthModuleOptions } from '@svton/nestjs-oauth';
+
+export const useOAuthConfig = (
+  configService: ConfigService,
+): OAuthModuleOptions => ({
+  wechat: [
+    {
+      platform: 'open',
+      appId: configService.get('WECHAT_OPEN_APP_ID'),
+      appSecret: configService.get('WECHAT_OPEN_APP_SECRET'),
+      callbackUrl: configService.get('WECHAT_OPEN_CALLBACK_URL'),
+    },
+    {
+      platform: 'miniprogram',
+      appId: configService.get('WECHAT_MINI_APP_ID'),
+      appSecret: configService.get('WECHAT_MINI_APP_SECRET'),
+    },
+  ],
+});

package/templates/configs/payment.config.ts

@@ -0,0 +1,44 @@
+import { ConfigService } from '@nestjs/config';
+import { PaymentModuleOptions } from '@svton/nestjs-payment';
+import * as fs from 'fs';
+
+/**
+ * 读取密钥文件
+ * @param filePath 文件路径
+ * @returns 文件内容
+ */
+function readKeyFile(filePath: string): string {
+  try {
+    if (fs.existsSync(filePath)) {
+      return fs.readFileSync(filePath, 'utf-8');
+    }
+    throw new Error(`Key file not found: ${filePath}`);
+  } catch (error) {
+    throw new Error(
+      `Failed to read key file: ${filePath}. Error: ${error instanceof Error ? error.message : String(error)}`,
+    );
+  }
+}
+
+export const usePaymentConfig = (
+  configService: ConfigService,
+): PaymentModuleOptions => ({
+  wechat: {
+    mchId: configService.getOrThrow('WECHAT_MCH_ID'),
+    privateKey: readKeyFile(
+      configService.get('WECHAT_PRIVATE_KEY', './certs/apiclient_key.pem'),
+    ),
+    serialNo: configService.getOrThrow('WECHAT_SERIAL_NO'),
+    apiV3Key: configService.getOrThrow('WECHAT_API_V3_KEY'),
+    appId: configService.getOrThrow('WECHAT_APP_ID'),
+  },
+  alipay: {
+    appId: configService.getOrThrow('ALIPAY_APP_ID'),
+    privateKey: readKeyFile(
+      configService.get('ALIPAY_PRIVATE_KEY', './certs/alipay_private_key.pem'),
+    ),
+    alipayPublicKey: readKeyFile(
+      configService.get('ALIPAY_PUBLIC_KEY', './certs/alipay_public_key.pem'),
+    ),
+  },
+});