@qlover/create-app 0.7.9 → 0.7.10

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 { I } from '@config/IOCIdentifier';
+import { useIOC } from '@/uikit/hook/useIOC';
+import type { RegisterI18nInterface } from '@config/i18n';
+
+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 { i18nConfig, register18n } from '@config/i18n';
+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 { 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/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/AppConfig.ts

@@ -1,3 +1,4 @@
+import type { StringValue } from 'ms';
 import { name, version } from '../../../package.json';
 import type { EnvConfigInterface } from '@qlover/corekit-bridge';
 
@@ -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,35 @@
+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) {
+      const message = this.i18nService.t(handleError.id);
+      this.dialogHandler.error(message);
+    }
+  }
+}

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