@qlover/create-app 0.7.9 → 0.7.10

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>;
+  }
+}

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

@@ -0,0 +1,48 @@
+import { RequestCommonPlugin } from '@qlover/corekit-bridge';
+import { FetchURLPlugin } from '@qlover/fe-corekit';
+import { DialogErrorPlugin } from '@/base/cases/DialogErrorPlugin';
+import { RequestEncryptPlugin } from '@/base/cases/RequestEncryptPlugin';
+import { StringEncryptor } from '@/base/cases/StringEncryptor';
+import { AppApiPlugin } from './AppApiPlugin';
+import { AppUserApi } from './AppUserApi';
+import type { UserApiConfig } from './AppUserType';
+import type {
+  BootstrapContext,
+  BootstrapExecutorPlugin
+} from '@qlover/corekit-bridge';
+import type { ExecutorContext, SerializerIneterface } from '@qlover/fe-corekit';
+
+export class AppUserApiBootstrap implements BootstrapExecutorPlugin {
+  readonly pluginName = 'AppUserApiBootstrap';
+
+  constructor(protected serializer: SerializerIneterface) {}
+
+  onBefore({ parameters: { ioc } }: BootstrapContext): void | Promise<void> {
+    const appUserApi = ioc.get<AppUserApi>(AppUserApi);
+
+    appUserApi.usePlugin(new FetchURLPlugin());
+    appUserApi.usePlugin(new RequestEncryptPlugin(ioc.get(StringEncryptor)));
+    appUserApi.usePlugin(
+      new RequestCommonPlugin({
+        requestDataSerializer: this.requestDataSerializer.bind(this)
+      })
+    );
+    appUserApi.usePlugin(new AppApiPlugin());
+    appUserApi.usePlugin(ioc.get(DialogErrorPlugin));
+  }
+
+  protected requestDataSerializer(
+    data: unknown,
+    context: ExecutorContext<UserApiConfig>
+  ): unknown {
+    if (data instanceof FormData) {
+      return data;
+    }
+
+    if (context.parameters?.responseType === 'json') {
+      return this.serializer.serialize(data);
+    }
+
+    return data;
+  }
+}

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

@@ -0,0 +1,51 @@
+import type { RequestEncryptPluginProps } from '@/base/cases/RequestEncryptPlugin';
+import type { AppApiResponse } from '@/base/port/AppApiInterface';
+import type {
+  RequestAdapterConfig,
+  RequestAdapterResponse,
+  RequestTransactionInterface
+} from '@qlover/fe-corekit';
+
+export interface UserApiConfig<Request = unknown>
+  extends RequestAdapterConfig<Request>,
+    RequestEncryptPluginProps<Request> {}
+
+/**
+ * UserApiResponse
+ *
+ * @description
+ * UserApiResponse is the response for the UserApi.
+ *
+ * extends:
+ * - RequestAdapterResponse<Request, Response>
+ */
+export type UserApiResponse<
+  Request = unknown,
+  Response = unknown
+> = RequestAdapterResponse<Request, AppApiResponse<Response>>;
+
+/**
+ * UserApi common transaction
+ */
+export interface UserApiTransaction<Request = unknown, Response = unknown>
+  extends RequestTransactionInterface<
+    UserApiConfig<Request>,
+    UserApiResponse<Request, Response>
+  > {
+  data: UserApiConfig<Request>['data'];
+}
+
+export type UserApiLoginTransaction = UserApiTransaction<
+  { email: string; password: string },
+  {
+    token: string;
+  }
+>;
+
+export type UserApiRegisterTransaction = UserApiTransaction<
+  {
+    email: string;
+    password: string;
+  },
+  UserApiTransaction['response']['data']
+>;

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

@@ -0,0 +1,43 @@
+import { RequestCommonPlugin } from '@qlover/corekit-bridge';
+import {
+  FetchAbortPlugin,
+  RequestTransaction,
+  RequestAdapterFetch,
+  FetchURLPlugin
+} from '@qlover/fe-corekit';
+import { inject, injectable } from 'inversify';
+import type { MigrationApiInterface } from '@/base/port/MigrationApiInterface';
+import type { RequestAdapterConfig } from '@qlover/fe-corekit';
+
+/**
+ * UserApi
+ *
+ * @description
+ * UserApi is a client for the user API.
+ *
+ */
+@injectable()
+export class MigrationsApi
+  extends RequestTransaction<RequestAdapterConfig>
+  implements MigrationApiInterface
+{
+  constructor(
+    @inject(FetchAbortPlugin) protected abortPlugin: FetchAbortPlugin
+  ) {
+    super(
+      new RequestAdapterFetch({
+        baseURL: '/api/admin/migrations',
+        responseType: 'json'
+      })
+    );
+
+    this.usePlugin(new FetchURLPlugin()).usePlugin(new RequestCommonPlugin());
+  }
+
+  async init(): Promise<unknown> {
+    return this.request({
+      url: '/init',
+      method: 'POST'
+    });
+  }
+}

package/dist/templates/next-app/src/core/bootstraps/BootstrapServer.ts

@@ -1,13 +1,19 @@
 import {
+  type ServiceIdentifier,
   type BootstrapContextValue,
   type BootstrapExecutorPlugin,
   type IOCContainerInterface,
   type IOCFunctionInterface,
   type LoggerInterface
 } from '@qlover/corekit-bridge';
-import { AsyncExecutor, type ExecutorPlugin } from '@qlover/fe-corekit';
+import {
+  AsyncExecutor,
+  type ExecutorError,
+  type PromiseTask,
+  type ExecutorPlugin
+} from '@qlover/fe-corekit';
 import { I, type IOCIdentifierMapServer } from '@config/IOCIdentifier';
-import type { ServerInterface } from '@/base/port/ServerInterface';
+import type { ServerInterface } from '@/server/port/ServerInterface';
 import { ServerIOC } from '../serverIoc/ServerIOC';
 
 export interface BootstrapServerResult {
@@ -20,6 +26,12 @@ export interface BootstrapServerContextValue extends BootstrapContextValue {
   messages: Record<string, string>;
 }
 
+interface BootstrapServerContext {
+  logger: LoggerInterface;
+  root: Record<string, unknown>;
+  IOC: IOCFunctionInterface<IOCIdentifierMapServer, IOCContainerInterface>;
+}
+
 export class BootstrapServer implements ServerInterface {
   protected executor: AsyncExecutor;
   protected root: Record<string, unknown> = {};
@@ -43,11 +55,12 @@ export class BootstrapServer implements ServerInterface {
   getIOC<T extends keyof IOCIdentifierMapServer>(
     identifier: T
   ): IOCIdentifierMapServer[T];
-  getIOC(
-    identifier?: keyof IOCIdentifierMapServer
+  getIOC<T>(serviceIdentifier: ServiceIdentifier<T>): T;
+  getIOC<T extends keyof IOCIdentifierMapServer>(
+    identifier?: T
   ):
     | IOCFunctionInterface<IOCIdentifierMapServer, IOCContainerInterface>
-    | IOCIdentifierMapServer[keyof IOCIdentifierMapServer] {
+    | IOCIdentifierMapServer[T] {
     if (identifier === undefined) {
       return this.IOC;
     }
@@ -75,4 +88,16 @@ export class BootstrapServer implements ServerInterface {
     this.executor.use(plugin as ExecutorPlugin<unknown>);
     return this;
   }
+
+  execNoError<Result>(
+    task?: PromiseTask<Result, BootstrapServerContext>
+  ): Promise<Result | ExecutorError> {
+    const context = {
+      logger: this.logger,
+      root: this.root,
+      IOC: this.IOC
+    };
+
+    return this.executor.execNoError(context, task);
+  }
 }

package/dist/templates/next-app/src/core/bootstraps/BootstrapsRegistry.ts

@@ -1,4 +1,5 @@
-import { IOCIdentifier } from '@config/IOCIdentifier';
+import { I, IOCIdentifier } from '@config/IOCIdentifier';
+import { AppUserApiBootstrap } from '@/base/services/appApi/AppUserApiBootstrap';
 import { IocIdentifierTest } from './IocIdentifierTest';
 import { printBootstrap } from './PrintBootstrap';
 import type { BootstrapAppArgs } from './BootstrapClient';
@@ -28,8 +29,8 @@ export class BootstrapsRegistry {
     i18nService.setPathname(this.args.pathname);
 
     const bootstrapList: BootstrapExecutorPlugin[] = [
-      i18nService
-      // new UserApiBootstarp(),
+      i18nService,
+      new AppUserApiBootstrap(IOC(I.JSONSerializer))
       // new FeApiBootstarp(),
       // AiApiBootstarp,
       // IOC(IOCIdentifier.I18nKeyErrorPlugin)

package/dist/templates/next-app/src/server/AppErrorApi.ts

@@ -0,0 +1,10 @@
+import type { AppApiErrorInterface } from '@/base/port/AppApiInterface';
+
+export class AppErrorApi implements AppApiErrorInterface {
+  readonly success = false;
+
+  constructor(
+    public readonly id: string,
+    public readonly message?: string
+  ) {}
+}

package/dist/templates/next-app/src/server/AppSuccessApi.ts

@@ -0,0 +1,7 @@
+import type { AppApiSuccessInterface } from '@/base/port/AppApiInterface';
+
+export class AppSuccessApi<T = unknown> implements AppApiSuccessInterface<T> {
+  readonly success = true;
+
+  constructor(public readonly data?: T) {}
+}