@jumentix/cli-init 0.0.0

package/templates/backend/src/modules/Users/adapters/out/persistence/UserDataRepository.ts

@@ -0,0 +1,215 @@
+/* istanbul ignore file */
+import type { IStore } from '@src/infra/ports/persistence/IStore';
+import {
+  throwIfPreUpdateValidationFails,
+  throwIfNotFound,
+  canNotBeEmpty
+} from '@src/shared/validators';
+import type {
+  IUser
+} from '@src/modules/Users/domain/Entity/IUser';
+import { User } from '@src/modules/Users/domain/Model/User';
+import type { RequestCreateUser } from '@src/modules/Users/interface/dto/RequestCreateUser';
+import type { RequestUpdateUser } from '@src/modules/Users/interface/dto/RequestUpdateUser';
+import type { RequestUpdatePassword } from '@src/modules/Users/interface/dto/RequestUpdatePassword';
+import type { RequestCreateDocument } from '@src/modules/Users/interface/dto/RequestCreateDocument';
+import type { RequestUpdateDocument } from '@src/modules/Users/interface/dto/RequestUpdateDocument';
+import type { RequestUpdatePhone } from '@src/modules/Users/interface/dto/RequestUpdatePhone';
+import type { RequestCreatePhone } from '@src/modules/Users/interface/dto/RequestCreatePhone';
+import type { RequestUpdateEmail } from '@src/modules/Users/interface/dto/RequestUpdateEmail';
+import type { RequestCreateEmail } from '@src/modules/Users/interface/dto/RequestCreateEmail';
+import type { IUserRepository } from '@src/modules/Users/service/ports/IUserRepository';
+import type {
+  IPagingRequest,
+  IPagingResponse,
+  IRepoConfig
+} from '@src/modules/port';
+import {
+  BaseRepo
+} from '@src/modules/port';
+
+import { _DEFAULT_PAGE_SIZE_ } from '@src/config/constants';
+
+export function exclude<T, Key extends keyof T>(
+  record: T,
+  keys: Key[]
+): Omit<T, Key> {
+  for (const key of keys) {
+    // eslint-disable-next-line no-param-reassign
+    delete record[key];
+  }
+  return record;
+}
+
+export class UserDataRepository
+  extends BaseRepo<User, RequestCreateUser, RequestUpdateUser>
+  implements IUserRepository {
+  public store: IStore<IUser>;
+
+  public limit: number;
+
+  public constructor(config: IRepoConfig) {
+    super(config);
+    const { limit } = config;
+    this.store = this.databaseClient.stores.User;
+    this.limit = limit ?? _DEFAULT_PAGE_SIZE_;
+  }
+
+  public async create(data: RequestCreateUser): Promise<User> {
+    canNotBeEmpty('password', data.password);
+    const model: User = new User(data);
+    await this.store.create(model.id, model.serialize());
+    model.password = '********';
+    model.salt = '***';
+
+    return model;
+  }
+
+  public async update(id: string, data: RequestUpdateUser): Promise<User> {
+    throwIfPreUpdateValidationFails(id, data);
+    const newData = { ...(new User({ ...data, password: '' })).serialize() };
+    delete (newData as any).password;
+    delete (newData as any).salt;
+    delete (newData as any).createdAt;
+    delete (newData as any).updatedAt;
+    const updatedDoc = await this.store.update(id, newData as IUser);
+    return new User(updatedDoc);
+  }
+
+  public async delete(id: string): Promise<boolean> {
+    const result = await this.store.delete(id);
+    return result;
+  }
+
+  public async getOneById(id: string): Promise<User> {
+    const rawUser = await this.store.getOneById(id);
+    throwIfNotFound(!!rawUser);
+    return new User({ ...rawUser, readOnly: true });
+  }
+
+  public async getAll(
+    filters: Record<string, string|number>,
+    paging: IPagingRequest
+  ): Promise<IPagingResponse<User[]>> {
+    const {
+      result, page, size, total
+    } = await this.store.getAll(filters, paging);
+    const currentPage = page ?? paging?.page ?? 1;
+    const currentSize = size ?? paging?.size ?? this.limit;
+    const rows = result ?? [];
+    const pagedResponse: IPagingResponse<User[]> = {
+      page: currentPage,
+      size: currentSize,
+      total,
+      result: rows.map((rawDoc: IUser) => new User(rawDoc))
+    };
+    return pagedResponse;
+  }
+
+  public static compile(config: IRepoConfig): UserDataRepository {
+    return new UserDataRepository(config);
+  }
+
+  public async updatePassword(id: string, data: RequestUpdatePassword): Promise<User> {
+    const oldDocument = await this.getOneById(id);
+    canNotBeEmpty('password', data.password);
+    const model: User = new User({ ...oldDocument.serialize() });
+    model.password = data.password;
+    model.salt = data.salt!;
+    await this.store.update(id, model.serialize());
+    return model;
+  }
+
+  public async createDocument(userId: string, data: RequestCreateDocument): Promise<User> {
+    const oldDocument = await this.getOneById(userId);
+    const model: User = new User({ ...oldDocument.serialize() });
+    model.createDocument(data);
+    await this.store.update(userId, model.serialize());
+    return model;
+  }
+
+  public async updateDocument(
+    userId: string,
+    documentId: string,
+    data: RequestUpdateDocument
+  ): Promise<User> {
+    const oldDocument = await this.getOneById(userId);
+    const model: User = new User({ ...oldDocument.serialize() });
+    model.updateDocument({ ...data, id: documentId });
+    await this.store.update(userId, model.serialize());
+    return model;
+  }
+
+  public async deleteDocument(
+    userId: string,
+    documentId: string
+  ): Promise<User> {
+    const oldDocument = await this.getOneById(userId);
+    const model: User = new User({ ...oldDocument.serialize() });
+    model.deleteDocument(documentId);
+    await this.store.update(userId, model.serialize());
+    return model;
+  }
+
+  public async createPhone(userId: string, data: RequestCreatePhone): Promise<User> {
+    const oldPhone = await this.getOneById(userId);
+    const model: User = new User({ ...oldPhone.serialize() });
+    model.createPhone(data);
+    await this.store.update(userId, model.serialize());
+    return model;
+  }
+
+  public async updatePhone(
+    userId: string,
+    phoneId: string,
+    data: RequestUpdatePhone
+  ): Promise<User> {
+    const oldPhone = await this.getOneById(userId);
+    const model: User = new User({ ...oldPhone.serialize() });
+    model.updatePhone({ ...data, id: phoneId });
+    await this.store.update(userId, model.serialize());
+    return model;
+  }
+
+  public async deletePhone(
+    userId: string,
+    phoneId: string
+  ): Promise<User> {
+    const oldPhone = await this.getOneById(userId);
+    const model: User = new User({ ...oldPhone.serialize() });
+    model.deletePhone(phoneId);
+    await this.store.update(userId, model.serialize());
+    return model;
+  }
+
+  public async createEmail(userId: string, data: RequestCreateEmail): Promise<User> {
+    const oldEmail = await this.getOneById(userId);
+    const model: User = new User({ ...oldEmail.serialize() });
+    model.createEmail(data);
+    await this.store.update(userId, model.serialize());
+    return model;
+  }
+
+  public async updateEmail(
+    userId: string,
+    emailId: string,
+    data: RequestUpdateEmail
+  ): Promise<User> {
+    const oldEmail = await this.getOneById(userId);
+    const model: User = new User({ ...oldEmail.serialize() });
+    model.updateEmail({ ...data, id: emailId });
+    await this.store.update(userId, model.serialize());
+    return model;
+  }
+
+  public async deleteEmail(
+    userId: string,
+    emailId: string
+  ): Promise<User> {
+    const oldEmail = await this.getOneById(userId);
+    const model: User = new User({ ...oldEmail.serialize() });
+    model.deleteEmail(emailId);
+    await this.store.update(userId, model.serialize());
+    return model;
+  }
+}

package/templates/backend/src/modules/Users/adapters/out/persistence/index.ts

@@ -0,0 +1 @@
+export { UserDataRepository } from './UserDataRepository';

package/templates/backend/src/modules/Users/application/AuthUseCases.ts

@@ -0,0 +1,103 @@
+import type { IAuthUseCases } from '@src/modules/Users/application/ports/IAuthUseCases';
+import { EAuthSchemaType } from '@src/modules/Users/service/ports/EAuthSchemaType';
+import type { IAuthService } from '@src/modules/Users/service/ports/IAuthService';
+import type { IMutexService } from '@src/infra/mutex/port/IMutexService';
+import type { IServiceResponse } from '@src/modules/port/IServiceResponse';
+import type { IAuthorizationHeader } from '@src/modules/Users/service/ports/IAuthorizationHeader';
+import type { ILoginRequest } from '@src/modules/Users/interface/dto/ILoginRequest';
+import type { IRegisterRequest } from '@src/modules/Users/interface/dto/IRegisterRequest';
+import type { IUpdatePasswordRequest } from '@src/modules/Users/interface/dto/IUpdatePasswordRequest';
+import type { ILogoutRequest } from '@src/modules/Users/interface/dto/ILogoutRequest';
+import { BaseError, ResourceLockedError, ValidationError } from '@src/infra/exceptions';
+
+export class AuthUseCases implements IAuthUseCases {
+  private readonly authService: IAuthService;
+
+  private readonly mutexService: IMutexService;
+
+  constructor(
+    authService: IAuthService,
+    mutexService: IMutexService
+  ) {
+    this.authService = authService;
+    this.mutexService = mutexService;
+  }
+
+  public async login(data: ILoginRequest): Promise<IServiceResponse<IAuthorizationHeader>> {
+    const { username, password, schemaType } = data;
+    return this.authService.authenticate(
+      username,
+      password,
+      schemaType ?? EAuthSchemaType.Bearer
+    );
+  }
+
+  public async register(data: IRegisterRequest): Promise<IServiceResponse<Record<string, any>>> {
+    return this.authService.register(data);
+  }
+
+  public async updatePassword(
+    authorization: string,
+    data: IUpdatePasswordRequest
+  ): Promise<IServiceResponse<boolean>> {
+    const serviceResponse: IServiceResponse<boolean> = { result: false };
+    let userId;
+    try {
+      const decodedToken = await this.authService.decodeToken(authorization);
+      if (!decodedToken) {
+        throw new ValidationError('Invalid request');
+      }
+
+      userId = decodedToken.id;
+
+      const lockUserId = await this.mutexService.lock('user', userId);
+      if (lockUserId?.result.previouslyLocked) {
+        throw new ResourceLockedError('user locked');
+      }
+
+      const response = await this.authService.updatePassword(
+        userId,
+        data.password
+      );
+      await this.mutexService.unlock('user', userId);
+
+      if (response.error) {
+        throw response.error;
+      }
+      serviceResponse.result = response.result;
+    } catch (error) {
+      if (userId) {
+        await this.mutexService.unlock('user', userId);
+      }
+      serviceResponse.error = error as BaseError;
+    }
+    return serviceResponse;
+  }
+
+  public async logout(
+    authorization: string,
+    data: ILogoutRequest
+  ): Promise<IServiceResponse<boolean>> {
+    const serviceResponse: IServiceResponse<boolean> = { result: false };
+    try {
+      const decodedToken = await this.authService.decodeToken(authorization);
+
+      if (decodedToken!.username !== data.username) {
+        throw new ValidationError('Invalid request');
+      }
+
+      const logoutResponse = await this.authService.logout(authorization);
+      if (logoutResponse.error) {
+        throw logoutResponse.error;
+      }
+      serviceResponse.result = logoutResponse.result;
+    } catch (error) {
+      serviceResponse.error = error as BaseError;
+    }
+    return serviceResponse;
+  }
+
+  public static compile(authService: IAuthService, mutexService: IMutexService): IAuthUseCases {
+    return new AuthUseCases(authService, mutexService);
+  }
+}

package/templates/backend/src/modules/Users/application/UserUseCases.ts

@@ -0,0 +1,89 @@
+import { UserService } from '@src/modules/Users/service/UserService';
+import type { IUserUseCases } from '@src/modules/Users/application/ports/IUserUseCases';
+
+export class UserUseCases implements IUserUseCases {
+  private readonly userService: UserService;
+
+  constructor(userService: UserService) {
+    this.userService = userService;
+  }
+
+  public async create(data: Parameters<UserService['create']>[0]) {
+    return this.userService.create(data);
+  }
+
+  public async update(id: string, data: Parameters<UserService['update']>[1]) {
+    return this.userService.update(id, data);
+  }
+
+  public async delete(id: string) {
+    return this.userService.delete(id);
+  }
+
+  public async getOneById(id: string) {
+    return this.userService.getOneById(id);
+  }
+
+  public async getAll(
+    filters: Parameters<UserService['getAll']>[0],
+    paging: Parameters<UserService['getAll']>[1]
+  ) {
+    return this.userService.getAll(filters, paging);
+  }
+
+  public async metrics(
+    filters: Parameters<UserService['metrics']>[0],
+    query: Parameters<UserService['metrics']>[1],
+    capabilities: Parameters<UserService['metrics']>[2]
+  ) {
+    return this.userService.metrics(filters, query, capabilities);
+  }
+
+  public async updatePassword(id: string, data: Parameters<UserService['updatePassword']>[1]) {
+    return this.userService.updatePassword(id, data);
+  }
+
+  public async createDocument(id: string, data: Parameters<UserService['createDocument']>[1]) {
+    return this.userService.createDocument(id, data);
+  }
+
+  public async updateDocument(
+    id: string,
+    documentId: string,
+    data: Parameters<UserService['updateDocument']>[2]
+  ) {
+    return this.userService.updateDocument(id, documentId, data);
+  }
+
+  public async deleteDocument(id: string, documentId: string) {
+    return this.userService.deleteDocument(id, documentId);
+  }
+
+  public async createPhone(id: string, data: Parameters<UserService['createPhone']>[1]) {
+    return this.userService.createPhone(id, data);
+  }
+
+  public async updatePhone(id: string, phoneId: string, data: Parameters<UserService['updatePhone']>[2]) {
+    return this.userService.updatePhone(id, phoneId, data);
+  }
+
+  public async deletePhone(id: string, phoneId: string) {
+    return this.userService.deletePhone(id, phoneId);
+  }
+
+  public async createEmail(id: string, data: Parameters<UserService['createEmail']>[1]) {
+    return this.userService.createEmail(id, data);
+  }
+
+  public async updateEmail(id: string, emailId: string, data: Parameters<UserService['updateEmail']>[2]) {
+    return this.userService.updateEmail(id, emailId, data);
+  }
+
+  public async deleteEmail(id: string, emailId: string) {
+    return this.userService.deleteEmail(id, emailId);
+  }
+
+  public static compile(userService: UserService): IUserUseCases {
+    return new UserUseCases(userService);
+  }
+}

package/templates/backend/src/modules/Users/application/ports/IAuthUseCases.ts

@@ -0,0 +1,19 @@
+import type { IServiceResponse } from '@src/modules/port/IServiceResponse';
+import type { IAuthorizationHeader } from '@src/modules/Users/service/ports/IAuthorizationHeader';
+import type { ILoginRequest } from '@src/modules/Users/interface/dto/ILoginRequest';
+import type { IRegisterRequest } from '@src/modules/Users/interface/dto/IRegisterRequest';
+import type { IUpdatePasswordRequest } from '@src/modules/Users/interface/dto/IUpdatePasswordRequest';
+import type { ILogoutRequest } from '@src/modules/Users/interface/dto/ILogoutRequest';
+
+export interface IAuthUseCases {
+  login(data: ILoginRequest): Promise<IServiceResponse<IAuthorizationHeader>>;
+  register(data: IRegisterRequest): Promise<IServiceResponse<Record<string, any>>>;
+  updatePassword(
+    authorization: string,
+    data: IUpdatePasswordRequest
+  ): Promise<IServiceResponse<boolean>>;
+  logout(
+    authorization: string,
+    data: ILogoutRequest
+  ): Promise<IServiceResponse<boolean>>;
+}

package/templates/backend/src/modules/Users/application/ports/IOrganizationUseCases.ts

@@ -0,0 +1,48 @@
+import type { IServiceResponse, IPagingRequest } from '@src/modules/port';
+import type { IOrganization } from '@src/modules/Users/domain/Entity/IOrganization';
+import type { RequestCreateAddress } from '@src/modules/Users/interface/dto/RequestCreateAddress';
+import type { RequestCreateEmail } from '@src/modules/Users/interface/dto/RequestCreateEmail';
+import type { RequestCreateOrganization } from '@src/modules/Users/interface/dto/RequestCreateOrganization';
+import type { RequestCreatePhone } from '@src/modules/Users/interface/dto/RequestCreatePhone';
+import type { RequestUpdateAddress } from '@src/modules/Users/interface/dto/RequestUpdateAddress';
+import type { RequestUpdateEmail } from '@src/modules/Users/interface/dto/RequestUpdateEmail';
+import type { RequestUpdateOrganization } from '@src/modules/Users/interface/dto/RequestUpdateOrganization';
+import type { RequestUpdatePhone } from '@src/modules/Users/interface/dto/RequestUpdatePhone';
+import type { IMetricsCapabilities, IMetricsQuery, IMetricsResult } from '@jumentix/persistence-contracts';
+
+export interface IOrganizationUseCases {
+  create(data: RequestCreateOrganization): Promise<IServiceResponse<IOrganization>>;
+  update(id: string, data: RequestUpdateOrganization): Promise<IServiceResponse<IOrganization>>;
+  delete(id: string): Promise<IServiceResponse<boolean>>;
+  getOneById(id: string): Promise<IServiceResponse<IOrganization>>;
+  getAll(
+    filters: Record<string, string | number>,
+    paging: IPagingRequest
+  ): Promise<IServiceResponse<IOrganization[]>>;
+  metrics(
+    filters: Record<string, string | number>,
+    query: IMetricsQuery,
+    capabilities: IMetricsCapabilities
+  ): Promise<IServiceResponse<IMetricsResult>>;
+  createAddress(id: string, data: RequestCreateAddress): Promise<IServiceResponse<IOrganization>>;
+  updateAddress(
+    id: string,
+    addressId: string,
+    data: RequestUpdateAddress
+  ): Promise<IServiceResponse<IOrganization>>;
+  deleteAddress(id: string, addressId: string): Promise<IServiceResponse<IOrganization>>;
+  createPhone(id: string, data: RequestCreatePhone): Promise<IServiceResponse<IOrganization>>;
+  updatePhone(
+    id: string,
+    phoneId: string,
+    data: RequestUpdatePhone
+  ): Promise<IServiceResponse<IOrganization>>;
+  deletePhone(id: string, phoneId: string): Promise<IServiceResponse<IOrganization>>;
+  createEmail(id: string, data: RequestCreateEmail): Promise<IServiceResponse<IOrganization>>;
+  updateEmail(
+    id: string,
+    emailId: string,
+    data: RequestUpdateEmail
+  ): Promise<IServiceResponse<IOrganization>>;
+  deleteEmail(id: string, emailId: string): Promise<IServiceResponse<IOrganization>>;
+}

package/templates/backend/src/modules/Users/application/ports/IUserUseCases.ts

@@ -0,0 +1,51 @@
+import type { IPagingRequest } from '@src/modules/port/IPagingRequest';
+import type { IServiceResponse } from '@src/modules/port/IServiceResponse';
+import type { IUser } from '@src/modules/Users/domain/Entity/IUser';
+import type { RequestCreateDocument } from '@src/modules/Users/interface/dto/RequestCreateDocument';
+import type { RequestCreateEmail } from '@src/modules/Users/interface/dto/RequestCreateEmail';
+import type { RequestCreatePhone } from '@src/modules/Users/interface/dto/RequestCreatePhone';
+import type { RequestCreateUser } from '@src/modules/Users/interface/dto/RequestCreateUser';
+import type { RequestUpdateDocument } from '@src/modules/Users/interface/dto/RequestUpdateDocument';
+import type { RequestUpdateEmail } from '@src/modules/Users/interface/dto/RequestUpdateEmail';
+import type { RequestUpdatePassword } from '@src/modules/Users/interface/dto/RequestUpdatePassword';
+import type { RequestUpdatePhone } from '@src/modules/Users/interface/dto/RequestUpdatePhone';
+import type { RequestUpdateUser } from '@src/modules/Users/interface/dto/RequestUpdateUser';
+import type { IMetricsCapabilities, IMetricsQuery, IMetricsResult } from '@jumentix/persistence-contracts';
+
+export interface IUserUseCases {
+  create(data: RequestCreateUser): Promise<IServiceResponse<IUser>>;
+  update(id: string, data: RequestUpdateUser): Promise<IServiceResponse<IUser>>;
+  delete(id: string): Promise<IServiceResponse<boolean>>;
+  getOneById(id: string): Promise<IServiceResponse<IUser>>;
+  getAll(
+    filters: Record<string, string|number>,
+    paging: IPagingRequest
+  ): Promise<IServiceResponse<IUser[]>>;
+  metrics(
+    filters: Record<string, string | number>,
+    query: IMetricsQuery,
+    capabilities: IMetricsCapabilities
+  ): Promise<IServiceResponse<IMetricsResult>>;
+  updatePassword(id: string, data: RequestUpdatePassword): Promise<IServiceResponse<IUser>>;
+  createDocument(id: string, data: RequestCreateDocument): Promise<IServiceResponse<IUser>>;
+  updateDocument(
+    id: string,
+    documentId: string,
+    data: RequestUpdateDocument
+  ): Promise<IServiceResponse<IUser>>;
+  deleteDocument(id: string, documentId: string): Promise<IServiceResponse<IUser>>;
+  createPhone(id: string, data: RequestCreatePhone): Promise<IServiceResponse<IUser>>;
+  updatePhone(
+    id: string,
+    phoneId: string,
+    data: RequestUpdatePhone
+  ): Promise<IServiceResponse<IUser>>;
+  deletePhone(id: string, phoneId: string): Promise<IServiceResponse<IUser>>;
+  createEmail(id: string, data: RequestCreateEmail): Promise<IServiceResponse<IUser>>;
+  updateEmail(
+    id: string,
+    emailId: string,
+    data: RequestUpdateEmail
+  ): Promise<IServiceResponse<IUser>>;
+  deleteEmail(id: string, emailId: string): Promise<IServiceResponse<IUser>>;
+}

package/templates/backend/src/modules/Users/application/use-cases/AuthUseCases.ts

@@ -0,0 +1 @@
+export { AuthUseCases } from '@src/modules/Users/application/AuthUseCases';

package/templates/backend/src/modules/Users/application/use-cases/OrganizationUseCases.ts

@@ -0,0 +1,124 @@
+import type { IServiceResponse, IPagingRequest } from '@src/modules/port';
+import type { IOrganization } from '@src/modules/Users/domain/Entity/IOrganization';
+import type { RequestCreateAddress } from '@src/modules/Users/interface/dto/RequestCreateAddress';
+import type { RequestCreateEmail } from '@src/modules/Users/interface/dto/RequestCreateEmail';
+import type { RequestCreateOrganization } from '@src/modules/Users/interface/dto/RequestCreateOrganization';
+import type { RequestCreatePhone } from '@src/modules/Users/interface/dto/RequestCreatePhone';
+import type { RequestUpdateAddress } from '@src/modules/Users/interface/dto/RequestUpdateAddress';
+import type { RequestUpdateEmail } from '@src/modules/Users/interface/dto/RequestUpdateEmail';
+import type { RequestUpdateOrganization } from '@src/modules/Users/interface/dto/RequestUpdateOrganization';
+import type { RequestUpdatePhone } from '@src/modules/Users/interface/dto/RequestUpdatePhone';
+import { OrganizationService } from '@src/modules/Users/service/OrganizationService';
+import type { IOrganizationUseCases } from '@src/modules/Users/application/ports/IOrganizationUseCases';
+
+export class OrganizationUseCases implements IOrganizationUseCases {
+  private readonly organizationService: OrganizationService;
+
+  constructor(organizationService: OrganizationService) {
+    this.organizationService = organizationService;
+  }
+
+  public async create(data: RequestCreateOrganization): Promise<IServiceResponse<IOrganization>> {
+    return this.organizationService.create(data);
+  }
+
+  public async update(
+    id: string,
+    data: RequestUpdateOrganization
+  ): Promise<IServiceResponse<IOrganization>> {
+    return this.organizationService.update(id, data);
+  }
+
+  public async delete(id: string): Promise<IServiceResponse<boolean>> {
+    return this.organizationService.delete(id);
+  }
+
+  public async getOneById(id: string): Promise<IServiceResponse<IOrganization>> {
+    return this.organizationService.getOneById(id);
+  }
+
+  public async getAll(
+    filters: Record<string, string | number>,
+    paging: IPagingRequest
+  ): Promise<IServiceResponse<IOrganization[]>> {
+    return this.organizationService.getAll(filters, paging);
+  }
+
+  public async metrics(
+    filters: Parameters<OrganizationService['metrics']>[0],
+    query: Parameters<OrganizationService['metrics']>[1],
+    capabilities: Parameters<OrganizationService['metrics']>[2]
+  ) {
+    return this.organizationService.metrics(filters, query, capabilities);
+  }
+
+  public async createAddress(
+    id: string,
+    data: RequestCreateAddress
+  ): Promise<IServiceResponse<IOrganization>> {
+    return this.organizationService.createAddress(id, data);
+  }
+
+  public async updateAddress(
+    id: string,
+    addressId: string,
+    data: RequestUpdateAddress
+  ): Promise<IServiceResponse<IOrganization>> {
+    return this.organizationService.updateAddress(id, addressId, data);
+  }
+
+  public async deleteAddress(
+    id: string,
+    addressId: string
+  ): Promise<IServiceResponse<IOrganization>> {
+    return this.organizationService.deleteAddress(id, addressId);
+  }
+
+  public async createPhone(
+    id: string,
+    data: RequestCreatePhone
+  ): Promise<IServiceResponse<IOrganization>> {
+    return this.organizationService.createPhone(id, data);
+  }
+
+  public async updatePhone(
+    id: string,
+    phoneId: string,
+    data: RequestUpdatePhone
+  ): Promise<IServiceResponse<IOrganization>> {
+    return this.organizationService.updatePhone(id, phoneId, data);
+  }
+
+  public async deletePhone(
+    id: string,
+    phoneId: string
+  ): Promise<IServiceResponse<IOrganization>> {
+    return this.organizationService.deletePhone(id, phoneId);
+  }
+
+  public async createEmail(
+    id: string,
+    data: RequestCreateEmail
+  ): Promise<IServiceResponse<IOrganization>> {
+    return this.organizationService.createEmail(id, data);
+  }
+
+  public async updateEmail(
+    id: string,
+    emailId: string,
+    data: RequestUpdateEmail
+  ): Promise<IServiceResponse<IOrganization>> {
+    return this.organizationService.updateEmail(id, emailId, data);
+  }
+
+  public async deleteEmail(
+    id: string,
+    emailId: string
+  ): Promise<IServiceResponse<IOrganization>> {
+    return this.organizationService.deleteEmail(id, emailId);
+  }
+
+  public static compile(organizationService: OrganizationService): OrganizationUseCases {
+    return new OrganizationUseCases(organizationService);
+  }
+}

package/templates/backend/src/modules/Users/application/use-cases/UserUseCases.ts

@@ -0,0 +1 @@
+export { UserUseCases } from '@src/modules/Users/application/UserUseCases';

package/templates/backend/src/modules/Users/application/use-cases/index.ts

@@ -0,0 +1,2 @@
+export { UserUseCases } from './UserUseCases';
+export { AuthUseCases } from './AuthUseCases';