@qlover/create-app 1.0.1 → 1.0.2

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

@@ -1,11 +1,7 @@
-import {
-  createClient,
-  type PostgrestSingleResponse,
-  type SupabaseClient,
-  type PostgrestResponse
-} from '@supabase/supabase-js';
+import { ExecutorError } from '@qlover/fe-corekit';
+import { AuthError } from '@supabase/supabase-js';
 import { injectable, inject } from 'inversify';
-import type { AppConfig } from '@/base/cases/AppConfig';
+import { createClient } from '@/lib/supabase/server';
 import type {
   BridgeEvent,
   DBBridgeInterface,
@@ -13,12 +9,18 @@ import type {
   BridgeOrderBy,
   Where
 } from '@/server/port/DBBridgeInterface';
+import { UserRole, UserSchema } from '@migrations/schema/UserSchema';
 import { I } from '@config/IOCIdentifier';
 import type { LoggerInterface } from '@qlover/logger';
+import type { PostgrestResponseFailure } from '@supabase/postgrest-js';
 import type {
-  PostgrestFilterBuilder,
-  PostgrestResponseFailure
-} from '@supabase/postgrest-js';
+  PostgrestSingleResponse,
+  SupabaseClient,
+  PostgrestResponse,
+  User,
+  AuthResponse,
+  UserResponse
+} from '@supabase/supabase-js';
 
 const whereHandlerMaps = {
   '=': 'eq',
@@ -34,36 +36,18 @@ export type SupabaseBridgeResponse<T> = DBBridgeResponse<T> &
 
 @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
-    );
-  }
+  constructor(@inject(I.Logger) protected logger: LoggerInterface) {}
 
-  /**
-   * @override
-   */
-  public getSupabase(): SupabaseClient {
-    return this.supabase;
+  public async getSupabase(): Promise<SupabaseClient> {
+    return await createClient();
   }
 
-  /**
-   * @override
-   */
   public async execSql(sql: string): Promise<SupabaseBridgeResponse<unknown>> {
-    const res = await this.supabase.rpc('exec_sql', { sql });
+    const supabase = await this.getSupabase();
+    const res = await supabase.rpc('exec_sql', { sql });
     return this.catch(res);
   }
 
-  /**
-   * @override
-   */
   protected async catch(
     result: PostgrestSingleResponse<unknown>
   ): Promise<SupabaseBridgeResponse<unknown>> {
@@ -82,23 +66,14 @@ export class SupabaseBridge implements DBBridgeInterface {
     return result as SupabaseBridgeResponse<unknown>;
   }
 
-  /**
-   * @override
-   */
   protected hasPausedProject(error: PostgrestResponseFailure): boolean {
     return (
       error.status === 0 && error.error.message === 'TypeError: fetch failed'
     );
   }
 
-  /**
-   * @override
-   */
-  protected handleWhere(
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    handler: PostgrestFilterBuilder<any, any, any, any, string, unknown, any>,
-    wheres: Where[]
-  ): void {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  protected handleWhere(handler: any, wheres: Where[]): void {
     for (const where of wheres) {
       const [key, operator, value] = where;
       const opr = whereHandlerMaps[operator];
@@ -116,19 +91,41 @@ export class SupabaseBridge implements DBBridgeInterface {
     }
   }
 
-  /**
-   * @override
-   */
-  protected handleOrderBy(
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    handler: PostgrestFilterBuilder<any, any, any, any, string, unknown, any>,
-    orderBy?: BridgeOrderBy
-  ): void {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  protected handleOrderBy(handler: any, orderBy?: BridgeOrderBy): void {
     if (orderBy) {
       handler.order(orderBy[0], { ascending: orderBy[1] === 0 });
     }
   }
 
+  public toUserSchema(user: User): UserSchema {
+    return {
+      id: user.id,
+      email: user.email!,
+      created_at: user.created_at,
+      updated_at: user.updated_at,
+      role: user.role === 'admin' ? UserRole.ADMIN : UserRole.USER,
+      // 始终为空
+      password: '',
+      credential_token: ''
+    };
+  }
+
+  public throwIfError(
+    response: AuthResponse | UserResponse | { error: unknown }
+  ): void {
+    const { error } = response;
+    if (error) {
+      this.logger.info('SupabaseBridge throw error:', error);
+
+      if (error instanceof AuthError) {
+        throw new ExecutorError('SupabaseAuthError', error);
+      }
+
+      throw new Error(error as string);
+    }
+  }
+
   /**
    * @override
    */
@@ -137,7 +134,8 @@ export class SupabaseBridge implements DBBridgeInterface {
     if (!data) {
       throw new Error('Data is required for add operation');
     }
-    const res = await this.supabase
+    const supabase = await this.getSupabase();
+    const res = await supabase
       .from(table)
       .insert(Array.isArray(data) ? data : [data]);
     return this.catch(res);
@@ -152,7 +150,9 @@ export class SupabaseBridge implements DBBridgeInterface {
       throw new Error('Data is required for upsert operation');
     }
     const selectFields = Array.isArray(fields) ? fields.join(',') : fields;
-    const res = await this.supabase
+    const supabase = await this.getSupabase();
+
+    const res = await supabase
       .from(table)
       .upsert(Array.isArray(data) ? data : [data], {
         onConflict: 'value'
@@ -169,8 +169,9 @@ export class SupabaseBridge implements DBBridgeInterface {
     if (!data) {
       throw new Error('Data is required for update operation');
     }
+    const supabase = await this.getSupabase();
 
-    const handler = this.supabase.from(table).update(data);
+    const handler = supabase.from(table).update(data);
 
     this.handleWhere(handler, where ?? []);
 
@@ -182,7 +183,9 @@ export class SupabaseBridge implements DBBridgeInterface {
    */
   public async delete(event: BridgeEvent): Promise<DBBridgeResponse<unknown>> {
     const { table, where } = event;
-    const handler = this.supabase.from(table).delete();
+    const supabase = await this.getSupabase();
+
+    const handler = supabase.from(table).delete();
 
     this.handleWhere(handler, where ?? []);
 
@@ -197,7 +200,9 @@ export class SupabaseBridge implements DBBridgeInterface {
   ): Promise<SupabaseBridgeResponse<unknown>> {
     const { table, fields = '*', where, orderBy } = event;
     const selectFields = Array.isArray(fields) ? fields.join(',') : fields;
-    const handler = this.supabase.from(table).select(selectFields);
+    const supabase = await this.getSupabase();
+
+    const handler = supabase.from(table).select(selectFields);
 
     this.handleWhere(handler, where ?? []);
 
@@ -222,8 +227,10 @@ export class SupabaseBridge implements DBBridgeInterface {
     } = event;
     const selectFields = Array.isArray(fields) ? fields.join(',') : fields;
 
+    const supabase = await this.getSupabase();
+
     // 获取总数
-    const countHandler = this.supabase
+    const countHandler = supabase
       .from(table)
       .select('*', { count: 'exact', head: true });
 
@@ -231,7 +238,7 @@ export class SupabaseBridge implements DBBridgeInterface {
     const countResult = await this.catch(await countHandler);
 
     // 获取分页数据
-    const handler = this.supabase.from(table).select(selectFields);
+    const handler = supabase.from(table).select(selectFields);
 
     this.handleOrderBy(handler, orderBy);
 

package/dist/templates/next-app/src/server/controllers/UserController.ts

@@ -8,20 +8,25 @@ import {
   LoginValidator,
   type LoginValidatorData
 } from '../validators/LoginValidator';
+import {
+  SignupVerifyParamType,
+  SignupVerifyValidator
+} from '../validators/SignupVerifyValidator';
 import type { ServerAuthInterface } from '../port/ServerAuthInterface';
-import type { UserControllerInerface } from '../port/UserControllerInerface';
 import type { UserServiceInterface } from '../port/UserServiceInterface';
 import type { ValidatorInterface } from '../port/ValidatorInterface';
 import type { EncryptorInterface } from '@qlover/fe-corekit';
 
 @injectable()
-export class UserController implements UserControllerInerface {
+export class UserController implements UserServiceInterface {
   constructor(
     @inject(ServerAuth) protected serverAuth: ServerAuthInterface,
     @inject(StringEncryptor)
     protected stringEncryptor: EncryptorInterface<string, string>,
     @inject(LoginValidator)
     protected loginValidator: ValidatorInterface<LoginValidatorData>,
+    @inject(SignupVerifyValidator)
+    protected verifyValidator: ValidatorInterface<SignupVerifyParamType>,
     @inject(UserService) protected userService: UserServiceInterface
   ) {}
 

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

@@ -1,3 +1,5 @@
+import type { UserSchema } from '@migrations/schema/UserSchema';
+
 export interface ServerAuthInterface {
   setAuth(credential_token: string): Promise<void>;
 
@@ -8,4 +10,6 @@ export interface ServerAuthInterface {
   hasAuth(): Promise<boolean>;
 
   throwIfNotAuth(): Promise<void>;
+
+  getUser(): Promise<UserSchema | null>;
 }

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

@@ -1,4 +1,5 @@
-import { ExecutorAsyncTask, type ExecutorError } from '@qlover/fe-corekit';
+import type { ExecutorAsyncTask } from '@qlover/fe-corekit';
+import { type ExecutorError } from '@qlover/fe-corekit';
 import { type IOCIdentifierMapServer } from '@config/IOCIdentifier';
 import type {
   ServiceIdentifier,

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