@qlover/create-app 0.7.8 → 0.7.10

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

@@ -0,0 +1,48 @@
+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 { AppUserApi } from './AppUserApi';
+import type { UserApiConfig } from './AppUserType';
+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<AppUserApi>(AppUserApi);
+
+    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));
+  }
+
+  protected requestDataSerializer(
+    data: unknown,
+    context: ExecutorContext<UserApiConfig>
+  ): 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/appApi/AppUserType.ts

@@ -0,0 +1,51 @@
+import type { RequestEncryptPluginProps } from '@/base/cases/RequestEncryptPlugin';
+import type { AppApiResponse } from '@/base/port/AppApiInterface';
+import type {
+  RequestAdapterConfig,
+  RequestAdapterResponse,
+  RequestTransactionInterface
+} from '@qlover/fe-corekit';
+
+export interface UserApiConfig<Request = unknown>
+  extends RequestAdapterConfig<Request>,
+    RequestEncryptPluginProps<Request> {}
+
+/**
+ * UserApiResponse
+ *
+ * @description
+ * UserApiResponse is the response for the UserApi.
+ *
+ * extends:
+ * - RequestAdapterResponse<Request, Response>
+ */
+export type UserApiResponse<
+  Request = unknown,
+  Response = unknown
+> = RequestAdapterResponse<Request, AppApiResponse<Response>>;
+
+/**
+ * UserApi common transaction
+ */
+export interface UserApiTransaction<Request = unknown, Response = unknown>
+  extends RequestTransactionInterface<
+    UserApiConfig<Request>,
+    UserApiResponse<Request, Response>
+  > {
+  data: UserApiConfig<Request>['data'];
+}
+
+export type UserApiLoginTransaction = UserApiTransaction<
+  { email: string; password: string },
+  {
+    token: string;
+  }
+>;
+
+export type UserApiRegisterTransaction = UserApiTransaction<
+  {
+    email: string;
+    password: string;
+  },
+  UserApiTransaction['response']['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/BootstrapServer.ts

@@ -1,13 +1,19 @@
 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 { I, type IOCIdentifierMapServer } from '@config/IOCIdentifier';
-import type { ServerInterface } from '@/base/port/ServerInterface';
+import type { ServerInterface } from '@/server/port/ServerInterface';
 import { ServerIOC } from '../serverIoc/ServerIOC';
 
 export interface BootstrapServerResult {
@@ -20,6 +26,12 @@ export interface BootstrapServerContextValue extends BootstrapContextValue {
   messages: Record<string, string>;
 }
 
+interface BootstrapServerContext {
+  logger: LoggerInterface;
+  root: Record<string, unknown>;
+  IOC: IOCFunctionInterface<IOCIdentifierMapServer, IOCContainerInterface>;
+}
+
 export class BootstrapServer implements ServerInterface {
   protected executor: AsyncExecutor;
   protected root: Record<string, unknown> = {};
@@ -43,11 +55,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 +88,16 @@ export class BootstrapServer implements ServerInterface {
     this.executor.use(plugin as ExecutorPlugin<unknown>);
     return this;
   }
+
+  execNoError<Result>(
+    task?: PromiseTask<Result, BootstrapServerContext>
+  ): Promise<Result | ExecutorError> {
+    const context = {
+      logger: this.logger,
+      root: this.root,
+      IOC: this.IOC
+    };
+
+    return this.executor.execNoError(context, task);
+  }
 }

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

@@ -1,4 +1,5 @@
-import { IOCIdentifier } from '@config/IOCIdentifier';
+import { I, IOCIdentifier } from '@config/IOCIdentifier';
+import { AppUserApiBootstrap } from '@/base/services/appApi/AppUserApiBootstrap';
 import { IocIdentifierTest } from './IocIdentifierTest';
 import { printBootstrap } from './PrintBootstrap';
 import type { BootstrapAppArgs } from './BootstrapClient';
@@ -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/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,50 @@
+import { inject, injectable } from 'inversify';
+import { cookies } from 'next/headers';
+import { I } from '@config/IOCIdentifier';
+import type { AppConfig } from '@/base/cases/AppConfig';
+import { UserCredentialToken } from './UserCredentialToken';
+import type { UserAuthInterface } from './port/UserAuthInterface';
+
+@injectable()
+export class ServerAuth implements UserAuthInterface {
+  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);
+  }
+}

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

@@ -0,0 +1,124 @@
+import {
+  createClient,
+  type PostgrestSingleResponse,
+  type SupabaseClient
+} 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 type { LoggerInterface } from '@qlover/logger';
+import type { PostgrestFilterBuilder } from '@supabase/postgrest-js';
+
+const whereHandlerMaps = {
+  '=': 'eq',
+  '!=': 'neq',
+  '>': 'gt',
+  '<': 'lt',
+  '>=': 'gte',
+  '<=': 'lte'
+};
+
+@injectable()
+export class SupabaseBridge implements DBBridgeInterface {
+  protected supabase: SupabaseClient;
+
+  constructor(
+    @inject(I.AppConfig) appConfig: AppConfig,
+    @inject(I.Logger) protected logger: LoggerInterface
+  ) {
+    this.supabase = createClient(
+      appConfig.supabaseUrl,
+      appConfig.supabaseAnonKey
+    );
+  }
+
+  getSupabase(): SupabaseClient {
+    return this.supabase;
+  }
+
+  async execSql(sql: string): Promise<PostgrestSingleResponse<unknown>> {
+    const res = await this.supabase.rpc('exec_sql', { sql });
+    return this.catch(res);
+  }
+
+  protected async catch(
+    result: PostgrestSingleResponse<unknown>
+  ): Promise<PostgrestSingleResponse<unknown>> {
+    if (result.error) {
+      this.logger.info(result);
+      throw new Error(result.error.message);
+    }
+    return result;
+  }
+
+  protected handleWhere(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    handler: PostgrestFilterBuilder<any, any, any, any, string, unknown, any>,
+    wheres: Where[]
+  ): void {
+    for (const where of wheres) {
+      const [key, operator, value] = where;
+      const opr = whereHandlerMaps[operator];
+      if (!opr) {
+        throw new Error(`Unsupported where operation: ${value}`);
+      }
+
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      if (typeof (handler as any)[opr] !== 'function') {
+        throw new Error(`Unsupported where operation: ${value}`);
+      }
+
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      (handler as any)[opr](key, value);
+    }
+  }
+
+  async add(event: BridgeEvent): Promise<PostgrestSingleResponse<unknown>> {
+    const { table, data } = event;
+    if (!data) {
+      throw new Error('Data is required for add operation');
+    }
+    const res = await this.supabase
+      .from(table)
+      .insert(Array.isArray(data) ? data : [data])
+      .select();
+    return this.catch(res);
+  }
+
+  async update(event: BridgeEvent): Promise<PostgrestSingleResponse<unknown>> {
+    const { table, data, where } = event;
+    if (!data) {
+      throw new Error('Data is required for update operation');
+    }
+
+    const handler = this.supabase.from(table).update(data);
+
+    this.handleWhere(handler, where ?? []);
+
+    return this.catch(await handler);
+  }
+
+  async delete(event: BridgeEvent): Promise<PostgrestSingleResponse<unknown>> {
+    const { table, where } = event;
+    const handler = this.supabase.from(table).delete();
+
+    this.handleWhere(handler, where ?? []);
+
+    return this.catch(await handler);
+  }
+
+  async get(event: BridgeEvent): Promise<PostgrestSingleResponse<unknown>> {
+    const { table, fields = '*', where } = event;
+    const selectFields = Array.isArray(fields) ? fields.join(',') : fields;
+    const handler = this.supabase.from(table).select(selectFields);
+
+    this.handleWhere(handler, where ?? []);
+
+    return this.catch(await handler);
+  }
+}

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

@@ -0,0 +1,49 @@
+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';
+
+export type UserCredentialTokenValue = Pick<UserSchema, 'id' | 'email'>;
+
+@injectable()
+export class UserCredentialToken
+  implements CrentialTokenInterface<UserCredentialTokenValue>
+{
+  protected jwtSecret: string;
+  protected jwtExpiresIn: string;
+
+  constructor(@inject(AppConfig) protected config: AppConfig) {
+    this.jwtSecret = config.jwtSecret;
+    this.jwtExpiresIn = config.jwtExpiresIn;
+  }
+
+  async generateToken(
+    data: UserCredentialTokenValue,
+    options: { expiresIn?: string } = {}
+  ): Promise<string> {
+    const { expiresIn = '30 days' } = options;
+
+    return jwt.sign({ i: data.id, e: data.email }, this.jwtSecret, {
+      expiresIn: expiresIn as jwt.SignOptions['expiresIn'],
+      algorithm: 'HS256',
+      noTimestamp: true
+    });
+  }
+
+  async parseToken(token: string): Promise<UserCredentialTokenValue> {
+    try {
+      const decoded = jwt.verify(token, this.jwtSecret) as {
+        i: UserSchema['id'];
+        e: string;
+      };
+
+      return {
+        id: decoded.i,
+        email: decoded.e
+      };
+    } catch {
+      throw new Error('Invalid token');
+    }
+  }
+}

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

@@ -0,0 +1,5 @@
+export interface CrentialTokenInterface<T> {
+  generateToken(data: T, options?: { expiresIn?: string }): Promise<string>;
+
+  parseToken(token: string): Promise<T>;
+}

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

@@ -0,0 +1,22 @@
+import { type ExecutorError, type PromiseTask } from '@qlover/fe-corekit';
+import { type IOCIdentifierMapServer } from '@config/IOCIdentifier';
+import type {
+  ServiceIdentifier,
+  IOCContainerInterface,
+  IOCFunctionInterface,
+  LoggerInterface
+} from '@qlover/corekit-bridge';
+
+export interface ServerInterface {
+  readonly logger: LoggerInterface;
+
+  getIOC(): IOCFunctionInterface<IOCIdentifierMapServer, IOCContainerInterface>;
+  getIOC<T extends keyof IOCIdentifierMapServer>(
+    identifier: T
+  ): IOCIdentifierMapServer[T];
+  getIOC<T>(serviceIdentifier: ServiceIdentifier<T>): T;
+
+  execNoError<Result>(
+    task?: PromiseTask<Result, unknown>
+  ): Promise<Result | ExecutorError>;
+}

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

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

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

@@ -0,0 +1,15 @@
+import type { DBTableInterface } from '@/base/port/DBTableInterface';
+import type { UserSchema } from '@migrations/schema/UserSchema';
+
+export interface UserRepositoryInterface extends DBTableInterface {
+  getUserByEmail(email: string): Promise<UserSchema | null>;
+  add(params: {
+    email: string;
+    password: string;
+  }): Promise<UserSchema[] | null>;
+
+  updateById(
+    id: number,
+    params: Partial<Omit<UserSchema, 'id' | 'created_at'>>
+  ): Promise<void>;
+}

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

@@ -0,0 +1,8 @@
+import type { UserSchema } from '@migrations/schema/UserSchema';
+
+export interface UserServiceInterface {
+  register(params: { email: string; password: string }): Promise<UserSchema>;
+  login(params: { email: string; password: string }): Promise<unknown>;
+
+  logout(): Promise<void>;
+}

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

@@ -0,0 +1,23 @@
+export interface ValidationFaildResult {
+  path: PropertyKey[];
+  message: string;
+}
+
+export interface ValidatorInterface {
+  /**
+   * Validate the data and return validation result
+   * @param data - The data to validate
+   * @returns true if validation passes, or ValidationError if validation fails
+   */
+  validate(
+    data: unknown
+  ): Promise<void | ValidationFaildResult> | void | ValidationFaildResult;
+
+  /**
+   * Get the data if it is valid, otherwise throw an error with validation details
+   * @param data - The data to validate
+   * @returns The data if it is valid
+   * @throws {import('@qlover/fe-corekit').ExecutorError} if the data is invalid, with validation errors
+   */
+  getThrow(data: unknown): unknown;
+}

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

@@ -0,0 +1,63 @@
+import { inject, injectable } from 'inversify';
+import { isEmpty, last } from 'lodash';
+import type { DBBridgeInterface } from '@/base/port/DBBridgeInterface';
+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';
+
+  constructor(@inject(SupabaseBridge) protected dbBridge: DBBridgeInterface) {}
+
+  getAll(): Promise<unknown> {
+    return this.dbBridge.get({ table: this.name });
+  }
+
+  /**
+   * @override
+   */
+  async getUserByEmail(email: string): Promise<UserSchema | null> {
+    const result = await this.dbBridge.get({
+      table: this.name,
+      where: [['email', '=', email]]
+    });
+
+    if (isEmpty(result.data)) {
+      return null;
+    }
+
+    return last(result.data as UserSchema[]) ?? null;
+  }
+
+  /**
+   * @override
+   */
+  async add(params: {
+    email: string;
+    password: string;
+  }): Promise<UserSchema[] | null> {
+    const result = await this.dbBridge.add({
+      table: this.name,
+      data: params
+    });
+
+    if (isEmpty(result.data)) {
+      return null;
+    }
+
+    return result.data as UserSchema[];
+  }
+
+  async updateById(
+    id: number,
+    params: Partial<Omit<UserSchema, 'id' | 'created_at'>>
+  ): Promise<void> {
+    await this.dbBridge.update({
+      table: this.name,
+      data: params,
+      where: [['id', '=', id]]
+    });
+  }
+}