@qlover/create-app 1.1.0 → 2.0.0

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

@@ -1,262 +0,0 @@
-import { ExecutorError } from '@qlover/fe-corekit';
-import { AuthError } from '@supabase/supabase-js';
-import { injectable, inject } from 'inversify';
-import { createClient } from '@/lib/supabase/server';
-import type {
-  BridgeEvent,
-  DBBridgeInterface,
-  DBBridgeResponse,
-  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 {
-  PostgrestSingleResponse,
-  SupabaseClient,
-  PostgrestResponse,
-  User,
-  AuthResponse,
-  UserResponse
-} from '@supabase/supabase-js';
-
-const whereHandlerMaps = {
-  '=': 'eq',
-  '!=': 'neq',
-  '>': 'gt',
-  '<': 'lt',
-  '>=': 'gte',
-  '<=': 'lte'
-};
-
-export type SupabaseBridgeResponse<T> = DBBridgeResponse<T> &
-  PostgrestResponse<T>;
-
-@injectable()
-export class SupabaseBridge implements DBBridgeInterface {
-  constructor(@inject(I.Logger) protected logger: LoggerInterface) {}
-
-  public async getSupabase(): Promise<SupabaseClient> {
-    return await createClient();
-  }
-
-  public async execSql(sql: string): Promise<SupabaseBridgeResponse<unknown>> {
-    const supabase = await this.getSupabase();
-    const res = await supabase.rpc('exec_sql', { sql });
-    return this.catch(res);
-  }
-
-  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'
-        );
-      }
-
-      throw new Error(result.error.details + ' ' + result.error.message);
-    }
-
-    return result as SupabaseBridgeResponse<unknown>;
-  }
-
-  protected hasPausedProject(error: PostgrestResponseFailure): boolean {
-    return (
-      error.status === 0 && error.error.message === 'TypeError: fetch failed'
-    );
-  }
-
-  // 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];
-      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);
-    }
-  }
-
-  // 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
-   */
-  public async add(event: BridgeEvent): Promise<DBBridgeResponse<unknown>> {
-    const { table, data } = event;
-    if (!data) {
-      throw new Error('Data is required for add operation');
-    }
-    const supabase = await this.getSupabase();
-    const res = await supabase
-      .from(table)
-      .insert(Array.isArray(data) ? data : [data]);
-    return this.catch(res);
-  }
-
-  /**
-   * @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');
-    }
-    const selectFields = Array.isArray(fields) ? fields.join(',') : fields;
-    const supabase = await this.getSupabase();
-
-    const res = await supabase
-      .from(table)
-      .upsert(Array.isArray(data) ? data : [data], {
-        onConflict: 'value'
-      })
-      .select(selectFields); // Request to return the upserted data
-    return this.catch(res);
-  }
-
-  /**
-   * @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');
-    }
-    const supabase = await this.getSupabase();
-
-    const handler = supabase.from(table).update(data);
-
-    this.handleWhere(handler, where ?? []);
-
-    return this.catch(await handler);
-  }
-
-  /**
-   * @override
-   */
-  public async delete(event: BridgeEvent): Promise<DBBridgeResponse<unknown>> {
-    const { table, where } = event;
-    const supabase = await this.getSupabase();
-
-    const handler = supabase.from(table).delete();
-
-    this.handleWhere(handler, where ?? []);
-
-    return this.catch(await handler);
-  }
-
-  /**
-   * @override
-   */
-  public async get(
-    event: BridgeEvent
-  ): Promise<SupabaseBridgeResponse<unknown>> {
-    const { table, fields = '*', where, orderBy } = event;
-    const selectFields = Array.isArray(fields) ? fields.join(',') : fields;
-    const supabase = await this.getSupabase();
-
-    const handler = supabase.from(table).select(selectFields);
-
-    this.handleWhere(handler, where ?? []);
-
-    this.handleOrderBy(handler, orderBy);
-
-    return this.catch(await handler);
-  }
-
-  /**
-   * @override
-   */
-  public async pagination(
-    event: BridgeEvent
-  ): Promise<DBBridgeResponse<unknown[]>> {
-    const {
-      table,
-      fields = '*',
-      where,
-      page = 1,
-      pageSize = 10,
-      orderBy
-    } = event;
-    const selectFields = Array.isArray(fields) ? fields.join(',') : fields;
-
-    const supabase = await this.getSupabase();
-
-    // 获取总数
-    const countHandler = supabase
-      .from(table)
-      .select('*', { count: 'exact', head: true });
-
-    this.handleWhere(countHandler, where ?? []);
-    const countResult = await this.catch(await countHandler);
-
-    // 获取分页数据
-    const handler = supabase.from(table).select(selectFields);
-
-    this.handleOrderBy(handler, orderBy);
-
-    handler.range((page - 1) * pageSize, page * pageSize - 1);
-
-    this.handleWhere(handler, where ?? []);
-    const result = await this.catch(await handler);
-
-    if (result.error) {
-      return result as DBBridgeResponse<unknown[]>;
-    }
-
-    return {
-      data: Array.isArray(result.data) ? result.data : [],
-      error: null,
-      count: countResult.count,
-      status: result.status,
-      statusText: result.statusText
-    } as DBBridgeResponse<unknown[]>;
-  }
-}

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

@@ -1,53 +0,0 @@
-import { inject, injectable } from 'inversify';
-import jwt from 'jsonwebtoken';
-import { AppConfig } from '@/base/cases/AppConfig';
-import type { UserSchema } from '@migrations/schema/UserSchema';
-import type { CrentialTokenInterface } from './port/CrentialTokenInterface';
-
-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;
-  }
-
-  /**
-   * @override
-   */
-  public 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
-    });
-  }
-
-  /**
-   * @override
-   */
-  public 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/controllers/AdminLocalesController.ts

@@ -1,86 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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

@@ -1,91 +0,0 @@
-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 {
-  SignupVerifyParamType,
-  SignupVerifyValidator
-} from '../validators/SignupVerifyValidator';
-import type { ServerAuthInterface } from '../port/ServerAuthInterface';
-import type { UserServiceInterface } from '../port/UserServiceInterface';
-import type { ValidatorInterface } from '../port/ValidatorInterface';
-import type { EncryptorInterface } from '@qlover/fe-corekit';
-
-@injectable()
-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
-  ) {}
-
-  /**
-   * @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

@@ -1,8 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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/CrentialTokenInterface.ts

@@ -1,5 +0,0 @@
-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/DBBridgeInterface.ts

@@ -1,36 +0,0 @@
-export type WhereOperation = '=' | '!=' | '>' | '<' | '>=' | '<=';
-export type Where = [string, WhereOperation, string | number];
-
-export interface BridgeEvent {
-  table: string;
-  fields?: string | string[];
-  orderBy?: BridgeOrderBy;
-  where?: Where[];
-  data?: unknown;
-  page?: number;
-  pageSize?: number;
-}
-
-export type BridgeOrderBy = [string, 0 | 1]; // 0: asc, 1: desc
-
-export interface PaginationInfo {
-  total: number;
-  page: number;
-  pageSize: number;
-}
-
-export interface DBBridgeResponse<T> {
-  error?: unknown;
-  data: T;
-  count?: number;
-  pagination?: PaginationInfo;
-}
-
-export interface DBBridgeInterface {
-  add(event: BridgeEvent): Promise<DBBridgeResponse<unknown>>;
-  update(event: BridgeEvent): Promise<DBBridgeResponse<unknown>>;
-  upsert(event: BridgeEvent): Promise<DBBridgeResponse<unknown>>;
-  delete(event: BridgeEvent): Promise<DBBridgeResponse<unknown>>;
-  get(event: BridgeEvent): Promise<DBBridgeResponse<unknown>>;
-  pagination(event: BridgeEvent): Promise<DBBridgeResponse<unknown[]>>;
-}

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

@@ -1,12 +0,0 @@
-import type { PaginationInterface } from '@/server/port/PaginationInterface';
-import type { BridgeOrderBy } from './DBBridgeInterface';
-
-export interface DBTableInterface {
-  readonly name: string;
-
-  pagination<T = unknown>(params: {
-    page: number;
-    pageSize: number;
-    orderBy?: BridgeOrderBy;
-  }): Promise<PaginationInterface<T>>;
-}

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

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