@qlover/create-app 1.0.2 → 2.0.0

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

@@ -1,137 +0,0 @@
-import { inject, injectable } from 'inversify';
-import { omit } from 'lodash';
-import { revalidateTag } from 'next/cache';
-import type { LocalesSchema } from '@migrations/schema/LocalesSchema';
-import type { LocaleType } from '@config/i18n';
-import { i18nConfig } from '@config/i18n';
-import { splitI18nKey } from '@config/i18n/i18nKeyScheam';
-import { LocalesRepository } from '../repositorys/LocalesRepository';
-import type { BridgeOrderBy } from '../port/DBBridgeInterface';
-import type {
-  LocalesRepositoryInterface,
-  UpsertResult
-} from '../port/LocalesRepositoryInterface';
-import type { PaginationInterface } from '../port/PaginationInterface';
-
-export type ImportLocalesData = {
-  namespace?: string;
-
-  values: {
-    [key in LocaleType]?: Record<string, string>;
-  };
-};
-
-export type GetLocalesParams = {
-  page: number;
-  pageSize: number;
-  orderBy?: BridgeOrderBy;
-};
-
-@injectable()
-export class ApiLocaleService {
-  constructor(
-    @inject(LocalesRepository)
-    protected localesRepository: LocalesRepositoryInterface
-  ) {}
-
-  public async getLocalesJson(
-    localeName: string,
-    orderBy?: BridgeOrderBy
-  ): Promise<Record<string, string>> {
-    const locales = await this.localesRepository.getLocales(
-      localeName,
-      orderBy
-    );
-    return locales.reduce(
-      (acc, locale) => {
-        // @ts-expect-error localeName is valid
-        acc[locale.value] = locale[localeName];
-        return acc;
-      },
-      {} as Record<string, string>
-    );
-  }
-
-  public async getLocales(
-    params: GetLocalesParams
-  ): Promise<PaginationInterface<LocalesSchema>> {
-    return this.localesRepository.pagination({
-      page: params.page,
-      pageSize: params.pageSize,
-      orderBy: params.orderBy
-    });
-  }
-
-  public async update(data: Partial<LocalesSchema>): Promise<void> {
-    if (!data.id || typeof data.id !== 'number') {
-      throw new Error(
-        'ID is required and must be a number for update operation'
-      );
-    }
-
-    await this.localesRepository.updateById(
-      data.id,
-      omit(data, ['id', 'created_at'])
-    );
-
-    // 清除所有支持的语言的缓存
-    const revalidatePromises = i18nConfig.supportedLngs.map(async (locale) => {
-      await revalidateTag(`i18n-${locale}`, 'default');
-    });
-    await Promise.all(revalidatePromises);
-  }
-
-  public async create(data: Partial<LocalesSchema>): Promise<void> {
-    await this.localesRepository.add(data as LocalesSchema);
-
-    // 清除所有支持的语言的缓存
-    const revalidatePromises = i18nConfig.supportedLngs.map(async (locale) => {
-      await revalidateTag(`i18n-${locale}`, 'default');
-    });
-    await Promise.all(revalidatePromises);
-  }
-
-  public async importLocales(data: ImportLocalesData): Promise<UpsertResult> {
-    const { namespace = 'common', values } = data;
-
-    const result: Record<string, Record<string, string>> = {};
-
-    Object.entries(values).forEach(([locale, values2]) => {
-      Object.entries(values2).forEach(([key, value]) => {
-        if (!result[key]) {
-          result[key] = {};
-        }
-
-        result[key]!['value'] = key;
-        result[key]![locale] = value;
-
-        if (locale === i18nConfig.fallbackLng) {
-          result[key]!['description'] = value;
-        }
-
-        const { namespace: namespace2 } = splitI18nKey(key);
-        result[key]!['namespace'] = namespace2 || namespace;
-      });
-    });
-
-    const localesSchemas = Object.values(result) as Partial<LocalesSchema>[];
-
-    // Use batch upsert method with chunk processing
-    const upsertResult = await this.localesRepository.upsert(localesSchemas, {
-      chunkSize: 100, // 100 items per chunk
-      concurrency: 3 // max 3 concurrent requests
-    });
-
-    // Clear cache for all supported languages if any data was successfully imported
-    if (upsertResult.successCount > 0) {
-      const revalidatePromises = i18nConfig.supportedLngs.map(
-        async (locale) => {
-          await revalidateTag(`i18n-${locale}`, 'default');
-        }
-      );
-      await Promise.all(revalidatePromises);
-    }
-
-    return upsertResult;
-  }
-}

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

@@ -1,29 +0,0 @@
-import { inject, injectable } from 'inversify';
-import type { PaginationInterface } from '@/server/port/PaginationInterface';
-import type { UserSchema } from '@migrations/schema/UserSchema';
-import { UserRepository } from '../repositorys/UserRepository';
-import {
-  type PaginationParams,
-  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<PaginationParams>
-  ) {}
-
-  public 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

@@ -1,134 +0,0 @@
-import { ExecutorError, type EncryptorInterface } from '@qlover/fe-corekit';
-import { Session, User } from '@supabase/supabase-js';
-import { inject, injectable } from 'inversify';
-import { isString } from 'lodash';
-import { AppConfig } from '@/base/cases/AppConfig';
-import type { UserSchema } from '@migrations/schema/UserSchema';
-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
-} from '../UserCredentialToken';
-import type { CrentialTokenInterface } from '../port/CrentialTokenInterface';
-import type { ServerAuthInterface } from '../port/ServerAuthInterface';
-import type { UserRepositoryInterface } from '../port/UserRepositoryInterface';
-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,
-    @inject(ServerAuth)
-    protected userAuth: ServerAuthInterface,
-    @inject(PasswordEncrypt)
-    protected encryptor: EncryptorInterface<string, string>,
-    @inject(UserCredentialToken)
-    protected credentialToken: CrentialTokenInterface<UserCredentialTokenValue>,
-    @inject(SupabaseBridge) protected supabaseBridge: SupabaseBridge
-  ) {}
-
-  /**
-   * @override
-   */
-  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: params.password
-
-      // options: {
-      //   emailRedirectTo: 'http://localhost:3100/callback'
-      // }
-    });
-    this.supabaseBridge.throwIfError(result);
-
-    if (!result.data.user) {
-      throw new Error(API_USER_NOT_FOUND);
-    }
-
-    return this.supabaseBridge.toUserSchema(result.data.user);
-  }
-
-  /**
-   * @override
-   */
-  public async login(params: {
-    email: string;
-    password: string;
-    authCode?: string;
-  }): Promise<UserSchema> {
-    const supabase = await this.supabaseBridge.getSupabase();
-
-    if (params.authCode) {
-      const ares = await supabase.auth.exchangeCodeForSession(params.authCode);
-      this.supabaseBridge.throwIfError(ares);
-    }
-
-    const result = await supabase.auth.signInWithPassword({
-      email: params.email,
-      password: params.password
-    });
-    this.supabaseBridge.throwIfError(result);
-
-    this.logger.info('supbase login succees', result.data);
-
-    return this.supabaseBridge.toUserSchema(result.data.user!);
-  }
-
-  /**
-   * @override
-   */
-  public async logout(): Promise<void> {
-    const supabase = await this.supabaseBridge.getSupabase();
-
-    const response = await supabase.auth.signOut();
-
-    this.supabaseBridge.throwIfError(response);
-  }
-
-  public async exchangeSessionForCode(code: string): Promise<{
-    user: User;
-    session: Session;
-  }> {
-    if (code == null || !isString(code)) {
-      throw new ExecutorError('code is required');
-    }
-
-    const supabase = await this.supabaseBridge.getSupabase();
-    const response = await supabase.auth.exchangeCodeForSession(code);
-    this.supabaseBridge.throwIfError(response);
-
-    this.logger.debug('exchangeSessionForCode', response.data);
-
-    if (!response.data.user) {
-      throw new ExecutorError(API_USER_NOT_FOUND);
-    }
-
-    return response.data;
-  }
-}

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

@@ -1,6 +0,0 @@
-import type { ValidationFaildResult } from '../port/ValidatorInterface';
-import type { ExecutorError } from '@qlover/fe-corekit';
-
-export interface ExtendedExecutorError extends ExecutorError {
-  issues?: ValidationFaildResult[];
-}

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

@@ -1,145 +0,0 @@
-import { ExecutorError } from '@qlover/fe-corekit';
-import { omit } from 'lodash';
-import type { LocalesSchema } from '@migrations/schema/LocalesSchema';
-import { localesSchema } from '@migrations/schema/LocalesSchema';
-import type { LocaleType } from '@config/i18n';
-import { i18nConfig } from '@config/i18n';
-import {
-  type ValidationFaildResult,
-  type ValidatorInterface
-} from '../port/ValidatorInterface';
-import type { ExtendedExecutorError } from './ExtendedExecutorError';
-import type { ImportLocalesData } from '../services/ApiLocaleService';
-
-export class LocalesValidator implements ValidatorInterface<
-  Omit<LocalesSchema, 'id' | 'created_at' | 'updated_at'>
-> {
-  /**
-   * @override
-   */
-  public validate(data: unknown): void | ValidationFaildResult {
-    if (typeof data !== 'object' || data === null) {
-      return {
-        path: ['form'],
-        message: 'form is required'
-      };
-    }
-
-    const result = localesSchema
-      .omit({ id: true, created_at: true, updated_at: true })
-      .safeParse(data);
-
-    if (!result.success) {
-      return result.error.issues[0];
-    }
-  }
-
-  /**
-   * @override
-   */
-  public getThrow(
-    data: unknown
-  ): Omit<LocalesSchema, 'id' | 'created_at' | 'updated_at'> {
-    const result = this.validate(data);
-
-    if (result == null) {
-      return omit(data as LocalesSchema, ['id', 'created_at', 'updated_at']);
-    }
-
-    const error: ExtendedExecutorError = new ExecutorError(result.message);
-    error.issues = [result];
-    throw error;
-  }
-}
-
-export class LocalesImportValidator implements ValidatorInterface<ImportLocalesData> {
-  public getHasAnyFilesLocale(
-    values: FormData
-  ): { language: LocaleType; value: FormDataEntryValue }[] {
-    const hasAnyFilesLocale = [];
-    for (const language of i18nConfig.supportedLngs) {
-      const value = values.get(language);
-      if (value != null) {
-        hasAnyFilesLocale.push({ language, value });
-      }
-    }
-    return hasAnyFilesLocale;
-  }
-
-  /**
-   * @override
-   */
-  public async validate(data: {
-    namespace?: string;
-    values: unknown;
-  }): Promise<void | ValidationFaildResult> {
-    const values = data.values;
-    if (!(values instanceof FormData)) {
-      return {
-        path: ['form'],
-        message: 'FormData is required'
-      };
-    }
-
-    const hasAnyFilesLocale = this.getHasAnyFilesLocale(values);
-
-    if (hasAnyFilesLocale.length === 0) {
-      return {
-        path: ['form'],
-        message: 'At least one language file is required'
-      };
-    }
-
-    for (const { language, value } of hasAnyFilesLocale) {
-      if (!(value instanceof File) || value.type !== 'application/json') {
-        return {
-          path: [language],
-          message: `File for language ${language} is not a JSON File`
-        };
-      }
-
-      try {
-        const content = await (value as File).text();
-        JSON.parse(content);
-      } catch {
-        return {
-          path: [language],
-          message: `File for language ${language} is not a valid JSON`
-        };
-      }
-    }
-  }
-
-  /**
-   * @override
-   */
-  public async getThrow(data: {
-    namespace?: string;
-    values: unknown;
-  }): Promise<ImportLocalesData> {
-    const result = await this.validate(data);
-
-    console.log(result);
-    if (result == null) {
-      const hasAnyFilesLocales = this.getHasAnyFilesLocale(
-        data.values as FormData
-      );
-      const result: { [key in LocaleType]?: Record<string, string> } = {};
-
-      for (const { language, value } of hasAnyFilesLocales) {
-        const content = await (value as File).text();
-        const jsonData = JSON.parse(content);
-        result[language as LocaleType] = jsonData;
-      }
-
-      return {
-        namespace: data.namespace || 'common',
-        values: result
-      };
-    }
-
-    const error: ExtendedExecutorError = new ExecutorError(result.message);
-    error.issues = [result];
-    throw error;
-  }
-}

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

@@ -1,82 +0,0 @@
-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/common/validators';
-import type { ExtendedExecutorError } from './ExtendedExecutorError';
-import type {
-  ValidatorInterface,
-  ValidationFaildResult
-} from '../port/ValidatorInterface';
-
-export interface LoginValidatorData {
-  email: string;
-  password: string;
-}
-
-const emailSchema = z.string().email({ message: V_EMAIL_INVALID });
-
-const passwordSchema = z
-  .string()
-  .min(6, { message: V_PASSWORD_MIN_LENGTH })
-  .max(50, { message: V_PASSWORD_MAX_LENGTH })
-  .regex(/^\S+$/, { message: V_PASSWORD_SPECIAL_CHARS });
-
-export class LoginValidator implements ValidatorInterface<LoginValidatorData> {
-  public validateEmail(data: unknown): void | ValidationFaildResult {
-    const emailResult = emailSchema.safeParse(data);
-    if (!emailResult.success) {
-      return emailResult.error.issues[0];
-    }
-  }
-
-  public validatePassword(data: unknown): void | ValidationFaildResult {
-    const passwordResult = passwordSchema.safeParse(data);
-    if (!passwordResult.success) {
-      return passwordResult.error.issues[0];
-    }
-  }
-
-  /**
-   * @override
-   */
-  public 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;
-    }
-  }
-
-  /**
-   * @override
-   */
-  public 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

@@ -1,70 +0,0 @@
-import { z } from 'zod';
-import { API_PAGE_INVALID } from '@config/Identifier';
-import {
-  type ValidationFaildResult,
-  type ValidatorInterface
-} from '../port/ValidatorInterface';
-import type { BridgeOrderBy } from '../port/DBBridgeInterface';
-
-const numberSchema = z
-  .number()
-  .or(z.string())
-  .transform((val) => Number(val))
-  .refine((val) => val > 0, {
-    message: API_PAGE_INVALID
-  });
-
-const paginationSchema = z.object({
-  page: numberSchema,
-  pageSize: numberSchema.optional().default(10),
-  orderBy: z.string().optional(),
-  order: z.string().optional().default('0')
-});
-
-export type PaginationParams = {
-  page: number;
-  pageSize: number;
-  orders?: BridgeOrderBy;
-};
-
-export class PaginationValidator implements ValidatorInterface<PaginationParams> {
-  protected defaultPageSize = 10;
-
-  /**
-   * @override
-   */
-  public validate(data: unknown): void | ValidationFaildResult {
-    if (typeof data !== 'object' || data === null) {
-      return {
-        path: ['form'],
-        message: 'form is required'
-      };
-    }
-
-    const result = paginationSchema.safeParse(data);
-    if (!result.success) {
-      return result.error.issues[0];
-    }
-  }
-
-  /**
-   * @override
-   */
-  public getThrow<T>(data: unknown): T {
-    const result = paginationSchema.safeParse(data);
-    if (!result.success) {
-      throw new Error(result.error.issues[0].message);
-    }
-
-    const order = result.data.order;
-
-    return {
-      page: result.data.page,
-      pageSize: result.data.pageSize,
-      orders: [
-        result.data.orderBy || 'updated_at',
-        order == '0' || order == '1' ? (+order as 0 | 1) : 0
-      ] as BridgeOrderBy
-    } as T;
-  }
-}

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

@@ -1,68 +0,0 @@
-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;
-  }
-}