@jumentix/cli-init 0.0.0

package/templates/backend/src/modules/Users/service/OrganizationService.ts

@@ -0,0 +1,348 @@
+import type {
+  IServiceConfig,
+  IServiceResponse,
+  IPagingRequest
+} from '@src/modules/port';
+import {
+  BaseService
+} from '@src/modules/port';
+import { BaseError, ValidationError } from '@src/infra/exceptions';
+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 { OrganizationDataRepository } from '@src/modules/Users/adapters/out/persistence/OrganizationDataRepository';
+import type { ICacheService } from '@src/infra/cache';
+import {
+  runMetricsQuery,
+  type IMetricsCapabilities,
+  type IMetricsQuery,
+  type IMetricsResult
+} from '@jumentix/persistence-contracts';
+
+interface IOrganizationServiceConfig extends IServiceConfig {
+}
+
+interface ISerializableOrganization extends IOrganization {
+  serialize(): IOrganization;
+}
+
+export class OrganizationService extends BaseService<
+IOrganization,
+RequestCreateOrganization,
+RequestUpdateOrganization
+> {
+  public dataRepository: OrganizationDataRepository;
+
+  private readonly cacheService?: ICacheService;
+
+  public constructor(config: IOrganizationServiceConfig) {
+    super(config);
+    this.dataRepository = config.dataRepository as OrganizationDataRepository;
+    this.cacheService = config.services?.cacheService as ICacheService | undefined;
+  }
+
+  private static serializeOrganization(organization: IOrganization): IOrganization {
+    const candidate = organization as Partial<ISerializableOrganization>;
+    return typeof candidate.serialize === 'function'
+      ? candidate.serialize()
+      : organization;
+  }
+
+  private static sortPayload(payload: any): any {
+    if (Array.isArray(payload)) {
+      return payload.map((item) => OrganizationService.sortPayload(item));
+    }
+    if (!payload || typeof payload !== 'object') {
+      return payload;
+    }
+    return Object.keys(payload)
+      .sort((a, b) => a.localeCompare(b))
+      .reduce((acc, key) => {
+        acc[key] = OrganizationService.sortPayload(payload[key]);
+        return acc;
+      }, {} as Record<string, any>);
+  }
+
+  private async getCacheVersion(): Promise<number> {
+    if (!this.cacheService) return 1;
+    return this.cacheService.getVersion('organizations');
+  }
+
+  private async invalidateReadCache(): Promise<void> {
+    if (!this.cacheService) return;
+    await this.cacheService.bumpVersion('organizations');
+  }
+
+  public async create(data: RequestCreateOrganization): Promise<IServiceResponse<IOrganization>> {
+    const serviceResponse: IServiceResponse<IOrganization> = {};
+    try {
+      serviceResponse.result = OrganizationService.serializeOrganization(
+        await this.dataRepository.create(data)
+      );
+      await this.invalidateReadCache();
+    } catch (error) {
+      serviceResponse.error = error as BaseError;
+    }
+    return serviceResponse;
+  }
+
+  public async update(
+    id: string,
+    data: RequestUpdateOrganization
+  ): Promise<IServiceResponse<IOrganization>> {
+    const serviceResponse: IServiceResponse<IOrganization> = {};
+    try {
+      serviceResponse.result = OrganizationService.serializeOrganization(
+        await this.dataRepository.update(id, data)
+      );
+      await this.invalidateReadCache();
+    } catch (error) {
+      serviceResponse.error = error as BaseError;
+    }
+    return serviceResponse;
+  }
+
+  public async delete(id: string): Promise<IServiceResponse<boolean>> {
+    const serviceResponse: IServiceResponse<boolean> = {};
+    try {
+      serviceResponse.result = await this.dataRepository.delete(id);
+      await this.invalidateReadCache();
+    } catch (error) {
+      serviceResponse.error = error as BaseError;
+    }
+    return serviceResponse;
+  }
+
+  public async getOneById(id: string): Promise<IServiceResponse<IOrganization>> {
+    const serviceResponse: IServiceResponse<IOrganization> = {};
+    try {
+      const version = await this.getCacheVersion();
+      const cacheKey = `organizations:v${version}:getOneById:${id}`;
+      const cached = await this.cacheService?.get<IOrganization>(cacheKey);
+      if (cached) {
+        serviceResponse.result = cached;
+        return serviceResponse;
+      }
+      serviceResponse.result = OrganizationService.serializeOrganization(
+        await this.dataRepository.getOneById(id)
+      );
+      if (serviceResponse.result) {
+        await this.cacheService?.set(cacheKey, serviceResponse.result);
+      }
+    } catch (error) {
+      serviceResponse.error = error as BaseError;
+    }
+    return serviceResponse;
+  }
+
+  public async getAll(
+    filters: Record<string, string | number>,
+    paging: IPagingRequest
+  ): Promise<IServiceResponse<IOrganization[]>> {
+    const serviceResponse: IServiceResponse<IOrganization[]> = {};
+    try {
+      const version = await this.getCacheVersion();
+      const cacheKey = `organizations:v${version}:getAll:${JSON.stringify(
+        OrganizationService.sortPayload({ filters, paging })
+      )}`;
+      const cached = await this.cacheService?.get<IServiceResponse<IOrganization[]>>(cacheKey);
+      if (cached) {
+        return cached;
+      }
+      const result = await this.dataRepository.getAll(filters, paging);
+      const serializedResult = {
+        ...result,
+        result: result.result.map((organization) => (
+          OrganizationService.serializeOrganization(organization)
+        ))
+      };
+      await this.cacheService?.set(cacheKey, serializedResult);
+      return serializedResult;
+    } catch (error) {
+      serviceResponse.error = error as BaseError;
+    }
+    return serviceResponse;
+  }
+
+  public async metrics(
+    filters: Record<string, string | number>,
+    query: IMetricsQuery,
+    capabilities: IMetricsCapabilities
+  ): Promise<IServiceResponse<IMetricsResult>> {
+    const serviceResponse: IServiceResponse<IMetricsResult> = {};
+    try {
+      const page = await this.dataRepository.getAll(filters, { page: 1, size: 10000 });
+      const rows = page.result.map((organization) => {
+        const serialized = OrganizationService.serializeOrganization(organization);
+        return {
+          ...serialized,
+          createdAt: serialized.createdAt instanceof Date
+            ? serialized.createdAt.toISOString()
+            : serialized.createdAt,
+          updatedAt: serialized.updatedAt instanceof Date
+            ? serialized.updatedAt.toISOString()
+            : serialized.updatedAt
+        };
+      }) as Array<Record<string, unknown>>;
+      serviceResponse.result = runMetricsQuery(rows, { ...query, filters }, capabilities);
+    } catch (error) {
+      if (error instanceof Error && /Accepted:/.test(error.message)) {
+        serviceResponse.error = new ValidationError(error.message);
+      } else {
+        serviceResponse.error = error as BaseError;
+      }
+    }
+    return serviceResponse;
+  }
+
+  public async createAddress(
+    id: string,
+    data: RequestCreateAddress
+  ): Promise<IServiceResponse<IOrganization>> {
+    const serviceResponse: IServiceResponse<IOrganization> = {};
+    try {
+      serviceResponse.result = OrganizationService.serializeOrganization(
+        await this.dataRepository.createAddress(id, data)
+      );
+      await this.invalidateReadCache();
+    } catch (error) {
+      serviceResponse.error = error as BaseError;
+    }
+    return serviceResponse;
+  }
+
+  public async updateAddress(
+    id: string,
+    addressId: string,
+    data: RequestUpdateAddress
+  ): Promise<IServiceResponse<IOrganization>> {
+    const serviceResponse: IServiceResponse<IOrganization> = {};
+    try {
+      serviceResponse.result = OrganizationService.serializeOrganization(
+        await this.dataRepository.updateAddress(id, addressId, data)
+      );
+      await this.invalidateReadCache();
+    } catch (error) {
+      serviceResponse.error = error as BaseError;
+    }
+    return serviceResponse;
+  }
+
+  public async deleteAddress(
+    id: string,
+    addressId: string
+  ): Promise<IServiceResponse<IOrganization>> {
+    const serviceResponse: IServiceResponse<IOrganization> = {};
+    try {
+      serviceResponse.result = OrganizationService.serializeOrganization(
+        await this.dataRepository.deleteAddress(id, addressId)
+      );
+      await this.invalidateReadCache();
+    } catch (error) {
+      serviceResponse.error = error as BaseError;
+    }
+    return serviceResponse;
+  }
+
+  public async createPhone(
+    id: string,
+    data: RequestCreatePhone
+  ): Promise<IServiceResponse<IOrganization>> {
+    const serviceResponse: IServiceResponse<IOrganization> = {};
+    try {
+      serviceResponse.result = OrganizationService.serializeOrganization(
+        await this.dataRepository.createPhone(id, data)
+      );
+      await this.invalidateReadCache();
+    } catch (error) {
+      serviceResponse.error = error as BaseError;
+    }
+    return serviceResponse;
+  }
+
+  public async updatePhone(
+    id: string,
+    phoneId: string,
+    data: RequestUpdatePhone
+  ): Promise<IServiceResponse<IOrganization>> {
+    const serviceResponse: IServiceResponse<IOrganization> = {};
+    try {
+      serviceResponse.result = OrganizationService.serializeOrganization(
+        await this.dataRepository.updatePhone(id, phoneId, data)
+      );
+      await this.invalidateReadCache();
+    } catch (error) {
+      serviceResponse.error = error as BaseError;
+    }
+    return serviceResponse;
+  }
+
+  public async deletePhone(id: string, phoneId: string): Promise<IServiceResponse<IOrganization>> {
+    const serviceResponse: IServiceResponse<IOrganization> = {};
+    try {
+      serviceResponse.result = OrganizationService.serializeOrganization(
+        await this.dataRepository.deletePhone(id, phoneId)
+      );
+      await this.invalidateReadCache();
+    } catch (error) {
+      serviceResponse.error = error as BaseError;
+    }
+    return serviceResponse;
+  }
+
+  public async createEmail(
+    id: string,
+    data: RequestCreateEmail
+  ): Promise<IServiceResponse<IOrganization>> {
+    const serviceResponse: IServiceResponse<IOrganization> = {};
+    try {
+      serviceResponse.result = OrganizationService.serializeOrganization(
+        await this.dataRepository.createEmail(id, data)
+      );
+      await this.invalidateReadCache();
+    } catch (error) {
+      serviceResponse.error = error as BaseError;
+    }
+    return serviceResponse;
+  }
+
+  public async updateEmail(
+    id: string,
+    emailId: string,
+    data: RequestUpdateEmail
+  ): Promise<IServiceResponse<IOrganization>> {
+    const serviceResponse: IServiceResponse<IOrganization> = {};
+    try {
+      serviceResponse.result = OrganizationService.serializeOrganization(
+        await this.dataRepository.updateEmail(id, emailId, data)
+      );
+      await this.invalidateReadCache();
+    } catch (error) {
+      serviceResponse.error = error as BaseError;
+    }
+    return serviceResponse;
+  }
+
+  public async deleteEmail(id: string, emailId: string): Promise<IServiceResponse<IOrganization>> {
+    const serviceResponse: IServiceResponse<IOrganization> = {};
+    try {
+      serviceResponse.result = OrganizationService.serializeOrganization(
+        await this.dataRepository.deleteEmail(id, emailId)
+      );
+      await this.invalidateReadCache();
+    } catch (error) {
+      serviceResponse.error = error as BaseError;
+    }
+    return serviceResponse;
+  }
+
+  public static compile(config: IOrganizationServiceConfig): OrganizationService {
+    return new OrganizationService(config);
+  }
+}

package/templates/backend/src/modules/Users/service/UserProviderLocal.ts

@@ -0,0 +1,45 @@
+/* eslint-disable class-methods-use-this */
+import type { IUserProvider } from '@src/modules/Users/service/ports/IUserProvider';
+
+import type { IUser } from '@src/modules/Users/domain/Entity/IUser';
+import type { RequestCreateUser } from '@src/modules/Users/interface/dto/RequestCreateUser';
+import type { RequestUpdateUser } from '@src/modules/Users/interface/dto/RequestUpdateUser';
+import { UserService } from '@src/modules/Users/service/UserService';
+import type { IServiceResponse } from '@src/modules/port';
+
+export class UserProviderLocal implements IUserProvider {
+  private readonly userService: UserService;
+
+  constructor(userService: UserService) {
+    this.userService = userService;
+  }
+
+  public async register(data: Record<string, any>): Promise<IServiceResponse<Record<string, any>>> {
+    return this.userService.create(data as RequestCreateUser);
+  }
+
+  public async update(
+    id: string,
+    data: Record<string, any>
+  ): Promise<IServiceResponse<Record<string, any>>> {
+    return this.userService.update(id, data as RequestUpdateUser);
+  }
+
+  public async delete(id: string): Promise<IServiceResponse<boolean>> {
+    return this.userService.delete(id);
+  }
+
+  public async findUser(username: string): Promise<IUser | null> {
+    const { result } = await this.userService.getOneByUsernameForAuth(username);
+    const userFound = result || null;
+    return userFound;
+  }
+
+  public async updatePassword(id: string, newPassword: string): Promise<IServiceResponse<IUser>> {
+    return this.userService.updatePassword(id, { password: newPassword });
+  }
+
+  public static compile(userService: UserService): IUserProvider {
+    return new UserProviderLocal(userService);
+  }
+}