@qlover/create-app 0.7.10 → 0.7.12

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

@@ -0,0 +1,45 @@
+import { inject, injectable } from 'inversify';
+import {
+  AdminPageInterface,
+  type AdminPageListParams,
+  AdminPageState
+} from '../port/AdminPageInterface';
+import { AdminUserApi } from './adminApi/AdminUserApi';
+import { RequestState } from '../cases/RequestState';
+import type { PaginationInterface } from '../port/PaginationInterface';
+
+@injectable()
+export class AdminUserService extends AdminPageInterface<AdminPageState> {
+  constructor(@inject(AdminUserApi) protected adminUserApi: AdminUserApi) {
+    super(() => new AdminPageState());
+  }
+
+  override async fetchList(
+    params: Partial<AdminPageListParams>
+  ): Promise<PaginationInterface<unknown>> {
+    this.changeListState(new RequestState(true));
+
+    try {
+      const response = await this.adminUserApi.getUserList(
+        Object.assign({}, this.state.listParams, params)
+      );
+
+      if (response.data.success) {
+        const paginationData = response.data
+          .data as PaginationInterface<unknown>;
+
+        this.changeListState(new RequestState(false, paginationData));
+
+        return paginationData;
+      }
+
+      this.changeListState(
+        new RequestState(false, null, response.data.message)
+      );
+    } catch (error) {
+      this.changeListState(new RequestState(false, null, error));
+    }
+
+    return this.state.listState.result!;
+  }
+}

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

@@ -1,8 +1,8 @@
 import { injectable, inject } from 'inversify';
+import type { UserSchema } from '@migrations/schema/UserSchema';
 import { AppConfig } from '../cases/AppConfig';
 import { UserServiceApi } from '../cases/UserServiceApi';
 import { UserServiceInterface } from '../port/UserServiceInterface';
-import type { UserSchema } from '@migrations/schema/UserSchema';
 import type { UserAuthApiInterface } from '@qlover/corekit-bridge';
 
 @injectable()

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

@@ -0,0 +1,21 @@
+import {
+  FetchAbortPlugin,
+  RequestAdapterFetch,
+  RequestTransaction
+} from '@qlover/fe-corekit';
+import { inject, injectable } from 'inversify';
+import type { AppApiConfig } from '../appApi/AppApiRequester';
+
+@injectable()
+export class AdminApiRequester extends RequestTransaction<AppApiConfig> {
+  constructor(
+    @inject(FetchAbortPlugin) protected abortPlugin: FetchAbortPlugin
+  ) {
+    super(
+      new RequestAdapterFetch({
+        baseURL: '/api/admin',
+        responseType: 'json'
+      })
+    );
+  }
+}

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

@@ -0,0 +1,34 @@
+import { inject, injectable } from 'inversify';
+import type { AdminPageListParams } from '@/base/port/AdminPageInterface';
+import type { PaginationInterface } from '@/base/port/PaginationInterface';
+import {
+  AppApiRequester,
+  type AppApiConfig,
+  type AppApiTransaction
+} from '../appApi/AppApiRequester';
+import type { RequestTransaction } from '@qlover/fe-corekit';
+
+export type AdminUserListTransaction = AppApiTransaction<
+  AdminPageListParams,
+  PaginationInterface<unknown>
+>;
+
+@injectable()
+export class AdminUserApi {
+  constructor(
+    @inject(AppApiRequester)
+    protected client: RequestTransaction<AppApiConfig>
+  ) {}
+
+  async getUserList(
+    params: AdminPageListParams
+  ): Promise<AdminUserListTransaction['response']> {
+    const response = await this.client.request<AdminUserListTransaction>({
+      url: '/admin/users',
+      method: 'GET',
+      params: params as unknown as Record<string, unknown>
+    });
+
+    return response;
+  }
+}

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

@@ -5,7 +5,7 @@ import {
   type ExecutorPlugin
 } from '@qlover/fe-corekit';
 import type { AppApiErrorInterface } from '@/base/port/AppApiInterface';
-import type { UserApiConfig } from './AppUserType';
+import type { AppApiConfig } from './AppApiRequester';
 
 export class AppApiPlugin implements ExecutorPlugin {
   readonly pluginName = 'AppApiPlugin';
@@ -30,7 +30,7 @@ export class AppApiPlugin implements ExecutorPlugin {
   }
 
   async onError(
-    context: ExecutorContext<UserApiConfig>
+    context: ExecutorContext<AppApiConfig>
   ): Promise<ExecutorError | void> {
     const { error, parameters } = context;
 

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

@@ -0,0 +1,56 @@
+import {
+  FetchAbortPlugin,
+  RequestAdapterFetch,
+  RequestTransaction
+} from '@qlover/fe-corekit';
+import { inject, injectable } from 'inversify';
+import type { RequestEncryptPluginProps } from '@/base/cases/RequestEncryptPlugin';
+import type { AppApiResult } from '@/base/port/AppApiInterface';
+import type {
+  RequestAdapterConfig,
+  RequestAdapterResponse,
+  RequestTransactionInterface
+} from '@qlover/fe-corekit';
+
+export interface AppApiConfig<Request = unknown>
+  extends RequestAdapterConfig<Request>,
+    RequestEncryptPluginProps<Request> {}
+
+/**
+ * UserApiResponse
+ *
+ * @description
+ * UserApiResponse is the response for the UserApi.
+ *
+ * extends:
+ * - RequestAdapterResponse<Request, Response>
+ */
+export type AppApiResponse<
+  Request = unknown,
+  Response = unknown
+> = RequestAdapterResponse<Request, AppApiResult<Response>>;
+
+/**
+ * UserApi common transaction
+ */
+export interface AppApiTransaction<Request = unknown, Response = unknown>
+  extends RequestTransactionInterface<
+    AppApiConfig<Request>,
+    AppApiResponse<Request, Response>
+  > {
+  data: AppApiConfig<Request>['data'];
+}
+
+@injectable()
+export class AppApiRequester extends RequestTransaction<AppApiConfig> {
+  constructor(
+    @inject(FetchAbortPlugin) protected abortPlugin: FetchAbortPlugin
+  ) {
+    super(
+      new RequestAdapterFetch({
+        baseURL: '/api',
+        responseType: 'json'
+      })
+    );
+  }
+}

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

@@ -1,16 +1,24 @@
-import {
-  FetchAbortPlugin,
-  RequestTransaction,
-  RequestAdapterFetch
-} from '@qlover/fe-corekit';
 import { inject, injectable } from 'inversify';
-import type { AppApiResponse } from '@/base/port/AppApiInterface';
+import type { AppApiResult } from '@/base/port/AppApiInterface';
 import type { AppUserApiInterface } from '@/base/port/AppUserApiInterface';
-import type {
-  UserApiConfig,
-  UserApiLoginTransaction,
-  UserApiRegisterTransaction
-} from './AppUserType';
+import { AppApiRequester } from './AppApiRequester';
+import type { AppApiConfig, AppApiTransaction } 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
@@ -20,25 +28,16 @@ import type {
  *
  */
 @injectable()
-export class AppUserApi
-  extends RequestTransaction<UserApiConfig>
-  implements AppUserApiInterface
-{
+export class AppUserApi implements AppUserApiInterface {
   constructor(
-    @inject(FetchAbortPlugin) protected abortPlugin: FetchAbortPlugin
-  ) {
-    super(
-      new RequestAdapterFetch({
-        baseURL: '/api',
-        responseType: 'json'
-      })
-    );
-  }
+    @inject(AppApiRequester)
+    protected client: RequestTransaction<AppApiConfig>
+  ) {}
 
   async login(
     params: UserApiLoginTransaction['data']
-  ): Promise<AppApiResponse<unknown>> {
-    const response = await this.request<UserApiLoginTransaction>({
+  ): Promise<AppApiResult<unknown>> {
+    const response = await this.client.request<UserApiLoginTransaction>({
       url: '/user/login',
       method: 'POST',
       data: params,
@@ -50,8 +49,8 @@ export class AppUserApi
 
   async register(
     params: UserApiRegisterTransaction['data']
-  ): Promise<AppApiResponse<unknown>> {
-    const response = await this.request<UserApiRegisterTransaction>({
+  ): Promise<AppApiResult<unknown>> {
+    const response = await this.client.request<UserApiRegisterTransaction>({
       url: '/user/register',
       method: 'POST',
       data: params,
@@ -61,12 +60,12 @@ export class AppUserApi
     return response.data;
   }
 
-  async logout(): Promise<AppApiResponse<unknown>> {
-    const response = await this.request({
+  async logout(): Promise<AppApiResult<unknown>> {
+    const response = await this.client.request({
       url: '/user/logout',
       method: 'POST'
     });
 
-    return response.data as AppApiResponse<unknown>;
+    return response.data as AppApiResult<unknown>;
   }
 }

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

@@ -4,8 +4,8 @@ import { DialogErrorPlugin } from '@/base/cases/DialogErrorPlugin';
 import { RequestEncryptPlugin } from '@/base/cases/RequestEncryptPlugin';
 import { StringEncryptor } from '@/base/cases/StringEncryptor';
 import { AppApiPlugin } from './AppApiPlugin';
-import { AppUserApi } from './AppUserApi';
-import type { UserApiConfig } from './AppUserType';
+import { AppApiRequester } from './AppApiRequester';
+import type { AppApiConfig } from './AppApiRequester';
 import type {
   BootstrapContext,
   BootstrapExecutorPlugin
@@ -18,7 +18,7 @@ export class AppUserApiBootstrap implements BootstrapExecutorPlugin {
   constructor(protected serializer: SerializerIneterface) {}
 
   onBefore({ parameters: { ioc } }: BootstrapContext): void | Promise<void> {
-    const appUserApi = ioc.get<AppUserApi>(AppUserApi);
+    const appUserApi = ioc.get<AppApiRequester>(AppApiRequester);
 
     appUserApi.usePlugin(new FetchURLPlugin());
     appUserApi.usePlugin(new RequestEncryptPlugin(ioc.get(StringEncryptor)));
@@ -29,11 +29,12 @@ export class AppUserApiBootstrap implements BootstrapExecutorPlugin {
     );
     appUserApi.usePlugin(new AppApiPlugin());
     appUserApi.usePlugin(ioc.get(DialogErrorPlugin));
+    console.log('jj AppUserApiBootstrap success');
   }
 
   protected requestDataSerializer(
     data: unknown,
-    context: ExecutorContext<UserApiConfig>
+    context: ExecutorContext<AppApiConfig>
   ): unknown {
     if (data instanceof FormData) {
       return data;

package/dist/templates/next-app/src/core/bootstraps/BootstrapClient.ts

@@ -1,9 +1,9 @@
 import { Bootstrap } from '@qlover/corekit-bridge';
 import { isObject } from 'lodash';
 import { browserGlobalsName } from '@config/common';
+import type { IOCIdentifierMap } from '@config/IOCIdentifier';
 import { BootstrapsRegistry } from './BootstrapsRegistry';
 import * as globals from '../globals';
-import type { IOCIdentifierMap } from '@config/IOCIdentifier';
 import type {
   IOCContainerInterface,
   IOCFunctionInterface

package/dist/templates/next-app/src/core/bootstraps/BootstrapServer.ts

@@ -12,23 +12,11 @@ import {
   type PromiseTask,
   type ExecutorPlugin
 } from '@qlover/fe-corekit';
-import { I, type IOCIdentifierMapServer } from '@config/IOCIdentifier';
 import type { ServerInterface } from '@/server/port/ServerInterface';
+import { I, type IOCIdentifierMapServer } from '@config/IOCIdentifier';
 import { ServerIOC } from '../serverIoc/ServerIOC';
 
-export interface BootstrapServerResult {
-  locale: string;
-  messages: Record<string, string>;
-}
-
 export interface BootstrapServerContextValue extends BootstrapContextValue {
-  locale: string;
-  messages: Record<string, string>;
-}
-
-interface BootstrapServerContext {
-  logger: LoggerInterface;
-  root: Record<string, unknown>;
   IOC: IOCFunctionInterface<IOCIdentifierMapServer, IOCContainerInterface>;
 }
 
@@ -90,11 +78,12 @@ export class BootstrapServer implements ServerInterface {
   }
 
   execNoError<Result>(
-    task?: PromiseTask<Result, BootstrapServerContext>
+    task?: PromiseTask<Result, BootstrapServerContextValue>
   ): Promise<Result | ExecutorError> {
     const context = {
       logger: this.logger,
       root: this.root,
+      ioc: this.IOC.implemention!,
       IOC: this.IOC
     };
 

package/dist/templates/next-app/src/core/bootstraps/BootstrapsRegistry.ts

@@ -1,9 +1,9 @@
-import { I, IOCIdentifier } from '@config/IOCIdentifier';
 import { AppUserApiBootstrap } from '@/base/services/appApi/AppUserApiBootstrap';
+import { I, IOCIdentifier } from '@config/IOCIdentifier';
+import type { IOCIdentifierMap } from '@config/IOCIdentifier';
 import { IocIdentifierTest } from './IocIdentifierTest';
 import { printBootstrap } from './PrintBootstrap';
 import type { BootstrapAppArgs } from './BootstrapClient';
-import type { IOCIdentifierMap } from '@config/IOCIdentifier';
 import type {
   BootstrapExecutorPlugin,
   EnvConfigInterface,

package/dist/templates/next-app/src/core/bootstraps/PrintBootstrap.ts

@@ -1,5 +1,5 @@
-import { browserGlobalsName } from '@config/common';
 import { AppConfig } from '@/base/cases/AppConfig';
+import { browserGlobalsName } from '@config/common';
 import type { BootstrapExecutorPlugin } from '@qlover/corekit-bridge';
 
 export const printBootstrap: BootstrapExecutorPlugin = {

package/dist/templates/next-app/src/core/clientIoc/ClientIOC.ts

@@ -5,9 +5,9 @@ import {
 } from '@qlover/corekit-bridge';
 import { InversifyContainer } from '@/base/cases/InversifyContainer';
 import type { IOCInterface } from '@/base/port/IOCInterface';
+import type { IOCIdentifierMap } from '@config/IOCIdentifier';
 import { ClientIOCRegister } from './ClientIOCRegister';
 import { appConfig } from '../globals';
-import type { IOCIdentifierMap } from '@config/IOCIdentifier';
 
 export class ClientIOC
   implements IOCInterface<IOCIdentifierMap, IOCContainerInterface>

package/dist/templates/next-app/src/core/clientIoc/ClientIOCRegister.ts

@@ -1,8 +1,8 @@
-import { IOCIdentifier as I } from '@config/IOCIdentifier';
 import { RouterService } from '@/base/cases/RouterService';
 import type { IocRegisterOptions } from '@/base/port/IOCInterface';
 import { I18nService } from '@/base/services/I18nService';
 import { UserService } from '@/base/services/UserService';
+import { IOCIdentifier as I } from '@config/IOCIdentifier';
 import { dialogHandler, logger, JSON } from '../globals';
 import type {
   IOCContainerInterface,

package/dist/templates/next-app/src/core/globals.ts

@@ -1,9 +1,9 @@
 // ! global variables, don't import any dependencies and don't have side effects
 import { ColorFormatter, ConsoleHandler, Logger } from '@qlover/corekit-bridge';
 import { JSONSerializer } from '@qlover/fe-corekit';
-import { loggerStyles } from '@config/common';
 import { AppConfig } from '@/base/cases/AppConfig';
 import { DialogHandler } from '@/base/cases/DialogHandler';
+import { loggerStyles } from '@config/common';
 
 export const appConfig = new AppConfig();
 

package/dist/templates/next-app/src/core/serverIoc/ServerIOC.ts

@@ -6,8 +6,8 @@ import {
 import { AppConfig } from '@/base/cases/AppConfig';
 import { InversifyContainer } from '@/base/cases/InversifyContainer';
 import type { IOCInterface } from '@/base/port/IOCInterface';
-import { ServerIOCRegister } from './ServerIOCRegister';
 import type { IOCIdentifierMapServer } from '@config/IOCIdentifier';
+import { ServerIOCRegister } from './ServerIOCRegister';
 
 export class ServerIOC
   implements IOCInterface<IOCIdentifierMapServer, IOCContainerInterface>

package/dist/templates/next-app/src/core/serverIoc/ServerIOCRegister.ts

@@ -6,8 +6,8 @@ import {
   type IOCManagerInterface,
   type IOCRegisterInterface
 } from '@qlover/corekit-bridge';
-import { IOCIdentifier as I } from '@config/IOCIdentifier';
 import type { IocRegisterOptions } from '@/base/port/IOCInterface';
+import { IOCIdentifier as I } from '@config/IOCIdentifier';
 
 export class ServerIOCRegister
   implements IOCRegisterInterface<IOCContainerInterface, IocRegisterOptions>

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

@@ -1,12 +1,14 @@
+import { ExecutorError } from '@qlover/fe-corekit';
 import { inject, injectable } from 'inversify';
 import { cookies } from 'next/headers';
-import { I } from '@config/IOCIdentifier';
 import type { AppConfig } from '@/base/cases/AppConfig';
+import { API_NOT_AUTHORIZED } from '@config/Identifier';
+import { I } from '@config/IOCIdentifier';
 import { UserCredentialToken } from './UserCredentialToken';
-import type { UserAuthInterface } from './port/UserAuthInterface';
+import type { ServerAuthInterface } from './port/ServerAuthInterface';
 
 @injectable()
-export class ServerAuth implements UserAuthInterface {
+export class ServerAuth implements ServerAuthInterface {
   protected userTokenKey: string;
   constructor(
     @inject(I.AppConfig) protected server: AppConfig,
@@ -47,4 +49,12 @@ export class ServerAuth implements UserAuthInterface {
     const cookieStore = await cookies();
     cookieStore.delete(this.userTokenKey);
   }
+
+  async throwIfNotAuth(): Promise<void> {
+    const hasAuth = await this.hasAuth();
+
+    if (!hasAuth) {
+      throw new ExecutorError(API_NOT_AUTHORIZED, 'Not authorized');
+    }
+  }
 }

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

@@ -1,16 +1,17 @@
 import {
   createClient,
   type PostgrestSingleResponse,
-  type SupabaseClient
+  type SupabaseClient,
+  type PostgrestResponse
 } from '@supabase/supabase-js';
 import { injectable, inject } from 'inversify';
-import { I } from '@config/IOCIdentifier';
 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';
 
@@ -121,4 +122,38 @@ export class SupabaseBridge implements DBBridgeInterface {
 
     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

@@ -1,8 +1,8 @@
 import { inject, injectable } from 'inversify';
 import jwt from 'jsonwebtoken';
 import { AppConfig } from '@/base/cases/AppConfig';
-import type { CrentialTokenInterface } from './port/CrentialTokenInterface';
 import type { UserSchema } from '@migrations/schema/UserSchema';
+import type { CrentialTokenInterface } from './port/CrentialTokenInterface';
 
 export type UserCredentialTokenValue = Pick<UserSchema, 'id' | 'email'>;
 

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/{UserAuthInterface.ts → ServerAuthInterface.ts}

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

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

@@ -1,4 +1,4 @@
-import type { DBTableInterface } from '@/base/port/DBTableInterface';
+import type { DBTableInterface } from '@/server/port/DBTableInterface';
 import type { UserSchema } from '@migrations/schema/UserSchema';
 
 export interface UserRepositoryInterface extends DBTableInterface {

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

@@ -1,14 +1,26 @@
 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';
-import type { UserSchema } from '@migrations/schema/UserSchema';
 
 @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> {
@@ -60,4 +72,23 @@ export class UserRepository implements UserRepositoryInterface {
       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();
+  }
+}