@qlover/create-app 0.7.9 → 0.7.11

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

@@ -0,0 +1,159 @@
+import {
+  createClient,
+  type PostgrestSingleResponse,
+  type SupabaseClient,
+  type PostgrestResponse
+} from '@supabase/supabase-js';
+import { injectable, inject } from 'inversify';
+import type { AppConfig } from '@/base/cases/AppConfig';
+import type {
+  BridgeEvent,
+  DBBridgeInterface,
+  Where
+} from '@/base/port/DBBridgeInterface';
+import { I } from '@config/IOCIdentifier';
+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);
+  }
+
+  async pagination(event: BridgeEvent): Promise<PostgrestResponse<unknown>> {
+    const { table, fields = '*', where, page = 1, pageSize = 10 } = event;
+    const selectFields = Array.isArray(fields) ? fields.join(',') : fields;
+
+    // 获取总数
+    const countHandler = this.supabase
+      .from(table)
+      .select('*', { count: 'exact', head: true });
+
+    this.handleWhere(countHandler, where ?? []);
+    const countResult = await this.catch(await countHandler);
+
+    // 获取分页数据
+    const handler = this.supabase
+      .from(table)
+      .select(selectFields)
+      .range((page - 1) * pageSize, page * pageSize - 1);
+
+    this.handleWhere(handler, where ?? []);
+    const result = await this.catch(await handler);
+
+    if (result.error) {
+      return result as PostgrestResponse<unknown>;
+    }
+
+    return {
+      data: Array.isArray(result.data) ? result.data : [],
+      error: null,
+      count: countResult.count,
+      status: result.status,
+      statusText: result.statusText
+    };
+  }
+}

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 { 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;
+  }
+
+  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/DBTableInterface.ts

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

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

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

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/UserRepositoryInterface.ts

@@ -0,0 +1,15 @@
+import type { DBTableInterface } from '@/server/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,94 @@
+import { inject, injectable } from 'inversify';
+import { isEmpty, last } from 'lodash';
+import type { DBBridgeInterface } from '@/base/port/DBBridgeInterface';
+import type { PaginationInterface } from '@/base/port/PaginationInterface';
+import type { UserSchema } from '@migrations/schema/UserSchema';
+import { SupabaseBridge } from '../SupabaseBridge';
+import type { UserRepositoryInterface } from '../port/UserRepositoryInterface';
+
+@injectable()
+export class UserRepository implements UserRepositoryInterface {
+  readonly name = 'fe_users';
+
+  protected safeFields = [
+    'created_at',
+    // 'credential_token',
+    'email',
+    'email_confirmed_at',
+    'id',
+    // 'password',
+    'role',
+    'updated_at'
+  ];
+
+  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]]
+    });
+  }
+
+  async pagination<UserSchema>(params: {
+    page: number;
+    pageSize: number;
+  }): Promise<PaginationInterface<UserSchema>> {
+    const result = await this.dbBridge.pagination({
+      table: this.name,
+      page: params.page,
+      pageSize: params.pageSize,
+      fields: this.safeFields
+    });
+
+    return {
+      list: result.data as UserSchema[],
+      total: result.count ?? 0,
+      page: params.page,
+      pageSize: params.pageSize
+    };
+  }
+}

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

@@ -0,0 +1,19 @@
+import type { BootstrapServerContextValue } from '@/core/bootstraps/BootstrapServer';
+import { ServerAuth } from '../ServerAuth';
+import type { ServerAuthInterface } from '../port/ServerAuthInterface';
+import type { BootstrapExecutorPlugin } from '@qlover/corekit-bridge';
+import type { ExecutorContext } from '@qlover/fe-corekit';
+
+export class AdminAuthPlugin implements BootstrapExecutorPlugin {
+  pluginName = 'AdminAuthPlugin';
+
+  async onBefore(
+    context: ExecutorContext<BootstrapServerContextValue>
+  ): Promise<void> {
+    const { IOC } = context.parameters;
+
+    const serverAuth: ServerAuthInterface = IOC(ServerAuth);
+
+    await serverAuth.throwIfNotAuth();
+  }
+}

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

@@ -0,0 +1,26 @@
+import { inject, injectable } from 'inversify';
+import type { PaginationInterface } from '@/base/port/PaginationInterface';
+import type { UserSchema } from '@migrations/schema/UserSchema';
+import { UserRepository } from '../repositorys/UserRepository';
+import { PaginationValidator } from '../validators/PaginationValidator';
+import type { UserRepositoryInterface } from '../port/UserRepositoryInterface';
+import type { ValidatorInterface } from '../port/ValidatorInterface';
+
+@injectable()
+export class ApiUserService {
+  constructor(
+    @inject(UserRepository)
+    protected userRepository: UserRepositoryInterface,
+    @inject(PaginationValidator)
+    protected paginationValidator: ValidatorInterface
+  ) {}
+
+  async getUsers(params: {
+    page: number;
+    pageSize: number;
+  }): Promise<PaginationInterface<UserSchema>> {
+    const result = await this.userRepository.pagination(params);
+
+    return result as PaginationInterface<UserSchema>;
+  }
+}

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 type { UserSchema } from '@migrations/schema/UserSchema';
+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 { ServerAuthInterface } from '../port/ServerAuthInterface';
+import type { UserRepositoryInterface } from '../port/UserRepositoryInterface';
+import type { UserServiceInterface } from '../port/UserServiceInterface';
+import type { Encryptor } from '@qlover/fe-corekit';
+
+@injectable()
+export class UserService implements UserServiceInterface {
+  constructor(
+    @inject(UserRepository)
+    protected userRepository: UserRepositoryInterface,
+    @inject(ServerAuth)
+    protected userAuth: ServerAuthInterface,
+    @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/server/validators/PaginationValidator.ts

@@ -0,0 +1,48 @@
+import { z } from 'zod';
+import type { PaginationInterface } from '@/base/port/PaginationInterface';
+import { API_PAGE_INVALID } from '@config/Identifier';
+import {
+  type ValidationFaildResult,
+  type ValidatorInterface
+} from '../port/ValidatorInterface';
+
+const pageSchema = z
+  .number()
+  .or(z.string())
+  .transform((val) => Number(val))
+  .refine((val) => val > 0, {
+    message: API_PAGE_INVALID
+  });
+
+export class PaginationValidator implements ValidatorInterface {
+  protected defaultPageSize = 10;
+
+  validatePageSize(value: unknown): void | ValidationFaildResult {
+    const result = pageSchema.safeParse(value);
+    if (!result.success) {
+      return result.error.issues[0];
+    }
+  }
+
+  validate(data: unknown): void | ValidationFaildResult {
+    if (typeof data !== 'object' || data === null) {
+      return {
+        path: ['form'],
+        message: 'form is required'
+      };
+    }
+
+    return this.validatePageSize((data as Record<string, unknown>).page);
+  }
+
+  getThrow(
+    data: unknown
+  ): Pick<PaginationInterface<unknown>, 'page' | 'pageSize'> {
+    const result = this.validate(data);
+    if (result) {
+      throw new Error(result.message);
+    }
+
+    return { page: 1, pageSize: 10 };
+  }
+}