@jumentix/cli-init 0.0.0

package/templates/backend/src/modules/Users/service/ports/IAuthSchema.ts

@@ -0,0 +1,6 @@
+import { EAuthSchemaType } from './EAuthSchemaType';
+
+export interface IAuthSchema {
+  type: EAuthSchemaType
+  token: string;
+}

package/templates/backend/src/modules/Users/service/ports/IAuthService.ts

@@ -0,0 +1,35 @@
+import type { IUser } from '@src/modules/Users/domain/Entity/IUser';
+import type { IServiceResponse } from '@src/modules/port';
+import type { IJwtService } from '@src/infra/jwt/IJwtService';
+
+import { EAuthSchemaType } from './EAuthSchemaType';
+import type { IAuthorizationHeader } from './IAuthorizationHeader';
+import type { ITokenObject } from './ITokenObject';
+
+export interface IAuthService {
+  start(): Promise<void>;
+  stop(): Promise<void>;
+  jwtService: IJwtService;
+  register(data: Record<string, any>): Promise<IServiceResponse<Record<string, any>>>;
+  updateUser(id: string, data: Record<string, any>): Promise<IServiceResponse<Record<string, any>>>;
+  deleteUser(id: string): Promise<IServiceResponse<boolean>>;
+  decodeToken(token: string): Promise<ITokenObject | null>;
+  authenticate(
+    username: string,
+    password: string,
+    schemaType: EAuthSchemaType
+  ): Promise<IServiceResponse<IAuthorizationHeader>>;
+  // authorize(/* identity: IAuthSchema */ request: any): Promise<any>;
+  authorize(/* identity: IAuthSchema */ header: string): Promise<ITokenObject>;
+  updatePassword(
+    id: string,
+    // oldPassword: string,
+    newPassword: string
+  ): Promise<IServiceResponse<boolean>>;
+  logout(authorization?: string): Promise<IServiceResponse<boolean>>;
+  throwIfUserHasNoAccessToResource(
+    user: IUser,
+    endPointConfig: Record<string, any>
+  ): boolean;
+  compile?(): IAuthService;
+}

package/templates/backend/src/modules/Users/service/ports/IAuthorizationHeader.ts

@@ -0,0 +1,4 @@
+export interface IAuthorizationHeader {
+  Authorization: string;
+  [key:string]: string;
+}

package/templates/backend/src/modules/Users/service/ports/IOrganizationRepository.ts

@@ -0,0 +1,42 @@
+import type { IPagingRequest, IPagingResponse } from '@src/modules/port';
+import { Organization } from '@src/modules/Users/domain/Model/Organization';
+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';
+
+export interface IOrganizationRepository {
+  create(data: RequestCreateOrganization): Promise<Organization>;
+  update(id: string, data: RequestUpdateOrganization): Promise<Organization>;
+  delete(id: string): Promise<boolean>;
+  getOneById(id: string): Promise<Organization>;
+  getAll(
+    filters: Record<string, string | number>,
+    paging: IPagingRequest
+  ): Promise<IPagingResponse<Organization[]>>;
+  createAddress(organizationId: string, data: RequestCreateAddress): Promise<Organization>;
+  updateAddress(
+    organizationId: string,
+    addressId: string,
+    data: RequestUpdateAddress
+  ): Promise<Organization>;
+  deleteAddress(organizationId: string, addressId: string): Promise<Organization>;
+  createPhone(organizationId: string, data: RequestCreatePhone): Promise<Organization>;
+  updatePhone(
+    organizationId: string,
+    phoneId: string,
+    data: RequestUpdatePhone
+  ): Promise<Organization>;
+  deletePhone(organizationId: string, phoneId: string): Promise<Organization>;
+  createEmail(organizationId: string, data: RequestCreateEmail): Promise<Organization>;
+  updateEmail(
+    organizationId: string,
+    emailId: string,
+    data: RequestUpdateEmail
+  ): Promise<Organization>;
+  deleteEmail(organizationId: string, emailId: string): Promise<Organization>;
+}

package/templates/backend/src/modules/Users/service/ports/ITokenObject.ts

@@ -0,0 +1,10 @@
+import { JwtPayload } from 'jsonwebtoken';
+
+export interface ITokenObject extends JwtPayload {
+  id: string;
+  username: string;
+  firstName: string;
+  avatar: string;
+  organization?: string;
+  roles?: string[];
+}

package/templates/backend/src/modules/Users/service/ports/IUserProvider.ts

@@ -0,0 +1,10 @@
+import type { IUser } from '@src/modules/Users/domain/Entity/IUser';
+import type { IServiceResponse } from '@src/modules/port';
+
+export interface IUserProvider {
+  register(data: Record<string, any>): Promise<IServiceResponse<Record<string, any>>>;
+  update(id: string, data: Record<string, any>): Promise<IServiceResponse<Record<string, any>>>;
+  delete(id: string): Promise<IServiceResponse<boolean>>;
+  findUser(username: string): Promise<any>;
+  updatePassword(id: string, newPassword: string): Promise<IServiceResponse<IUser>>;
+}

package/templates/backend/src/modules/Users/service/ports/IUserRepository.ts

@@ -0,0 +1,33 @@
+import type { IPagingRequest, IPagingResponse } from '@src/modules/port';
+
+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 { RequestCreatePhone } from '@src/modules/Users/interface/dto/RequestCreatePhone';
+import type { RequestUpdatePhone } from '@src/modules/Users/interface/dto/RequestUpdatePhone';
+import type { RequestCreateEmail } from '@src/modules/Users/interface/dto/RequestCreateEmail';
+import type { RequestUpdateEmail } from '@src/modules/Users/interface/dto/RequestUpdateEmail';
+
+export interface IUserRepository {
+  create(data: RequestCreateUser): Promise<User>;
+  update(id: string, data: RequestUpdateUser): Promise<User>;
+  delete(id: string): Promise<boolean>;
+  getOneById(id: string): Promise<User>;
+  getAll(
+    filters: Record<string, string|number>,
+    paging: IPagingRequest
+  ): Promise<IPagingResponse<User[]>>;
+  updatePassword(id: string, data: RequestUpdatePassword): Promise<User>;
+  createDocument(userId: string, data: RequestCreateDocument): Promise<User>;
+  updateDocument(userId: string, documentId: string, data: RequestUpdateDocument): Promise<User>;
+  deleteDocument(userId: string, documentId: string): Promise<User>;
+  createPhone(userId: string, data: RequestCreatePhone): Promise<User>;
+  updatePhone(userId: string, phoneId: string, data: RequestUpdatePhone): Promise<User>;
+  deletePhone(userId: string, phoneId: string): Promise<User>;
+  createEmail(userId: string, data: RequestCreateEmail): Promise<User>;
+  updateEmail(userId: string, emailId: string, data: RequestUpdateEmail): Promise<User>;
+  deleteEmail(userId: string, emailId: string): Promise<User>;
+}

package/templates/backend/src/modules/ddd/valueObjects/AddressValueObject.ts

@@ -0,0 +1,39 @@
+/* eslint-disable @typescript-eslint/no-unsafe-declaration-merging */
+import { UUID } from '@src/modules/port';
+import { canNotBeEmpty } from '@src/shared/validators';
+import { EAddressType } from '@src/modules/ddd/valueObjects/EAddressType';
+
+export interface AddressValueObject {
+  id: string;
+  email: string;
+  type: EAddressType;
+  isPrimary: boolean;
+}
+
+export class AddressValueObject {
+  public id: string;
+
+  public email: string;
+
+  public type: EAddressType;
+
+  public isPrimary: boolean;
+
+  constructor(payload: any) {
+    const {
+      id,
+      email,
+      type,
+      isPrimary
+    } = payload;
+    canNotBeEmpty('email', email);
+    canNotBeEmpty('type', type);
+    if (!Object.values(EAddressType).includes(type)) {
+      throw new Error(`Address type must be one of: ${Object.values(EAddressType).join(', ')}`);
+    }
+    this.id = id ? UUID.parse(id).toString() : UUID.create().toString();
+    this.email = email;
+    this.type = type;
+    this.isPrimary = !!isPrimary || false;
+  }
+}

package/templates/backend/src/modules/ddd/valueObjects/DocumentValueObject.ts

@@ -0,0 +1,78 @@
+import { EDocumentType } from '@src/modules/ddd/valueObjects/EDocumentType';
+import { UUID } from '@src/modules/port';
+import { canNotBeEmpty, throwIfIsNotObject } from '@src/shared/validators';
+import { DomainValidationError } from '@src/infra/exceptions';
+
+export interface IDocumentValueObjectPayload {
+  id?: string;
+  type: EDocumentType | string;
+  countryIssue: string;
+  data: string;
+}
+
+export class DocumentValueObject {
+  public readonly id: string;
+
+  public readonly type: EDocumentType;
+
+  public readonly countryIssue: string;
+
+  public readonly data: string;
+
+  public constructor(payload: IDocumentValueObjectPayload) {
+    throwIfIsNotObject('payload', payload);
+    const {
+      id,
+      type,
+      countryIssue,
+      data
+    } = payload;
+    canNotBeEmpty('type', type);
+    canNotBeEmpty('countryIssue', countryIssue);
+    canNotBeEmpty('data', data);
+
+    const normalizedType = DocumentValueObject.normalizeType(type);
+    const normalizedCountryIssue = DocumentValueObject.normalizeCountryIssue(countryIssue);
+    const normalizedData = DocumentValueObject.normalizeData(data);
+
+    this.id = id ? UUID.parse(id).toString() : UUID.create().toString();
+    this.type = normalizedType;
+    this.data = normalizedData;
+    this.countryIssue = normalizedCountryIssue;
+  }
+
+  private static normalizeType(input: EDocumentType | string): EDocumentType {
+    const value = `${input}`.trim();
+    if (!value) {
+      throw new DomainValidationError('type can not be empty');
+    }
+
+    const enumValues = Object.values(EDocumentType);
+    const directMatch = enumValues.find((item) => item === value);
+    if (directMatch) {
+      return directMatch as EDocumentType;
+    }
+
+    if (value.toUpperCase() === 'PASSPORT') {
+      return EDocumentType.PASSPORT;
+    }
+
+    throw new DomainValidationError(`Invalid document type: ${value}`);
+  }
+
+  private static normalizeCountryIssue(input: string): string {
+    const value = `${input}`.trim().toUpperCase();
+    if (!value) {
+      throw new DomainValidationError('countryIssue can not be empty');
+    }
+    return value;
+  }
+
+  private static normalizeData(input: string): string {
+    const value = `${input}`.trim();
+    if (!value) {
+      throw new DomainValidationError('data can not be empty');
+    }
+    return value;
+  }
+}

package/templates/backend/src/modules/ddd/valueObjects/EAddressType.ts

@@ -0,0 +1,6 @@
+// eslint-disable-next-line no-shadow
+export enum EAddressType {
+  work = 'work',
+  home = 'home',
+  vacation = 'vacation'
+}

package/templates/backend/src/modules/ddd/valueObjects/EDocumentType.ts

@@ -0,0 +1,7 @@
+// eslint-disable-next-line no-shadow
+export enum EDocumentType {
+  CPF = 'CPF',
+  RG = 'RG',
+  SSN = 'SSN',
+  PASSPORT = 'passport',
+}

package/templates/backend/src/modules/ddd/valueObjects/EEmailType.ts

@@ -0,0 +1,5 @@
+// eslint-disable-next-line no-shadow
+export enum EEmailType {
+  work = 'work',
+  personal = 'personal',
+}

package/templates/backend/src/modules/ddd/valueObjects/EmailValueObject.ts

@@ -0,0 +1,36 @@
+/* eslint-disable @typescript-eslint/no-unsafe-declaration-merging */
+import { UUID } from '@src/modules/port';
+import { canNotBeEmpty } from '@src/shared/validators';
+import { EEmailType } from '@src/modules/ddd/valueObjects/EEmailType';
+
+export interface EmailValueObject {
+  id: string;
+  email: string;
+  type: EEmailType;
+  isPrimary: boolean;
+}
+
+export class EmailValueObject {
+  public id: string;
+
+  public type: EEmailType;
+
+  public email: string;
+
+  public isPrimary: boolean;
+
+  constructor(payload: any) {
+    const {
+      id,
+      type,
+      email,
+      isPrimary
+    } = payload;
+    canNotBeEmpty('email', email);
+    canNotBeEmpty('type', type);
+    this.id = id ? UUID.parse(id).toString() : UUID.create().toString();
+    this.email = email;
+    this.type = type;
+    this.isPrimary = !!isPrimary || false;
+  }
+}

package/templates/backend/src/modules/ddd/valueObjects/LoginCustomValueObject.ts

@@ -0,0 +1,4 @@
+export interface LoginCustomValueObject {
+  username: string;
+  password: string;
+}

package/templates/backend/src/modules/ddd/valueObjects/PhoneValueObject.ts

@@ -0,0 +1,36 @@
+import { UUID } from '@src/modules/port';
+import { canNotBeEmpty } from '@src/shared/validators';
+
+export class PhoneValueObject {
+  public id: string;
+
+  public countryCode: string;
+
+  public localCode: string;
+
+  public number: string;
+
+  public isPrimary: boolean;
+
+  constructor(payload: any) {
+    const {
+      id,
+      countryCode,
+      localCode,
+      number,
+      isPrimary
+    } = payload;
+    canNotBeEmpty('number', number);
+    canNotBeEmpty('localCode', localCode);
+    canNotBeEmpty('countryCode', countryCode);
+    // mustBeNumeric('countryCode', countryCode);
+    // mustBePositiveNumber('countryCode', countryCode);
+    // mustBeNumeric('localCode', localCode);
+    // mustBePositiveNumber('localCode', localCode);
+    this.id = id ? UUID.parse(id).toString() : UUID.create().toString();
+    this.number = number;
+    this.localCode = localCode;
+    this.countryCode = countryCode;
+    this.isPrimary = !!isPrimary || false;
+  }
+}

package/templates/backend/src/modules/ddd/valueObjects/index.ts

@@ -0,0 +1,9 @@
+export { EEmailType } from './EEmailType';
+export { EDocumentType } from './EDocumentType';
+export { EAddressType } from './EAddressType';
+export { EmailValueObject } from './EmailValueObject';
+export type { LoginCustomValueObject } from './LoginCustomValueObject';
+export type { IDocumentValueObjectPayload } from './DocumentValueObject';
+export { DocumentValueObject } from './DocumentValueObject';
+export { PhoneValueObject } from './PhoneValueObject';
+export { AddressValueObject } from './AddressValueObject';

package/templates/backend/src/modules/port/BaseDomainEvent.ts

@@ -0,0 +1,70 @@
+import { Context } from '@src/infra/context/Context';
+import type { IDomainEventMetadata } from './IDomainEventMetadata';
+import type { IEventMessage } from './IEventMessage';
+
+export abstract class BaseDomainEvent<TPayload = any> {
+  public type: string = this.constructor.name;
+
+  public authorization: string = '';
+
+  public input: TPayload = {} as TPayload;
+
+  public params: any = {};
+
+  public queryString: any = {};
+
+  public entity: string = '';
+
+  public action: string = '';
+
+  public message: any;
+
+  public dateTime: Date = new Date();
+
+  public schemaOAS: any = {};
+
+  public readonly metadata: IDomainEventMetadata;
+
+  constructor(message: IEventMessage) {
+    const {
+      input,
+      authorization,
+      entity,
+      action,
+      params,
+      queryString,
+      schemaOAS,
+      metadata
+    } = message;
+    this.input = input || {};
+    if (typeof input === 'string') {
+      this.input = JSON.parse(input);
+    }
+    if (authorization) {
+      this.authorization = authorization;
+    }
+    this.entity = entity ?? '';
+    this.action = action ?? '';
+    if (params) {
+      this.params = params;
+    }
+    if (queryString) {
+      this.queryString = queryString;
+    }
+    if (schemaOAS) {
+      this.schemaOAS = schemaOAS;
+    }
+    const store: Map<any, any> = Context.getStore() as Map<any, any>;
+    const correlationId = metadata?.correlationId ?? (store ? store.get('correlationId') : '');
+    const timestamp = metadata?.timestamp ?? Date.now();
+    const userId = metadata?.userId ?? (store ? store.get('userId') : '');
+    const causationId = metadata?.causationId ?? (store ? store.get('correlationId') : '');
+
+    this.metadata = {
+      correlationId,
+      causationId,
+      timestamp,
+      userId
+    };
+  }
+}

package/templates/backend/src/modules/port/BaseModel.ts

@@ -0,0 +1,119 @@
+/* eslint-disable no-underscore-dangle */
+import type {
+  IOpenApiDataEntityLike,
+  IOpenApiFieldDefinitionLike
+} from '@src/shared/openapi/OpenApi31DataEntity';
+import {
+  throwIfDataEntityPayloadIsNotOpenApi31Compliant,
+  throwIfDataEntityIsNotOpenApi31Compliant,
+  throwIfFieldDefinitionIsNotOpenApi31Compliant
+} from '@src/shared/openapi/OpenApi31DataEntity';
+import { DomainValidationError } from '@src/infra/exceptions';
+import { UUID } from './UUID';
+
+export abstract class BaseModel<T> {
+  private readonly _createdAt: Date;
+
+  private _updatedAt: Date;
+
+  private readonly _id: string;
+
+  public _excludeOnSerialize: string[] = [];
+
+  protected _deletedAt: string | null;
+
+  constructor(meta?: {
+    id?: string;
+    createdAt?: Date | string;
+    updatedAt?: Date | string;
+    deletedAt?: Date | string | null;
+  }) {
+    this._id = meta?.id ? UUID.parse(meta.id).toString() : UUID.create().toString();
+    const now = new Date();
+    this._createdAt = meta?.createdAt ? new Date(meta.createdAt) : now;
+    this._updatedAt = meta?.updatedAt ? new Date(meta.updatedAt) : this._createdAt;
+    if (meta?.deletedAt === undefined || meta.deletedAt === null) {
+      this._deletedAt = null;
+    } else if (meta.deletedAt instanceof Date) {
+      this._deletedAt = meta.deletedAt.toISOString();
+    } else {
+      this._deletedAt = String(meta.deletedAt);
+    }
+  }
+
+  public get id(): string {
+    return this._id;
+  }
+
+  public get createdAt(): Date {
+    return this._createdAt;
+  }
+
+  public get updatedAt(): Date {
+    return this._updatedAt;
+  }
+
+  public set updatedAt(_updatedAt: Date) {
+    this._updatedAt = _updatedAt;
+  }
+
+  public get deletedAt(): string | null {
+    return this._deletedAt;
+  }
+
+  public set deletedAt(value: Date | string | null) {
+    if (value === undefined || value === null || value === '') {
+      this._deletedAt = value === '' ? '' : null;
+      return;
+    }
+    this._deletedAt = value instanceof Date ? value.toISOString() : String(value);
+  }
+
+  public static throwIfFieldSchemaIsNotOpenApi31Compliant(
+    field: IOpenApiFieldDefinitionLike
+  ): void {
+    throwIfFieldDefinitionIsNotOpenApi31Compliant(field);
+  }
+
+  public static throwIfDataEntitySchemaIsNotOpenApi31Compliant(
+    entity: IOpenApiDataEntityLike
+  ): void {
+    throwIfDataEntityIsNotOpenApi31Compliant(entity);
+  }
+
+  public static throwIfModelPayloadIsNotOpenApi31Compliant(
+    payload: Record<string, any>,
+    entity: IOpenApiDataEntityLike
+  ): void {
+    try {
+      throwIfDataEntityPayloadIsNotOpenApi31Compliant(payload, entity);
+    } catch (error) {
+      throw new DomainValidationError((error as Error).message);
+    }
+  }
+
+  public serialize(): T {
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    const self: any = this;
+    const protoObj = Object.getOwnPropertyDescriptors(Object.getPrototypeOf(this));
+    const protoKeys = Object.keys(protoObj);
+    const api: any = {};
+    for (const property of protoKeys) {
+      // eslint-disable-next-line no-continue
+      if (property === 'constructor') continue;
+      // eslint-disable-next-line no-continue
+      if (property === 'serialize') continue;
+      // eslint-disable-next-line no-continue
+      if (this._excludeOnSerialize.indexOf(property) > -1) continue;
+      api[property] = self[property];
+    }
+
+    return Object.freeze({
+      id: this.id,
+      ...api,
+      createdAt: this._createdAt,
+      updatedAt: this._updatedAt,
+      deletedAt: this._deletedAt
+    });
+  }
+}

package/templates/backend/src/modules/port/BaseRepo.ts

@@ -0,0 +1,33 @@
+import type { IDatabaseClient } from '@src/infra/persistence/port/IDatabaseClient';
+import { _DEFAULT_PAGE_SIZE_ } from '@src/config/constants';
+
+import type { IPagingRequest } from './IPagingRequest';
+import type { IPagingResponse } from './IPagingResponse';
+import type { IRepoConfig } from './IRepoConfig';
+
+export abstract class BaseRepo<Model, RequestCreateDTO, RequestUpdateDTO> {
+  public databaseClient: IDatabaseClient;
+
+  public limit: number;
+
+  constructor(config: IRepoConfig) {
+    const { limit, databaseClient } = config;
+
+    this.databaseClient = databaseClient;
+
+    this.limit = limit ?? _DEFAULT_PAGE_SIZE_;
+  }
+
+  public abstract create(data: RequestCreateDTO): Promise<Model>;
+
+  public abstract update(id: string, data: RequestUpdateDTO): Promise<Model>;
+
+  public abstract delete(id: string): Promise<boolean>;
+
+  public abstract getOneById(id: string): Promise<Model>;
+
+  public abstract getAll(
+    filters: Record<string, string|number>,
+    paging: IPagingRequest
+  ): Promise<IPagingResponse<Model[]>>;
+}

package/templates/backend/src/modules/port/BaseService.ts

@@ -0,0 +1,50 @@
+import type { IPagingRequest } from './IPagingRequest';
+import type { IServiceResponse } from './IServiceResponse';
+import type { IServiceConfig } from './IServiceConfig';
+import type { TRepos } from './TRepos';
+import type { TServices } from './TServices';
+import { BaseRepo } from './BaseRepo';
+import { BaseModel } from './BaseModel';
+
+export abstract class BaseService<ResponseDataEntity, RequestCreateDTO, RequestUpdateDTO> {
+  /**
+   * dataRepository is the main data dataRepository associated to the service.
+   * Mandatory
+   */
+  public dataRepository: BaseRepo<BaseModel<Record<any, any>>, Record<any, any>, Record<any, any>>;
+
+  /**
+   * repos hold a collection of injected repos to be used when needed inside the service
+   * Not Mandatory
+   */
+  public repos: TRepos;
+
+  /**
+   * services hold a collection of injected services to be used when needed inside the service
+   * Not Mandatory
+   */
+  public services: TServices;
+
+  constructor(config: IServiceConfig) {
+    this.repos = config.repos ?? {};
+    this.services = config.services ?? {};
+    if (!config.dataRepository) throw Error('You must provide a data repository when creating a service instance.');
+    this.dataRepository = config.dataRepository;
+  }
+
+  public abstract create(data: RequestCreateDTO): Promise<IServiceResponse<ResponseDataEntity>>;
+
+  public abstract update(
+    id: string,
+    data: RequestUpdateDTO
+  ): Promise<IServiceResponse<ResponseDataEntity>>;
+
+  public abstract delete(id: string): Promise<IServiceResponse<boolean>>;
+
+  public abstract getOneById(id: string): Promise<IServiceResponse<ResponseDataEntity>>;
+
+  public abstract getAll(
+    filters: Record<string, string|number>,
+    paging: IPagingRequest
+  ):Promise<IServiceResponse<ResponseDataEntity[]>>;
+}

package/templates/backend/src/modules/port/IDomainEventMetadata.ts

@@ -0,0 +1,18 @@
+export type IDomainEventMetadata = {
+  /** Timestamp when this domain event occurred */
+  readonly timestamp: number;
+
+  /** ID for correlation purposes (for Integration Events,logs correlation, etc).
+   */
+  readonly correlationId: string;
+
+  /**
+   * Causation id used to reconstruct execution order if needed
+   */
+  readonly causationId?: string;
+
+  /**
+   * User ID for debugging and logging purposes
+   */
+  readonly userId?: string;
+};