@qlover/create-app 0.7.9 → 0.7.11

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

@@ -0,0 +1,63 @@
+import {
+  ExecutorError,
+  RequestError,
+  type ExecutorContext,
+  type ExecutorPlugin
+} from '@qlover/fe-corekit';
+import type { AppApiErrorInterface } from '@/base/port/AppApiInterface';
+import type { AppApiConfig } from './AppApiRequester';
+
+export class AppApiPlugin implements ExecutorPlugin {
+  readonly pluginName = 'AppApiPlugin';
+
+  isAppApiErrorInterface(value: unknown): value is AppApiErrorInterface {
+    return (
+      typeof value === 'object' &&
+      value !== null &&
+      'success' in value &&
+      value.success === false &&
+      'id' in value &&
+      typeof value.id === 'string'
+    );
+  }
+
+  onSuccess(context: ExecutorContext<unknown>): void | Promise<void> {
+    const response = context.returnValue;
+
+    if (this.isAppApiErrorInterface(response)) {
+      throw new Error(response.message || response.id);
+    }
+  }
+
+  async onError(
+    context: ExecutorContext<AppApiConfig>
+  ): Promise<ExecutorError | void> {
+    const { error, parameters } = context;
+
+    if (error instanceof RequestError && parameters.responseType === 'json') {
+      // @ts-expect-error response is not defined in Error
+      let response = error?.response;
+
+      if (response instanceof Response) {
+        // clone the response to avoid mutating the original response
+        response = response.clone();
+
+        const json = await this.getResponseJson(response);
+
+        if (this.isAppApiErrorInterface(json)) {
+          const newError = new ExecutorError(json.message || json.id);
+          // context.error = newError;
+          return newError;
+        }
+      }
+    }
+  }
+
+  protected async getResponseJson(response: Response): Promise<unknown> {
+    try {
+      return await response.json();
+    } catch {
+      return {};
+    }
+  }
+}

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

@@ -0,0 +1,71 @@
+import { inject, injectable } from 'inversify';
+import type { AppApiResult } from '@/base/port/AppApiInterface';
+import type { AppUserApiInterface } from '@/base/port/AppUserApiInterface';
+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
+ *
+ * @description
+ * UserApi is a client for the user API.
+ *
+ */
+@injectable()
+export class AppUserApi implements AppUserApiInterface {
+  constructor(
+    @inject(AppApiRequester)
+    protected client: RequestTransaction<AppApiConfig>
+  ) {}
+
+  async login(
+    params: UserApiLoginTransaction['data']
+  ): Promise<AppApiResult<unknown>> {
+    const response = await this.client.request<UserApiLoginTransaction>({
+      url: '/user/login',
+      method: 'POST',
+      data: params,
+      encryptProps: 'password'
+    });
+
+    return response.data;
+  }
+
+  async register(
+    params: UserApiRegisterTransaction['data']
+  ): Promise<AppApiResult<unknown>> {
+    const response = await this.client.request<UserApiRegisterTransaction>({
+      url: '/user/register',
+      method: 'POST',
+      data: params,
+      encryptProps: 'password'
+    });
+
+    return response.data;
+  }
+
+  async logout(): Promise<AppApiResult<unknown>> {
+    const response = await this.client.request({
+      url: '/user/logout',
+      method: 'POST'
+    });
+
+    return response.data as AppApiResult<unknown>;
+  }
+}

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

@@ -0,0 +1,49 @@
+import { RequestCommonPlugin } from '@qlover/corekit-bridge';
+import { FetchURLPlugin } from '@qlover/fe-corekit';
+import { DialogErrorPlugin } from '@/base/cases/DialogErrorPlugin';
+import { RequestEncryptPlugin } from '@/base/cases/RequestEncryptPlugin';
+import { StringEncryptor } from '@/base/cases/StringEncryptor';
+import { AppApiPlugin } from './AppApiPlugin';
+import { AppApiRequester } from './AppApiRequester';
+import type { AppApiConfig } from './AppApiRequester';
+import type {
+  BootstrapContext,
+  BootstrapExecutorPlugin
+} from '@qlover/corekit-bridge';
+import type { ExecutorContext, SerializerIneterface } from '@qlover/fe-corekit';
+
+export class AppUserApiBootstrap implements BootstrapExecutorPlugin {
+  readonly pluginName = 'AppUserApiBootstrap';
+
+  constructor(protected serializer: SerializerIneterface) {}
+
+  onBefore({ parameters: { ioc } }: BootstrapContext): void | Promise<void> {
+    const appUserApi = ioc.get<AppApiRequester>(AppApiRequester);
+
+    appUserApi.usePlugin(new FetchURLPlugin());
+    appUserApi.usePlugin(new RequestEncryptPlugin(ioc.get(StringEncryptor)));
+    appUserApi.usePlugin(
+      new RequestCommonPlugin({
+        requestDataSerializer: this.requestDataSerializer.bind(this)
+      })
+    );
+    appUserApi.usePlugin(new AppApiPlugin());
+    appUserApi.usePlugin(ioc.get(DialogErrorPlugin));
+    console.log('jj AppUserApiBootstrap success');
+  }
+
+  protected requestDataSerializer(
+    data: unknown,
+    context: ExecutorContext<AppApiConfig>
+  ): unknown {
+    if (data instanceof FormData) {
+      return data;
+    }
+
+    if (context.parameters?.responseType === 'json') {
+      return this.serializer.serialize(data);
+    }
+
+    return data;
+  }
+}

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

@@ -0,0 +1,43 @@
+import { RequestCommonPlugin } from '@qlover/corekit-bridge';
+import {
+  FetchAbortPlugin,
+  RequestTransaction,
+  RequestAdapterFetch,
+  FetchURLPlugin
+} from '@qlover/fe-corekit';
+import { inject, injectable } from 'inversify';
+import type { MigrationApiInterface } from '@/base/port/MigrationApiInterface';
+import type { RequestAdapterConfig } from '@qlover/fe-corekit';
+
+/**
+ * UserApi
+ *
+ * @description
+ * UserApi is a client for the user API.
+ *
+ */
+@injectable()
+export class MigrationsApi
+  extends RequestTransaction<RequestAdapterConfig>
+  implements MigrationApiInterface
+{
+  constructor(
+    @inject(FetchAbortPlugin) protected abortPlugin: FetchAbortPlugin
+  ) {
+    super(
+      new RequestAdapterFetch({
+        baseURL: '/api/admin/migrations',
+        responseType: 'json'
+      })
+    );
+
+    this.usePlugin(new FetchURLPlugin()).usePlugin(new RequestCommonPlugin());
+  }
+
+  async init(): Promise<unknown> {
+    return this.request({
+      url: '/init',
+      method: 'POST'
+    });
+  }
+}

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

@@ -1,23 +1,23 @@
 import {
+  type ServiceIdentifier,
   type BootstrapContextValue,
   type BootstrapExecutorPlugin,
   type IOCContainerInterface,
   type IOCFunctionInterface,
   type LoggerInterface
 } from '@qlover/corekit-bridge';
-import { AsyncExecutor, type ExecutorPlugin } from '@qlover/fe-corekit';
+import {
+  AsyncExecutor,
+  type ExecutorError,
+  type PromiseTask,
+  type ExecutorPlugin
+} from '@qlover/fe-corekit';
+import type { ServerInterface } from '@/server/port/ServerInterface';
 import { I, type IOCIdentifierMapServer } from '@config/IOCIdentifier';
-import type { ServerInterface } from '@/base/port/ServerInterface';
 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>;
+  IOC: IOCFunctionInterface<IOCIdentifierMapServer, IOCContainerInterface>;
 }
 
 export class BootstrapServer implements ServerInterface {
@@ -43,11 +43,12 @@ export class BootstrapServer implements ServerInterface {
   getIOC<T extends keyof IOCIdentifierMapServer>(
     identifier: T
   ): IOCIdentifierMapServer[T];
-  getIOC(
-    identifier?: keyof IOCIdentifierMapServer
+  getIOC<T>(serviceIdentifier: ServiceIdentifier<T>): T;
+  getIOC<T extends keyof IOCIdentifierMapServer>(
+    identifier?: T
   ):
     | IOCFunctionInterface<IOCIdentifierMapServer, IOCContainerInterface>
-    | IOCIdentifierMapServer[keyof IOCIdentifierMapServer] {
+    | IOCIdentifierMapServer[T] {
     if (identifier === undefined) {
       return this.IOC;
     }
@@ -75,4 +76,17 @@ export class BootstrapServer implements ServerInterface {
     this.executor.use(plugin as ExecutorPlugin<unknown>);
     return this;
   }
+
+  execNoError<Result>(
+    task?: PromiseTask<Result, BootstrapServerContextValue>
+  ): Promise<Result | ExecutorError> {
+    const context = {
+      logger: this.logger,
+      root: this.root,
+      ioc: this.IOC.implemention!,
+      IOC: this.IOC
+    };
+
+    return this.executor.execNoError(context, task);
+  }
 }

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

@@ -1,8 +1,9 @@
-import { 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,
@@ -28,8 +29,8 @@ export class BootstrapsRegistry {
     i18nService.setPathname(this.args.pathname);
 
     const bootstrapList: BootstrapExecutorPlugin[] = [
-      i18nService
-      // new UserApiBootstarp(),
+      i18nService,
+      new AppUserApiBootstrap(IOC(I.JSONSerializer))
       // new FeApiBootstarp(),
       // AiApiBootstarp,
       // IOC(IOCIdentifier.I18nKeyErrorPlugin)

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/AppErrorApi.ts

@@ -0,0 +1,10 @@
+import type { AppApiErrorInterface } from '@/base/port/AppApiInterface';
+
+export class AppErrorApi implements AppApiErrorInterface {
+  readonly success = false;
+
+  constructor(
+    public readonly id: string,
+    public readonly message?: string
+  ) {}
+}

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

@@ -0,0 +1,7 @@
+import type { AppApiSuccessInterface } from '@/base/port/AppApiInterface';
+
+export class AppSuccessApi<T = unknown> implements AppApiSuccessInterface<T> {
+  readonly success = true;
+
+  constructor(public readonly data?: T) {}
+}

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

@@ -0,0 +1,12 @@
+import crypto from 'crypto';
+import type { Encryptor } from '@qlover/fe-corekit';
+
+export class PasswordEncrypt implements Encryptor<string, string> {
+  encrypt(password: string): string {
+    return crypto.createHash('md5').update(password).digest('hex');
+  }
+
+  decrypt(): string {
+    throw new Error('Md5Encrypt is not decryptable');
+  }
+}

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

@@ -0,0 +1,60 @@
+import { ExecutorError } from '@qlover/fe-corekit';
+import { inject, injectable } from 'inversify';
+import { cookies } from 'next/headers';
+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 { ServerAuthInterface } from './port/ServerAuthInterface';
+
+@injectable()
+export class ServerAuth implements ServerAuthInterface {
+  protected userTokenKey: string;
+  constructor(
+    @inject(I.AppConfig) protected server: AppConfig,
+    @inject(UserCredentialToken)
+    protected userCredentialToken: UserCredentialToken
+  ) {
+    this.userTokenKey = server.userTokenKey;
+  }
+
+  async setAuth(credential_token: string): Promise<void> {
+    const cookieStore = await cookies();
+
+    cookieStore.set(this.userTokenKey, credential_token);
+  }
+
+  async hasAuth(): Promise<boolean> {
+    const token = await this.getAuth();
+
+    if (!token) {
+      return false;
+    }
+
+    try {
+      const user = await this.userCredentialToken.parseToken(token);
+
+      return !!user;
+    } catch {
+      return false;
+    }
+  }
+
+  async getAuth(): Promise<string> {
+    const cookieStore = await cookies();
+    return cookieStore.get(this.userTokenKey)?.value || '';
+  }
+
+  async clear(): Promise<void> {
+    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');
+    }
+  }
+}