@qlover/create-app 0.7.6 → 0.7.8

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

@@ -0,0 +1,92 @@
+import type {
+  AntdStaticApiInterface,
+  MessageApi,
+  ModalApi,
+  NotificationApi
+} from '@brain-toolkit/antd-theme-override/react';
+import type {
+  UIDialogInterface,
+  NotificationOptions
+} from '@qlover/corekit-bridge';
+import type { ModalFuncProps } from 'antd';
+
+export interface DialogHandlerOptions
+  extends NotificationOptions,
+    ModalFuncProps {
+  content: string;
+}
+
+/**
+ * Dialog Handler Implementation
+ *
+ * Implements the InteractionHubInterface using Ant Design components.
+ * Provides concrete implementations for displaying notifications and confirmation dialogs.
+ *
+ * Features:
+ * - Uses Ant Design's message component for notifications
+ * - Uses Ant Design's Modal component for confirmations
+ * - Supports customizable display durations
+ * - Handles error objects appropriately
+ *
+ * @example
+ * const dialog = new DialogHandler();
+ * dialog.success('Data saved successfully');
+ * dialog.confirm({
+ *   title: 'Confirm Delete',
+ *   content: 'Are you sure you want to delete this item?',
+ *   onOk: () => handleDelete(),
+ * });
+ */
+export class DialogHandler
+  implements UIDialogInterface<DialogHandlerOptions>, AntdStaticApiInterface
+{
+  protected antds: {
+    message?: MessageApi;
+    modal?: ModalApi;
+    notification?: NotificationApi;
+  } = {};
+
+  setMessage(message: MessageApi): void {
+    this.antds.message = message;
+  }
+
+  setModal(modal: ModalApi): void {
+    this.antds.modal = modal;
+  }
+
+  setNotification(notification: NotificationApi): void {
+    this.antds.notification = notification;
+  }
+
+  /**
+   * Formats error message from various error types
+   */
+  protected formatErrorMessage(error: unknown): string {
+    if (error instanceof Error) return error.message;
+    if (typeof error === 'string') return error;
+    return 'An unknown error occurred';
+  }
+
+  public success(msg: string, options?: NotificationOptions): void {
+    this.antds.message?.success({ content: msg, ...options });
+  }
+
+  public error(msg: string, options?: NotificationOptions): void {
+    this.antds.message?.error({
+      content: options?.error ? this.formatErrorMessage(options.error) : msg,
+      ...options
+    });
+  }
+
+  public info(msg: string, options?: NotificationOptions): void {
+    this.antds.message?.info({ content: msg, ...options });
+  }
+
+  public warn(msg: string, options?: NotificationOptions): void {
+    this.antds.message?.warning({ content: msg, ...options });
+  }
+
+  public confirm(options: DialogHandlerOptions): void {
+    this.antds.modal?.confirm(options);
+  }
+}

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

@@ -0,0 +1,33 @@
+import { Container } from 'inversify';
+import type { IOCIdentifierMap } from '@config/IOCIdentifier';
+import type {
+  IOCContainerInterface,
+  ServiceIdentifier
+} from '@qlover/corekit-bridge';
+
+export class InversifyContainer implements IOCContainerInterface {
+  protected container: Container;
+
+  constructor() {
+    this.container = new Container({
+      // allow `@injectable` decorator, auto bind injectable classes
+      autobind: true,
+      // use singleton scope
+      defaultScope: 'Singleton'
+    });
+  }
+
+  bind<T>(key: ServiceIdentifier<T>, value: T): void {
+    this.container.bind<T>(key).toConstantValue(value);
+  }
+
+  get<K extends keyof IOCIdentifierMap>(
+    serviceIdentifier: K
+  ): IOCIdentifierMap[K];
+  get<T>(serviceIdentifier: ServiceIdentifier<T>): T;
+  get<T, K extends keyof IOCIdentifierMap>(
+    serviceIdentifier: ServiceIdentifier<T> | K
+  ): T | IOCIdentifierMap[K] {
+    return this.container.get<T>(serviceIdentifier);
+  }
+}

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

@@ -0,0 +1,16 @@
+import { injectable } from 'inversify';
+import type { UIBridgeInterface } from '@qlover/corekit-bridge';
+import type { AppRouterInstance } from 'next/dist/shared/lib/app-router-context.shared-runtime';
+
+@injectable()
+export class NavigateBridge implements UIBridgeInterface<AppRouterInstance> {
+  protected navigate: AppRouterInstance | null = null;
+
+  setUIBridge(ui: AppRouterInstance): void {
+    this.navigate = ui;
+  }
+
+  getUIBridge(): AppRouterInstance | null {
+    return this.navigate;
+  }
+}

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

@@ -0,0 +1,74 @@
+import { notFound } from 'next/navigation';
+import { getMessages, getTranslations } from 'next-intl/server';
+import { i18nConfig } from '@config/i18n';
+import type { ParamsHandlerInterface as ParamsHandlerInterface } from '../port/ParamsHandlerInterface';
+import type { LocaleType, PageI18nInterface } from '@config/i18n';
+
+export interface PageWithParams {
+  params?: Promise<PageParamsType>;
+}
+
+export interface PageParamsType {
+  locale?: string;
+}
+
+/**
+ * Handler Page Params
+ */
+export class PageParams implements ParamsHandlerInterface {
+  private locale: string | null;
+
+  constructor(protected readonly params: PageParamsType) {
+    this.locale = this.params.locale || i18nConfig.fallbackLng;
+  }
+
+  public getLocale(defaultLocale?: string): string {
+    if (this.locale) {
+      return this.locale;
+    }
+
+    this.locale = this.params.locale || defaultLocale || i18nConfig.fallbackLng;
+
+    return this.locale;
+  }
+
+  public getI18nWithNotFound(): string {
+    const locale = this.getLocale();
+
+    if (!i18nConfig.supportedLngs.includes(locale as LocaleType)) {
+      notFound();
+    }
+
+    return locale;
+  }
+
+  public async getI18nMessages(): Promise<Record<string, string>> {
+    const locale = this.getLocale();
+
+    const messages = await getMessages({ locale });
+
+    return messages;
+  }
+
+  public async getI18nInterface<T extends PageI18nInterface>(
+    i18nInterface: T,
+    namespace?: string
+  ): Promise<T> {
+    // Load translation messages from the HomePage namespace
+    const t = await getTranslations({
+      locale: this.getLocale(),
+      namespace: namespace
+    });
+
+    const result = Object.fromEntries(
+      Object.entries(i18nInterface).map(([key, value]) => {
+        if (typeof value === 'string') {
+          return [key, t(value)];
+        }
+        return [key, value];
+      })
+    ) as T;
+
+    return result;
+  }
+}

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

@@ -0,0 +1,35 @@
+import { inject, injectable } from 'inversify';
+import { NavigateBridge } from './NavigateBridge';
+import type { RouterInterface, RouterPathname } from '../port/RouterInterface';
+import type { UIBridgeInterface } from '@qlover/corekit-bridge';
+import type { AppRouterInstance } from 'next/dist/shared/lib/app-router-context.shared-runtime';
+
+@injectable()
+export class RouterService implements RouterInterface {
+  protected locale: string = '';
+
+  constructor(
+    @inject(NavigateBridge)
+    protected uiBridge: UIBridgeInterface<AppRouterInstance>
+  ) {}
+
+  protected padLocaleHref(href: RouterPathname): string {
+    return `/${this.locale}${href === '/' ? '' : href}`;
+  }
+
+  goto(href: RouterPathname): void {
+    this.uiBridge.getUIBridge()?.push(this.padLocaleHref(href));
+  }
+
+  gotoHome(): void {
+    this.goto('/');
+  }
+
+  setLocale(locale: string): void {
+    this.locale = locale;
+  }
+
+  getLocale(): string {
+    return this.locale;
+  }
+}

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

@@ -0,0 +1,17 @@
+import { cookies } from 'next/headers';
+import { I } from '@config/IOCIdentifier';
+import type { ServerAuthInterface } from '../port/ServerAuthInterface';
+import type { ServerInterface } from '../port/ServerInterface';
+
+export class ServerAuth implements ServerAuthInterface {
+  constructor(protected server: ServerInterface) {}
+
+  async hasAuth(): Promise<boolean> {
+    const cookieStore = await cookies();
+    const appConfig = this.server.getIOC(I.AppConfig);
+
+    const token = cookieStore.get(appConfig.userTokenKey);
+
+    return !!token;
+  }
+}

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

@@ -0,0 +1,27 @@
+import { ExecutorError, type ExecutorContext } from '@qlover/fe-corekit';
+import { SERVER_AUTH_ERROR } from '@config/Identifier';
+import type { BootstrapServerContextValue } from '@/core/bootstraps/BootstrapServer';
+import type { BootstrapExecutorPlugin } from '@qlover/corekit-bridge';
+
+export class ServerErrorHandler implements BootstrapExecutorPlugin {
+  pluginName = 'ServerErrorHandler';
+
+  onError(
+    context: ExecutorContext<BootstrapServerContextValue>
+  ): ExecutorError | void {
+    const { parameters, error } = context;
+    const { messages } = parameters;
+
+    if (error instanceof Error) {
+      const messageId = error.message;
+
+      if (messageId === SERVER_AUTH_ERROR) {
+        const message = messages[messageId];
+
+        if (message) {
+          return new ExecutorError(messageId, message);
+        }
+      }
+    }
+  }
+}

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

@@ -0,0 +1,25 @@
+import {
+  StoreInterface,
+  type StoreStateInterface
+} from '@qlover/corekit-bridge';
+import type { i18nConfig } from '@config/i18n';
+
+export type SupportedLocale = (typeof i18nConfig.supportedLngs)[number];
+export type SupportedNamespace = typeof i18nConfig.fallbackLng;
+export type I18nServiceLocale = SupportedLocale;
+
+export class I18nServiceState implements StoreStateInterface {
+  loading: boolean = false;
+  constructor(public language: I18nServiceLocale) {}
+}
+export abstract class I18nServiceInterface
+  extends StoreInterface<I18nServiceState>
+  implements I18nServiceInterface
+{
+  abstract t(key: string, params?: Record<string, unknown>): Promise<string>;
+  abstract changeLanguage(language: I18nServiceLocale): Promise<void>;
+  abstract changeLoading(loading: boolean): void;
+  abstract getCurrentLanguage(): Promise<I18nServiceLocale>;
+  abstract isValidLanguage(language: string): language is I18nServiceLocale;
+  abstract getSupportedLanguages(): I18nServiceLocale[];
+}

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

@@ -0,0 +1,24 @@
+import type {
+  EnvConfigInterface,
+  IOCContainerInterface,
+  IOCFunctionInterface
+} from '@qlover/corekit-bridge';
+
+/**
+ * IOC register options
+ */
+export type IocRegisterOptions = {
+  /**
+   * The app config
+   */
+  appConfig: EnvConfigInterface;
+};
+
+export interface IOCInterface<
+  IdentifierMap,
+  IOCContainer extends IOCContainerInterface
+> {
+  create(
+    options: IocRegisterOptions
+  ): IOCFunctionInterface<IdentifierMap, IOCContainer>;
+}

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

@@ -0,0 +1,11 @@
+import type { PageI18nInterface } from '@config/i18n';
+
+export interface ParamsHandlerInterface {
+  getLocale(defaultLocale?: string): string;
+  getI18nWithNotFound(): string;
+  getI18nMessages(): Promise<Record<string, string>>;
+  getI18nInterface<T extends PageI18nInterface>(
+    i18nInterface: T,
+    namespace?: string
+  ): Promise<T>;
+}

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

@@ -0,0 +1,11 @@
+import type { redirect } from '@/i18n/routing';
+export type RouterPathname = Parameters<typeof redirect>[0]['href'];
+
+export interface RouterInterface {
+  gotoHome(): void;
+  goto(href: RouterPathname): void;
+
+  getLocale(): string;
+
+  setLocale(locale: string): void;
+}

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

@@ -0,0 +1,3 @@
+export interface ServerAuthInterface {
+  hasAuth(): Promise<boolean>;
+}

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

@@ -0,0 +1,12 @@
+import {
+  type IOCContainerInterface,
+  type IOCFunctionInterface
+} from '@qlover/corekit-bridge';
+import { type IOCIdentifierMapServer } from '@config/IOCIdentifier';
+
+export interface ServerInterface {
+  getIOC(): IOCFunctionInterface<IOCIdentifierMapServer, IOCContainerInterface>;
+  getIOC<T extends keyof IOCIdentifierMapServer>(
+    identifier: T
+  ): IOCIdentifierMapServer[T];
+}

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

@@ -0,0 +1,11 @@
+import { ImagicaAuthService } from '@brain-toolkit/bridge';
+import type { ExecutorPlugin } from '@qlover/fe-corekit';
+
+export abstract class UserServiceInterface
+  extends ImagicaAuthService
+  implements ExecutorPlugin
+{
+  readonly pluginName = 'UserService';
+
+  abstract getToken(): string | null;
+}

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

@@ -0,0 +1,115 @@
+import { useLocaleRoutes } from '@config/common';
+import { i18nConfig } from '@config/i18n';
+import {
+  I18nServiceInterface,
+  I18nServiceState
+} from '../port/I18nServiceInterface';
+import type { I18nServiceLocale } from '../port/I18nServiceInterface';
+import type { useTranslations } from 'next-intl';
+
+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;
+
+  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;
+  }
+
+  setTranslator(translator: TranslationFunction): void {
+    this.translator = translator;
+  }
+
+  /**
+   * @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;
+  }
+
+  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);
+      }
+    } finally {
+      this.changeLoading(false);
+    }
+  }
+
+  override changeLoading(loading: boolean): void {
+    this.emit({ ...this.state, loading });
+  }
+
+  override async getCurrentLanguage(): Promise<I18nServiceLocale> {
+    await this.ensureInitialized();
+    return this.getCurrentLanguageFromPath() as I18nServiceLocale;
+  }
+
+  override isValidLanguage(language: string): language is I18nServiceLocale {
+    return i18nConfig.supportedLngs.includes(language as I18nServiceLocale);
+  }
+
+  override getSupportedLanguages(): I18nServiceLocale[] {
+    return [...i18nConfig.supportedLngs];
+  }
+
+  override async t(
+    key: string,
+    params?: Record<string, string | number | Date>
+  ): Promise<string> {
+    await this.ensureInitialized();
+
+    if (!this.translator) {
+      return key;
+    }
+
+    try {
+      return this.translator(key, params);
+    } catch {
+      return key;
+    }
+  }
+}

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

@@ -0,0 +1,23 @@
+import { CookieStorage } from '@qlover/corekit-bridge';
+import { injectable, inject } from 'inversify';
+import { AppConfig } from '../cases/AppConfig';
+import { UserServiceInterface } from '../port/UserServiceInterface';
+
+@injectable()
+export class UserService extends UserServiceInterface {
+  constructor(@inject(AppConfig) protected appConfig: AppConfig) {
+    super({
+      credentialStorage: {
+        key: appConfig.userTokenKey,
+        storage: new CookieStorage()
+      },
+      requestConfig: {
+        env: appConfig.env !== 'production' ? 'development' : 'production'
+      }
+    });
+  }
+
+  getToken(): string | null {
+    return this.store.getCredential();
+  }
+}

package/dist/templates/next-app/src/base/types/PageProps.ts

@@ -0,0 +1,9 @@
+import type { PageWithParams } from '@/base/cases/PageParams';
+
+export interface PageParamsProps extends PageWithParams {
+  searchParams: Promise<{ [key: string]: string | string[] | undefined }>;
+}
+
+export interface PageLayoutProps extends PageWithParams {
+  children: React.ReactNode;
+}

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

@@ -0,0 +1,61 @@
+import { Bootstrap } from '@qlover/corekit-bridge';
+import { isObject } from 'lodash';
+import { browserGlobalsName } from '@config/common';
+import { BootstrapsRegistry } from './BootstrapsRegistry';
+import * as globals from '../globals';
+import type { IOCIdentifierMap } from '@config/IOCIdentifier';
+import type {
+  IOCContainerInterface,
+  IOCFunctionInterface
+} from '@qlover/corekit-bridge';
+
+export type BootstrapAppArgs = {
+  /**
+   * 启动的根节点，通常是window
+   */
+  root: unknown;
+  /**
+   * 当前路径
+   */
+  pathname: string;
+  /**
+   * IOC容器
+   */
+  IOC: IOCFunctionInterface<IOCIdentifierMap, IOCContainerInterface>;
+};
+
+export class BootstrapClient {
+  static async main(args: BootstrapAppArgs): Promise<BootstrapAppArgs> {
+    const { root, IOC } = args;
+
+    if (!isObject(root)) {
+      throw new Error('root is not an object');
+    }
+
+    const { logger, appConfig } = globals;
+
+    const bootstrap = new Bootstrap({
+      root,
+      logger,
+      ioc: {
+        manager: IOC
+      },
+      globalOptions: {
+        sources: globals,
+        target: browserGlobalsName
+      }
+    });
+
+    try {
+      await bootstrap.initialize();
+
+      const bootstrapsRegistry = new BootstrapsRegistry(args);
+
+      await bootstrap.use(bootstrapsRegistry.register()).start();
+    } catch (error) {
+      logger.error(`${appConfig.appName} starup error:`, error);
+    }
+
+    return args;
+  }
+}