@qlover/create-app 0.7.14 → 0.8.0

package/dist/templates/next-app/src/server/repositorys/LocalesRepository.ts

@@ -0,0 +1,197 @@
+import { inject, injectable } from 'inversify';
+import pLimit from 'p-limit';
+import { Datetime } from '@/base/cases/Datetime';
+import type {
+  BridgeOrderBy,
+  DBBridgeInterface
+} from '@/server/port/DBBridgeInterface';
+import type { PaginationInterface } from '@/server/port/PaginationInterface';
+import {
+  localesSchema,
+  type LocalesSchema
+} from '@migrations/schema/LocalesSchema';
+import { I } from '@config/IOCIdentifier';
+import type {
+  LocalesRepositoryInterface,
+  UpsertResult
+} from '../port/LocalesRepositoryInterface';
+
+@injectable()
+export class LocalesRepository implements LocalesRepositoryInterface {
+  readonly name = 'next_app_locales';
+
+  protected safeFields = Object.keys(localesSchema.shape);
+
+  constructor(
+    @inject(I.DBBridgeInterface) protected dbBridge: DBBridgeInterface,
+    @inject(Datetime) protected datetime: Datetime
+  ) {}
+
+  async getAll(): Promise<LocalesSchema[]> {
+    const result = await this.dbBridge.get({
+      table: this.name,
+      fields: this.safeFields
+    });
+    return (result.data as LocalesSchema[]) || [];
+  }
+
+  async getLocales(
+    localeName: string,
+    orderBy?: BridgeOrderBy
+  ): Promise<LocalesSchema[]> {
+    const result = await this.dbBridge.get({
+      table: this.name,
+      fields: this.safeFields,
+      orderBy
+    });
+
+    const data = result.data as LocalesSchema[];
+    return data && data.length > 0 ? data : [];
+  }
+
+  async add(params: LocalesSchema): Promise<LocalesSchema[] | null> {
+    const now = this.datetime.timestampz();
+    const data = {
+      ...params,
+      created_at: now,
+      updated_at: now
+    };
+
+    const result = await this.dbBridge.add({
+      table: this.name,
+      fields: this.safeFields,
+      data
+    });
+
+    return (result.data as LocalesSchema[]) || null;
+  }
+
+  async updateById(
+    id: number,
+    params: Partial<Omit<LocalesSchema, 'id' | 'created_at'>>
+  ): Promise<void> {
+    const data = {
+      ...params,
+      updated_at: this.datetime.timestampz()
+    };
+
+    await this.dbBridge.update({
+      table: this.name,
+      fields: this.safeFields,
+      data,
+      where: [['id', '=', id]]
+    });
+  }
+
+  async pagination<T = LocalesSchema>(params: {
+    page: number;
+    pageSize: number;
+    orderBy?: BridgeOrderBy;
+  }): Promise<PaginationInterface<T>> {
+    const result = await this.dbBridge.pagination({
+      table: this.name,
+      fields: this.safeFields,
+      page: params.page,
+      pageSize: params.pageSize,
+      orderBy: params.orderBy
+    });
+
+    return {
+      list: (result.data || []) as T[],
+      total: result.count || 0,
+      page: params.page,
+      pageSize: params.pageSize
+    };
+  }
+
+  /**
+   * batch upsert data, support chunk processing and concurrency control
+   * @param data - data to upsert
+   * @param options - options
+   * @param options.chunkSize - chunk size, default 100
+   * @param options.concurrency - concurrency, default 3
+   * @returns UpsertResult - contains success/failure details with returned data
+   */
+  async upsert(
+    data: Partial<LocalesSchema>[],
+    options?: {
+      chunkSize?: number;
+      concurrency?: number;
+    }
+  ): Promise<UpsertResult> {
+    const { chunkSize = 100, concurrency = 3 } = options || {};
+
+    // Initialize result
+    const result: UpsertResult = {
+      totalCount: data.length,
+      successCount: 0,
+      failureCount: 0,
+      successChunks: [],
+      failureChunks: [],
+      allReturnedData: []
+    };
+
+    if (data.length === 0) {
+      return result;
+    }
+
+    const now = this.datetime.timestampz();
+
+    // Add timestamps to all data
+    const dataWithTimestamp = data.map((item) => ({
+      ...item,
+      created_at: item.created_at || now,
+      updated_at: now
+    }));
+
+    // Split data into chunks
+    const chunks: Partial<LocalesSchema>[][] = [];
+    for (let i = 0; i < dataWithTimestamp.length; i += chunkSize) {
+      chunks.push(dataWithTimestamp.slice(i, i + chunkSize));
+    }
+
+    // Use p-limit to control concurrency
+    const limit = pLimit(concurrency);
+
+    // Execute upsert for each chunk and collect results
+    const tasks = chunks.map((chunk, index) =>
+      limit(async () => {
+        try {
+          const response = await this.dbBridge.upsert({
+            table: this.name,
+            fields: this.safeFields,
+            data: chunk
+          });
+
+          // Extract returned data from database
+          const returnedData = (response.data as LocalesSchema[]) || [];
+          const affectedCount = response.count || returnedData.length;
+
+          // Success
+          result.successCount += affectedCount;
+          result.allReturnedData.push(...returnedData);
+          result.successChunks.push({
+            success: true,
+            chunkIndex: index,
+            inputData: chunk,
+            returnedData: returnedData,
+            affectedCount: affectedCount
+          });
+        } catch (error) {
+          // Failure
+          result.failureCount += chunk.length;
+          result.failureChunks.push({
+            success: false,
+            chunkIndex: index,
+            inputData: chunk,
+            error: error instanceof Error ? error.message : String(error)
+          });
+        }
+      })
+    );
+
+    await Promise.all(tasks);
+
+    return result;
+  }
+}

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

@@ -0,0 +1,122 @@
+import { inject, injectable } from 'inversify';
+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>;
+  };
+};
+
+@injectable()
+export class ApiLocaleService {
+  constructor(
+    @inject(LocalesRepository)
+    protected localesRepository: LocalesRepositoryInterface
+  ) {}
+
+  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>
+    );
+  }
+
+  async getLocales(params: {
+    page: number;
+    pageSize: number;
+    orderBy?: BridgeOrderBy;
+  }): Promise<PaginationInterface<LocalesSchema>> {
+    return this.localesRepository.pagination({
+      page: params.page,
+      pageSize: params.pageSize,
+      orderBy: params.orderBy
+    });
+  }
+
+  async update(data: Partial<LocalesSchema>): Promise<void> {
+    await this.localesRepository.updateById(
+      data.id!,
+      data as Omit<LocalesSchema, 'id' | 'created_at'>
+    );
+
+    // 清除所有支持的语言的缓存
+    const revalidatePromises = i18nConfig.supportedLngs.map(async (locale) => {
+      await revalidateTag(`i18n-${locale}`);
+    });
+    await Promise.all(revalidatePromises);
+  }
+
+  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}`);
+    });
+    await Promise.all(revalidatePromises);
+  }
+
+  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;
+
+        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}`);
+        }
+      );
+      await Promise.all(revalidatePromises);
+    }
+
+    return upsertResult;
+  }
+}

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

@@ -10,11 +10,15 @@ import type {
   BridgeEvent,
   DBBridgeInterface,
   DBBridgeResponse,
+  BridgeOrderBy,
   Where
 } from '@/server/port/DBBridgeInterface';
 import { I } from '@config/IOCIdentifier';
 import type { LoggerInterface } from '@qlover/logger';
-import type { PostgrestFilterBuilder } from '@supabase/postgrest-js';
+import type {
+  PostgrestFilterBuilder,
+  PostgrestResponseFailure
+} from '@supabase/postgrest-js';
 
 const whereHandlerMaps = {
   '=': 'eq',
@@ -55,13 +59,24 @@ export class SupabaseBridge implements DBBridgeInterface {
     result: PostgrestSingleResponse<unknown>
   ): Promise<SupabaseBridgeResponse<unknown>> {
     if (result.error) {
-      this.logger.info(result);
-      throw new Error(result.error.message);
+      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'
+    );
+  }
+
   protected handleWhere(
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     handler: PostgrestFilterBuilder<any, any, any, any, string, unknown, any>,
@@ -84,6 +99,16 @@ export class SupabaseBridge implements DBBridgeInterface {
     }
   }
 
+  protected handleOrderBy(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    handler: PostgrestFilterBuilder<any, any, any, any, string, unknown, any>,
+    orderBy?: BridgeOrderBy
+  ): void {
+    if (orderBy) {
+      handler.order(orderBy[0], { ascending: orderBy[1] === 0 });
+    }
+  }
+
   async add(event: BridgeEvent): Promise<DBBridgeResponse<unknown>> {
     const { table, data } = event;
     if (!data) {
@@ -91,8 +116,22 @@ export class SupabaseBridge implements DBBridgeInterface {
     }
     const res = await this.supabase
       .from(table)
-      .insert(Array.isArray(data) ? data : [data])
-      .select();
+      .insert(Array.isArray(data) ? data : [data]);
+    return this.catch(res);
+  }
+
+  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 res = await this.supabase
+      .from(table)
+      .upsert(Array.isArray(data) ? data : [data], {
+        onConflict: 'value'
+      })
+      .select(selectFields); // Request to return the upserted data
     return this.catch(res);
   }
 
@@ -119,17 +158,26 @@ export class SupabaseBridge implements DBBridgeInterface {
   }
 
   async get(event: BridgeEvent): Promise<SupabaseBridgeResponse<unknown>> {
-    const { table, fields = '*', where } = event;
+    const { table, fields = '*', where, orderBy } = event;
     const selectFields = Array.isArray(fields) ? fields.join(',') : fields;
     const handler = this.supabase.from(table).select(selectFields);
 
     this.handleWhere(handler, where ?? []);
 
+    this.handleOrderBy(handler, orderBy);
+
     return this.catch(await handler);
   }
 
   async pagination(event: BridgeEvent): Promise<DBBridgeResponse<unknown[]>> {
-    const { table, fields = '*', where, page = 1, pageSize = 10 } = event;
+    const {
+      table,
+      fields = '*',
+      where,
+      page = 1,
+      pageSize = 10,
+      orderBy
+    } = event;
     const selectFields = Array.isArray(fields) ? fields.join(',') : fields;
 
     // 获取总数
@@ -141,10 +189,11 @@ export class SupabaseBridge implements DBBridgeInterface {
     const countResult = await this.catch(await countHandler);
 
     // 获取分页数据
-    const handler = this.supabase
-      .from(table)
-      .select(selectFields)
-      .range((page - 1) * pageSize, page * pageSize - 1);
+    const handler = this.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);

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

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

@@ -0,0 +1,131 @@
+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 {
+  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];
+    }
+  }
+
+  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 {
+  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;
+  }
+
+  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`
+        };
+      }
+    }
+  }
+
+  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

@@ -6,7 +6,8 @@ import {
   V_PASSWORD_MIN_LENGTH,
   V_PASSWORD_MAX_LENGTH,
   V_PASSWORD_SPECIAL_CHARS
-} from '@config/Identifier/validator';
+} from '@config/Identifier/common/validators';
+import type { ExtendedExecutorError } from './ExtendedExecutorError';
 import type {
   ValidatorInterface,
   ValidationFaildResult
@@ -25,10 +26,6 @@ const passwordSchema = z
   .max(50, { message: V_PASSWORD_MAX_LENGTH })
   .regex(/^\S+$/, { message: 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);

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

@@ -5,8 +5,9 @@ import {
   type ValidationFaildResult,
   type ValidatorInterface
 } from '../port/ValidatorInterface';
+import type { BridgeOrderBy } from '../port/DBBridgeInterface';
 
-const pageSchema = z
+const numberSchema = z
   .number()
   .or(z.string())
   .transform((val) => Number(val))
@@ -14,16 +15,16 @@ const pageSchema = z
     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 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 {
@@ -32,17 +33,32 @@ export class PaginationValidator implements ValidatorInterface {
       };
     }
 
-    return this.validatePageSize((data as Record<string, unknown>).page);
+    const result = paginationSchema.safeParse(data);
+    if (!result.success) {
+      return result.error.issues[0];
+    }
   }
 
-  getThrow(
-    data: unknown
-  ): Pick<PaginationInterface<unknown>, 'page' | 'pageSize'> {
-    const result = this.validate(data);
-    if (result) {
-      throw new Error(result.message);
+  getThrow(data: unknown): Pick<
+    PaginationInterface<unknown>,
+    'page' | 'pageSize'
+  > & {
+    orders: BridgeOrderBy;
+  } {
+    const result = paginationSchema.safeParse(data);
+    if (!result.success) {
+      throw new Error(result.error.issues[0].message);
     }
 
-    return { page: 1, pageSize: 10 };
+    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
+      ]
+    };
   }
 }

package/dist/templates/next-app/src/styles/css/antd-themes/pagination/_default.css

@@ -1,6 +1,7 @@
 /* custom variables - for antd and custom css */
 html,
-.fe-theme {
+.fe-theme .ant-pagination-css-var,
+.fe-theme.ant-pagination {
   /* Antd Pagination 组件变量 */
   .ant-pagination-css-var {
     --fe-pagination-item-bg: rgb(var(--color-bg-base));