@qlover/create-app 0.7.15 → 0.9.0

package/dist/templates/next-app/src/base/services/AdminLocalesService.ts

@@ -0,0 +1,20 @@
+import { ResourceStore } from '@qlover/corekit-bridge';
+import { inject, injectable } from 'inversify';
+import { ResourceService } from '@/base/services/ResourceService';
+import type { LocalesSchema } from '@migrations/schema/LocalesSchema';
+import { AdminLocalesApi } from './adminApi/AdminLocalesApi';
+import { ResourceState } from '../cases/ResourceState';
+
+@injectable()
+export class AdminLocalesService extends ResourceService<
+  LocalesSchema,
+  ResourceStore<ResourceState>
+> {
+  constructor(
+    @inject(AdminLocalesApi)
+    protected adminLocalesApi: AdminLocalesApi
+  ) {
+    const store = new ResourceStore(() => new ResourceState());
+    super('admin_locales', store, adminLocalesApi);
+  }
+}

package/dist/templates/next-app/src/base/services/AdminPageEvent.ts

@@ -0,0 +1,26 @@
+import { ResourceEvent } from '@brain-toolkit/antd-blocks/resourceTable/ResourceEvent';
+import type { ResourceService } from './ResourceService';
+import type { DialogHandlerOptions } from '../cases/DialogHandler';
+import type { ResourceState } from '../cases/ResourceState';
+import type { ResourceTableEventCommonParams } from '@brain-toolkit/antd-blocks';
+import type { UIDialogInterface, ResourceStore } from '@qlover/corekit-bridge';
+import type { FormInstance } from 'antd';
+
+export class AdminPageEvent extends ResourceEvent {
+  constructor(
+    namespace: string,
+    resource: ResourceService<unknown, ResourceStore<ResourceState>>,
+    schemaFormRef?: FormInstance<unknown>,
+    protected uiDialog?: UIDialogInterface<DialogHandlerOptions>
+  ) {
+    super(namespace, resource, undefined, schemaFormRef);
+  }
+
+  override onDeleted(_params: ResourceTableEventCommonParams): void {
+    this.uiDialog?.confirm({
+      title: 'Confirm Delete',
+      content: 'Are you sure you want to delete this item?',
+      onOk: () => this.actionDelete(_params)
+    });
+  }
+}

package/dist/templates/next-app/src/base/services/AdminPageScheduler.ts

@@ -0,0 +1,42 @@
+import { RequestState, type LifecycleInterface } from '@qlover/corekit-bridge';
+import type { ResourceService } from '@/base/services/ResourceService';
+
+export class AdminPageScheduler implements LifecycleInterface {
+  /**
+   * @override
+   */
+  async created(parmas: {
+    resource: ResourceService<unknown>;
+  }): Promise<unknown> {
+    const { resource } = parmas;
+    const store = resource.getStore();
+
+    store.changeInitState(new RequestState(true));
+
+    try {
+      const result = await resource.search(store.state.searchParams);
+
+      store.changeInitState(new RequestState(false, result).end());
+      return result;
+    } catch (error) {
+      store.changeInitState(new RequestState(false, null, error).end());
+
+      return error;
+    }
+  }
+
+  /**
+   * @override
+   */
+  destroyed(parmas: { resource: ResourceService<unknown> }): void {
+    const { resource } = parmas;
+    const store = resource.getStore();
+
+    store.reset();
+  }
+
+  /**
+   * @override
+   */
+  updated(): void {}
+}

package/dist/templates/next-app/src/base/services/ResourceService.ts

@@ -0,0 +1,122 @@
+import {
+  RequestState,
+  type ResourceStore,
+  type ResourceStateInterface,
+  type ResourceServiceInterface,
+  type ResourceInterface,
+  type ResourceQuery
+} from '@qlover/corekit-bridge';
+import type { AppApiResponse } from '@/base/services/appApi/AppApiRequester';
+import type { PaginationInterface } from '@/server/port/PaginationInterface';
+
+export class ResourceService<
+  T,
+  Store extends
+    ResourceStore<ResourceStateInterface> = ResourceStore<ResourceStateInterface>
+> implements ResourceServiceInterface<T>
+{
+  readonly unionKey: string = 'id';
+
+  constructor(
+    readonly serviceName: string,
+    readonly store: Store,
+    readonly resourceApi: ResourceInterface<T>
+  ) {}
+
+  getStore(): Store {
+    return this.store;
+  }
+
+  /**
+   * @override
+   */
+  async created(): Promise<unknown> {
+    this.store.changeInitState(new RequestState(true));
+
+    try {
+      const result = await this.search(this.store.state.searchParams);
+
+      this.store.changeInitState(new RequestState(false, result).end());
+      return result;
+    } catch (error) {
+      this.store.changeInitState(new RequestState(false, null, error).end());
+
+      return error;
+    }
+  }
+
+  /**
+   * @override
+   */
+  destroyed(): void {
+    this.store.reset();
+  }
+
+  /**
+   * @override
+   */
+  updated(): void {}
+
+  async search(
+    params: Partial<ResourceQuery>
+  ): Promise<PaginationInterface<T>> {
+    this.store.changeListState(
+      new RequestState(true, this.store.state.listState.result)
+    );
+
+    try {
+      const response = (await this.resourceApi.search(
+        Object.assign({}, this.store.state.searchParams, params)
+      )) as AppApiResponse<ResourceQuery, PaginationInterface<T>>;
+
+      if (response.data.success) {
+        const resultData = response.data.data as PaginationInterface<T>;
+        this.store.changeListState(new RequestState(false, resultData).end());
+        return resultData;
+      }
+
+      this.store.changeListState(
+        new RequestState(false, null, response.data.message).end()
+      );
+    } catch (error) {
+      this.store.changeListState(new RequestState(false, null, error).end());
+    }
+
+    return this.store.state.listState.result! as PaginationInterface<T>;
+  }
+
+  refresh(): Promise<unknown> {
+    return this.search(this.store.state.searchParams);
+  }
+
+  async update(data: Partial<T>): Promise<unknown> {
+    const result = await this.resourceApi.update(data);
+
+    // 更新本地列表数据
+    const listResult = this.store.state.listState
+      .result as PaginationInterface<T>;
+    if (listResult && listResult.list) {
+      const updatedData = listResult.list.map((item) =>
+        (item as Record<string, unknown>)[this.unionKey] ===
+        (data as Record<string, unknown>)[this.unionKey]
+          ? { ...item, ...data }
+          : item
+      );
+      this.store.changeListState(
+        new RequestState(false, { ...listResult, list: updatedData })
+      );
+    }
+
+    return result;
+  }
+
+  create(data: T): Promise<unknown> {
+    return this.resourceApi.create(data);
+  }
+  remove(data: T): Promise<unknown> {
+    return this.resourceApi.remove(data);
+  }
+  export(data: T): Promise<unknown> {
+    return this.resourceApi.export(data);
+  }
+}

package/dist/templates/next-app/src/base/services/adminApi/AdminLocalesApi.ts

@@ -0,0 +1,104 @@
+import { inject, injectable } from 'inversify';
+import type { PaginationInterface } from '@/server/port/PaginationInterface';
+import type { LocalesSchema } from '@migrations/schema/LocalesSchema';
+import type { LocaleType } from '@config/i18n';
+import {
+  AppApiRequester,
+  type AppApiConfig,
+  type AppApiTransaction
+} from '../appApi/AppApiRequester';
+import type { ResourceInterface, ResourceQuery } from '@qlover/corekit-bridge';
+import type { RequestTransaction } from '@qlover/fe-corekit';
+
+export type AdminLocalesListTransaction = AppApiTransaction<
+  ResourceQuery,
+  PaginationInterface<unknown>
+>;
+
+export type AdminLocalesUpdateTransaction = AppApiTransaction<
+  Partial<LocalesSchema>,
+  LocalesSchema
+>;
+
+@injectable()
+export class AdminLocalesApi implements ResourceInterface<LocalesSchema> {
+  constructor(
+    @inject(AppApiRequester)
+    protected client: RequestTransaction<AppApiConfig>
+  ) {}
+
+  /**
+   * @override
+   */
+  create(data: LocalesSchema): Promise<unknown> {
+    return this.client.request<AdminLocalesListTransaction>({
+      url: '/admin/locales/create',
+      method: 'POST',
+      data: data as unknown as Record<string, unknown>
+    });
+  }
+
+  /**
+   * @override
+   */
+  remove(data: Partial<LocalesSchema>): Promise<unknown> {
+    return this.client.request<AdminLocalesListTransaction>({
+      url: '/admin/locales',
+      method: 'DELETE',
+      data: data as unknown as Record<string, unknown>
+    });
+  }
+
+  /**
+   * @override
+   */
+  search(
+    params: ResourceQuery
+  ): Promise<AdminLocalesListTransaction['response']> {
+    return this.client.request<AdminLocalesListTransaction>({
+      url: '/admin/locales',
+      method: 'GET',
+      params: params as unknown as Record<string, unknown>
+    });
+  }
+
+  /**
+   * @override
+   */
+  export(data: LocalesSchema): Promise<unknown> {
+    return this.client.request<AdminLocalesListTransaction>({
+      url: '/admin/locales',
+      method: 'GET',
+      data: data as unknown as Record<string, unknown>
+    });
+  }
+
+  /**
+   * @override
+   */
+  update(
+    data: Partial<LocalesSchema>
+  ): Promise<AdminLocalesUpdateTransaction['response']> {
+    return this.client.request<AdminLocalesUpdateTransaction>({
+      url: `/admin/locales/update`,
+      method: 'POST',
+      data
+    });
+  }
+
+  import(data: {
+    [key in LocaleType]?: File;
+  }): Promise<unknown> {
+    const formdata = new FormData();
+    for (const [key, value] of Object.entries(data)) {
+      formdata.append(key, value);
+    }
+
+    return this.client.request({
+      url: '/admin/locales/import',
+      method: 'POST',
+      data: formdata,
+      responseType: 'formdata'
+    });
+  }
+}

package/dist/templates/next-app/src/base/services/adminApi/AdminUserApi.ts

@@ -1,27 +1,28 @@
 import { inject, injectable } from 'inversify';
-import type { AdminPageListParams } from '@/base/port/AdminPageInterface';
 import type { PaginationInterface } from '@/server/port/PaginationInterface';
+import type { UserSchema } from '@migrations/schema/UserSchema';
 import {
   AppApiRequester,
   type AppApiConfig,
   type AppApiTransaction
 } from '../appApi/AppApiRequester';
+import type { ResourceInterface, ResourceQuery } from '@qlover/corekit-bridge';
 import type { RequestTransaction } from '@qlover/fe-corekit';
 
 export type AdminUserListTransaction = AppApiTransaction<
-  AdminPageListParams,
+  ResourceQuery,
   PaginationInterface<unknown>
 >;
 
 @injectable()
-export class AdminUserApi {
+export class AdminUserApi implements ResourceInterface<UserSchema> {
   constructor(
     @inject(AppApiRequester)
     protected client: RequestTransaction<AppApiConfig>
   ) {}
 
-  async getUserList(
-    params: AdminPageListParams
+  async search(
+    params: AdminUserListTransaction['request']
   ): Promise<AdminUserListTransaction['response']> {
     const response = await this.client.request<AdminUserListTransaction>({
       url: '/admin/users',
@@ -31,4 +32,36 @@ export class AdminUserApi {
 
     return response;
   }
+
+  create(data: UserSchema): Promise<unknown> {
+    return this.client.request<AdminUserListTransaction>({
+      url: '/admin/users',
+      method: 'POST',
+      data: data as unknown as Record<string, unknown>
+    });
+  }
+
+  remove(data: UserSchema): Promise<unknown> {
+    return this.client.request<AdminUserListTransaction>({
+      url: '/admin/users',
+      method: 'DELETE',
+      data: data as unknown as Record<string, unknown>
+    });
+  }
+
+  update(data: UserSchema): Promise<unknown> {
+    return this.client.request<AdminUserListTransaction>({
+      url: '/admin/users',
+      method: 'PUT',
+      data: data as unknown as Record<string, unknown>
+    });
+  }
+
+  export(data: UserSchema): Promise<unknown> {
+    return this.client.request<AdminUserListTransaction>({
+      url: '/admin/users',
+      method: 'GET',
+      data: data as unknown as Record<string, unknown>
+    });
+  }
 }

package/dist/templates/next-app/src/base/services/appApi/AppApiPlugin.ts

@@ -58,7 +58,7 @@ export class AppApiPlugin implements ExecutorPlugin {
         const json = await this.getResponseJson(response);
 
         if (this.isAppApiErrorInterface(json)) {
-          const newError = new ExecutorError(json.message || json.id);
+          const newError = new ExecutorError(json.id, json.message);
           // context.error = newError;
           return newError;
         }

package/dist/templates/next-app/src/i18n/request.ts

@@ -1,6 +1,7 @@
 // src/i18n/request.ts
 
 import { getRequestConfig } from 'next-intl/server';
+import { useApiLocales } from '@config/common';
 import { routing, type Locale } from './routing';
 
 // Export a function to configure next-intl on each request (server-side)
@@ -13,9 +14,37 @@ export default getRequestConfig(async ({ requestLocale }) => {
     locale = routing.defaultLocale;
   }
 
+  // use api locales
+  if (useApiLocales) {
+    const app_host = process.env.APP_HOST;
+    const localeUrl = `${app_host}/api/locales/json?locale=${locale}`;
+    const response = await fetch(localeUrl);
+    const data = await response.json();
+    return {
+      locale,
+      messages: data,
+      // 将 MISSING_MESSAGE 错误转换为警告
+      onError: (error) => {
+        if (error.message.includes('MISSING_MESSAGE')) {
+          console.warn(`[i18n] Missing translation: ${error.message}`);
+          return error.key; // 返回 key 作为 fallback 文本
+        }
+        throw error; // 其他错误仍然抛出
+      }
+    };
+  }
+
   // Dynamically import the translation messages for the selected locale
   return {
     locale,
-    messages: (await import(`../../public/locales/${locale}.json`)).default
+    messages: (await import(`../../public/locales/${locale}.json`)).default,
+    // 将 MISSING_MESSAGE 错误转换为警告
+    onError: (error) => {
+      if (error.message.includes('MISSING_MESSAGE')) {
+        console.warn(`[i18n] Missing translation: ${error.message}`);
+        return error.key; // 返回 key 作为 fallback 文本
+      }
+      throw error; // 其他错误仍然抛出
+    }
   };
 });

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

@@ -1,5 +1,6 @@
 import { notFound } from 'next/navigation';
 import { getMessages, getTranslations } from 'next-intl/server';
+import { TranslateI18nInterface } from '@/base/cases/TranslateI18nInterface';
 import { i18nConfig } from '@config/i18n';
 import type { LocaleType, PageI18nInterface } from '@config/i18n';
 import type { ParamsHandlerInterface as ParamsHandlerInterface } from './port/ParamsHandlerInterface';
@@ -60,15 +61,6 @@ export class PageParams implements ParamsHandlerInterface {
       namespace: namespace
     });
 
-    const result = Object.fromEntries(
-      Object.entries(i18nInterface).map(([key, value]) => {
-        if (typeof value === 'string') {
-          return [key, t(value)];
-        }
-        return [key, value];
-      })
-    ) as T;
-
-    return result;
+    return TranslateI18nInterface.translate<T>(i18nInterface, t);
   }
 }

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

@@ -4,12 +4,15 @@ 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;
@@ -19,12 +22,14 @@ export interface PaginationInfo {
 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,4 +1,5 @@
 import type { PaginationInterface } from '@/server/port/PaginationInterface';
+import type { BridgeOrderBy } from './DBBridgeInterface';
 
 export interface DBTableInterface {
   readonly name: string;
@@ -6,5 +7,6 @@ export interface DBTableInterface {
   pagination<T = unknown>(params: {
     page: number;
     pageSize: number;
+    orderBy?: BridgeOrderBy;
   }): Promise<PaginationInterface<T>>;
 }

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

@@ -0,0 +1,43 @@
+import type { DBTableInterface } from '@/server/port/DBTableInterface';
+import type { LocalesSchema } from '@migrations/schema/LocalesSchema';
+import type { BridgeOrderBy } from './DBBridgeInterface';
+
+export interface UpsertChunkResult {
+  success: boolean;
+  chunkIndex: number;
+  inputData: Partial<LocalesSchema>[]; // Original data sent to upsert
+  returnedData?: LocalesSchema[]; // Actual data returned from database
+  affectedCount?: number; // Number of rows affected
+  error?: string;
+}
+
+export interface UpsertResult {
+  totalCount: number; // Total items attempted
+  successCount: number; // Successfully upserted items
+  failureCount: number; // Failed items
+  successChunks: UpsertChunkResult[];
+  failureChunks: UpsertChunkResult[];
+  allReturnedData: LocalesSchema[]; // All successfully upserted data combined
+}
+
+export interface LocalesRepositoryInterface extends DBTableInterface {
+  getLocales(
+    localeName: string,
+    orderBy?: BridgeOrderBy
+  ): Promise<LocalesSchema[]>;
+
+  add(params: LocalesSchema): Promise<LocalesSchema[] | null>;
+
+  updateById(
+    id: number,
+    params: Partial<Omit<LocalesSchema, 'id' | 'created_at'>>
+  ): Promise<void>;
+
+  upsert(
+    params: Partial<LocalesSchema>[],
+    options?: {
+      chunkSize?: number;
+      concurrency?: number;
+    }
+  ): Promise<UpsertResult>;
+}