@qlover/create-app 0.10.1 → 0.10.3

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

@@ -18,13 +18,19 @@ export class ServerAuth implements ServerAuthInterface {
     this.userTokenKey = server.userTokenKey;
   }
 
-  async setAuth(credential_token: string): Promise<void> {
+  /**
+   * @override
+   */
+  public async setAuth(credential_token: string): Promise<void> {
     const cookieStore = await cookies();
 
     cookieStore.set(this.userTokenKey, credential_token);
   }
 
-  async hasAuth(): Promise<boolean> {
+  /**
+   * @override
+   */
+  public async hasAuth(): Promise<boolean> {
     const token = await this.getAuth();
 
     if (!token) {
@@ -40,17 +46,26 @@ export class ServerAuth implements ServerAuthInterface {
     }
   }
 
-  async getAuth(): Promise<string> {
+  /**
+   * @override
+   */
+  public async getAuth(): Promise<string> {
     const cookieStore = await cookies();
     return cookieStore.get(this.userTokenKey)?.value || '';
   }
 
-  async clear(): Promise<void> {
+  /**
+   * @override
+   */
+  public async clear(): Promise<void> {
     const cookieStore = await cookies();
     cookieStore.delete(this.userTokenKey);
   }
 
-  async throwIfNotAuth(): Promise<void> {
+  /**
+   * @override
+   */
+  public async throwIfNotAuth(): Promise<void> {
     const hasAuth = await this.hasAuth();
 
     if (!hasAuth) {

package/dist/templates/next-app/src/server/{sqlBridges/SupabaseBridge.ts → SupabaseBridge.ts}

@@ -46,19 +46,30 @@ export class SupabaseBridge implements DBBridgeInterface {
     );
   }
 
-  getSupabase(): SupabaseClient {
+  /**
+   * @override
+   */
+  public getSupabase(): SupabaseClient {
     return this.supabase;
   }
 
-  async execSql(sql: string): Promise<SupabaseBridgeResponse<unknown>> {
+  /**
+   * @override
+   */
+  public async execSql(sql: string): Promise<SupabaseBridgeResponse<unknown>> {
     const res = await this.supabase.rpc('exec_sql', { sql });
     return this.catch(res);
   }
 
+  /**
+   * @override
+   */
   protected async catch(
     result: PostgrestSingleResponse<unknown>
   ): Promise<SupabaseBridgeResponse<unknown>> {
     if (result.error) {
+      this.logger.error('', result);
+
       if (this.hasPausedProject(result)) {
         throw new Error(
           'Project is paused, Please Restore project: https://supabase.com/dashboard'
@@ -71,12 +82,18 @@ 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>,
@@ -99,6 +116,9 @@ 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>,
@@ -109,7 +129,10 @@ export class SupabaseBridge implements DBBridgeInterface {
     }
   }
 
-  async add(event: BridgeEvent): Promise<DBBridgeResponse<unknown>> {
+  /**
+   * @override
+   */
+  public async add(event: BridgeEvent): Promise<DBBridgeResponse<unknown>> {
     const { table, data } = event;
     if (!data) {
       throw new Error('Data is required for add operation');
@@ -120,7 +143,10 @@ export class SupabaseBridge implements DBBridgeInterface {
     return this.catch(res);
   }
 
-  async upsert(event: BridgeEvent): Promise<DBBridgeResponse<unknown>> {
+  /**
+   * @override
+   */
+  public async upsert(event: BridgeEvent): Promise<DBBridgeResponse<unknown>> {
     const { table, data, fields = '*' } = event;
     if (!data) {
       throw new Error('Data is required for upsert operation');
@@ -135,7 +161,10 @@ export class SupabaseBridge implements DBBridgeInterface {
     return this.catch(res);
   }
 
-  async update(event: BridgeEvent): Promise<DBBridgeResponse<unknown>> {
+  /**
+   * @override
+   */
+  public async update(event: BridgeEvent): Promise<DBBridgeResponse<unknown>> {
     const { table, data, where } = event;
     if (!data) {
       throw new Error('Data is required for update operation');
@@ -148,7 +177,10 @@ export class SupabaseBridge implements DBBridgeInterface {
     return this.catch(await handler);
   }
 
-  async delete(event: BridgeEvent): Promise<DBBridgeResponse<unknown>> {
+  /**
+   * @override
+   */
+  public async delete(event: BridgeEvent): Promise<DBBridgeResponse<unknown>> {
     const { table, where } = event;
     const handler = this.supabase.from(table).delete();
 
@@ -157,7 +189,12 @@ export class SupabaseBridge implements DBBridgeInterface {
     return this.catch(await handler);
   }
 
-  async get(event: BridgeEvent): Promise<SupabaseBridgeResponse<unknown>> {
+  /**
+   * @override
+   */
+  public async get(
+    event: BridgeEvent
+  ): 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);
@@ -169,7 +206,12 @@ export class SupabaseBridge implements DBBridgeInterface {
     return this.catch(await handler);
   }
 
-  async pagination(event: BridgeEvent): Promise<DBBridgeResponse<unknown[]>> {
+  /**
+   * @override
+   */
+  public async pagination(
+    event: BridgeEvent
+  ): Promise<DBBridgeResponse<unknown[]>> {
     const {
       table,
       fields = '*',

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

@@ -16,7 +16,10 @@ export class UserCredentialToken implements CrentialTokenInterface<UserCredentia
     this.jwtExpiresIn = config.jwtExpiresIn;
   }
 
-  async generateToken(
+  /**
+   * @override
+   */
+  public async generateToken(
     data: UserCredentialTokenValue,
     options: { expiresIn?: string } = {}
   ): Promise<string> {
@@ -29,7 +32,10 @@ export class UserCredentialToken implements CrentialTokenInterface<UserCredentia
     });
   }
 
-  async parseToken(token: string): Promise<UserCredentialTokenValue> {
+  /**
+   * @override
+   */
+  public async parseToken(token: string): Promise<UserCredentialTokenValue> {
     try {
       const decoded = jwt.verify(token, this.jwtSecret) as {
         i: UserSchema['id'];

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

@@ -0,0 +1,86 @@
+import { inject, injectable } from 'inversify';
+import { AdminLocalesService } from '@/server/services/AdminLocalesService';
+import type { LocalesSchema } from '@migrations/schema/LocalesSchema';
+import {
+  ApiLocaleService,
+  type ImportLocalesData
+} from '../services/ApiLocaleService';
+import {
+  LocalesImportValidator,
+  LocalesValidator
+} from '../validators/LocalesValidator';
+import { PaginationValidator } from '../validators/PaginationValidator';
+import type { AdminLocalesControllerInterface } from '../port/AdminLocalesControllerInterface';
+import type { BridgeOrderBy } from '../port/DBBridgeInterface';
+import type { UpsertResult } from '../port/LocalesRepositoryInterface';
+import type { PaginationInterface } from '../port/PaginationInterface';
+import type { ValidatorInterface } from '../port/ValidatorInterface';
+import type { PaginationParams } from '../validators/PaginationValidator';
+
+@injectable()
+export class AdminLocalesController implements AdminLocalesControllerInterface {
+  constructor(
+    @inject(AdminLocalesService)
+    protected adminLocalesService: AdminLocalesService,
+    @inject(PaginationValidator)
+    protected paginationValidator: ValidatorInterface<PaginationParams>,
+    @inject(ApiLocaleService)
+    protected apiLocaleService: ApiLocaleService,
+    @inject(LocalesValidator)
+    protected localesValidator: ValidatorInterface<Partial<LocalesSchema>>,
+    @inject(LocalesImportValidator)
+    protected localesImportValidator: ValidatorInterface<ImportLocalesData>
+  ) {}
+
+  /**
+   * @override
+   */
+  public async getLocales(query: {
+    page: number;
+    pageSize: number;
+    orders?: BridgeOrderBy;
+  }): Promise<PaginationInterface<LocalesSchema>> {
+    const paginationParams = await this.paginationValidator.getThrow(query);
+
+    const result = await this.apiLocaleService.getLocales({
+      page: paginationParams.page,
+      pageSize: paginationParams.pageSize,
+      orderBy: paginationParams?.orders
+    });
+
+    return result;
+  }
+
+  /**
+   * @override
+   */
+  public async createLocale(
+    body: Omit<LocalesSchema, 'id' | 'created_at' | 'updated_at'>
+  ): Promise<{ success: boolean }> {
+    const localesParams = await this.localesValidator.getThrow(body);
+
+    await this.apiLocaleService.create(localesParams);
+
+    return {
+      success: true
+    };
+  }
+  /**
+   * @override
+   */
+  public async updateLocale(body: Partial<LocalesSchema>): Promise<void> {
+    await this.apiLocaleService.update(body);
+  }
+  /**
+   * @override
+   */
+  public async importLocales(formData: unknown): Promise<UpsertResult> {
+    const localesParams = await this.localesImportValidator.getThrow({
+      values: formData
+    });
+
+    const result = await this.apiLocaleService.importLocales(localesParams);
+
+    return result;
+  }
+}

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

@@ -0,0 +1,42 @@
+import { inject, injectable } from 'inversify';
+
+import type { UserSchema } from '@migrations/schema/UserSchema';
+import { UserRepository } from '../repositorys/UserRepository';
+import { ApiUserService } from '../services/ApiUserService';
+import { PaginationValidator } from '../validators/PaginationValidator';
+import type { AdminUserControllerInterface } from '../port/AdminUserControllerInterface';
+import type { BridgeOrderBy } from '../port/DBBridgeInterface';
+import type { PaginationInterface } from '../port/PaginationInterface';
+import type { UserRepositoryInterface } from '../port/UserRepositoryInterface';
+import type { ValidatorInterface } from '../port/ValidatorInterface';
+import type { PaginationParams } from '../validators/PaginationValidator';
+
+@injectable()
+export class AdminUserController implements AdminUserControllerInterface {
+  constructor(
+    @inject(UserRepository)
+    protected userRepository: UserRepositoryInterface,
+    @inject(PaginationValidator)
+    protected paginationValidator: ValidatorInterface<PaginationParams>,
+    @inject(ApiUserService)
+    protected apiUserService: ApiUserService
+  ) {}
+
+  /**
+   * @override
+   */
+  public async getUsers(query: {
+    page: number;
+    pageSize: number;
+    orderBy?: BridgeOrderBy;
+  }): Promise<PaginationInterface<UserSchema>> {
+    const paginationParams = await this.paginationValidator.getThrow(query);
+
+    const result = await this.apiUserService.getUsers({
+      page: paginationParams.page,
+      pageSize: paginationParams.pageSize
+    });
+
+    return result;
+  }
+}

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

@@ -0,0 +1,36 @@
+import { inject, injectable } from 'inversify';
+import { i18nConfig } from '@config/i18n';
+import type { LocaleType } from '@config/i18n';
+import { ApiLocaleService } from '../services/ApiLocaleService';
+import type {
+  LocalesControllerInterface,
+  LocalesControllerJsonQuery
+} from '../port/LocalesControllerInterface';
+
+@injectable()
+export class LocalesController implements LocalesControllerInterface {
+  constructor(
+    @inject(ApiLocaleService)
+    protected apiLocaleService: ApiLocaleService
+  ) {}
+
+  /**
+   * @override
+   */
+  public async json(
+    query: LocalesControllerJsonQuery
+  ): Promise<Record<string, string>> {
+    const locale = query.locale as LocaleType;
+
+    if (!locale || !i18nConfig.supportedLngs.includes(locale)) {
+      return {};
+    }
+
+    const result = await this.apiLocaleService.getLocalesJson(
+      locale,
+      query.orderBy
+    );
+
+    return result;
+  }
+}

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

@@ -0,0 +1,86 @@
+import { ExecutorError } from '@qlover/fe-corekit';
+import { inject, injectable } from 'inversify';
+import { StringEncryptor } from '@/base/cases/StringEncryptor';
+import type { UserSchema } from '@migrations/schema/UserSchema';
+import { ServerAuth } from '../ServerAuth';
+import { UserService } from '../services/UserService';
+import {
+  LoginValidator,
+  type LoginValidatorData
+} from '../validators/LoginValidator';
+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 { Encryptor } from '@qlover/fe-corekit';
+
+@injectable()
+export class UserController implements UserControllerInerface {
+  constructor(
+    @inject(ServerAuth) protected serverAuth: ServerAuthInterface,
+    @inject(StringEncryptor)
+    protected stringEncryptor: Encryptor<string, string>,
+    @inject(LoginValidator)
+    protected loginValidator: ValidatorInterface<LoginValidatorData>,
+    @inject(UserService) protected userService: UserServiceInterface
+  ) {}
+
+  /**
+   * @override
+   */
+  public async login(requestBody: LoginValidatorData): Promise<UserSchema> {
+    try {
+      if (requestBody.password) {
+        requestBody.password = this.stringEncryptor.decrypt(
+          requestBody.password
+        );
+      }
+    } catch {
+      throw new ExecutorError(
+        'encrypt_password_failed',
+        'Encrypt password failed'
+      );
+    }
+    const body = await this.loginValidator.getThrow(requestBody);
+
+    const user = await this.userService.login(body);
+
+    await this.serverAuth.setAuth(user.credential_token);
+
+    return user;
+  }
+
+  /**
+   * @override
+   */
+  public async register(requestBody: LoginValidatorData): Promise<UserSchema> {
+    try {
+      if (requestBody.password) {
+        requestBody.password = this.stringEncryptor.decrypt(
+          requestBody.password
+        );
+      }
+    } catch {
+      throw new ExecutorError(
+        'encrypt_password_failed',
+        'Encrypt password failed'
+      );
+    }
+
+    const body = await this.loginValidator.getThrow(requestBody);
+
+    const user = await this.userService.register({
+      email: body.email,
+      password: body.password
+    });
+
+    return user;
+  }
+
+  /**
+   * @override
+   */
+  public async logout(): Promise<void> {
+    return await this.userService.logout();
+  }
+}

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

@@ -0,0 +1,8 @@
+import type { AppApiResult } from '@/base/port/AppApiInterface';
+import type { ChatCompletionMessageParam } from 'openai/resources/chat/completions';
+
+export interface AIControllerInterface {
+  completions(body: {
+    messages: ChatCompletionMessageParam[];
+  }): Promise<AppApiResult<unknown>>;
+}

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

@@ -0,0 +1,21 @@
+import type { LocalesSchema } from '@migrations/schema/LocalesSchema';
+import type { BridgeOrderBy } from './DBBridgeInterface';
+import type { UpsertResult } from './LocalesRepositoryInterface';
+import type { PaginationInterface } from './PaginationInterface';
+import type { ImportLocalesData } from '../services/ApiLocaleService';
+
+export interface AdminLocalesControllerInterface {
+  getLocales(query: {
+    page: number;
+    pageSize: number;
+    orderBy?: BridgeOrderBy;
+  }): Promise<PaginationInterface<LocalesSchema>>;
+
+  createLocale(
+    body: Omit<LocalesSchema, 'id' | 'created_at' | 'updated_at'>
+  ): Promise<{ success: boolean }>;
+
+  updateLocale(body: Partial<LocalesSchema>): Promise<void>;
+
+  importLocales(formData: ImportLocalesData): Promise<UpsertResult>;
+}

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

@@ -0,0 +1,11 @@
+import type { UserSchema } from '@migrations/schema/UserSchema';
+import type { BridgeOrderBy } from './DBBridgeInterface';
+import type { PaginationInterface } from './PaginationInterface';
+
+export interface AdminUserControllerInterface {
+  getUsers(query: {
+    page: number;
+    pageSize: number;
+    orderBy?: BridgeOrderBy;
+  }): Promise<PaginationInterface<UserSchema>>;
+}

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

@@ -0,0 +1,10 @@
+import type { BridgeOrderBy } from './DBBridgeInterface';
+
+export interface LocalesControllerJsonQuery {
+  locale: string;
+  orderBy?: BridgeOrderBy;
+}
+
+export interface LocalesControllerInterface {
+  json(query: LocalesControllerJsonQuery): Promise<Record<string, string>>;
+}

package/dist/templates/next-app/src/server/port/{ParamsHandlerInterface.ts → RouteParamsnHandlerInterface.ts}

@@ -1,11 +1,18 @@
 import type { PageI18nInterface } from '@config/i18n';
 
-export interface ParamsHandlerInterface {
+/**
+ * 用于处理页面渲染的路由参数处理接口
+ */
+export interface RouteParamsnHandlerInterface {
   getLocale(defaultLocale?: string): string;
   getI18nWithNotFound(): string;
-  getI18nMessages(): Promise<Record<string, string>>;
+  getI18nMessages(
+    namespace?: string | string[]
+  ): Promise<Record<string, string>>;
   getI18nInterface<T extends PageI18nInterface>(
     i18nInterface: T,
     namespace?: string
   ): Promise<T>;
+
+  getTheme(): string | Promise<string>;
 }

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

@@ -3,9 +3,9 @@ import { type IOCIdentifierMapServer } from '@config/IOCIdentifier';
 import type {
   ServiceIdentifier,
   IOCContainerInterface,
-  IOCFunctionInterface,
-  LoggerInterface
+  IOCFunctionInterface
 } from '@qlover/corekit-bridge';
+import type { LoggerInterface } from '@qlover/logger';
 
 export interface ServerInterface {
   readonly logger: LoggerInterface;

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

@@ -0,0 +1,8 @@
+import type { UserSchema } from '@migrations/schema/UserSchema';
+import type { LoginValidatorData } from '../validators/LoginValidator';
+
+export interface UserControllerInerface {
+  login(body: LoginValidatorData): Promise<UserSchema>;
+  register(body: LoginValidatorData): Promise<UserSchema>;
+  logout(): Promise<void>;
+}

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

@@ -2,7 +2,7 @@ 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>;
+  login(params: { email: string; password: string }): Promise<UserSchema>;
 
   logout(): Promise<void>;
 }

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

@@ -3,7 +3,7 @@ export interface ValidationFaildResult {
   message: string;
 }
 
-export interface ValidatorInterface {
+export interface ValidatorInterface<T> {
   /**
    * Validate the data and return validation result
    * @param data - The data to validate
@@ -19,5 +19,5 @@ export interface ValidatorInterface {
    * @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;
+  getThrow(data: unknown): Promise<T> | T;
 }