@qlover/create-app 1.0.1 → 1.1.0

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

@@ -1,7 +1,13 @@
 import type { UserSchema } from '@migrations/schema/UserSchema';
 
+export type UserServiceRegisterParams = {
+  username?: string;
+  email: string;
+  password: string;
+};
+
 export interface UserServiceInterface {
-  register(params: { email: string; password: string }): Promise<UserSchema>;
+  register(params: UserServiceRegisterParams): Promise<UserSchema>;
   login(params: { email: string; password: string }): Promise<UserSchema>;
 
   logout(): Promise<void>;

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

@@ -27,9 +27,6 @@ export class LocalesRepository implements LocalesRepositoryInterface {
     @inject(Datetime) protected datetime: Datetime
   ) {}
 
-  /**
-   * @override
-   */
   public async getAll(): Promise<LocalesSchema[]> {
     const result = await this.dbBridge.get({
       table: this.name,

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

@@ -25,9 +25,6 @@ export class UserRepository implements UserRepositoryInterface {
     @inject(I.DBBridgeInterface) protected dbBridge: DBBridgeInterface
   ) {}
 
-  /**
-   * @override
-   */
   public getAll(): Promise<unknown> {
     return this.dbBridge.get({ table: this.name });
   }

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

@@ -1,13 +1,15 @@
+import { ExecutorError, type EncryptorInterface } from '@qlover/fe-corekit';
+import { Session, User } from '@supabase/supabase-js';
 import { inject, injectable } from 'inversify';
-import { isEmpty, last, omit } from 'lodash';
+import { isString } from 'lodash';
+import { AppConfig } from '@/base/cases/AppConfig';
 import type { UserSchema } from '@migrations/schema/UserSchema';
-import {
-  API_USER_NOT_FOUND,
-  API_USER_ALREADY_EXISTS
-} from '@config/Identifier/api';
+import { API_USER_NOT_FOUND } from '@config/Identifier/api';
+import { I } from '@config/IOCIdentifier';
 import { PasswordEncrypt } from '../PasswordEncrypt';
 import { UserRepository } from '../repositorys/UserRepository';
 import { ServerAuth } from '../ServerAuth';
+import { SupabaseBridge } from '../SupabaseBridge';
 import {
   UserCredentialToken,
   type UserCredentialTokenValue
@@ -15,11 +17,20 @@ import {
 import type { CrentialTokenInterface } from '../port/CrentialTokenInterface';
 import type { ServerAuthInterface } from '../port/ServerAuthInterface';
 import type { UserRepositoryInterface } from '../port/UserRepositoryInterface';
-import type { UserServiceInterface } from '../port/UserServiceInterface';
-import type { EncryptorInterface } from '@qlover/fe-corekit';
+import type {
+  UserServiceInterface,
+  UserServiceRegisterParams
+} from '../port/UserServiceInterface';
+import type { LoggerInterface } from '@qlover/logger';
 
 @injectable()
 export class UserService implements UserServiceInterface {
+  @inject(I.Logger)
+  protected logger!: LoggerInterface;
+
+  @inject(I.AppConfig)
+  protected appConfig!: AppConfig;
+
   constructor(
     @inject(UserRepository)
     protected userRepository: UserRepositoryInterface,
@@ -28,33 +39,39 @@ export class UserService implements UserServiceInterface {
     @inject(PasswordEncrypt)
     protected encryptor: EncryptorInterface<string, string>,
     @inject(UserCredentialToken)
-    protected credentialToken: CrentialTokenInterface<UserCredentialTokenValue>
+    protected credentialToken: CrentialTokenInterface<UserCredentialTokenValue>,
+    @inject(SupabaseBridge) protected supabaseBridge: SupabaseBridge
   ) {}
 
   /**
    * @override
    */
-  public 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({
+  public async register(
+    params: UserServiceRegisterParams
+  ): Promise<UserSchema> {
+    const supabase = await this.supabaseBridge.getSupabase();
+
+    // TODO: 检查 username, 是否重复
+    // const user = await this.userRepository.getUserByEmail(params.email);
+    // if (!isEmpty(user)) {
+    //   throw new Error(API_USER_ALREADY_EXISTS);
+    // }
+
+    const result = await supabase.auth.signUp({
       email: params.email,
-      password: this.encryptor.encrypt(params.password)
+      password: params.password
+
+      // options: {
+      //   emailRedirectTo: 'http://localhost:3100/callback'
+      // }
     });
+    this.supabaseBridge.throwIfError(result);
 
-    const target = last(result);
-    if (!target) {
+    if (!result.data.user) {
       throw new Error(API_USER_NOT_FOUND);
     }
 
-    return omit(target, 'password') as UserSchema;
+    return this.supabaseBridge.toUserSchema(result.data.user);
   }
 
   /**
@@ -63,52 +80,55 @@ export class UserService implements UserServiceInterface {
   public async login(params: {
     email: string;
     password: string;
+    authCode?: 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);
+    const supabase = await this.supabaseBridge.getSupabase();
 
-    if (encryptedPassword !== user.password) {
-      throw new Error(API_USER_NOT_FOUND);
+    if (params.authCode) {
+      const ares = await supabase.auth.exchangeCodeForSession(params.authCode);
+      this.supabaseBridge.throwIfError(ares);
     }
 
-    const credentialToken = await this.credentialToken.generateToken(user);
-
-    await this.userRepository.updateById(user.id, {
-      credential_token: credentialToken
+    const result = await supabase.auth.signInWithPassword({
+      email: params.email,
+      password: params.password
     });
+    this.supabaseBridge.throwIfError(result);
 
-    return Object.assign(omit(user, 'password') as UserSchema, {
-      credential_token: credentialToken
-    });
+    this.logger.info('supbase login succees', result.data);
+
+    return this.supabaseBridge.toUserSchema(result.data.user!);
   }
 
   /**
    * @override
    */
   public async logout(): Promise<void> {
-    const auth = await this.userAuth.getAuth();
+    const supabase = await this.supabaseBridge.getSupabase();
+
+    const response = await supabase.auth.signOut();
+
+    this.supabaseBridge.throwIfError(response);
+  }
 
-    if (!auth) {
-      return;
+  public async exchangeSessionForCode(code: string): Promise<{
+    user: User;
+    session: Session;
+  }> {
+    if (code == null || !isString(code)) {
+      throw new ExecutorError('code is required');
     }
 
-    try {
-      const user = await this.credentialToken.parseToken(auth);
+    const supabase = await this.supabaseBridge.getSupabase();
+    const response = await supabase.auth.exchangeCodeForSession(code);
+    this.supabaseBridge.throwIfError(response);
 
-      console.log('user', user);
+    this.logger.debug('exchangeSessionForCode', response.data);
 
-      await this.userRepository.updateById(user.id, {
-        credential_token: ''
-      });
-    } catch {
-      return;
+    if (!response.data.user) {
+      throw new ExecutorError(API_USER_NOT_FOUND);
     }
 
-    await this.userAuth.clear();
+    return response.data;
   }
 }

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

@@ -53,9 +53,6 @@ export class LocalesValidator implements ValidatorInterface<
 }
 
 export class LocalesImportValidator implements ValidatorInterface<ImportLocalesData> {
-  /**
-   * @override
-   */
   public getHasAnyFilesLocale(
     values: FormData
   ): { language: LocaleType; value: FormDataEntryValue }[] {

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

@@ -27,9 +27,6 @@ const passwordSchema = z
   .regex(/^\S+$/, { message: V_PASSWORD_SPECIAL_CHARS });
 
 export class LoginValidator implements ValidatorInterface<LoginValidatorData> {
-  /**
-   * @override
-   */
   public validateEmail(data: unknown): void | ValidationFaildResult {
     const emailResult = emailSchema.safeParse(data);
     if (!emailResult.success) {
@@ -37,9 +34,6 @@ export class LoginValidator implements ValidatorInterface<LoginValidatorData> {
     }
   }
 
-  /**
-   * @override
-   */
   public validatePassword(data: unknown): void | ValidationFaildResult {
     const passwordResult = passwordSchema.safeParse(data);
     if (!passwordResult.success) {

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

@@ -0,0 +1,68 @@
+import { ExecutorError } from '@qlover/fe-corekit';
+import { isPlainObject, isString } from 'lodash';
+import type { ExtendedExecutorError } from './ExtendedExecutorError';
+import type {
+  ValidationFaildResult,
+  ValidatorInterface
+} from '../port/ValidatorInterface';
+import type { EmailOtpType } from '@supabase/supabase-js';
+
+export type SignupVerifyParamType = {
+  access_token: string;
+  expires_at: string;
+  expires_in: string;
+  refresh_token: string;
+  token_type: string;
+  type: EmailOtpType;
+};
+
+export const emailVerifyParamKeys = [
+  'access_token',
+  'expires_at',
+  'expires_in',
+  'refresh_token',
+  'token_type',
+  'type'
+] as const;
+
+export class SignupVerifyValidator implements ValidatorInterface<SignupVerifyParamType> {
+  /**
+   * @override
+   */
+  public validate(data: unknown): void | ValidationFaildResult {
+    if (!isPlainObject(data)) {
+      return {
+        path: ['form'],
+        message: 'Invalid Signup verify params'
+      };
+    }
+
+    for (const key of emailVerifyParamKeys) {
+      if (
+        !(
+          isString((data as SignupVerifyParamType)[key]) &&
+          (data as SignupVerifyParamType)[key]
+        )
+      ) {
+        return {
+          path: [key],
+          message: `Invalid Signup verify ${key} params`
+        };
+      }
+    }
+  }
+  /**
+   * @override
+   */
+  public getThrow(data: unknown): SignupVerifyParamType {
+    const result = this.validate(data);
+
+    if (result == null) {
+      return data as SignupVerifyParamType;
+    }
+
+    const error: ExtendedExecutorError = new ExecutorError(result.message);
+    error.issues = [result];
+    throw error;
+  }
+}

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

@@ -1,14 +1,14 @@
 'use client';
 import '@ant-design/v5-patch-for-react-19';
 
-import { useEffect, useState } from 'react';
 import { useLocale } from 'next-intl';
+import { useEffect, useState } from 'react';
+import type { I18nServiceLocale } from '@/base/port/I18nServiceInterface';
 import { BootstrapClient } from '@/core/bootstraps/BootstrapClient';
+import { I } from '@config/IOCIdentifier';
 import { useIOC } from '../hook/useIOC';
 import { useStrictEffect } from '../hook/useStrictEffect';
 import { useWarnTranslations } from '../hook/useWarnTranslations';
-import { I } from '@config/IOCIdentifier';
-import type { I18nServiceLocale } from '@/base/port/I18nServiceInterface';
 
 export function BootstrapsProvider(props: { children: React.ReactNode }) {
   const IOC = useIOC();

package/dist/templates/next-app/src/uikit/components/localesImportButton/LocalesImportEvent.ts

@@ -10,18 +10,12 @@ export class LocalesImportEvent extends StoreInterface<LocalesImportEventState>
     super(() => new LocalesImportEventState());
   }
 
-  /**
-   * @override
-   */
   protected validate(file: File): void {
     if (file.type !== 'application/json') {
       throw new Error('File must be a JSON file');
     }
   }
 
-  /**
-   * @override
-   */
   public async onImport(type: LocaleType, file: File): Promise<void> {
     try {
       this.validate(file);

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

@@ -0,0 +1,29 @@
+import { TeamOutlined } from '@ant-design/icons';
+import { bootstrapServer } from '@/core/bootstraps/BootstrapServer';
+import { ServerAuth } from '@/server/ServerAuth';
+import { LocaleLink } from '../components/LocaleLink';
+
+export async function AdminButton(props: {
+  adminTitle: string;
+  locale?: string;
+}) {
+  const { adminTitle, locale } = props;
+  const hasAuth = await bootstrapServer.getIOC(ServerAuth).hasAuth();
+
+  if (!hasAuth) {
+    return null;
+  }
+
+  return (
+    <LocaleLink
+      data-testid="AdminButton"
+      key="admin-button"
+      href="/admin"
+      title={adminTitle}
+      locale={locale}
+      className="text-text hover:text-text-hover cursor-pointer text-lg transition-colors"
+    >
+      <TeamOutlined className="text-lg text-text" />
+    </LocaleLink>
+  );
+}

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

@@ -1,10 +1,10 @@
-import { TeamOutlined } from '@ant-design/icons';
 import { clsx } from 'clsx';
 import { useLocale } from 'next-intl';
-import { useMemo, type HTMLAttributes } from 'react';
+import { Suspense, type HTMLAttributes } from 'react';
+import { AdminButton } from './AdminButton';
 import { AppBridge } from './AppBridge';
+import { AuthButton } from './AuthButton';
 import { LanguageSwitcher } from './LanguageSwitcher';
-import { LogoutButton } from './LogoutButton';
 import { ThemeSwitcher } from './ThemeSwitcher';
 import { LocaleLink } from '../components/LocaleLink';
 
@@ -14,9 +14,9 @@ export interface AppRoutePageTT {
 }
 
 export interface AppRoutePageProps extends HTMLAttributes<HTMLDivElement> {
-  showLogoutButton?: boolean;
   showAdminButton?: boolean;
   mainProps?: HTMLAttributes<HTMLElement>;
+  showAuthButton?: boolean;
   headerClassName?: string;
   headerHref?: string;
   tt: AppRoutePageTT;
@@ -34,10 +34,10 @@ export interface AppRoutePageProps extends HTMLAttributes<HTMLDivElement> {
  */
 export function AppRoutePage({
   children,
-  showLogoutButton,
   showAdminButton,
   mainProps,
   headerClassName,
+  showAuthButton,
   tt,
   headerHref = '/',
   ...props
@@ -45,28 +45,6 @@ export function AppRoutePage({
   const locale = useLocale();
   const adminTitle = tt.adminTitle;
 
-  const actions = useMemo(() => {
-    return [
-      showAdminButton && (
-        <LocaleLink
-          key="admin-button"
-          href="/admin"
-          title={adminTitle}
-          locale={locale}
-          className="text-text hover:text-text-hover cursor-pointer text-lg transition-colors"
-        >
-          <TeamOutlined className="text-lg text-text" />
-        </LocaleLink>
-      ),
-
-      <LanguageSwitcher key="language-switcher" />,
-
-      <ThemeSwitcher key="theme-switcher" />,
-
-      showLogoutButton && <LogoutButton key="logout-button" />
-    ].filter(Boolean);
-  }, [adminTitle, showAdminButton, showLogoutButton, locale]);
-
   return (
     <div
       data-testid="AppRoutePage"
@@ -100,7 +78,22 @@ export function AppRoutePage({
               </span>
             </LocaleLink>
           </div>
-          <div className="flex items-center gap-2 md:gap-4">{actions}</div>
+          <div className="flex items-center gap-2 md:gap-4">
+            {showAdminButton && (
+              <Suspense>
+                <AdminButton adminTitle={adminTitle} locale={locale} />
+              </Suspense>
+            )}
+
+            <LanguageSwitcher key="language-switcher" />
+            <ThemeSwitcher key="theme-switcher" />
+
+            {showAuthButton && (
+              <Suspense>
+                <AuthButton />
+              </Suspense>
+            )}
+          </div>
         </div>
       </header>
 

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

@@ -0,0 +1,20 @@
+import { bootstrapServer } from '@/core/bootstraps/BootstrapServer';
+import { Link } from '@/i18n/routing';
+import { ServerAuth } from '@/server/ServerAuth';
+import { ROUTE_LOGIN, ROUTE_REGISTER } from '@config/route';
+import { LogoutButton } from './LogoutButton';
+
+export async function AuthButton() {
+  const hasAuth = await bootstrapServer.getIOC(ServerAuth).hasAuth();
+
+  if (hasAuth) {
+    return <LogoutButton data-testid="logout-button" />;
+  }
+
+  return (
+    <div data-testid="AuthButton" className="flex gap-2" data-auth={hasAuth}>
+      <Link href={ROUTE_LOGIN}>Sign in</Link>
+      <Link href={ROUTE_REGISTER}>Sign up</Link>
+    </div>
+  );
+}

package/dist/templates/next-app/src/uikit/hook/useI18nInterface.ts

@@ -1,5 +1,5 @@
 import { useMemo } from 'react';
-import { TranslateI18nInterface } from '@/base/cases/TranslateI18nInterface';
+import { TranslateI18nUtil } from '@/base/cases/TranslateI18nUtil';
 import { useWarnTranslations } from './useWarnTranslations';
 
 /**
@@ -14,7 +14,7 @@ export function useI18nInterface<T extends Record<string, string>>(
   const t = useWarnTranslations();
 
   const i18n = useMemo(
-    () => TranslateI18nInterface.translate(i18nInterface, t),
+    () => TranslateI18nUtil.translate(i18nInterface, t),
     [i18nInterface, t]
   );
 

package/dist/templates/next-app/src/uikit/hook/useWarnTranslations.ts

@@ -1,25 +1,11 @@
 import { useTranslations as useNextTranslations } from 'next-intl';
-import { useCallback } from 'react';
-import { i18nWarnMissingTranslation } from '@config/common';
+import { useMemo } from 'react';
+import { TranslateI18nUtil } from '@/base/cases/TranslateI18nUtil';
 
 export function useWarnTranslations() {
   const t = useNextTranslations();
 
-  const overrideT = useCallback(
-    (key: string) => {
-      if (!i18nWarnMissingTranslation) {
-        return t(key);
-      }
-
-      if (t.has(key)) {
-        return t(key);
-      }
-
-      console.warn(`[i18n] Missing translation: ${key}`);
-      return key;
-    },
-    [t]
-  );
+  const overrideT = useMemo(() => TranslateI18nUtil.overrideTranslateT(t), [t]);
 
   return Object.assign(overrideT, t);
 }

package/dist/templates/next-app/src/uikit/utils/getHashParams.ts

@@ -0,0 +1,8 @@
+export function getHashParams(hash: string): Record<string, string | null> {
+  const sp = new URLSearchParams(hash.startsWith('#') ? hash.slice(1) : hash);
+  const params = {};
+  sp.forEach((value, key) => {
+    Object.assign(params, { [key]: value });
+  });
+  return params;
+}

package/dist/templates/next-app/src/uikit/utils/getHashVerifyEmailParams.ts

@@ -0,0 +1,42 @@
+import { isString, pick } from 'lodash';
+import type { SignupVerifyParamType } from '@/server/validators/SignupVerifyValidator';
+
+export const emailVerifyParamKeys = [
+  'access_token',
+  'expires_at',
+  'expires_in',
+  'refresh_token',
+  'token_type',
+  'type'
+] as const;
+
+export function getHashParams(hash: string): Record<string, string | null> {
+  const sp = new URLSearchParams(hash.startsWith('#') ? hash.slice(1) : hash);
+  const params = {};
+  sp.forEach((value, key) => {
+    Object.assign(params, { [key]: value });
+  });
+  return params;
+}
+
+export function isEmailVerifyParam(
+  value: unknown
+): value is SignupVerifyParamType {
+  return emailVerifyParamKeys.every(
+    (key) =>
+      emailVerifyParamKeys.includes(key) &&
+      (value as SignupVerifyParamType)[key] != null &&
+      isString((value as SignupVerifyParamType)[key])
+  );
+}
+
+export function getHashVerifyEmailParams(
+  hash: string
+): SignupVerifyParamType | null {
+  if (!hash) {
+    return null;
+  }
+
+  const hashParams = pick(getHashParams(hash), emailVerifyParamKeys);
+  return isEmailVerifyParam(hashParams) ? hashParams : null;
+}

package/dist/templates/react-app/config/i18n/PageI18nInterface.ts

@@ -48,4 +48,6 @@ export interface PageI18nInterface {
   author?: string;
   publishedTime?: string;
   modifiedTime?: string;
+
+  [key: string]: unknown;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qlover/create-app",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "Create a new app with a single command",
   "private": false,
   "type": "module",
@@ -38,7 +38,7 @@
   "dependencies": {
     "commander": "^13.1.0",
     "inquirer": "^12.3.2",
-    "@qlover/scripts-context": "2.0.0"
+    "@qlover/scripts-context": "2.1.0"
   },
   "scripts": {
     "lint": "eslint src --fix",

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

@@ -1,25 +0,0 @@
-import type { PageI18nInterface } from '@config/i18n';
-import type { useTranslations } from 'next-intl';
-
-/**
- * Translate I18n Interface tools class
- *
- * @param i18nInterface - The i18n interface to translate
- * @param t - The translations function
- * @returns The translated i18n interface
- */
-export class TranslateI18nInterface {
-  public static translate<T extends PageI18nInterface | Record<string, string>>(
-    source: T,
-    t: ReturnType<typeof useTranslations>
-  ): T {
-    return Object.fromEntries(
-      Object.entries(source).map(([key, value]) => {
-        if (typeof value === 'string') {
-          return [key, t(value)];
-        }
-        return [key, value];
-      })
-    ) as T;
-  }
-}