@qlover/create-app 0.7.8 → 0.7.10

package/dist/templates/next-app/src/base/cases/RequestEncryptPlugin.ts

@@ -0,0 +1,70 @@
+import { clone, isObject } from 'lodash';
+import type {
+  Encryptor,
+  ExecutorContext,
+  ExecutorPlugin,
+  RequestAdapterConfig
+} from '@qlover/fe-corekit';
+
+export interface RequestEncryptPluginProps<Request = unknown>
+  extends RequestAdapterConfig<Request> {
+  /**
+   * 加密密码在 HTTP 请求中
+   *
+   * - 如果为空，则不加密密码
+   * - 如果为字符串，则加密密码
+   * - 如果为数组，则加密密码
+   */
+  encryptProps?: string[] | string;
+}
+
+export class RequestEncryptPlugin
+  implements ExecutorPlugin<RequestEncryptPluginProps>
+{
+  readonly pluginName = 'RequestEncryptPlugin';
+
+  constructor(protected encryptor: Encryptor<string, string>) {}
+
+  onBefore(
+    context: ExecutorContext<RequestEncryptPluginProps>
+  ): void | Promise<void> {
+    const { responseType, encryptProps } = context.parameters;
+
+    if (
+      responseType === 'json' &&
+      isObject(context.parameters.data) &&
+      encryptProps
+    ) {
+      context.parameters.data = this.encryptData(
+        clone(context.parameters.data),
+        encryptProps
+      );
+    }
+  }
+
+  protected encryptData<T extends object>(
+    data: T,
+    encryptProps?: string | string[]
+  ): T {
+    if (typeof encryptProps === 'string') {
+      const targetValue = data[encryptProps as keyof T];
+
+      if (typeof targetValue === 'string') {
+        const newValue = this.encryptor.encrypt(targetValue);
+        Object.assign(data, { [encryptProps]: newValue });
+      }
+    }
+
+    if (Array.isArray(encryptProps)) {
+      encryptProps.forEach((prop) => {
+        const targetValue = data[prop as keyof T];
+        if (typeof targetValue === 'string') {
+          const newValue = this.encryptor.encrypt(targetValue);
+          Object.assign(data, { [prop]: newValue });
+        }
+      });
+    }
+
+    return data;
+  }
+}

package/dist/templates/next-app/src/base/cases/RouterService.ts

@@ -25,6 +25,10 @@ export class RouterService implements RouterInterface {
     this.goto('/');
   }
 
+  gotoLogin(): void {
+    this.goto('/login');
+  }
+
   setLocale(locale: string): void {
     this.locale = locale;
   }

package/dist/templates/next-app/src/base/cases/StringEncryptor.ts

@@ -0,0 +1,67 @@
+import { Base64Serializer, type Encryptor } from '@qlover/fe-corekit';
+import { inject, injectable } from 'inversify';
+import { I } from '@config/IOCIdentifier';
+import type { AppConfig } from './AppConfig';
+
+@injectable()
+export class StringEncryptor implements Encryptor<string, string> {
+  private readonly key;
+
+  constructor(
+    @inject(I.AppConfig) appConfig: AppConfig,
+    @inject(Base64Serializer) protected base64Serializer: Base64Serializer
+  ) {
+    if (!appConfig.stringEncryptorKey) {
+      throw new Error('StringEncryptorKey is not set');
+    }
+
+    this.key = appConfig.stringEncryptorKey;
+  }
+
+  protected encryptWithKey(str: string, key: string): string {
+    const result = [];
+    for (let i = 0; i < str.length; i++) {
+      // 使用字符的 Unicode 值和密钥进行混合运算
+      const charCode = str.charCodeAt(i);
+      const keyChar = key.charCodeAt(i % key.length);
+      // 使用多个运算来增加复杂度
+      const encrypted = (charCode + keyChar * 13) ^ (keyChar + i * 7);
+      result.push(String.fromCharCode(encrypted % 65536)); // 确保结果在有效的 Unicode 范围内
+    }
+    return result.join('');
+  }
+
+  protected decryptWithKey(str: string, key: string): string {
+    const result = [];
+    for (let i = 0; i < str.length; i++) {
+      const charCode = str.charCodeAt(i);
+      const keyChar = key.charCodeAt(i % key.length);
+      // 反向运算还原原始字符
+      const decrypted = (charCode ^ (keyChar + i * 7)) - keyChar * 13;
+      result.push(String.fromCharCode(decrypted));
+    }
+    return result.join('');
+  }
+
+  encrypt(value: string): string {
+    try {
+      const encrypted = this.encryptWithKey(value, this.key);
+      return this.base64Serializer.serialize(encrypted);
+    } catch (error) {
+      console.error('Encryption failed:', error);
+      throw new Error('Encryption failed');
+    }
+  }
+
+  decrypt(encryptedValue: string): string {
+    try {
+      // 1. 先用 base64 反序列化
+      const decoded = this.base64Serializer.deserialize(encryptedValue);
+      // 2. 然后用密钥解密
+      return this.decryptWithKey(decoded, this.key);
+    } catch (error) {
+      console.error('Decryption failed:', error);
+      throw new Error('Decryption failed');
+    }
+  }
+}

package/dist/templates/next-app/src/base/cases/UserServiceApi.ts

@@ -0,0 +1,48 @@
+import { inject, injectable } from 'inversify';
+import { AppUserApi } from '../services/appApi/AppUserApi';
+import type { AppApiSuccessInterface } from '../port/AppApiInterface';
+import type { AppUserApiInterface } from '../port/AppUserApiInterface';
+import type { UserSchema } from '@migrations/schema/UserSchema';
+import type {
+  LoginResponseData,
+  UserAuthApiInterface,
+  UserAuthStoreInterface
+} from '@qlover/corekit-bridge';
+
+@injectable()
+export class UserServiceApi implements UserAuthApiInterface<UserSchema> {
+  protected store: UserAuthStoreInterface<UserSchema> | null = null;
+
+  constructor(@inject(AppUserApi) protected appUserApi: AppUserApiInterface) {}
+
+  getStore(): UserAuthStoreInterface<UserSchema> | null {
+    return this.store;
+  }
+  setStore(store: UserAuthStoreInterface<UserSchema>): void {
+    this.store = store;
+  }
+
+  async login(params: {
+    email: string;
+    password: string;
+  }): Promise<LoginResponseData> {
+    const response = await this.appUserApi.login(params);
+    return (response as AppApiSuccessInterface).data as LoginResponseData;
+  }
+
+  async register(params: {
+    email: string;
+    password: string;
+  }): Promise<LoginResponseData> {
+    const response = await this.appUserApi.register(params);
+    return (response as AppApiSuccessInterface).data as LoginResponseData;
+  }
+
+  async logout(): Promise<void> {
+    await this.appUserApi.logout();
+  }
+
+  getUserInfo(loginData: LoginResponseData): Promise<UserSchema> {
+    return Promise.resolve(loginData as unknown as UserSchema);
+  }
+}

package/dist/templates/next-app/src/base/port/AppApiInterface.ts

@@ -0,0 +1,14 @@
+export interface AppApiErrorInterface {
+  success: false;
+  id: string;
+  message?: string;
+}
+
+export interface AppApiSuccessInterface<T = unknown> {
+  success: true;
+  data?: T;
+}
+
+export type AppApiResponse<T = unknown> =
+  | AppApiErrorInterface
+  | AppApiSuccessInterface<T>;

package/dist/templates/next-app/src/base/port/AppUserApiInterface.ts

@@ -0,0 +1,15 @@
+import type { AppApiResponse } from './AppApiInterface';
+
+export interface AppUserApiInterface {
+  login(params: {
+    email: string;
+    password: string;
+  }): Promise<AppApiResponse<unknown>>;
+
+  register(params: {
+    email: string;
+    password: string;
+  }): Promise<AppApiResponse<unknown>>;
+
+  logout(): Promise<AppApiResponse<unknown>>;
+}

package/dist/templates/next-app/src/base/port/DBBridgeInterface.ts

@@ -0,0 +1,18 @@
+import type { PostgrestSingleResponse } from '@supabase/supabase-js';
+
+export type WhereOperation = '=' | '!=' | '>' | '<' | '>=' | '<=';
+export type Where = [string, WhereOperation, string | number];
+
+export interface BridgeEvent {
+  table: string;
+  fields?: string | string[];
+  where?: Where[];
+  data?: unknown;
+}
+
+export interface DBBridgeInterface {
+  add(event: BridgeEvent): Promise<PostgrestSingleResponse<unknown>>;
+  update(event: BridgeEvent): Promise<PostgrestSingleResponse<unknown>>;
+  delete(event: BridgeEvent): Promise<PostgrestSingleResponse<unknown>>;
+  get(event: BridgeEvent): Promise<PostgrestSingleResponse<unknown>>;
+}

package/dist/templates/next-app/src/base/port/DBMigrationInterface.ts

@@ -0,0 +1,92 @@
+export interface MigrationConfig {
+  /**
+   * Migration version number or identifier
+   */
+  version: string | number;
+
+  /**
+   * Description of what this migration does
+   */
+  description: string;
+
+  /**
+   * Timestamp when migration was created
+   */
+  timestamp?: number;
+}
+
+export interface MigrationResult {
+  /**
+   * Whether the migration was successful
+   */
+  success: boolean;
+
+  /**
+   * Error message if migration failed
+   */
+  error?: string;
+
+  /**
+   * Migration version that was executed
+   */
+  version: string | number;
+
+  /**
+   * Time taken to execute the migration in milliseconds
+   */
+  executionTime?: number;
+}
+
+export interface DBMigrationInterface {
+  /**
+   * Get current database version
+   */
+  getCurrentVersion(): Promise<string | number>;
+
+  /**
+   * Get list of all applied migrations
+   */
+  getAppliedMigrations(): Promise<MigrationConfig[]>;
+
+  /**
+   * Get list of pending migrations that need to be applied
+   */
+  getPendingMigrations(): Promise<MigrationConfig[]>;
+
+  /**
+   * Apply a specific migration
+   * @param migration Migration configuration
+   */
+  applyMigration(migration: MigrationConfig): Promise<MigrationResult>;
+
+  /**
+   * Rollback a specific migration
+   * @param migration Migration configuration
+   */
+  rollbackMigration(migration: MigrationConfig): Promise<MigrationResult>;
+
+  /**
+   * Apply all pending migrations
+   */
+  migrateUp(): Promise<MigrationResult[]>;
+
+  /**
+   * Rollback to a specific version
+   * @param targetVersion Version to rollback to
+   */
+  migrateDown(targetVersion: string | number): Promise<MigrationResult[]>;
+
+  /**
+   * Create a new migration file/record
+   * @param name Name/description of the migration
+   */
+  createMigration(name: string): Promise<MigrationConfig>;
+
+  /**
+   * Validate migration history and database state
+   */
+  validateMigrations(): Promise<{
+    valid: boolean;
+    errors?: string[];
+  }>;
+}

package/dist/templates/next-app/src/base/port/DBTableInterface.ts

@@ -0,0 +1,3 @@
+export interface DBTableInterface {
+  readonly name: string;
+}

package/dist/templates/next-app/src/base/port/I18nServiceInterface.ts

@@ -2,11 +2,12 @@ import {
   StoreInterface,
   type StoreStateInterface
 } from '@qlover/corekit-bridge';
+import type { Locale } from '@/i18n/routing';
 import type { i18nConfig } from '@config/i18n';
 
 export type SupportedLocale = (typeof i18nConfig.supportedLngs)[number];
 export type SupportedNamespace = typeof i18nConfig.fallbackLng;
-export type I18nServiceLocale = SupportedLocale;
+export type I18nServiceLocale = Locale;
 
 export class I18nServiceState implements StoreStateInterface {
   loading: boolean = false;
@@ -16,7 +17,7 @@ export abstract class I18nServiceInterface
   extends StoreInterface<I18nServiceState>
   implements I18nServiceInterface
 {
-  abstract t(key: string, params?: Record<string, unknown>): Promise<string>;
+  abstract t(key: string, params?: Record<string, unknown>): string;
   abstract changeLanguage(language: I18nServiceLocale): Promise<void>;
   abstract changeLoading(loading: boolean): void;
   abstract getCurrentLanguage(): Promise<I18nServiceLocale>;

package/dist/templates/next-app/src/base/port/MigrationApiInterface.ts

@@ -0,0 +1,3 @@
+export interface MigrationApiInterface {
+  init(): Promise<unknown>;
+}

package/dist/templates/next-app/src/base/port/ServerApiResponseInterface.ts

@@ -0,0 +1,6 @@
+export interface ServerApiResponseInterface<T> {
+  success?: boolean;
+  message?: string;
+  data?: T;
+  error?: string;
+}

package/dist/templates/next-app/src/base/port/UserServiceInterface.ts

@@ -1,8 +1,9 @@
-import { ImagicaAuthService } from '@brain-toolkit/bridge';
+import { UserAuthService } from '@qlover/corekit-bridge';
+import type { UserSchema } from '@migrations/schema/UserSchema';
 import type { ExecutorPlugin } from '@qlover/fe-corekit';
 
 export abstract class UserServiceInterface
-  extends ImagicaAuthService
+  extends UserAuthService<UserSchema>
   implements ExecutorPlugin
 {
   readonly pluginName = 'UserService';

package/dist/templates/next-app/src/base/services/I18nService.ts

@@ -1,4 +1,3 @@
-import { useLocaleRoutes } from '@config/common';
 import { i18nConfig } from '@config/i18n';
 import {
   I18nServiceInterface,
@@ -11,20 +10,13 @@ type TranslationFunction = ReturnType<typeof useTranslations>;
 
 export class I18nService extends I18nServiceInterface {
   readonly pluginName = 'I18nService';
-  private initialized: boolean = false;
-  private pathname: string = '';
-  private translator: TranslationFunction | null = null;
+  protected pathname: string = '';
+  protected translator: TranslationFunction | null = null;
 
   constructor() {
     super(() => new I18nServiceState(i18nConfig.fallbackLng));
   }
 
-  private async ensureInitialized(): Promise<void> {
-    if (!this.initialized) {
-      throw new Error('I18nService not initialized');
-    }
-  }
-
   setPathname(pathname: string): void {
     this.pathname = pathname;
   }
@@ -36,44 +28,19 @@ export class I18nService extends I18nServiceInterface {
   /**
    * @override
    */
-  async onBefore(): Promise<void> {
-    if (this.initialized) {
-      return;
-    }
-
-    this.initialized = true;
-
-    // 初始化语言状态
-    const currentLang = this.getCurrentLanguageFromPath();
-    if (this.isValidLanguage(currentLang)) {
-      this.emit({ ...this.state, language: currentLang });
-    }
-  }
-
-  private getCurrentLanguageFromPath(): string {
-    const paths = this.pathname.split('/');
-
-    for (const path of paths) {
-      if (this.isValidLanguage(path)) {
-        return path;
-      }
-    }
-
-    return i18nConfig.fallbackLng;
-  }
+  async onBefore(): Promise<void> {}
 
   override async changeLanguage(language: I18nServiceLocale): Promise<void> {
     try {
       this.changeLoading(true);
-      await this.ensureInitialized();
 
       // 在这里我们只需要更新状态，因为实际的语言切换会通过路由处理
       this.emit({ ...this.state, language });
 
       // 如果不使用本地化路由，则保存语言设置到本地存储
-      if (!useLocaleRoutes && typeof window !== 'undefined') {
-        window.localStorage.setItem('i18nextLng', language);
-      }
+      // if (!useLocaleRoutes && typeof window !== 'undefined') {
+      //   window.localStorage.setItem('i18nextLng', language);
+      // }
     } finally {
       this.changeLoading(false);
     }
@@ -84,8 +51,7 @@ export class I18nService extends I18nServiceInterface {
   }
 
   override async getCurrentLanguage(): Promise<I18nServiceLocale> {
-    await this.ensureInitialized();
-    return this.getCurrentLanguageFromPath() as I18nServiceLocale;
+    return this.state.language;
   }
 
   override isValidLanguage(language: string): language is I18nServiceLocale {
@@ -96,12 +62,10 @@ export class I18nService extends I18nServiceInterface {
     return [...i18nConfig.supportedLngs];
   }
 
-  override async t(
+  override t(
     key: string,
     params?: Record<string, string | number | Date>
-  ): Promise<string> {
-    await this.ensureInitialized();
-
+  ): string {
     if (!this.translator) {
       return key;
     }

package/dist/templates/next-app/src/base/services/UserService.ts

@@ -1,18 +1,19 @@
-import { CookieStorage } from '@qlover/corekit-bridge';
 import { injectable, inject } from 'inversify';
 import { AppConfig } from '../cases/AppConfig';
+import { UserServiceApi } from '../cases/UserServiceApi';
 import { UserServiceInterface } from '../port/UserServiceInterface';
+import type { UserSchema } from '@migrations/schema/UserSchema';
+import type { UserAuthApiInterface } from '@qlover/corekit-bridge';
 
 @injectable()
 export class UserService extends UserServiceInterface {
-  constructor(@inject(AppConfig) protected appConfig: AppConfig) {
-    super({
+  constructor(
+    @inject(AppConfig) protected appConfig: AppConfig,
+    @inject(UserServiceApi) protected userApi: UserAuthApiInterface<UserSchema>
+  ) {
+    super(userApi, {
       credentialStorage: {
-        key: appConfig.userTokenKey,
-        storage: new CookieStorage()
-      },
-      requestConfig: {
-        env: appConfig.env !== 'production' ? 'development' : 'production'
+        key: appConfig.userTokenKey
       }
     });
   }

package/dist/templates/next-app/src/base/services/appApi/AppApiPlugin.ts

@@ -0,0 +1,63 @@
+import {
+  ExecutorError,
+  RequestError,
+  type ExecutorContext,
+  type ExecutorPlugin
+} from '@qlover/fe-corekit';
+import type { AppApiErrorInterface } from '@/base/port/AppApiInterface';
+import type { UserApiConfig } from './AppUserType';
+
+export class AppApiPlugin implements ExecutorPlugin {
+  readonly pluginName = 'AppApiPlugin';
+
+  isAppApiErrorInterface(value: unknown): value is AppApiErrorInterface {
+    return (
+      typeof value === 'object' &&
+      value !== null &&
+      'success' in value &&
+      value.success === false &&
+      'id' in value &&
+      typeof value.id === 'string'
+    );
+  }
+
+  onSuccess(context: ExecutorContext<unknown>): void | Promise<void> {
+    const response = context.returnValue;
+
+    if (this.isAppApiErrorInterface(response)) {
+      throw new Error(response.message || response.id);
+    }
+  }
+
+  async onError(
+    context: ExecutorContext<UserApiConfig>
+  ): Promise<ExecutorError | void> {
+    const { error, parameters } = context;
+
+    if (error instanceof RequestError && parameters.responseType === 'json') {
+      // @ts-expect-error response is not defined in Error
+      let response = error?.response;
+
+      if (response instanceof Response) {
+        // clone the response to avoid mutating the original response
+        response = response.clone();
+
+        const json = await this.getResponseJson(response);
+
+        if (this.isAppApiErrorInterface(json)) {
+          const newError = new ExecutorError(json.message || json.id);
+          // context.error = newError;
+          return newError;
+        }
+      }
+    }
+  }
+
+  protected async getResponseJson(response: Response): Promise<unknown> {
+    try {
+      return await response.json();
+    } catch {
+      return {};
+    }
+  }
+}

package/dist/templates/next-app/src/base/services/appApi/AppUserApi.ts

@@ -0,0 +1,72 @@
+import {
+  FetchAbortPlugin,
+  RequestTransaction,
+  RequestAdapterFetch
+} from '@qlover/fe-corekit';
+import { inject, injectable } from 'inversify';
+import type { AppApiResponse } from '@/base/port/AppApiInterface';
+import type { AppUserApiInterface } from '@/base/port/AppUserApiInterface';
+import type {
+  UserApiConfig,
+  UserApiLoginTransaction,
+  UserApiRegisterTransaction
+} from './AppUserType';
+
+/**
+ * UserApi
+ *
+ * @description
+ * UserApi is a client for the user API.
+ *
+ */
+@injectable()
+export class AppUserApi
+  extends RequestTransaction<UserApiConfig>
+  implements AppUserApiInterface
+{
+  constructor(
+    @inject(FetchAbortPlugin) protected abortPlugin: FetchAbortPlugin
+  ) {
+    super(
+      new RequestAdapterFetch({
+        baseURL: '/api',
+        responseType: 'json'
+      })
+    );
+  }
+
+  async login(
+    params: UserApiLoginTransaction['data']
+  ): Promise<AppApiResponse<unknown>> {
+    const response = await this.request<UserApiLoginTransaction>({
+      url: '/user/login',
+      method: 'POST',
+      data: params,
+      encryptProps: 'password'
+    });
+
+    return response.data;
+  }
+
+  async register(
+    params: UserApiRegisterTransaction['data']
+  ): Promise<AppApiResponse<unknown>> {
+    const response = await this.request<UserApiRegisterTransaction>({
+      url: '/user/register',
+      method: 'POST',
+      data: params,
+      encryptProps: 'password'
+    });
+
+    return response.data;
+  }
+
+  async logout(): Promise<AppApiResponse<unknown>> {
+    const response = await this.request({
+      url: '/user/logout',
+      method: 'POST'
+    });
+
+    return response.data as AppApiResponse<unknown>;
+  }
+}