@qlover/create-app 0.10.0 → 0.10.2

package/dist/templates/next-app/src/app/api/user/login/route.ts

@@ -1,50 +1,10 @@
-import { ExecutorError } from '@qlover/fe-corekit';
-import { NextResponse } from 'next/server';
-import { StringEncryptor } from '@/base/cases/StringEncryptor';
-import { BootstrapServer } from '@/core/bootstraps/BootstrapServer';
-import { AppErrorApi } from '@/server/AppErrorApi';
-import { AppSuccessApi } from '@/server/AppSuccessApi';
-import type { UserServiceInterface } from '@/server/port/UserServiceInterface';
-import { ServerAuth } from '@/server/ServerAuth';
-import { UserService } from '@/server/services/UserService';
-import { LoginValidator } from '@/server/validators/LoginValidator';
-import type { UserSchema } from '@migrations/schema/UserSchema';
+import { UserController } from '@/server/controllers/UserController';
+import { NextApiServer } from '@/server/NextApiServer';
 import type { NextRequest } from 'next/server';
 
 export async function POST(req: NextRequest) {
-  const server = new BootstrapServer();
-
-  const result = await server.execNoError(async ({ parameters: { IOC } }) => {
-    const requestBody = await req.json();
-
-    try {
-      if (requestBody.password) {
-        requestBody.password = IOC(StringEncryptor).decrypt(
-          requestBody.password
-        );
-      }
-    } catch {
-      throw new ExecutorError(
-        'encrypt_password_failed',
-        'Encrypt password failed'
-      );
-    }
-    const body = IOC(LoginValidator).getThrow(requestBody);
-
-    const userService: UserServiceInterface = IOC(UserService);
-
-    const user = (await userService.login(body)) as UserSchema;
-
-    await IOC(ServerAuth).setAuth(user.credential_token);
-
-    return user;
-  });
-
-  if (result instanceof ExecutorError) {
-    return NextResponse.json(new AppErrorApi(result.id, result.message), {
-      status: 400
-    });
-  }
-
-  return NextResponse.json(new AppSuccessApi(result));
+  const requestBody = await req.json();
+  return await new NextApiServer().runWithJson(
+    async ({ parameters: { IOC } }) => IOC(UserController).login(requestBody)
+  );
 }

package/dist/templates/next-app/src/app/api/user/logout/route.ts

@@ -1,27 +1,8 @@
-import { ExecutorError } from '@qlover/fe-corekit';
-import { NextResponse } from 'next/server';
-import { BootstrapServer } from '@/core/bootstraps/BootstrapServer';
-import { AppErrorApi } from '@/server/AppErrorApi';
-import { AppSuccessApi } from '@/server/AppSuccessApi';
-import type { UserServiceInterface } from '@/server/port/UserServiceInterface';
-import { UserService } from '@/server/services/UserService';
+import { UserController } from '@/server/controllers/UserController';
+import { NextApiServer } from '@/server/NextApiServer';
 
 export async function POST() {
-  const server = new BootstrapServer();
-
-  const result = await server.execNoError(async ({ parameters: { IOC } }) => {
-    const userService: UserServiceInterface = IOC(UserService);
-
-    await userService.logout();
-
-    return true;
-  });
-
-  if (result instanceof ExecutorError) {
-    return NextResponse.json(new AppErrorApi(result.id, result.message), {
-      status: 400
-    });
-  }
-
-  return NextResponse.json(new AppSuccessApi(result));
+  return await new NextApiServer().runWithJson(
+    async ({ parameters: { IOC } }) => IOC(UserController).logout()
+  );
 }

package/dist/templates/next-app/src/app/api/user/register/route.ts

@@ -1,50 +1,11 @@
-import { ExecutorError } from '@qlover/fe-corekit';
-import { NextResponse } from 'next/server';
-import { StringEncryptor } from '@/base/cases/StringEncryptor';
-import { BootstrapServer } from '@/core/bootstraps/BootstrapServer';
-import { AppErrorApi } from '@/server/AppErrorApi';
-import { AppSuccessApi } from '@/server/AppSuccessApi';
-import type { UserServiceInterface } from '@/server/port/UserServiceInterface';
-import { UserService } from '@/server/services/UserService';
-import { LoginValidator } from '@/server/validators/LoginValidator';
+import { UserController } from '@/server/controllers/UserController';
+import { NextApiServer } from '@/server/NextApiServer';
 import type { NextRequest } from 'next/server';
 
 export async function POST(req: NextRequest) {
-  const server = new BootstrapServer();
+  const requestBody = await req.json();
 
-  const result = await server.execNoError(async ({ parameters: { IOC } }) => {
-    const requestBody = await req.json();
-
-    try {
-      if (requestBody.password) {
-        requestBody.password = IOC(StringEncryptor).decrypt(
-          requestBody.password
-        );
-      }
-    } catch {
-      throw new ExecutorError(
-        'encrypt_password_failed',
-        'Encrypt password failed'
-      );
-    }
-
-    const body = IOC(LoginValidator).getThrow(requestBody);
-
-    const userService: UserServiceInterface = IOC(UserService);
-
-    const user = await userService.register({
-      email: body.email,
-      password: body.password
-    });
-
-    return user;
-  });
-
-  if (result instanceof ExecutorError) {
-    return NextResponse.json(new AppErrorApi(result.id, result.message), {
-      status: 400
-    });
-  }
-
-  return NextResponse.json(new AppSuccessApi(result));
+  return await new NextApiServer().runWithJson(
+    async ({ parameters: { IOC } }) => IOC(UserController).register(requestBody)
+  );
 }

package/dist/templates/next-app/src/app/manifest.ts

@@ -0,0 +1,16 @@
+import { getTranslations } from 'next-intl/server';
+import { routing } from '@/i18n/routing';
+import { COMMON_MANIFEST_NAME } from '@config/Identifier';
+import type { MetadataRoute } from 'next';
+
+export default async function manifest(): Promise<MetadataRoute.Manifest> {
+  const t = await getTranslations({
+    locale: routing.defaultLocale
+  });
+
+  return {
+    name: t(COMMON_MANIFEST_NAME),
+    start_url: '/',
+    theme_color: '#101E33'
+  };
+}

package/dist/templates/next-app/src/app/robots.txt

@@ -0,0 +1,2 @@
+User-Agent: *
+Allow: *

package/dist/templates/next-app/src/base/cases/DialogHandler.ts

@@ -11,8 +11,7 @@ import type {
 import type { ModalFuncProps } from 'antd';
 
 export interface DialogHandlerOptions
-  extends NotificationOptions,
-    ModalFuncProps {
+  extends NotificationOptions, ModalFuncProps {
   content: string;
 }
 

package/dist/templates/next-app/src/base/cases/NavigateBridge.ts

@@ -1,16 +1,26 @@
-import { injectable } from 'inversify';
+import { inject, injectable } from 'inversify';
+import type { useRouter } from '@/i18n/routing';
+import { I } from '@config/IOCIdentifier';
 import type { UIBridgeInterface } from '@qlover/corekit-bridge';
-import type { AppRouterInstance } from 'next/dist/shared/lib/app-router-context.shared-runtime';
+import type { LoggerInterface } from '@qlover/logger';
+
+type AppRouterInstance = ReturnType<typeof useRouter>;
 
 @injectable()
 export class NavigateBridge implements UIBridgeInterface<AppRouterInstance> {
   protected navigate: AppRouterInstance | null = null;
 
+  constructor(@inject(I.Logger) protected logger: LoggerInterface) {}
+
   setUIBridge(ui: AppRouterInstance): void {
     this.navigate = ui;
   }
 
   getUIBridge(): AppRouterInstance | null {
+    if (!this.navigate) {
+      this.logger.debug('NavigateBridge this.navigate is not set');
+    }
+
     return this.navigate;
   }
 }

package/dist/templates/next-app/src/base/cases/RequestEncryptPlugin.ts

@@ -6,8 +6,9 @@ import type {
   RequestAdapterConfig
 } from '@qlover/fe-corekit';
 
-export interface RequestEncryptPluginProps<Request = unknown>
-  extends RequestAdapterConfig<Request> {
+export interface RequestEncryptPluginProps<
+  Request = unknown
+> extends RequestAdapterConfig<Request> {
   /**
    * 加密密码在 HTTP 请求中
    *
@@ -18,9 +19,7 @@ export interface RequestEncryptPluginProps<Request = unknown>
   encryptProps?: string[] | string;
 }
 
-export class RequestEncryptPlugin
-  implements ExecutorPlugin<RequestEncryptPluginProps>
-{
+export class RequestEncryptPlugin implements ExecutorPlugin<RequestEncryptPluginProps> {
   readonly pluginName = 'RequestEncryptPlugin';
 
   constructor(protected encryptor: Encryptor<string, string>) {}

package/dist/templates/next-app/src/base/cases/RouterService.ts

@@ -13,12 +13,8 @@ export class RouterService implements RouterInterface {
     protected uiBridge: UIBridgeInterface<AppRouterInstance>
   ) {}
 
-  protected padLocaleHref(href: RouterPathname): string {
-    return `/${this.locale}${href === '/' ? '' : href}`;
-  }
-
   goto(href: RouterPathname): void {
-    this.uiBridge.getUIBridge()?.push(this.padLocaleHref(href));
+    this.uiBridge.getUIBridge()?.push(href as string);
   }
 
   gotoHome(): void {
@@ -29,6 +25,10 @@ export class RouterService implements RouterInterface {
     this.goto('/login');
   }
 
+  replaceHome(): void {
+    this.uiBridge.getUIBridge()?.replace('/');
+  }
+
   setLocale(locale: string): void {
     this.locale = locale;
   }

package/dist/templates/next-app/src/base/cases/UserServiceApi.ts

@@ -1,48 +1,63 @@
 import { inject, injectable } from 'inversify';
-import type { UserSchema } from '@migrations/schema/UserSchema';
+import { omit } from 'lodash';
+import type { LoginValidatorData } from '@/server/validators/LoginValidator';
+import {
+  isWebUserSchema,
+  type UserCredential,
+  type UserSchema
+} from '@migrations/schema/UserSchema';
 import { AppUserApi } from '../services/appApi/AppUserApi';
-import type { AppApiSuccessInterface } from '../port/AppApiInterface';
 import type { AppUserApiInterface } from '../port/AppUserApiInterface';
-import type {
-  LoginResponseData,
-  UserAuthApiInterface,
-  UserAuthStoreInterface
-} from '@qlover/corekit-bridge';
+import type { UserServiceGateway } from '@qlover/corekit-bridge';
 
 @injectable()
-export class UserServiceApi implements UserAuthApiInterface<UserSchema> {
-  protected store: UserAuthStoreInterface<UserSchema> | null = null;
-
+export class UserServiceApi implements UserServiceGateway<
+  UserSchema,
+  UserCredential
+> {
   constructor(@inject(AppUserApi) protected appUserApi: AppUserApiInterface) {}
 
-  getStore(): UserAuthStoreInterface<UserSchema> | null {
-    return this.store;
+  getUserInfo(_params?: unknown): Promise<UserSchema | null> {
+    if (_params && isWebUserSchema(_params).success) {
+      return Promise.resolve(omit(_params, 'credential_token') as UserSchema);
+    }
+
+    return Promise.resolve(null);
   }
-  setStore(store: UserAuthStoreInterface<UserSchema>): void {
-    this.store = store;
+
+  refreshUserInfo<Params>(
+    _params?: Params | undefined
+  ): Promise<UserSchema | null> {
+    return this.getUserInfo(_params);
   }
 
-  async login(params: {
-    email: string;
-    password: string;
-  }): Promise<LoginResponseData> {
+  async login(params: LoginValidatorData): Promise<UserCredential> {
     const response = await this.appUserApi.login(params);
-    return (response as AppApiSuccessInterface).data as LoginResponseData;
+
+    if (!response.data.success) {
+      throw response;
+    }
+
+    return response.data.data as UserCredential;
   }
 
-  async register(params: {
-    email: string;
-    password: string;
-  }): Promise<LoginResponseData> {
+  async register(params: LoginValidatorData): Promise<UserSchema> {
     const response = await this.appUserApi.register(params);
-    return (response as AppApiSuccessInterface).data as LoginResponseData;
-  }
 
-  async logout(): Promise<void> {
-    await this.appUserApi.logout();
+    if (!response.data.success) {
+      throw response;
+    }
+
+    return response.data.data as UserSchema;
   }
 
-  getUserInfo(loginData: LoginResponseData): Promise<UserSchema> {
-    return Promise.resolve(loginData as unknown as UserSchema);
+  async logout<P = unknown, Result = void>(params?: P): Promise<Result> {
+    const response = await this.appUserApi.logout(params);
+
+    if (!response.data.success) {
+      throw response;
+    }
+
+    return response.data.data as Result;
   }
 }

package/dist/templates/next-app/src/base/cases/ZodColumnBuilder.ts

@@ -33,8 +33,7 @@ export const ZodType2RenderFormMap = {
 export class ZodColumnBuilder<
   Value extends ZodRawShape,
   Input extends ZodObject<Value>
-> implements ZodBuilderInterface<Input, ResourceTableOption<z.infer<Input>>>
-{
+> implements ZodBuilderInterface<Input, ResourceTableOption<z.infer<Input>>> {
   protected optionMap: OptionMap<Value, Input>;
 
   constructor(

package/dist/templates/next-app/src/base/port/AppApiInterface.ts

@@ -12,3 +12,25 @@ export interface AppApiSuccessInterface<T = unknown> {
 export type AppApiResult<T = unknown> =
   | AppApiErrorInterface
   | AppApiSuccessInterface<T>;
+
+export function isAppApiSuccessInterface(
+  result: unknown
+): result is AppApiSuccessInterface {
+  return (
+    typeof result === 'object' &&
+    result !== null &&
+    'success' in result &&
+    result.success === true
+  );
+}
+
+export function isAppApiErrorInterface(
+  result: unknown
+): result is AppApiErrorInterface {
+  return (
+    typeof result === 'object' &&
+    result !== null &&
+    'success' in result &&
+    result.success === false
+  );
+}

package/dist/templates/next-app/src/base/port/AppUserApiInterface.ts

@@ -1,15 +1,27 @@
-import type { AppApiResult } from './AppApiInterface';
+import type { LoginValidatorData } from '@/server/validators/LoginValidator';
+import type { UserSchema } from '@migrations/schema/UserSchema';
+import type { AppApiTransaction } from '../services/appApi/AppApiRequester';
+
+export type UserApiLoginTransaction = AppApiTransaction<
+  LoginValidatorData,
+  UserSchema
+>;
+
+export type UserApiRegisterTransaction = AppApiTransaction<
+  LoginValidatorData,
+  UserSchema
+>;
+
+export type UserApiLogoutTransaction = AppApiTransaction<unknown, void>;
 
 export interface AppUserApiInterface {
-  login(params: {
-    email: string;
-    password: string;
-  }): Promise<AppApiResult<unknown>>;
+  login(
+    params: UserApiLoginTransaction['data']
+  ): Promise<UserApiLoginTransaction['response']>;
 
-  register(params: {
-    email: string;
-    password: string;
-  }): Promise<AppApiResult<unknown>>;
+  register(
+    params: UserApiRegisterTransaction['data']
+  ): Promise<UserApiRegisterTransaction['response']>;
 
-  logout(): Promise<AppApiResult<unknown>>;
+  logout(params?: unknown): Promise<UserApiLogoutTransaction['response']>;
 }

package/dist/templates/next-app/src/base/port/IOCInterface.ts

@@ -21,4 +21,13 @@ export interface IOCInterface<
   create(
     options: IocRegisterOptions
   ): IOCFunctionInterface<IdentifierMap, IOCContainer>;
+
+  /**
+   * 该方法主要用于在应用启动前注册所有依赖
+   *
+   * 因为ssr渲染的原因可能需要在一些特定的环境下注册一些依赖
+   *
+   * @param options - 注册选项
+   */
+  register(options?: IocRegisterOptions): void;
 }

package/dist/templates/next-app/src/base/port/UserServiceInterface.ts

@@ -1,12 +1,20 @@
-import { UserAuthService } from '@qlover/corekit-bridge';
-import type { UserSchema } from '@migrations/schema/UserSchema';
-import type { ExecutorPlugin } from '@qlover/fe-corekit';
+import type { UserCredential, UserSchema } from '@migrations/schema/UserSchema';
+import type { UserService as CorekitBridgeUserServiceInterface } from '@qlover/corekit-bridge';
 
-export abstract class UserServiceInterface
-  extends UserAuthService<UserSchema>
-  implements ExecutorPlugin
-{
-  readonly pluginName = 'UserService';
+export interface UserServiceInterface extends CorekitBridgeUserServiceInterface<
+  UserSchema,
+  UserCredential
+> {
+  // You can add your own methods here
 
-  abstract getToken(): string | null;
+  /**
+   * Get the user token
+   *
+   * This is a extends method from the corekit-bridge UserServiceInterface.
+   */
+  getToken(): string;
+
+  isUserInfo(value: unknown): value is UserSchema;
+
+  isUserCredential(value: unknown): value is UserCredential;
 }

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

@@ -11,10 +11,9 @@ import type { PaginationInterface } from '@/server/port/PaginationInterface';
 
 export class ResourceService<
   T,
-  Store extends
-    ResourceStore<ResourceStateInterface> = ResourceStore<ResourceStateInterface>
-> implements ResourceServiceInterface<T>
-{
+  Store extends ResourceStore<ResourceStateInterface> =
+    ResourceStore<ResourceStateInterface>
+> implements ResourceServiceInterface<T> {
   readonly unionKey: string = 'id';
 
   constructor(

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

@@ -1,24 +1,48 @@
+import { UserService as CorekitBridgeUserService } from '@qlover/corekit-bridge';
 import { injectable, inject } from 'inversify';
-import type { UserSchema } from '@migrations/schema/UserSchema';
-import { AppConfig } from '../cases/AppConfig';
+import { isObject, isString } from 'lodash';
+import {
+  userSchema,
+  type UserCredential,
+  type UserSchema
+} from '@migrations/schema/UserSchema';
 import { UserServiceApi } from '../cases/UserServiceApi';
-import { UserServiceInterface } from '../port/UserServiceInterface';
-import type { UserAuthApiInterface } from '@qlover/corekit-bridge';
+import type { UserServiceInterface } from '../port/UserServiceInterface';
+import type { UserServiceGateway } from '@qlover/corekit-bridge';
 
 @injectable()
-export class UserService extends UserServiceInterface {
+export class UserService
+  extends CorekitBridgeUserService<UserSchema, UserCredential>
+  implements UserServiceInterface
+{
   constructor(
-    @inject(AppConfig) protected appConfig: AppConfig,
-    @inject(UserServiceApi) protected userApi: UserAuthApiInterface<UserSchema>
+    @inject(UserServiceApi)
+    userApi: UserServiceGateway<UserSchema, UserCredential>
   ) {
-    super(userApi, {
-      credentialStorage: {
-        key: appConfig.userTokenKey
-      }
+    super({
+      gateway: userApi
+      // next-js ssr 将 credential 存储在 cookie 中无需存储用户信息到本地
+      // store: {
+      //   storageKey: appConfig.userInfoKey,
+      //   credentialStorageKey: appConfig.userTokenKey,
+      //   persistUserInfo: true,
+      // }
     });
   }
 
-  getToken(): string | null {
-    return this.store.getCredential();
+  getToken(): string {
+    return this.store.getCredential()?.credential_token ?? '';
+  }
+
+  isUserInfo(value: unknown): value is UserSchema {
+    return userSchema.safeParse(value).success;
+  }
+
+  isUserCredential(value: unknown): value is UserCredential {
+    return (
+      isObject(value) &&
+      'credential_token' in value &&
+      isString(value.credential_token)
+    );
   }
 }

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

@@ -13,8 +13,7 @@ import type {
 } from '@qlover/fe-corekit';
 
 export interface AppApiConfig<Request = unknown>
-  extends RequestAdapterConfig<Request>,
-    RequestEncryptPluginProps<Request> {}
+  extends RequestAdapterConfig<Request>, RequestEncryptPluginProps<Request> {}
 
 /**
  * UserApiResponse
@@ -33,11 +32,13 @@ export type AppApiResponse<
 /**
  * UserApi common transaction
  */
-export interface AppApiTransaction<Request = unknown, Response = unknown>
-  extends RequestTransactionInterface<
-    AppApiConfig<Request>,
-    AppApiResponse<Request, Response>
-  > {
+export interface AppApiTransaction<
+  Request = unknown,
+  Response = unknown
+> extends RequestTransactionInterface<
+  AppApiConfig<Request>,
+  AppApiResponse<Request, Response>
+> {
   data: AppApiConfig<Request>['data'];
 }
 

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

@@ -1,25 +1,14 @@
 import { inject, injectable } from 'inversify';
-import type { AppApiResult } from '@/base/port/AppApiInterface';
-import type { AppUserApiInterface } from '@/base/port/AppUserApiInterface';
+import type {
+  AppUserApiInterface,
+  UserApiLoginTransaction,
+  UserApiLogoutTransaction,
+  UserApiRegisterTransaction
+} from '@/base/port/AppUserApiInterface';
 import { AppApiRequester } from './AppApiRequester';
-import type { AppApiConfig, AppApiTransaction } from './AppApiRequester';
+import type { AppApiConfig } from './AppApiRequester';
 import type { RequestTransaction } from '@qlover/fe-corekit';
 
-export type UserApiLoginTransaction = AppApiTransaction<
-  { email: string; password: string },
-  {
-    token: string;
-  }
->;
-
-export type UserApiRegisterTransaction = AppApiTransaction<
-  {
-    email: string;
-    password: string;
-  },
-  AppApiTransaction['response']['data']
->;
-
 /**
  * UserApi
  *
@@ -36,7 +25,7 @@ export class AppUserApi implements AppUserApiInterface {
 
   async login(
     params: UserApiLoginTransaction['data']
-  ): Promise<AppApiResult<unknown>> {
+  ): Promise<UserApiLoginTransaction['response']> {
     const response = await this.client.request<UserApiLoginTransaction>({
       url: '/user/login',
       method: 'POST',
@@ -44,12 +33,12 @@ export class AppUserApi implements AppUserApiInterface {
       encryptProps: 'password'
     });
 
-    return response.data;
+    return response;
   }
 
   async register(
     params: UserApiRegisterTransaction['data']
-  ): Promise<AppApiResult<unknown>> {
+  ): Promise<UserApiRegisterTransaction['response']> {
     const response = await this.client.request<UserApiRegisterTransaction>({
       url: '/user/register',
       method: 'POST',
@@ -57,15 +46,15 @@ export class AppUserApi implements AppUserApiInterface {
       encryptProps: 'password'
     });
 
-    return response.data;
+    return response;
   }
 
-  async logout(): Promise<AppApiResult<unknown>> {
-    const response = await this.client.request({
+  async logout(
+    _params?: unknown
+  ): Promise<UserApiLogoutTransaction['response']> {
+    return await this.client.request<UserApiLogoutTransaction>({
       url: '/user/logout',
       method: 'POST'
     });
-
-    return response.data as AppApiResult<unknown>;
   }
 }