@qlover/create-app 0.7.9 → 0.7.11

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 type { UserSchema } from '@migrations/schema/UserSchema';
+import { AppUserApi } from '../services/appApi/AppUserApi';
+import type { AppApiSuccessInterface } from '../port/AppApiInterface';
+import type { AppUserApiInterface } from '../port/AppUserApiInterface';
+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/AdminLayoutInterface.ts

@@ -0,0 +1,26 @@
+import { StoreInterface } from '@qlover/corekit-bridge';
+import type { StoreStateInterface } from '@qlover/corekit-bridge';
+
+export interface NavItemInterface {
+  key: string;
+  /**
+   * 可以是 i18n key
+   */
+  i18nKey: string;
+
+  pathname?: string;
+}
+
+export interface AdminPageState extends StoreStateInterface {
+  navItems: NavItemInterface[];
+  collapsedSidebar: boolean;
+}
+
+export abstract class AdminLayoutInterface extends StoreInterface<AdminPageState> {
+  public readonly selectors = {
+    collapsedSidebar: (state: AdminPageState) => state.collapsedSidebar,
+    navItems: (state: AdminPageState) => state.navItems
+  };
+
+  abstract toggleSidebar(): void;
+}

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

@@ -0,0 +1,87 @@
+import { StoreInterface } from '@qlover/corekit-bridge';
+import { RequestState } from '../cases/RequestState';
+import type { PaginationInterface } from './PaginationInterface';
+import type { StoreStateInterface } from '@qlover/corekit-bridge';
+
+export interface AdminPageListParams {
+  page: number;
+  pageSize: number;
+}
+
+export class AdminPageState implements StoreStateInterface {
+  listParams: AdminPageListParams = {
+    page: 1,
+    pageSize: 10
+  };
+  initState = new RequestState<unknown>();
+  listState = new RequestState<PaginationInterface<unknown>>();
+}
+
+export abstract class AdminPageInterface<
+  S extends AdminPageState
+> extends StoreInterface<S> {
+  /**
+   * 初始化
+   * @returns
+   */
+  async initialize(): Promise<unknown> {
+    this.emit(
+      this.cloneState({
+        initState: new RequestState(true)
+      } as Partial<S>)
+    );
+
+    try {
+      const result = await this.fetchList(this.state.listParams);
+
+      console.log('jj result', result);
+
+      this.emit(
+        this.cloneState({
+          initState: new RequestState(false, result).end()
+        } as Partial<S>)
+      );
+      return result;
+    } catch (error) {
+      this.emit(
+        this.cloneState({
+          initState: new RequestState(false, null, error).end()
+        } as Partial<S>)
+      );
+
+      return error;
+    }
+  }
+
+  /**
+   * 销毁
+   */
+  destroy(): void {
+    this.reset();
+  }
+
+  /**
+   * 获取列表
+   * @param params
+   * @returns
+   */
+  abstract fetchList(
+    params: Partial<AdminPageListParams>
+  ): Promise<PaginationInterface<unknown>>;
+
+  changeListState(state: RequestState<unknown>): void {
+    this.emit(
+      this.cloneState({
+        listState: state
+      } as Partial<S>)
+    );
+  }
+
+  changeListParams(params: Partial<AdminPageListParams>): void {
+    this.emit(
+      this.cloneState({
+        listParams: params
+      } as Partial<S>)
+    );
+  }
+}

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 AppApiResult<T = unknown> =
+  | AppApiErrorInterface
+  | AppApiSuccessInterface<T>;

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

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

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

@@ -0,0 +1,7 @@
+export interface AsyncStateInterface<T> {
+  loading: boolean;
+  result: T | null;
+  error: unknown | null;
+  startTime: number;
+  endTime: number;
+}

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

@@ -0,0 +1,21 @@
+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;
+  page?: number;
+  pageSize?: number;
+}
+
+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>>;
+  pagination(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/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/PaginationInterface.ts

@@ -0,0 +1,6 @@
+export interface PaginationInterface<T> {
+  list: T[];
+  total: number;
+  page: number;
+  pageSize: number;
+}

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/AdminUserService.ts

@@ -0,0 +1,45 @@
+import { inject, injectable } from 'inversify';
+import {
+  AdminPageInterface,
+  type AdminPageListParams,
+  AdminPageState
+} from '../port/AdminPageInterface';
+import { AdminUserApi } from './adminApi/AdminUserApi';
+import { RequestState } from '../cases/RequestState';
+import type { PaginationInterface } from '../port/PaginationInterface';
+
+@injectable()
+export class AdminUserService extends AdminPageInterface<AdminPageState> {
+  constructor(@inject(AdminUserApi) protected adminUserApi: AdminUserApi) {
+    super(() => new AdminPageState());
+  }
+
+  override async fetchList(
+    params: Partial<AdminPageListParams>
+  ): Promise<PaginationInterface<unknown>> {
+    this.changeListState(new RequestState(true));
+
+    try {
+      const response = await this.adminUserApi.getUserList(
+        Object.assign({}, this.state.listParams, params)
+      );
+
+      if (response.data.success) {
+        const paginationData = response.data
+          .data as PaginationInterface<unknown>;
+
+        this.changeListState(new RequestState(false, paginationData));
+
+        return paginationData;
+      }
+
+      this.changeListState(
+        new RequestState(false, null, response.data.message)
+      );
+    } catch (error) {
+      this.changeListState(new RequestState(false, null, error));
+    }
+
+    return this.state.listState.result!;
+  }
+}

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 type { UserSchema } from '@migrations/schema/UserSchema';
 import { AppConfig } from '../cases/AppConfig';
+import { UserServiceApi } from '../cases/UserServiceApi';
 import { UserServiceInterface } from '../port/UserServiceInterface';
+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/adminApi/AdminApiRequester.ts

@@ -0,0 +1,21 @@
+import {
+  FetchAbortPlugin,
+  RequestAdapterFetch,
+  RequestTransaction
+} from '@qlover/fe-corekit';
+import { inject, injectable } from 'inversify';
+import type { AppApiConfig } from '../appApi/AppApiRequester';
+
+@injectable()
+export class AdminApiRequester extends RequestTransaction<AppApiConfig> {
+  constructor(
+    @inject(FetchAbortPlugin) protected abortPlugin: FetchAbortPlugin
+  ) {
+    super(
+      new RequestAdapterFetch({
+        baseURL: '/api/admin',
+        responseType: 'json'
+      })
+    );
+  }
+}

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

@@ -0,0 +1,34 @@
+import { inject, injectable } from 'inversify';
+import type { AdminPageListParams } from '@/base/port/AdminPageInterface';
+import type { PaginationInterface } from '@/base/port/PaginationInterface';
+import {
+  AppApiRequester,
+  type AppApiConfig,
+  type AppApiTransaction
+} from '../appApi/AppApiRequester';
+import type { RequestTransaction } from '@qlover/fe-corekit';
+
+export type AdminUserListTransaction = AppApiTransaction<
+  AdminPageListParams,
+  PaginationInterface<unknown>
+>;
+
+@injectable()
+export class AdminUserApi {
+  constructor(
+    @inject(AppApiRequester)
+    protected client: RequestTransaction<AppApiConfig>
+  ) {}
+
+  async getUserList(
+    params: AdminPageListParams
+  ): Promise<AdminUserListTransaction['response']> {
+    const response = await this.client.request<AdminUserListTransaction>({
+      url: '/admin/users',
+      method: 'GET',
+      params: params as unknown as Record<string, unknown>
+    });
+
+    return response;
+  }
+}