@qlover/create-app 0.7.9 → 0.7.10

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

@@ -0,0 +1,12 @@
+import crypto from 'crypto';
+import type { Encryptor } from '@qlover/fe-corekit';
+
+export class PasswordEncrypt implements Encryptor<string, string> {
+  encrypt(password: string): string {
+    return crypto.createHash('md5').update(password).digest('hex');
+  }
+
+  decrypt(): string {
+    throw new Error('Md5Encrypt is not decryptable');
+  }
+}

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

@@ -0,0 +1,50 @@
+import { inject, injectable } from 'inversify';
+import { cookies } from 'next/headers';
+import { I } from '@config/IOCIdentifier';
+import type { AppConfig } from '@/base/cases/AppConfig';
+import { UserCredentialToken } from './UserCredentialToken';
+import type { UserAuthInterface } from './port/UserAuthInterface';
+
+@injectable()
+export class ServerAuth implements UserAuthInterface {
+  protected userTokenKey: string;
+  constructor(
+    @inject(I.AppConfig) protected server: AppConfig,
+    @inject(UserCredentialToken)
+    protected userCredentialToken: UserCredentialToken
+  ) {
+    this.userTokenKey = server.userTokenKey;
+  }
+
+  async setAuth(credential_token: string): Promise<void> {
+    const cookieStore = await cookies();
+
+    cookieStore.set(this.userTokenKey, credential_token);
+  }
+
+  async hasAuth(): Promise<boolean> {
+    const token = await this.getAuth();
+
+    if (!token) {
+      return false;
+    }
+
+    try {
+      const user = await this.userCredentialToken.parseToken(token);
+
+      return !!user;
+    } catch {
+      return false;
+    }
+  }
+
+  async getAuth(): Promise<string> {
+    const cookieStore = await cookies();
+    return cookieStore.get(this.userTokenKey)?.value || '';
+  }
+
+  async clear(): Promise<void> {
+    const cookieStore = await cookies();
+    cookieStore.delete(this.userTokenKey);
+  }
+}

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

@@ -0,0 +1,124 @@
+import {
+  createClient,
+  type PostgrestSingleResponse,
+  type SupabaseClient
+} from '@supabase/supabase-js';
+import { injectable, inject } from 'inversify';
+import { I } from '@config/IOCIdentifier';
+import type { AppConfig } from '@/base/cases/AppConfig';
+import type {
+  BridgeEvent,
+  DBBridgeInterface,
+  Where
+} from '@/base/port/DBBridgeInterface';
+import type { LoggerInterface } from '@qlover/logger';
+import type { PostgrestFilterBuilder } from '@supabase/postgrest-js';
+
+const whereHandlerMaps = {
+  '=': 'eq',
+  '!=': 'neq',
+  '>': 'gt',
+  '<': 'lt',
+  '>=': 'gte',
+  '<=': 'lte'
+};
+
+@injectable()
+export class SupabaseBridge implements DBBridgeInterface {
+  protected supabase: SupabaseClient;
+
+  constructor(
+    @inject(I.AppConfig) appConfig: AppConfig,
+    @inject(I.Logger) protected logger: LoggerInterface
+  ) {
+    this.supabase = createClient(
+      appConfig.supabaseUrl,
+      appConfig.supabaseAnonKey
+    );
+  }
+
+  getSupabase(): SupabaseClient {
+    return this.supabase;
+  }
+
+  async execSql(sql: string): Promise<PostgrestSingleResponse<unknown>> {
+    const res = await this.supabase.rpc('exec_sql', { sql });
+    return this.catch(res);
+  }
+
+  protected async catch(
+    result: PostgrestSingleResponse<unknown>
+  ): Promise<PostgrestSingleResponse<unknown>> {
+    if (result.error) {
+      this.logger.info(result);
+      throw new Error(result.error.message);
+    }
+    return result;
+  }
+
+  protected handleWhere(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    handler: PostgrestFilterBuilder<any, any, any, any, string, unknown, any>,
+    wheres: Where[]
+  ): void {
+    for (const where of wheres) {
+      const [key, operator, value] = where;
+      const opr = whereHandlerMaps[operator];
+      if (!opr) {
+        throw new Error(`Unsupported where operation: ${value}`);
+      }
+
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      if (typeof (handler as any)[opr] !== 'function') {
+        throw new Error(`Unsupported where operation: ${value}`);
+      }
+
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      (handler as any)[opr](key, value);
+    }
+  }
+
+  async add(event: BridgeEvent): Promise<PostgrestSingleResponse<unknown>> {
+    const { table, data } = event;
+    if (!data) {
+      throw new Error('Data is required for add operation');
+    }
+    const res = await this.supabase
+      .from(table)
+      .insert(Array.isArray(data) ? data : [data])
+      .select();
+    return this.catch(res);
+  }
+
+  async update(event: BridgeEvent): Promise<PostgrestSingleResponse<unknown>> {
+    const { table, data, where } = event;
+    if (!data) {
+      throw new Error('Data is required for update operation');
+    }
+
+    const handler = this.supabase.from(table).update(data);
+
+    this.handleWhere(handler, where ?? []);
+
+    return this.catch(await handler);
+  }
+
+  async delete(event: BridgeEvent): Promise<PostgrestSingleResponse<unknown>> {
+    const { table, where } = event;
+    const handler = this.supabase.from(table).delete();
+
+    this.handleWhere(handler, where ?? []);
+
+    return this.catch(await handler);
+  }
+
+  async get(event: BridgeEvent): Promise<PostgrestSingleResponse<unknown>> {
+    const { table, fields = '*', where } = event;
+    const selectFields = Array.isArray(fields) ? fields.join(',') : fields;
+    const handler = this.supabase.from(table).select(selectFields);
+
+    this.handleWhere(handler, where ?? []);
+
+    return this.catch(await handler);
+  }
+}

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

@@ -0,0 +1,49 @@
+import { inject, injectable } from 'inversify';
+import jwt from 'jsonwebtoken';
+import { AppConfig } from '@/base/cases/AppConfig';
+import type { CrentialTokenInterface } from './port/CrentialTokenInterface';
+import type { UserSchema } from '@migrations/schema/UserSchema';
+
+export type UserCredentialTokenValue = Pick<UserSchema, 'id' | 'email'>;
+
+@injectable()
+export class UserCredentialToken
+  implements CrentialTokenInterface<UserCredentialTokenValue>
+{
+  protected jwtSecret: string;
+  protected jwtExpiresIn: string;
+
+  constructor(@inject(AppConfig) protected config: AppConfig) {
+    this.jwtSecret = config.jwtSecret;
+    this.jwtExpiresIn = config.jwtExpiresIn;
+  }
+
+  async generateToken(
+    data: UserCredentialTokenValue,
+    options: { expiresIn?: string } = {}
+  ): Promise<string> {
+    const { expiresIn = '30 days' } = options;
+
+    return jwt.sign({ i: data.id, e: data.email }, this.jwtSecret, {
+      expiresIn: expiresIn as jwt.SignOptions['expiresIn'],
+      algorithm: 'HS256',
+      noTimestamp: true
+    });
+  }
+
+  async parseToken(token: string): Promise<UserCredentialTokenValue> {
+    try {
+      const decoded = jwt.verify(token, this.jwtSecret) as {
+        i: UserSchema['id'];
+        e: string;
+      };
+
+      return {
+        id: decoded.i,
+        email: decoded.e
+      };
+    } catch {
+      throw new Error('Invalid token');
+    }
+  }
+}

package/dist/templates/next-app/src/server/port/CrentialTokenInterface.ts

@@ -0,0 +1,5 @@
+export interface CrentialTokenInterface<T> {
+  generateToken(data: T, options?: { expiresIn?: string }): Promise<string>;
+
+  parseToken(token: string): Promise<T>;
+}

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

@@ -0,0 +1,22 @@
+import { type ExecutorError, type PromiseTask } from '@qlover/fe-corekit';
+import { type IOCIdentifierMapServer } from '@config/IOCIdentifier';
+import type {
+  ServiceIdentifier,
+  IOCContainerInterface,
+  IOCFunctionInterface,
+  LoggerInterface
+} from '@qlover/corekit-bridge';
+
+export interface ServerInterface {
+  readonly logger: LoggerInterface;
+
+  getIOC(): IOCFunctionInterface<IOCIdentifierMapServer, IOCContainerInterface>;
+  getIOC<T extends keyof IOCIdentifierMapServer>(
+    identifier: T
+  ): IOCIdentifierMapServer[T];
+  getIOC<T>(serviceIdentifier: ServiceIdentifier<T>): T;
+
+  execNoError<Result>(
+    task?: PromiseTask<Result, unknown>
+  ): Promise<Result | ExecutorError>;
+}

package/dist/templates/next-app/src/server/port/UserAuthInterface.ts

@@ -0,0 +1,9 @@
+export interface UserAuthInterface {
+  setAuth(credential_token: string): Promise<void>;
+
+  getAuth(): Promise<string>;
+
+  clear(): Promise<void>;
+
+  hasAuth(): Promise<boolean>;
+}

package/dist/templates/next-app/src/server/port/UserRepositoryInterface.ts

@@ -0,0 +1,15 @@
+import type { DBTableInterface } from '@/base/port/DBTableInterface';
+import type { UserSchema } from '@migrations/schema/UserSchema';
+
+export interface UserRepositoryInterface extends DBTableInterface {
+  getUserByEmail(email: string): Promise<UserSchema | null>;
+  add(params: {
+    email: string;
+    password: string;
+  }): Promise<UserSchema[] | null>;
+
+  updateById(
+    id: number,
+    params: Partial<Omit<UserSchema, 'id' | 'created_at'>>
+  ): Promise<void>;
+}

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

@@ -0,0 +1,8 @@
+import type { UserSchema } from '@migrations/schema/UserSchema';
+
+export interface UserServiceInterface {
+  register(params: { email: string; password: string }): Promise<UserSchema>;
+  login(params: { email: string; password: string }): Promise<unknown>;
+
+  logout(): Promise<void>;
+}

package/dist/templates/next-app/src/server/port/ValidatorInterface.ts

@@ -0,0 +1,23 @@
+export interface ValidationFaildResult {
+  path: PropertyKey[];
+  message: string;
+}
+
+export interface ValidatorInterface {
+  /**
+   * Validate the data and return validation result
+   * @param data - The data to validate
+   * @returns true if validation passes, or ValidationError if validation fails
+   */
+  validate(
+    data: unknown
+  ): Promise<void | ValidationFaildResult> | void | ValidationFaildResult;
+
+  /**
+   * Get the data if it is valid, otherwise throw an error with validation details
+   * @param data - The data to validate
+   * @returns The data if it is valid
+   * @throws {import('@qlover/fe-corekit').ExecutorError} if the data is invalid, with validation errors
+   */
+  getThrow(data: unknown): unknown;
+}

package/dist/templates/next-app/src/server/repositorys/UserRepository.ts

@@ -0,0 +1,63 @@
+import { inject, injectable } from 'inversify';
+import { isEmpty, last } from 'lodash';
+import type { DBBridgeInterface } from '@/base/port/DBBridgeInterface';
+import { SupabaseBridge } from '../SupabaseBridge';
+import type { UserRepositoryInterface } from '../port/UserRepositoryInterface';
+import type { UserSchema } from '@migrations/schema/UserSchema';
+
+@injectable()
+export class UserRepository implements UserRepositoryInterface {
+  readonly name = 'fe_users';
+
+  constructor(@inject(SupabaseBridge) protected dbBridge: DBBridgeInterface) {}
+
+  getAll(): Promise<unknown> {
+    return this.dbBridge.get({ table: this.name });
+  }
+
+  /**
+   * @override
+   */
+  async getUserByEmail(email: string): Promise<UserSchema | null> {
+    const result = await this.dbBridge.get({
+      table: this.name,
+      where: [['email', '=', email]]
+    });
+
+    if (isEmpty(result.data)) {
+      return null;
+    }
+
+    return last(result.data as UserSchema[]) ?? null;
+  }
+
+  /**
+   * @override
+   */
+  async add(params: {
+    email: string;
+    password: string;
+  }): Promise<UserSchema[] | null> {
+    const result = await this.dbBridge.add({
+      table: this.name,
+      data: params
+    });
+
+    if (isEmpty(result.data)) {
+      return null;
+    }
+
+    return result.data as UserSchema[];
+  }
+
+  async updateById(
+    id: number,
+    params: Partial<Omit<UserSchema, 'id' | 'created_at'>>
+  ): Promise<void> {
+    await this.dbBridge.update({
+      table: this.name,
+      data: params,
+      where: [['id', '=', id]]
+    });
+  }
+}

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

@@ -0,0 +1,105 @@
+import { inject, injectable } from 'inversify';
+import { isEmpty, last, omit } from 'lodash';
+import {
+  API_USER_NOT_FOUND,
+  API_USER_ALREADY_EXISTS
+} from '@config/Identifier/api';
+import { PasswordEncrypt } from '../PasswordEncrypt';
+import { UserRepository } from '../repositorys/UserRepository';
+import { ServerAuth } from '../ServerAuth';
+import {
+  UserCredentialToken,
+  type UserCredentialTokenValue
+} from '../UserCredentialToken';
+import type { CrentialTokenInterface } from '../port/CrentialTokenInterface';
+import type { UserAuthInterface } from '../port/UserAuthInterface';
+import type { UserRepositoryInterface } from '../port/UserRepositoryInterface';
+import type { UserServiceInterface } from '../port/UserServiceInterface';
+import type { UserSchema } from '@migrations/schema/UserSchema';
+import type { Encryptor } from '@qlover/fe-corekit';
+
+@injectable()
+export class UserService implements UserServiceInterface {
+  constructor(
+    @inject(UserRepository)
+    protected userRepository: UserRepositoryInterface,
+    @inject(ServerAuth)
+    protected userAuth: UserAuthInterface,
+    @inject(PasswordEncrypt)
+    protected encryptor: Encryptor<string, string>,
+    @inject(UserCredentialToken)
+    protected credentialToken: CrentialTokenInterface<UserCredentialTokenValue>
+  ) {}
+
+  async register(params: {
+    email: string;
+    password: string;
+  }): Promise<UserSchema> {
+    const user = await this.userRepository.getUserByEmail(params.email);
+
+    if (!isEmpty(user)) {
+      throw new Error(API_USER_ALREADY_EXISTS);
+    }
+
+    const result = await this.userRepository.add({
+      email: params.email,
+      password: this.encryptor.encrypt(params.password)
+    });
+
+    const target = last(result);
+    if (!target) {
+      throw new Error(API_USER_NOT_FOUND);
+    }
+
+    return omit(target, 'password') as UserSchema;
+  }
+
+  async login(params: {
+    email: string;
+    password: string;
+  }): Promise<UserSchema> {
+    const user = await this.userRepository.getUserByEmail(params.email);
+
+    if (!user) {
+      throw new Error(API_USER_NOT_FOUND);
+    }
+
+    const encryptedPassword = this.encryptor.encrypt(params.password);
+
+    if (encryptedPassword !== user.password) {
+      throw new Error(API_USER_NOT_FOUND);
+    }
+
+    const credentialToken = await this.credentialToken.generateToken(user);
+
+    await this.userRepository.updateById(user.id, {
+      credential_token: credentialToken
+    });
+
+    return Object.assign(omit(user, 'password') as UserSchema, {
+      credential_token: credentialToken
+    });
+  }
+
+  async logout(): Promise<void> {
+    const auth = await this.userAuth.getAuth();
+
+    if (!auth) {
+      return;
+    }
+
+    try {
+      const user = await this.credentialToken.parseToken(auth);
+
+      console.log('user', user);
+
+      await this.userRepository.updateById(user.id, {
+        credential_token: ''
+      });
+    } catch {
+      return;
+    }
+
+    await this.userAuth.clear();
+  }
+}

package/dist/templates/next-app/src/server/validators/LoginValidator.ts

@@ -0,0 +1,79 @@
+import { ExecutorError } from '@qlover/fe-corekit';
+import { z } from 'zod';
+import {
+  V_LOGIN_PARAMS_REQUIRED,
+  V_EMAIL_INVALID,
+  V_PASSWORD_MIN_LENGTH,
+  V_PASSWORD_MAX_LENGTH,
+  V_PASSWORD_SPECIAL_CHARS
+} from '@config/Identifier/validator';
+import type {
+  ValidatorInterface,
+  ValidationFaildResult
+} from '../port/ValidatorInterface';
+
+export interface LoginValidatorData {
+  email: string;
+  password: string;
+}
+
+const emailSchema = z.email({ error: V_EMAIL_INVALID });
+
+const passwordSchema = z
+  .string()
+  .min(6, { error: V_PASSWORD_MIN_LENGTH })
+  .max(50, { error: V_PASSWORD_MAX_LENGTH })
+  .regex(/^\S+$/, { error: V_PASSWORD_SPECIAL_CHARS });
+
+interface ExtendedExecutorError extends ExecutorError {
+  issues?: ValidationFaildResult[];
+}
+
+export class LoginValidator implements ValidatorInterface {
+  validateEmail(data: unknown): void | ValidationFaildResult {
+    const emailResult = emailSchema.safeParse(data);
+    if (!emailResult.success) {
+      return emailResult.error.issues[0];
+    }
+  }
+
+  validatePassword(data: unknown): void | ValidationFaildResult {
+    const passwordResult = passwordSchema.safeParse(data);
+    if (!passwordResult.success) {
+      return passwordResult.error.issues[0];
+    }
+  }
+
+  validate(data: unknown): void | ValidationFaildResult {
+    if (typeof data !== 'object' || data === null) {
+      return {
+        path: ['form'],
+        message: V_LOGIN_PARAMS_REQUIRED
+      };
+    }
+
+    const { email, password } = data as Record<string, unknown>;
+
+    let validateResult = this.validateEmail(email);
+    if (validateResult != null) {
+      return validateResult;
+    }
+
+    validateResult = this.validatePassword(password);
+    if (validateResult != null) {
+      return validateResult;
+    }
+  }
+
+  getThrow(data: unknown): LoginValidatorData {
+    const result = this.validate(data);
+
+    if (result == null) {
+      return data as LoginValidatorData;
+    }
+
+    const error: ExtendedExecutorError = new ExecutorError(result.message);
+    error.issues = [result];
+    throw error;
+  }
+}

package/dist/templates/next-app/src/uikit/components/BaseHeader.tsx

@@ -31,7 +31,7 @@ export function BaseHeader(props: { showLogoutButton?: boolean }) {
             </span>
           </Link>
         </div>
-        <div className="flex items-center gap-2">
+        <div className="flex items-center gap-2 md:gap-4">
           <LanguageSwitcher i18nService={i18nService} />
           <ThemeSwitcher />
           {showLogoutButton && <LogoutButton />}

package/dist/templates/next-app/src/uikit/components/BootstrapsProvider.tsx

@@ -1,10 +1,11 @@
 'use client';
 import '@ant-design/v5-patch-for-react-19';
 import { useRouter } from 'next/navigation';
-import { useLocale } from 'next-intl';
+import { useLocale, useTranslations } from 'next-intl';
 import { useEffect } from 'react';
 import { I } from '@config/IOCIdentifier';
 import { NavigateBridge } from '@/base/cases/NavigateBridge';
+import type { I18nServiceLocale } from '@/base/port/I18nServiceInterface';
 import { BootstrapClient } from '@/core/bootstraps/BootstrapClient';
 import { clientIOC } from '@/core/clientIoc/ClientIOC';
 import { IOCContext } from '../context/IOCContext';
@@ -13,12 +14,18 @@ export function BootstrapsProvider(props: { children: React.ReactNode }) {
   const IOC = clientIOC.create();
   const locale = useLocale();
   const router = useRouter();
+  const t = useTranslations();
 
   useEffect(() => {
     IOC(I.RouterServiceInterface).setLocale(locale);
     IOC(NavigateBridge).setUIBridge(router);
   }, [locale, router, IOC]);
 
+  useEffect(() => {
+    IOC(I.I18nServiceInterface).changeLanguage(locale as I18nServiceLocale);
+    IOC(I.I18nServiceInterface).setTranslator(t);
+  }, [t, IOC, locale]);
+
   useEffect(() => {
     if (typeof window !== 'undefined') {
       BootstrapClient.main({

package/dist/templates/next-app/src/uikit/components/LogoutButton.tsx

@@ -1,34 +1,44 @@
-import { Button } from 'antd';
+import { LogoutOutlined } from '@ant-design/icons';
+import { Tooltip } from 'antd';
 import { useCallback } from 'react';
 import {
   AUTH_LOGOUT_DIALOG_CONTENT,
   AUTH_LOGOUT_DIALOG_TITLE
 } from '@config/Identifier';
-import { IOCIdentifier } from '@config/IOCIdentifier';
+import { I } from '@config/IOCIdentifier';
 import { useI18nInterface } from '../hook/useI18nInterface';
 import { useIOC } from '../hook/useIOC';
 import type { PageI18nInterface } from '@config/i18n';
 
 export function LogoutButton() {
-  const IOC = useIOC();
+  const dialogHandler = useIOC(I.DialogHandler);
+  const userService = useIOC(I.UserServiceInterface);
+  const routerService = useIOC(I.RouterServiceInterface);
+
   const tt = useI18nInterface({
     title: AUTH_LOGOUT_DIALOG_TITLE,
     content: AUTH_LOGOUT_DIALOG_CONTENT
   } as PageI18nInterface);
 
   const onClick = useCallback(() => {
-    IOC(IOCIdentifier.DialogHandler).confirm({
+    dialogHandler.confirm({
       title: tt.title,
       content: tt.content,
-      onOk: () => {
-        IOC(IOCIdentifier.UserServiceInterface).logout();
+      onOk: async () => {
+        await userService.logout();
+        routerService.gotoLogin();
       }
     });
-  }, [tt, IOC]);
+  }, [tt, dialogHandler, userService, routerService]);
 
   return (
-    <Button data-testid="LogoutButton" danger onClick={onClick}>
-      {tt.title}
-    </Button>
+    <Tooltip data-testid="LogoutIcon" title={tt.title} placement="right">
+      <span
+        className="text-text hover:text-red-500 cursor-pointer text-lg transition-colors"
+        onClick={onClick}
+      >
+        <LogoutOutlined />
+      </span>
+    </Tooltip>
   );
 }