@koalarx/nest 3.1.49 → 4.0.1

package/koala-nest/src/application/person/jobs/cron/create-person.job.ts

@@ -0,0 +1,58 @@
+import { CronExpression } from '@/core/constants/cron.constants';
+import { CreatePersonHandler } from '@/application/person/create/create-person.handler';
+import { IPersonRepository } from '@/domain/repositories/iperson.repository';
+import {
+  CronJobHandlerBase,
+  CronJobSettings,
+  cronJobSettings,
+} from '@/core/background-services/cron-service/cron-job.handler.base';
+import { EventQueue } from '@/core/background-services/event-service/event-queue';
+import { ILoggingService } from '@/domain/common/ilogging.service';
+import { IRedLockService } from '@/domain/common/ired-lock.service';
+import { Injectable, Logger } from '@nestjs/common';
+import { InactivePersonEvent } from '@/application/person/jobs/events/person/inactive-person/inactive-person.event';
+import { PersonEventJob } from '@/application/person/jobs/events/person/person-event.job';
+
+@Injectable()
+export class CreatePersonJob extends CronJobHandlerBase {
+  private readonly logger = new Logger(CreatePersonJob.name);
+
+  constructor(
+    redlockService: IRedLockService,
+    loggingService: ILoggingService,
+    private readonly createPerson: CreatePersonHandler,
+    private readonly repository: IPersonRepository,
+  ) {
+    super(redlockService, loggingService);
+  }
+
+  protected settings(): Promise<CronJobSettings> {
+    return Promise.resolve(cronJobSettings(CronExpression.EVERY_15_SECONDS));
+  }
+
+  protected async run(): Promise<void> {
+    this.logger.debug('Iniciando criação de pessoa...');
+
+    const created = await this.createPerson.handle({
+      name: 'John Doe',
+      contacts: [{ contact: '22999999999@example.com' }],
+      address: { address: 'Street 1' },
+    });
+
+    const person = await this.repository.findById(created.id);
+
+    if (person) {
+      this.logger.log(`Pessoa criada com sucesso. ID: ${person.id}`);
+
+      const jobs = new PersonEventJob();
+      jobs.addEvent(new InactivePersonEvent());
+      EventQueue.dispatchEventsForAggregate(jobs._id);
+
+      this.logger.log('Evento de inativação disparado.');
+    } else {
+      this.logger.log('Pessoa não encontrada após criação.');
+    }
+
+    this.logger.log('Job concluído.');
+  }
+}

package/koala-nest/src/application/person/jobs/cron/delete-inactive.job.ts

@@ -0,0 +1,57 @@
+import { CronExpression } from '@/core/constants/cron.constants';
+import { DeletePersonHandler } from '@/application/person/delete/delete-person.handler';
+import { ReadManyPersonHandler } from '@/application/person/read-many/read-many-person.handler';
+import { ReadManyPersonRequest } from '@/application/person/read-many/read-many-person.request';
+import {
+  CronJobHandlerBase,
+  CronJobSettings,
+  cronJobSettings,
+} from '@/core/background-services/cron-service/cron-job.handler.base';
+import { ILoggingService } from '@/domain/common/ilogging.service';
+import { IRedLockService } from '@/domain/common/ired-lock.service';
+import { Injectable, Logger } from '@nestjs/common';
+
+@Injectable()
+export class DeleteInactiveJob extends CronJobHandlerBase {
+  private readonly logger = new Logger(DeleteInactiveJob.name);
+
+  constructor(
+    redlockService: IRedLockService,
+    loggingService: ILoggingService,
+    private readonly readManyPerson: ReadManyPersonHandler,
+    private readonly deletePerson: DeletePersonHandler,
+  ) {
+    super(redlockService, loggingService);
+  }
+
+  protected settings(): Promise<CronJobSettings> {
+    return Promise.resolve(cronJobSettings(CronExpression.EVERY_15_SECONDS));
+  }
+
+  protected async run(): Promise<void> {
+    this.logger.debug('Iniciando remoção de pessoas inativas...');
+
+    const request = new ReadManyPersonRequest();
+    request.active = false;
+
+    const result = await this.readManyPerson.handle(request);
+
+    if (result.items.length === 0) {
+      this.logger.log('Nenhuma pessoa inativa encontrada.');
+      this.logger.log('Job concluído sem ação.');
+      return;
+    }
+
+    this.logger.debug('Removendo pessoas inativas...', result.items.length);
+
+    for (const person of result.items) {
+      await this.deletePerson.handle(person.id);
+    }
+
+    this.logger.log(
+      'Pessoas inativas removidas com sucesso.',
+      result.items.length,
+    );
+    this.logger.log('Job concluído.');
+  }
+}

package/koala-nest/src/application/person/jobs/events/person/inactive-person/inactive-person.event.ts

@@ -0,0 +1,4 @@
+import { EventClass } from '@/core/background-services/event-service/event-class';
+import { Person } from '@/domain/entities/person/person';
+
+export class InactivePersonEvent extends EventClass<Person> {}

package/koala-nest/src/application/person/jobs/events/person/inactive-person/inactive-person.handler.ts

@@ -0,0 +1,54 @@
+import { PersonQueryDto } from '@/domain/dtos/person-query.dto';
+import { IPersonRepository } from '@/domain/repositories/iperson.repository';
+import { ICacheService } from '@/domain/common/icache.service';
+import { invalidatePersonListCache } from '@/core/utils/person-list-cache';
+import { EventHandlerBase } from '@/core/background-services/event-service/event-handler.base';
+import { Injectable, Logger } from '@nestjs/common';
+import { InactivePersonEvent } from './inactive-person.event';
+
+@Injectable()
+export class InactivePersonHandler extends EventHandlerBase<InactivePersonEvent> {
+  private readonly logger = new Logger(InactivePersonHandler.name);
+
+  constructor(
+    private readonly repository: IPersonRepository,
+    private readonly cache: ICacheService,
+  ) {
+    super(InactivePersonEvent);
+  }
+
+  async handleEvent(_event: InactivePersonEvent): Promise<void> {
+    try {
+      this.logger.log('Recebido evento de inativação de pessoas.');
+      this.logger.debug('Iniciando inativação de pessoas ativas...');
+
+      const query = new PersonQueryDto();
+      query.active = true;
+      query.limit = 1000;
+      query.page = 0;
+
+      const { items } = await this.repository.findMany(query);
+
+      if (items.length === 0) {
+        this.logger.log('Nenhuma pessoa ativa encontrada.');
+        return;
+      }
+
+      this.logger.debug('Inativando pessoas ativas...', items.length);
+
+      for (const person of items) {
+        person.active = false;
+        await this.repository.save(person);
+      }
+
+      await invalidatePersonListCache(this.cache);
+
+      this.logger.log('Pessoas inativadas com sucesso.', items.length);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+
+      this.logger.error(`Erro ao processar evento de inativação: ${message}`);
+      throw error;
+    }
+  }
+}

package/koala-nest/src/application/person/jobs/events/person/person-event.job.ts

@@ -0,0 +1,19 @@
+import { Person } from '@/domain/entities/person/person';
+import { EventHandlerBase } from '@/core/background-services/event-service/event-handler.base';
+import { EventJob } from '@/core/background-services/event-service/event-job';
+import { Type } from '@nestjs/common';
+import { InactivePersonHandler } from './inactive-person/inactive-person.handler';
+
+/**
+ * Agregado de eventos do domínio Person.
+ *
+ * `defineHandlers()` é usado pelo `EventQueue` no dispatch para rotear cada
+ * evento ao handler correto. Os handlers também precisam estar em
+ * `JobsModule.register({ eventHandlers })` para o Nest instanciá-los e chamar
+ * `setupSubscriptions()`.
+ */
+export class PersonEventJob extends EventJob<Person> {
+  defineHandlers(): Type<EventHandlerBase>[] {
+    return [InactivePersonHandler];
+  }
+}

package/koala-nest/src/application/person/person.schemas.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+
+export const personAddressSchema = (withId = false) =>
+  z.object({
+    ...(withId ? { id: z.number().positive() } : {}),
+    address: z.string().min(1),
+  });
+
+export const personContactSchema = (withId = false) =>
+  z.object({
+    ...(withId ? { id: z.number().positive().optional() } : {}),
+    contact: z.string().min(1),
+  });
+
+export const personBodySchema = (withId = false) =>
+  z.object({
+    ...(withId ? { id: z.number().positive() } : {}),
+    name: z.string().min(1),
+    address: personAddressSchema(withId),
+    contacts: z.array(personContactSchema(withId)),
+  });

package/koala-nest/src/application/person/read/read-person.handler.ts

@@ -0,0 +1,22 @@
+import { RequestHandlerBase } from '@/application/common/request-handler.base';
+import { findPersonOrThrow } from '@/application/person/find-person-or-throw';
+import { AutoMapper } from '@/core/tools/mapping';
+import { Person } from '@/domain/entities/person/person';
+import { IPersonRepository } from '@/domain/repositories/iperson.repository';
+import { Injectable } from '@nestjs/common';
+import { ReadPersonResponse } from './read-person.response';
+
+@Injectable()
+export class ReadPersonHandler extends RequestHandlerBase<
+  number,
+  ReadPersonResponse
+> {
+  constructor(private readonly repository: IPersonRepository) {
+    super();
+  }
+
+  async handle(id: number): Promise<ReadPersonResponse> {
+    const person = await findPersonOrThrow(this.repository, id);
+    return AutoMapper.map(person, Person, ReadPersonResponse);
+  }
+}

package/koala-nest/src/application/person/read/read-person.response.ts

@@ -0,0 +1,44 @@
+import { AutoMap } from '@/core/tools/mapping';
+import { ApiProperty } from '@nestjs/swagger';
+
+export class ReadPersonAddressResponse {
+  @ApiProperty({ example: 1 })
+  @AutoMap()
+  id: number;
+
+  @ApiProperty({ example: '123 Main St' })
+  @AutoMap()
+  address: string;
+}
+
+export class ReadPersonContactResponse {
+  @ApiProperty({ example: 1 })
+  @AutoMap()
+  id: number;
+
+  @ApiProperty({ example: 'john.doe@example.com' })
+  @AutoMap()
+  contact: string;
+}
+
+export class ReadPersonResponse {
+  @ApiProperty({ example: 1 })
+  @AutoMap()
+  id: number;
+
+  @ApiProperty({ example: 'John Doe' })
+  @AutoMap()
+  name: string;
+
+  @ApiProperty({ example: true })
+  @AutoMap()
+  active: boolean;
+
+  @ApiProperty({ type: () => ReadPersonAddressResponse })
+  @AutoMap()
+  address: ReadPersonAddressResponse;
+
+  @ApiProperty({ type: () => ReadPersonContactResponse, isArray: true })
+  @AutoMap({ type: () => ReadPersonContactResponse })
+  contacts: ReadPersonContactResponse[];
+}

package/koala-nest/src/application/person/read-many/read-many-person.handler.ts

@@ -0,0 +1,63 @@
+import { CacheTtlSeconds } from '@/core/constants/cache.constants';
+import { RequestHandlerBase } from '@/application/common/request-handler.base';
+import { AutoMapper } from '@/core/tools/mapping';
+import { buildListCacheKey } from '@/core/utils/build-list-cache-key';
+import { PERSON_LIST_CACHE_PREFIX } from '@/core/utils/person-list-cache';
+import { ICacheService } from '@/domain/common/icache.service';
+import { PersonQueryDto } from '@/domain/dtos/person-query.dto';
+import { IPersonRepository } from '@/domain/repositories/iperson.repository';
+import { Injectable } from '@nestjs/common';
+import { ReadManyPersonRequest } from './read-many-person.request';
+import {
+  ReadManyPersonResponse,
+  ReadManyPersonResponseItem,
+} from './read-many-person.response';
+import { ReadManyPersonValidator } from './read-many-person.validator';
+import { Person } from '@/domain/entities/person/person';
+
+const PERSON_LIST_CACHE_TTL_SECONDS = CacheTtlSeconds.PERSON_LIST;
+
+@Injectable()
+export class ReadManyPersonHandler extends RequestHandlerBase<
+  ReadManyPersonRequest,
+  ReadManyPersonResponse
+> {
+  constructor(
+    private readonly repository: IPersonRepository,
+    private readonly cache: ICacheService,
+  ) {
+    super();
+  }
+
+  async handle(req: ReadManyPersonRequest): Promise<ReadManyPersonResponse> {
+    const query = AutoMapper.map(
+      new ReadManyPersonValidator(req).validate(),
+      ReadManyPersonRequest,
+      PersonQueryDto,
+    );
+
+    const cacheKey = buildListCacheKey(PERSON_LIST_CACHE_PREFIX, query);
+    const cached = await this.cache.get(cacheKey);
+
+    if (cached) {
+      return ReadManyPersonResponse.from(JSON.parse(cached));
+    }
+
+    const response = ReadManyPersonResponse.from(
+      await this.repository.findMany(query).then((result) => ({
+        items: result.items.map((item) =>
+          AutoMapper.map(item, Person, ReadManyPersonResponseItem),
+        ),
+        count: result.count,
+      })),
+    );
+
+    await this.cache.set(
+      cacheKey,
+      JSON.stringify(response),
+      PERSON_LIST_CACHE_TTL_SECONDS,
+    );
+
+    return response;
+  }
+}

package/koala-nest/src/application/person/read-many/read-many-person.request.ts

@@ -0,0 +1,13 @@
+import { PaginationRequest } from '@/application/common/pagination.request';
+import { AutoMap } from '@/core/tools/mapping';
+import { ApiProperty } from '@nestjs/swagger';
+
+export class ReadManyPersonRequest extends PaginationRequest {
+  @ApiProperty({ required: false })
+  @AutoMap()
+  name?: string;
+
+  @ApiProperty({ required: false })
+  @AutoMap()
+  active?: boolean;
+}

package/koala-nest/src/application/person/read-many/read-many-person.response.ts

@@ -0,0 +1,30 @@
+import { ObjectClass } from '@/core/base/object-class';
+import { AutoMap } from '@/core/tools/mapping';
+import { ListResponse } from '@/core/types';
+import { ApiProperty } from '@nestjs/swagger';
+
+export class ReadManyPersonResponseItem {
+  @ApiProperty()
+  @AutoMap()
+  id: number;
+
+  @ApiProperty()
+  @AutoMap()
+  name: string;
+
+  @ApiProperty()
+  @AutoMap()
+  active: boolean;
+}
+
+export class ReadManyPersonResponse extends ObjectClass<
+  ListResponse<ReadManyPersonResponseItem>
+> {
+  @ApiProperty({ type: [ReadManyPersonResponseItem] })
+  @AutoMap({ type: () => ReadManyPersonResponseItem })
+  items: ReadManyPersonResponseItem[];
+
+  @ApiProperty()
+  @AutoMap()
+  count: number;
+}

package/koala-nest/src/application/person/read-many/read-many-person.validator.ts

@@ -0,0 +1,15 @@
+import { RequestValidatorBase } from '@/application/common/request-validator.base';
+import { booleanSchema, LIST_QUERY_SCHEMA } from '@/core/schemas';
+import { z } from 'zod';
+import { ReadManyPersonRequest } from './read-many-person.request';
+
+export class ReadManyPersonValidator extends RequestValidatorBase<ReadManyPersonRequest> {
+  protected get schema() {
+    return LIST_QUERY_SCHEMA.and(
+      z.object({
+        name: z.string().optional().nullable(),
+        active: booleanSchema(),
+      }),
+    );
+  }
+}

package/koala-nest/src/application/person/update/update-person.handler.ts

@@ -0,0 +1,51 @@
+import { RequestHandlerBase } from '@/application/common/request-handler.base';
+import { findPersonOrThrow } from '@/application/person/find-person-or-throw';
+import { PersonContact } from '@/domain/entities/person/person-contact';
+import { IPersonRepository } from '@/domain/repositories/iperson.repository';
+import { Injectable } from '@nestjs/common';
+import { UpdatePersonRequest } from './update-person.request';
+import { UpdatePersonValidator } from './update-person.validator';
+import { ICacheService } from '@/domain/common/icache.service';
+import { invalidatePersonListCache } from '@/core/utils/person-list-cache';
+
+@Injectable()
+export class UpdatePersonHandler extends RequestHandlerBase<
+  UpdatePersonRequest,
+  void
+> {
+  constructor(
+    private readonly repository: IPersonRepository,
+    private readonly cache: ICacheService,
+  ) {
+    super();
+  }
+
+  async handle(request: UpdatePersonRequest): Promise<void> {
+    const validated = new UpdatePersonValidator(request).validate();
+    const person = await findPersonOrThrow(this.repository, validated.id);
+
+    person.name = validated.name;
+    person.address.address = validated.address.address;
+
+    person.contacts = validated.contacts.map((contactRequest) => {
+      if (contactRequest.id) {
+        const existing = person.contacts.find(
+          (contact) => contact.id === contactRequest.id,
+        );
+
+        if (existing) {
+          existing.contact = contactRequest.contact;
+          return existing;
+        }
+      }
+
+      const contact = new PersonContact();
+      contact.contact = contactRequest.contact;
+      contact.person = person;
+      return contact;
+    });
+
+    await this.repository.save(person);
+    await invalidatePersonListCache(this.cache);
+  }
+}

package/koala-nest/src/application/person/update/update-person.request.ts

@@ -0,0 +1,41 @@
+import { ObjectClass } from '@/core/base/object-class';
+import { AutoMap } from '@/core/tools/mapping';
+import { ApiProperty } from '@nestjs/swagger';
+
+export class UpdatePersonAddressRequest extends ObjectClass<UpdatePersonAddressRequest> {
+  @ApiProperty({ example: 1 })
+  @AutoMap()
+  id: number;
+
+  @ApiProperty({ example: '123 Main St' })
+  @AutoMap()
+  address: string;
+}
+
+export class UpdatePersonContactRequest extends ObjectClass<UpdatePersonContactRequest> {
+  @ApiProperty({ example: 1 })
+  @AutoMap()
+  id: number;
+
+  @ApiProperty({ example: 'john.doe@example.com' })
+  @AutoMap()
+  contact: string;
+}
+
+export class UpdatePersonRequest extends ObjectClass<UpdatePersonRequest> {
+  @ApiProperty({ example: 1 })
+  @AutoMap()
+  id: number;
+
+  @ApiProperty({ example: 'John Doe' })
+  @AutoMap()
+  name: string;
+
+  @ApiProperty({ type: () => UpdatePersonAddressRequest })
+  @AutoMap()
+  address: UpdatePersonAddressRequest;
+
+  @ApiProperty({ type: () => UpdatePersonContactRequest, isArray: true })
+  @AutoMap({ type: () => UpdatePersonContactRequest })
+  contacts: UpdatePersonContactRequest[];
+}

package/koala-nest/src/application/person/update/update-person.validator.ts

@@ -0,0 +1,9 @@
+import { RequestValidatorBase } from '@/application/common/request-validator.base';
+import { personBodySchema } from '@/application/person/person.schemas';
+import { UpdatePersonRequest } from './update-person.request';
+
+export class UpdatePersonValidator extends RequestValidatorBase<UpdatePersonRequest> {
+  protected get schema() {
+    return personBodySchema(true);
+  }
+}

package/koala-nest/src/core/auth/assert-user-active.ts

@@ -0,0 +1,18 @@
+import { UserStatus } from '@/domain/entities/user/enums/user-status.enum';
+import { ForbiddenException } from '@nestjs/common';
+
+type UserWithStatus = { status: UserStatus };
+
+export function assertUserIsActive(user: UserWithStatus): void {
+  if (user.status === UserStatus.inactive) {
+    throw new ForbiddenException('User is inactive');
+  }
+
+  if (user.status === UserStatus.blocked) {
+    throw new ForbiddenException('User is blocked');
+  }
+
+  if (user.status === UserStatus.pending) {
+    throw new ForbiddenException('User is pending');
+  }
+}

package/koala-nest/src/core/auth/auth-profile.enum.ts

@@ -0,0 +1,7 @@
+/**
+ * Perfis de exemplo — substitua ou estenda conforme o domínio do seu projeto.
+ */
+export enum AuthProfile {
+  user = 'user',
+  admin = 'admin',
+}

package/koala-nest/src/core/auth/auth-routes.ts

@@ -0,0 +1,5 @@
+export const AUTH_REFRESH_ROUTE_SUFFIX = '/auth/refresh';
+
+export function isAuthRefreshRoute(url?: string): boolean {
+  return url?.includes(AUTH_REFRESH_ROUTE_SUFFIX) ?? false;
+}

package/koala-nest/src/core/auth/auth.constants.ts

@@ -0,0 +1,6 @@
+/** Valores usados na camada HTTP de autenticação. */
+export const AuthHttp = {
+  BEARER_PREFIX: 'Bearer ',
+  REFRESH_TOKEN_COOKIE: 'refreshToken',
+  JWT_ALGORITHM: 'RS256',
+} as const;

package/koala-nest/src/core/auth/jwt-claims.ts

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import { AuthProfile } from './auth-profile.enum';
+
+export const jwtClaimsSchema = z.object({
+  sub: z.string().min(1),
+});
+
+export type JwtClaims = z.infer<typeof jwtClaimsSchema>;
+
+export const jwtPayloadSchema = jwtClaimsSchema.extend({
+  exp: z.number().optional(),
+  iat: z.number().optional(),
+});
+
+export type JwtPayload = z.infer<typeof jwtPayloadSchema>;
+
+export type AuthenticatedUser = JwtClaims & {
+  name?: string;
+  profile?: AuthProfile;
+  login?: string;
+  email?: string;
+  refreshToken?: string;
+};

package/koala-nest/src/core/auth/oauth-provider.registry.ts

@@ -0,0 +1,94 @@
+import { EnvService } from '@/infra/common/env.service';
+import { Injectable, NotFoundException } from '@nestjs/common';
+
+export interface OAuthProviderEnvConfig {
+  key: string;
+  domain?: string;
+  clientId: string;
+  clientSecret: string;
+  scope: string;
+  redirectPath?: string;
+  authorizationUrl?: string;
+  tokenUrl?: string;
+  userInfoUrl?: string;
+}
+
+/**
+ * Registry genérico de provedores OAuth2.
+ *
+ * Suporta **qualquer quantidade** de providers em `OAUTH2_PROVIDERS` (lista separada por vírgula).
+ * Para cada CHAVE, configure `OAUTH2_{CHAVE}_*` — google/microsoft no `.env.example` são só exemplos.
+ *
+ * Provedor OIDC (terceiro): `OAUTH2_{CHAVE}_DOMAIN` → discovery automático.
+ * Servidor OAuth próprio: `_AUTHORIZATION_URL`, `_TOKEN_URL`, `_USERINFO_URL` (sem `_DOMAIN`).
+ */
+@Injectable()
+export class OAuthProviderRegistry {
+  constructor(private readonly env: EnvService) {}
+
+  listProviders(): string[] {
+    const raw = this.env.get('OAUTH2_PROVIDERS');
+
+    if (!raw) {
+      return [];
+    }
+
+    return raw
+      .split(',')
+      .map((item) => item.trim().toLowerCase())
+      .filter(Boolean);
+  }
+
+  listConfiguredProviders(): string[] {
+    return this.listProviders().filter((key) => {
+      try {
+        this.getProvider(key);
+        return true;
+      } catch {
+        return false;
+      }
+    });
+  }
+
+  getProvider(key: string): OAuthProviderEnvConfig {
+    const normalizedKey = key.trim().toLowerCase();
+    const entry = this.env.get('OAUTH2_PROVIDER_ENV')[normalizedKey];
+    const domain = entry?.domain;
+    const clientId = entry?.clientId;
+    const clientSecret = entry?.clientSecret;
+    const scope = entry?.scope;
+    const redirectPath = entry?.redirectPath;
+    const authorizationUrl = entry?.authorizationUrl;
+    const tokenUrl = entry?.tokenUrl;
+    const userInfoUrl = entry?.userInfoUrl;
+
+    const hasManualEndpoints = authorizationUrl && tokenUrl && userInfoUrl;
+    const hasDiscoveryDomain = Boolean(domain);
+
+    if (!clientId || !clientSecret || !scope) {
+      const prefix = `OAUTH2_${normalizedKey.toUpperCase()}`;
+      throw new NotFoundException(
+        `Provedor OAuth2 "${normalizedKey}" não configurado. Verifique variáveis ${prefix}_* no .env`,
+      );
+    }
+
+    if (!hasManualEndpoints && !hasDiscoveryDomain) {
+      const prefix = `OAUTH2_${normalizedKey.toUpperCase()}`;
+      throw new NotFoundException(
+        `Provedor OAuth2 "${normalizedKey}" incompleto. Defina ${prefix}_DOMAIN (OIDC) ou ${prefix}_AUTHORIZATION_URL, ${prefix}_TOKEN_URL e ${prefix}_USERINFO_URL`,
+      );
+    }
+
+    return {
+      key: normalizedKey,
+      domain,
+      clientId,
+      clientSecret,
+      scope,
+      redirectPath: redirectPath ?? '/sso/callback',
+      authorizationUrl,
+      tokenUrl,
+      userInfoUrl,
+    };
+  }
+}