@qlover/create-app 0.7.9 → 0.7.11

package/dist/templates/next-app/src/app/[locale]/page.tsx

@@ -1,12 +1,12 @@
 import { Button } from 'antd';
-import { i18nConfig } from '@config/i18n';
-import { homeI18n } from '@config/i18n/HomeI18n ';
 import { PageParams, type PageParamsType } from '@/base/cases/PageParams';
-import { ServerAuth } from '@/base/cases/ServerAuth';
 import type { PageParamsProps } from '@/base/types/PageProps';
 import { BootstrapServer } from '@/core/bootstraps/BootstrapServer';
 import { redirect } from '@/i18n/routing';
+import { ServerAuth } from '@/server/ServerAuth';
 import { BaseLayout } from '@/uikit/components/BaseLayout';
+import { i18nConfig } from '@config/i18n';
+import { homeI18n } from '@config/i18n/HomeI18n ';
 import type { Metadata } from 'next';
 
 // const navigationItems = [
@@ -45,12 +45,12 @@ export default async function Home({ params }: PageParamsProps) {
   const locale = pageParams.getLocale();
   const tt = await pageParams.getI18nInterface(homeI18n);
 
-  if (!(await new ServerAuth(server).hasAuth())) {
+  if (!(await server.getIOC(ServerAuth).hasAuth())) {
     return redirect({ href: '/login', locale });
   }
 
   return (
-    <BaseLayout data-testid="HomePage">
+    <BaseLayout data-testid="HomePage" showLogoutButton showAdminButton>
       {/* Hero Section */}
       <section className="py-16 px-4">
         <div className="max-w-4xl mx-auto text-center">

package/dist/templates/next-app/src/app/[locale]/register/RegisterForm.tsx

@@ -0,0 +1,176 @@
+'use client';
+
+import { LockOutlined, MailOutlined, UserOutlined } from '@ant-design/icons';
+import { Button, Checkbox, Form, Input } from 'antd';
+import { useState } from 'react';
+import { useIOC } from '@/uikit/hook/useIOC';
+import type { RegisterI18nInterface } from '@config/i18n';
+import { I } from '@config/IOCIdentifier';
+
+export function RegisterForm(props: { tt: RegisterI18nInterface }) {
+  const { tt } = props;
+  const userService = useIOC(I.UserServiceInterface);
+  const logger = useIOC(I.Logger);
+  const routerService = useIOC(I.RouterServiceInterface);
+  const [loading, setLoading] = useState(false);
+
+  const handleRegister = async (values: unknown) => {
+    try {
+      setLoading(true);
+      await userService.register(values);
+      routerService.gotoLogin();
+    } catch (error) {
+      logger.error(error);
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  const handleLoginClick = (e: React.MouseEvent) => {
+    e.preventDefault();
+    routerService.gotoLogin();
+  };
+
+  return (
+    <Form
+      data-testid="RegisterForm"
+      name="register"
+      onFinish={handleRegister}
+      layout="vertical"
+      className="space-y-4"
+      validateTrigger="onSubmit"
+    >
+      <Form.Item
+        name="username"
+        rules={[
+          {
+            required: true,
+            message: tt.username_required
+          }
+        ]}
+      >
+        <Input
+          prefix={<UserOutlined className="text-text-tertiary" />}
+          placeholder={tt.username}
+          className="h-12 text-base bg-secondary border-border"
+        />
+      </Form.Item>
+
+      <Form.Item
+        name="email"
+        rules={[
+          {
+            required: true,
+            type: 'email',
+            message: tt.email_required
+          }
+        ]}
+      >
+        <Input
+          prefix={<MailOutlined className="text-text-tertiary" />}
+          placeholder={tt.email}
+          className="h-12 text-base bg-secondary border-border"
+        />
+      </Form.Item>
+
+      <Form.Item
+        name="password"
+        rules={[
+          {
+            required: true,
+            message: tt.password_required
+          }
+        ]}
+      >
+        <Input.Password
+          prefix={<LockOutlined />}
+          placeholder={tt.password}
+          className="h-12 text-base"
+        />
+      </Form.Item>
+
+      <Form.Item
+        name="confirmPassword"
+        dependencies={['password']}
+        rules={[
+          {
+            required: true,
+            message: tt.confirm_password_required
+          },
+          ({ getFieldValue }) => ({
+            validator(_, value) {
+              if (!value || getFieldValue('password') === value) {
+                return Promise.resolve();
+              }
+              return Promise.reject(tt.password_mismatch);
+            }
+          })
+        ]}
+      >
+        <Input.Password
+          prefix={<LockOutlined />}
+          placeholder={tt.confirm_password}
+          className="h-12 text-base"
+        />
+      </Form.Item>
+
+      <Form.Item
+        name="agreeToTerms"
+        valuePropName="checked"
+        rules={[
+          {
+            validator: (_, value) =>
+              value
+                ? Promise.resolve()
+                : Promise.reject(new Error(tt.terms_required))
+          }
+        ]}
+      >
+        <Checkbox>
+          <span className="text-text-secondary">
+            {tt.terms_prefix}{' '}
+            <a
+              href="#"
+              className="text-brand hover:text-brand-hover"
+              target="_blank"
+              rel="noopener noreferrer"
+            >
+              {tt.terms_link}
+            </a>{' '}
+            {tt.terms_and}{' '}
+            <a
+              href="#"
+              className="text-brand hover:text-brand-hover"
+              target="_blank"
+              rel="noopener noreferrer"
+            >
+              {tt.privacy_link}
+            </a>
+          </span>
+        </Checkbox>
+      </Form.Item>
+
+      <Form.Item>
+        <Button
+          type="primary"
+          htmlType="submit"
+          loading={loading}
+          className="w-full h-12 text-base"
+        >
+          {tt.button}
+        </Button>
+      </Form.Item>
+
+      <div className="text-center mt-6">
+        <span className="text-text-tertiary">{tt.have_account} </span>
+        <a
+          href="#"
+          className="text-brand hover:text-brand-hover"
+          onClick={handleLoginClick}
+        >
+          {tt.login_link}
+        </a>
+      </div>
+    </Form>
+  );
+}

package/dist/templates/next-app/src/app/[locale]/register/page.tsx

@@ -0,0 +1,79 @@
+import { notFound } from 'next/navigation';
+import { PageParams, type PageParamsType } from '@/base/cases/PageParams';
+import type { PageParamsProps } from '@/base/types/PageProps';
+import { BootstrapServer } from '@/core/bootstraps/BootstrapServer';
+import { redirect } from '@/i18n/routing';
+import { ServerAuth } from '@/server/ServerAuth';
+import { BaseLayout } from '@/uikit/components/BaseLayout';
+import { FeatureItem } from '@/uikit/components/FeatureItem';
+import { i18nConfig, register18n } from '@config/i18n';
+import { RegisterForm } from './RegisterForm';
+import type { Metadata } from 'next';
+
+// Generate static params for all supported locales (used for SSG)
+export async function generateStaticParams() {
+  // Return one entry for each supported locale
+  return i18nConfig.supportedLngs.map((locale) => ({ locale }));
+}
+
+// Allow Next.js to statically generate this page if possible (default behavior)
+export const dynamic = 'auto'; // Enable static generation when possible, fallback to dynamic if needed
+
+// Optional: Use revalidate if you want ISR (Incremental Static Regeneration)
+// export const revalidate = 3600; // Rebuild every hour (optional)
+
+// Generate localized SEO metadata per locale (Next.js 15+ best practice)
+export async function generateMetadata({
+  params
+}: {
+  params: Promise<PageParamsType>;
+}): Promise<Metadata> {
+  const pageParams = new PageParams(await params);
+
+  return await pageParams.getI18nInterface(register18n);
+}
+
+export default async function LoginPage(props: PageParamsProps) {
+  if (!props.params) {
+    return notFound();
+  }
+
+  const params = await props.params;
+  const pageParams = new PageParams(params);
+
+  const server = new BootstrapServer();
+
+  if (await server.getIOC(ServerAuth).hasAuth()) {
+    return redirect({ href: '/', locale: params.locale! });
+  }
+
+  const tt = await pageParams.getI18nInterface(register18n);
+
+  return (
+    <BaseLayout
+      data-testid="RegisterPage"
+      mainProps={{
+        className: 'text-xs1 bg-primary flex min-h-screen'
+      }}
+    >
+      <div className="hidden lg:flex bg-secondary lg:w-1/2 p-12 flex-col">
+        <h1 className="text-4xl font-bold text-text mb-4">{tt.welcome}</h1>
+        <p className="text-text-secondary text-lg mb-8">{tt.subtitle}</p>
+        <div className="space-y-4">
+          <FeatureItem icon="🎯" text={tt.feature_ai_paths} />
+          <FeatureItem icon="🎯" text={tt.feature_smart_recommendations} />
+          <FeatureItem icon="📊" text={tt.feature_progress_tracking} />
+        </div>
+      </div>
+
+      <div className="w-full lg:w-1/2 p-8 sm:p-12 flex items-center justify-center">
+        <div className="w-full max-w-[420px]">
+          <h2 className="text-2xl font-semibold mb-2 text-text">{tt.title}</h2>
+          <p className="text-text-secondary mb-8">{tt.subtitle}</p>
+
+          <RegisterForm tt={tt} />
+        </div>
+      </div>
+    </BaseLayout>
+  );
+}

package/dist/templates/next-app/src/app/api/admin/users/route.ts

@@ -0,0 +1,39 @@
+import { ExecutorError } from '@qlover/fe-corekit';
+import { NextResponse } from 'next/server';
+import { BootstrapServer } from '@/core/bootstraps/BootstrapServer';
+import { AppErrorApi } from '@/server/AppErrorApi';
+import { AppSuccessApi } from '@/server/AppSuccessApi';
+import { AdminAuthPlugin } from '@/server/services/AdminAuthPlugin';
+import { ApiUserService } from '@/server/services/ApiUserService';
+import { PaginationValidator } from '@/server/validators/PaginationValidator';
+import type { NextRequest } from 'next/server';
+
+export async function GET(req: NextRequest) {
+  const server = new BootstrapServer();
+
+  const result = await server
+    .use(new AdminAuthPlugin())
+    .execNoError(async ({ parameters: { IOC } }) => {
+      const searchParams = Object.fromEntries(
+        req.nextUrl.searchParams.entries()
+      );
+      const paginationParams = IOC(PaginationValidator).getThrow(searchParams);
+
+      const apiUserService = IOC(ApiUserService);
+
+      const result = await apiUserService.getUsers({
+        page: paginationParams.page,
+        pageSize: paginationParams.pageSize
+      });
+
+      return result;
+    });
+
+  if (result instanceof ExecutorError) {
+    return NextResponse.json(new AppErrorApi(result.id, result.message), {
+      status: 400
+    });
+  }
+
+  return NextResponse.json(new AppSuccessApi(result));
+}

package/dist/templates/next-app/src/app/api/user/login/route.ts

@@ -0,0 +1,50 @@
+import { ExecutorError } from '@qlover/fe-corekit';
+import { NextResponse } from 'next/server';
+import { StringEncryptor } from '@/base/cases/StringEncryptor';
+import { BootstrapServer } from '@/core/bootstraps/BootstrapServer';
+import { AppErrorApi } from '@/server/AppErrorApi';
+import { AppSuccessApi } from '@/server/AppSuccessApi';
+import type { UserServiceInterface } from '@/server/port/UserServiceInterface';
+import { ServerAuth } from '@/server/ServerAuth';
+import { UserService } from '@/server/services/UserService';
+import { LoginValidator } from '@/server/validators/LoginValidator';
+import type { UserSchema } from '@migrations/schema/UserSchema';
+import type { NextRequest } from 'next/server';
+
+export async function POST(req: NextRequest) {
+  const server = new BootstrapServer();
+
+  const result = await server.execNoError(async ({ parameters: { IOC } }) => {
+    const requestBody = await req.json();
+
+    try {
+      if (requestBody.password) {
+        requestBody.password = IOC(StringEncryptor).decrypt(
+          requestBody.password
+        );
+      }
+    } catch {
+      throw new ExecutorError(
+        'encrypt_password_failed',
+        'Encrypt password failed'
+      );
+    }
+    const body = IOC(LoginValidator).getThrow(requestBody);
+
+    const userService: UserServiceInterface = IOC(UserService);
+
+    const user = (await userService.login(body)) as UserSchema;
+
+    await IOC(ServerAuth).setAuth(user.credential_token);
+
+    return user;
+  });
+
+  if (result instanceof ExecutorError) {
+    return NextResponse.json(new AppErrorApi(result.id, result.message), {
+      status: 400
+    });
+  }
+
+  return NextResponse.json(new AppSuccessApi(result));
+}

package/dist/templates/next-app/src/app/api/user/logout/route.ts

@@ -0,0 +1,27 @@
+import { ExecutorError } from '@qlover/fe-corekit';
+import { NextResponse } from 'next/server';
+import { BootstrapServer } from '@/core/bootstraps/BootstrapServer';
+import { AppErrorApi } from '@/server/AppErrorApi';
+import { AppSuccessApi } from '@/server/AppSuccessApi';
+import type { UserServiceInterface } from '@/server/port/UserServiceInterface';
+import { UserService } from '@/server/services/UserService';
+
+export async function POST() {
+  const server = new BootstrapServer();
+
+  const result = await server.execNoError(async ({ parameters: { IOC } }) => {
+    const userService: UserServiceInterface = IOC(UserService);
+
+    await userService.logout();
+
+    return true;
+  });
+
+  if (result instanceof ExecutorError) {
+    return NextResponse.json(new AppErrorApi(result.id, result.message), {
+      status: 400
+    });
+  }
+
+  return NextResponse.json(new AppSuccessApi(result));
+}

package/dist/templates/next-app/src/app/api/user/register/route.ts

@@ -0,0 +1,50 @@
+import { ExecutorError } from '@qlover/fe-corekit';
+import { NextResponse } from 'next/server';
+import { StringEncryptor } from '@/base/cases/StringEncryptor';
+import { BootstrapServer } from '@/core/bootstraps/BootstrapServer';
+import { AppErrorApi } from '@/server/AppErrorApi';
+import { AppSuccessApi } from '@/server/AppSuccessApi';
+import type { UserServiceInterface } from '@/server/port/UserServiceInterface';
+import { UserService } from '@/server/services/UserService';
+import { LoginValidator } from '@/server/validators/LoginValidator';
+import type { NextRequest } from 'next/server';
+
+export async function POST(req: NextRequest) {
+  const server = new BootstrapServer();
+
+  const result = await server.execNoError(async ({ parameters: { IOC } }) => {
+    const requestBody = await req.json();
+
+    try {
+      if (requestBody.password) {
+        requestBody.password = IOC(StringEncryptor).decrypt(
+          requestBody.password
+        );
+      }
+    } catch {
+      throw new ExecutorError(
+        'encrypt_password_failed',
+        'Encrypt password failed'
+      );
+    }
+
+    const body = IOC(LoginValidator).getThrow(requestBody);
+
+    const userService: UserServiceInterface = IOC(UserService);
+
+    const user = await userService.register({
+      email: body.email,
+      password: body.password
+    });
+
+    return user;
+  });
+
+  if (result instanceof ExecutorError) {
+    return NextResponse.json(new AppErrorApi(result.id, result.message), {
+      status: 400
+    });
+  }
+
+  return NextResponse.json(new AppSuccessApi(result));
+}

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

@@ -0,0 +1,40 @@
+import { injectable } from 'inversify';
+import { AdminLayoutInterface } from '../port/AdminLayoutInterface';
+import type {
+  NavItemInterface,
+  AdminPageState
+} from '../port/AdminLayoutInterface';
+
+const defaultNavItems: NavItemInterface[] = [
+  {
+    key: 'dashboard',
+    i18nKey: 'Dashboard',
+    pathname: '/admin'
+  },
+  {
+    key: 'users',
+    i18nKey: 'User Management',
+    pathname: '/admin/users'
+  }
+];
+
+class AdminPageManagerState implements AdminPageState {
+  collapsedSidebar = false;
+
+  navItems: NavItemInterface[] = defaultNavItems;
+}
+
+@injectable()
+export class AdminPageManager extends AdminLayoutInterface {
+  constructor() {
+    super(() => new AdminPageManagerState());
+  }
+
+  override toggleSidebar(): void {
+    this.emit(
+      this.cloneState({
+        collapsedSidebar: !this.state.collapsedSidebar
+      })
+    );
+  }
+}

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

@@ -1,5 +1,6 @@
 import { name, version } from '../../../package.json';
 import type { EnvConfigInterface } from '@qlover/corekit-bridge';
+import type { StringValue } from 'ms';
 
 export class AppConfig implements EnvConfigInterface {
   /**
@@ -12,4 +13,22 @@ export class AppConfig implements EnvConfigInterface {
   readonly appVersion: string = version;
 
   readonly userTokenKey: string = '_user_token';
+
+  readonly testLoginEmail: string = process.env.NEXT_PUBLIC_LOGIN_USER!;
+  readonly testLoginPassword: string = process.env.NEXT_PUBLIC_LOGIN_PASSWORD!;
+
+  readonly supabaseUrl: string = process.env.SUPABASE_URL!;
+  readonly supabaseAnonKey: string = process.env.SUPABASE_ANON_KEY!;
+
+  readonly stringEncryptorKey: string =
+    process.env.NEXT_PUBLIC_STRING_ENCRYPT_KEY!;
+
+  readonly jwtSecret: string = process.env.JWT_SECRET!;
+  /**
+   * login user token expires in
+   *
+   * @example '30 days'
+   * @example '1 year'
+   */
+  readonly jwtExpiresIn: StringValue = '30 days';
 }

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

@@ -0,0 +1,46 @@
+import {
+  ExecutorError,
+  type ExecutorContext,
+  type ExecutorPlugin
+} from '@qlover/fe-corekit';
+import { inject, injectable } from 'inversify';
+import { I } from '@config/IOCIdentifier';
+import type { DialogHandlerOptions } from './DialogHandler';
+import type { I18nServiceInterface } from '../port/I18nServiceInterface';
+import type { UIDialogInterface } from '@qlover/corekit-bridge';
+
+@injectable()
+export class DialogErrorPlugin implements ExecutorPlugin {
+  readonly pluginName = 'DialogErrorPlugin';
+
+  constructor(
+    @inject(I.DialogHandler)
+    protected dialogHandler: UIDialogInterface<DialogHandlerOptions>,
+    @inject(I.I18nServiceInterface) protected i18nService: I18nServiceInterface
+  ) {}
+
+  onError(context: ExecutorContext<unknown>): void | Promise<void> {
+    const { error, hooksRuntimes } = context;
+    const runtimesError = hooksRuntimes.returnValue;
+
+    // 优先使用 runtime 的错误, 他可能在运行时被修改
+    // 比如 RequestError 会被 AppApiPlugin 修改为 ExecutorError
+    const handleError = runtimesError || error;
+
+    if (handleError instanceof ExecutorError) {
+      if (this.isI18nMessage(handleError.message)) {
+        const message = this.i18nService.t(handleError.id);
+        this.dialogHandler.error(message);
+      } else {
+        this.dialogHandler.error(handleError.message);
+      }
+    }
+  }
+
+  protected isI18nMessage(message: string): boolean {
+    // Check if message follows the pattern of underscore-separated format
+    // e.g., "namespace_key" or "namespace__key"
+    const pattern = /^[a-zA-Z]+(?:_[a-zA-Z]+)+$|^[a-zA-Z]+(?:__[a-zA-Z]+)+$/;
+    return pattern.test(message);
+  }
+}

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

@@ -1,8 +1,8 @@
 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';
+import type { ParamsHandlerInterface as ParamsHandlerInterface } from '../port/ParamsHandlerInterface';
 
 export interface PageWithParams {
   params?: Promise<PageParamsType>;

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

@@ -0,0 +1,20 @@
+import type { AsyncStateInterface } from '@/base/port/AsyncStateInterface';
+
+export class RequestState<T = unknown> implements AsyncStateInterface<T> {
+  startTime: number;
+  endTime: number;
+
+  constructor(
+    public loading: boolean = false,
+    public result: T | null = null,
+    public error: unknown | null = null
+  ) {
+    this.startTime = Date.now();
+    this.endTime = 0;
+  }
+
+  end(): this {
+    this.endTime = Date.now();
+    return this;
+  }
+}

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