@hed-hog/core 0.0.295 → 0.0.297

package/src/integration/services/outbox.service.ts

@@ -0,0 +1,209 @@
+import { PrismaService } from '@hed-hog/api-prisma';
+import { Injectable } from '@nestjs/common';
+import { OutboxEvent, OutboxEventStatus } from '../types';
+
+export interface CreateOutboxEventDto {
+  eventName: string;
+  sourceModule: string;
+  aggregateType: string;
+  aggregateId: string;
+  payload: Record<string, any>;
+}
+
+export interface OutboxEventPersistenceClient {
+  outbox_event: PrismaService['outbox_event'];
+}
+
+interface OutboxEventRecord {
+  id: number;
+  event_name: string;
+  source_module: string;
+  aggregate_type: string;
+  aggregate_id: string;
+  payload: Record<string, any>;
+  status: OutboxEventStatus;
+  attempt_count: number;
+  last_error: string | null;
+  available_at: Date;
+  processed_at: Date | null;
+  created_at: Date;
+  updated_at: Date;
+}
+
+@Injectable()
+export class OutboxService {
+  constructor(private readonly prisma: PrismaService) {}
+
+  private toDomainEvent(record: OutboxEventRecord): OutboxEvent {
+    return {
+      id: String(record.id),
+      eventName: record.event_name,
+      sourceModule: record.source_module,
+      aggregateType: record.aggregate_type,
+      aggregateId: record.aggregate_id,
+      payload: record.payload,
+      status: record.status,
+      attemptCount: record.attempt_count,
+      lastError: record.last_error,
+      availableAt: record.available_at,
+      processedAt: record.processed_at,
+      createdAt: record.created_at,
+      updatedAt: record.updated_at,
+    };
+  }
+
+  private toDatabaseId(eventId: string | number): number {
+    return typeof eventId === 'number' ? eventId : Number(eventId);
+  }
+
+  private toDatabaseUpdate(
+    partialUpdate?: {
+      attemptCount?: number;
+      lastError?: string | null;
+      availableAt?: Date;
+      processedAt?: Date | null;
+    },
+  ) {
+    if (!partialUpdate) {
+      return undefined;
+    }
+
+    return {
+      attempt_count: partialUpdate.attemptCount,
+      last_error: partialUpdate.lastError,
+      available_at: partialUpdate.availableAt,
+      processed_at: partialUpdate.processedAt,
+    };
+  }
+
+  /**
+   * Write a new event to the outbox
+   */
+  async createEvent(
+    dto: CreateOutboxEventDto,
+    persistenceClient?: OutboxEventPersistenceClient,
+  ): Promise<OutboxEvent> {
+    const client = persistenceClient ?? this.prisma;
+
+    const record = await client.outbox_event.create({
+      data: {
+        event_name: dto.eventName,
+        source_module: dto.sourceModule,
+        aggregate_type: dto.aggregateType,
+        aggregate_id: dto.aggregateId,
+        payload: dto.payload,
+        status: OutboxEventStatus.PENDING,
+        available_at: new Date(),
+        attempt_count: 0,
+      },
+    });
+
+    return this.toDomainEvent(record as OutboxEventRecord);
+  }
+
+  /**
+   * Find pending events available for processing, ordered by creation time
+   */
+  async findPending(
+    limit: number,
+    leaseMs: number,
+  ): Promise<OutboxEvent[]> {
+    const now = new Date();
+    const leaseThreshold = new Date(now.getTime() - leaseMs);
+
+    const records = await this.prisma.outbox_event.findMany({
+      where: {
+        OR: [
+          { status: OutboxEventStatus.PENDING },
+          {
+            status: OutboxEventStatus.PROCESSING,
+            available_at: { lte: leaseThreshold },
+          },
+        ],
+      },
+      orderBy: { created_at: 'asc' },
+      take: limit,
+    });
+
+    return records.map((record) => this.toDomainEvent(record as OutboxEventRecord));
+  }
+
+  /**
+   * Update event status and related fields
+   */
+  async updateStatus(
+    eventId: string | number,
+    status: OutboxEventStatus,
+    partialUpdate?: {
+      attemptCount?: number;
+      lastError?: string | null;
+      availableAt?: Date;
+      processedAt?: Date | null;
+    },
+  ): Promise<OutboxEvent> {
+    const record = await this.prisma.outbox_event.update({
+      where: { id: this.toDatabaseId(eventId) },
+      data: {
+        status,
+        ...this.toDatabaseUpdate(partialUpdate),
+      },
+    });
+
+    return this.toDomainEvent(record as OutboxEventRecord);
+  }
+
+  /**
+   * Mark event as processing and set lease time
+   */
+  async markProcessing(
+    eventId: string | number,
+    leaseMs: number,
+  ): Promise<OutboxEvent> {
+    const leaseUntil = new Date(Date.now() + leaseMs);
+    return this.updateStatus(eventId, OutboxEventStatus.PROCESSING, {
+      availableAt: leaseUntil,
+    });
+  }
+
+  /**
+   * Increment attempt count and optionally update error
+   */
+  async incrementAttempt(
+    eventId: string | number,
+    error?: string,
+  ): Promise<OutboxEvent> {
+    const record = await this.prisma.outbox_event.findUnique({
+      where: { id: this.toDatabaseId(eventId) },
+    });
+    if (!record) {
+      throw new Error(`Event ${eventId} not found`);
+    }
+
+    const event = this.toDomainEvent(record as OutboxEventRecord);
+
+    return this.updateStatus(eventId, event.status, {
+      attemptCount: event.attemptCount + 1,
+      lastError: error || null,
+    });
+  }
+
+  /**
+   * Get event by ID
+   */
+  async getById(eventId: string | number): Promise<OutboxEvent | null> {
+    const record = await this.prisma.outbox_event.findUnique({
+      where: { id: this.toDatabaseId(eventId) },
+    });
+
+    return record ? this.toDomainEvent(record as OutboxEventRecord) : null;
+  }
+
+  /**
+   * Count events by status
+   */
+  async countByStatus(status: OutboxEventStatus): Promise<number> {
+    return this.prisma.outbox_event.count({
+      where: { status },
+    });
+  }
+}

package/src/integration/types/event.types.ts

@@ -0,0 +1,93 @@
+/**
+ * Event status throughout the integration lifecycle
+ */
+export enum OutboxEventStatus {
+  PENDING = 'pending',
+  PROCESSING = 'processing',
+  PROCESSED = 'processed',
+  FAILED = 'failed',
+  DEAD_LETTER = 'dead_letter',
+}
+
+/**
+ * Inbox event processing status per consumer
+ */
+export enum InboxEventStatus {
+  RECEIVED = 'received',
+  PROCESSING = 'processing',
+  PROCESSED = 'processed',
+  FAILED = 'failed',
+  SKIPPED = 'skipped',
+}
+
+/**
+ * Type of link between entities from different modules
+ */
+export enum LinkType {
+  REFERENCE = 'reference',
+  CASCADE = 'cascade',
+  AGGREGATE_ROOT = 'aggregate_root',
+}
+
+/**
+ * Domain event interface that is published and processed
+ */
+export interface DomainEvent {
+  eventName: string;
+  sourceModule: string;
+  aggregateType: string;
+  aggregateId: string;
+  payload: Record<string, any>;
+  timestamp: Date;
+}
+
+/**
+ * Outbox event record from database
+ */
+export interface OutboxEvent {
+  id: string;
+  eventName: string;
+  sourceModule: string;
+  aggregateType: string;
+  aggregateId: string;
+  payload: Record<string, any>;
+  status: OutboxEventStatus;
+  attemptCount: number;
+  lastError: string | null;
+  availableAt: Date;
+  processedAt: Date | null;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+/**
+ * Inbox event record from database for idempotency tracking
+ */
+export interface InboxEvent {
+  id: string;
+  outboxEventId: string;
+  consumerName: string;
+  status: InboxEventStatus;
+  attemptCount: number;
+  lastError: string | null;
+  processedAt: Date | null;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+/**
+ * Integration link between entities across modules
+ */
+export interface IntegrationLink {
+  id: string;
+  sourceModule: string;
+  sourceEntityType: string;
+  sourceEntityId: string;
+  targetModule: string;
+  targetEntityType: string;
+  targetEntityId: string;
+  linkType: LinkType;
+  metadata: Record<string, any> | null;
+  createdAt: Date;
+  updatedAt: Date;
+}

package/src/integration/types/index.ts

@@ -0,0 +1,3 @@
+export * from './event.types';
+export * from './subscriber.types';
+

package/src/integration/types/subscriber.types.ts

@@ -0,0 +1,37 @@
+import { Logger } from '@nestjs/common';
+import { DomainEvent } from './event.types';
+
+/**
+ * Context passed to event handlers
+ */
+export interface SubscriberContext {
+  logger: Logger;
+  inboxService: any; // To be injected at runtime
+  linkService: any; // To be injected at runtime
+}
+
+/**
+ * Event handler function signature
+ */
+export type EventHandler = (
+  event: DomainEvent,
+  context: SubscriberContext,
+) => Promise<void>;
+
+/**
+ * Event subscriber definition
+ */
+export interface SubscriberDefinition {
+  eventName: string;
+  consumerName: string;
+  priority?: number;
+  handler: EventHandler;
+}
+
+/**
+ * Subscription registry entry
+ */
+export interface SubscriptionEntry {
+  definition: SubscriberDefinition;
+  handler: EventHandler;
+}

package/src/oauth/oauth.controller.ts

@@ -1,17 +1,17 @@
 
 import { Public, User } from '@hed-hog/api';
 import { Locale } from '@hed-hog/api-locale';
-import { user_account_provider_enum } from '@hed-hog/api-prisma';
+import { user_account_provider_52222e2ecb_enum } from '@hed-hog/api-prisma';
 import {
-  Body,
-  Controller,
-  Delete,
-  Get,
-  Headers,
-  Ip,
-  Param,
-  Query,
-  Res,
+    Body,
+    Controller,
+    Delete,
+    Get,
+    Headers,
+    Ip,
+    Param,
+    Query,
+    Res,
 } from '@nestjs/common';
 import { SettingService } from '../setting/setting.service';
 import { OAuthService } from './oauth.service';
@@ -37,7 +37,7 @@ export class OAuthController {
   @Get(':provider/login')
   async login(@Param('provider') provider: string, @Res() res) {
     const url = await this.service.getAuthUrl(
-      provider as user_account_provider_enum,
+      provider as user_account_provider_52222e2ecb_enum,
       `/callback/${provider}/login`,
     );
     return res.redirect(url);
@@ -48,7 +48,7 @@ export class OAuthController {
   @Get(':provider/register')
   async register(@Param('provider') provider: string, @Res() res) {
     const url = await this.service.getAuthUrl(
-      provider as user_account_provider_enum,
+      provider as user_account_provider_52222e2ecb_enum,
       `/callback/${provider}/register`,
     );
     return res.redirect(url);
@@ -59,7 +59,7 @@ export class OAuthController {
   @Get(':provider/connect')
   async connect(@Param('provider') provider: string, @Res() res) {
     const url = this.service.getAuthUrl(
-      provider as user_account_provider_enum,
+      provider as user_account_provider_52222e2ecb_enum,
       `/callback/${provider}/connect`,
     );
     return res.redirect(url);
@@ -76,7 +76,7 @@ export class OAuthController {
     @Query('code') code: string,
     @Res({ passthrough: true }) res,
   ) {
-    return this.service.handleCallback({ res, locale, ipAddress, userAgent, provider: provider as user_account_provider_enum, code, type: 'login' });
+    return this.service.handleCallback({ res, locale, ipAddress, userAgent, provider: provider as user_account_provider_52222e2ecb_enum, code, type: 'login' });
   }
 
 
@@ -90,7 +90,7 @@ export class OAuthController {
     @Query('code') code: string,
     @Res({ passthrough: true }) res,
   ) {
-    return this.service.handleCallback({ res, locale, ipAddress, userAgent, provider: provider as user_account_provider_enum, code, type: 'register' });
+    return this.service.handleCallback({ res, locale, ipAddress, userAgent, provider: provider as user_account_provider_52222e2ecb_enum, code, type: 'register' });
   }
 
 
@@ -104,7 +104,7 @@ export class OAuthController {
     @Query('code') code: string,
     @Res({ passthrough: true }) res,
   ) {
-    return this.service.handleCallback({ res, locale, ipAddress, userAgent, provider: provider as user_account_provider_enum, code, type: 'connect', userId: id });
+    return this.service.handleCallback({ res, locale, ipAddress, userAgent, provider: provider as user_account_provider_52222e2ecb_enum, code, type: 'connect', userId: id });
   }
 
 
@@ -117,6 +117,6 @@ export class OAuthController {
     @Body('email') email: string,
     @Res({ passthrough: true }) res,
   ) {
-    return this.service.handleCallback({ res, locale, ipAddress, userAgent, provider: provider as user_account_provider_enum, email, type: 'disconnect' });
+    return this.service.handleCallback({ res, locale, ipAddress, userAgent, provider: provider as user_account_provider_52222e2ecb_enum, email, type: 'disconnect' });
   }
 }

package/src/oauth/oauth.service.ts

@@ -1,11 +1,11 @@
-import { PrismaService, user_account_provider_enum } from '@hed-hog/api-prisma';
+import { PrismaService, user_account_provider_52222e2ecb_enum } from '@hed-hog/api-prisma';
 import {
-  BadRequestException,
-  ConflictException,
-  Inject,
-  Injectable,
-  NotFoundException,
-  forwardRef
+    BadRequestException,
+    ConflictException,
+    Inject,
+    Injectable,
+    NotFoundException,
+    forwardRef
 } from '@nestjs/common';
 import { AuthService } from '../auth/auth.service';
 import { FileService } from '../file/file.service';
@@ -26,7 +26,7 @@ type HandleCallbackProps = {
   ipAddress: string; 
   userAgent: string;
   res: Response;
-  provider: user_account_provider_enum;
+  provider: user_account_provider_52222e2ecb_enum;
   code?: string;
   type: 'login' | 'register' | 'connect' | 'disconnect';
   userId?: number;
@@ -61,7 +61,7 @@ export class OAuthService {
     this.providers.set(microsoftEntraId.getProviderType(), microsoftEntraId);
   }
 
-  getAuthUrl(provider: user_account_provider_enum, callbackPath: string) {
+  getAuthUrl(provider: user_account_provider_52222e2ecb_enum, callbackPath: string) {
     return this.getProvider(provider).getAuthUrl(callbackPath);
   }
 
@@ -96,14 +96,14 @@ export class OAuthService {
     }
   }
 
-  private getProvider(provider: user_account_provider_enum) {
+  private getProvider(provider: user_account_provider_52222e2ecb_enum) {
     const prov = this.providers.get(String(provider).toUpperCase());
     if (!prov)
       throw new BadRequestException(`Provider ${provider} não suportado`);
     return prov;
   }
 
-  private async getProviderScopes(provider: user_account_provider_enum) {
+  private async getProviderScopes(provider: user_account_provider_52222e2ecb_enum) {
     const settingKey = `${String(provider).toLowerCase().replace(/-/g, '_')}_scopes`;
 
     const settings = await this.setting.getSettingValues([
@@ -118,13 +118,13 @@ export class OAuthService {
     return settings[settingKey].join(',') || '';
   }
 
-  private async handleLogin(res: Response, locale: string, ipAddress: string, userAgent: string, provider: user_account_provider_enum, profile: any) {
+  private async handleLogin(res: Response, locale: string, ipAddress: string, userAgent: string, provider: user_account_provider_52222e2ecb_enum, profile: any) {
 
     console.log('[OAuthService] Handling login for provider:', provider);
 
     const userAccount = await this.prisma.user_account.findFirst({
       where: {
-        provider: String(provider).toLowerCase().replace(/-/g, '_') as user_account_provider_enum,
+        provider: String(provider).toLowerCase().replace(/-/g, '_') as user_account_provider_52222e2ecb_enum,
         email: profile.email,
       },
       include: {
@@ -177,7 +177,7 @@ export class OAuthService {
     }
   }
 
-  private async handleRegister(res: Response, locale: string, ipAddress: string, userAgent: string, provider: user_account_provider_enum, profile: any) {
+  private async handleRegister(res: Response, locale: string, ipAddress: string, userAgent: string, provider: user_account_provider_52222e2ecb_enum, profile: any) {
     const existingUser = await this.prisma.user_identifier.findFirst({
       where: {
         type: 'email',
@@ -223,7 +223,7 @@ export class OAuthService {
         },
         user_account: {
           create: {
-            provider: String(provider).toLowerCase().replace(/-/g, '_') as user_account_provider_enum,
+            provider: String(provider).toLowerCase().replace(/-/g, '_') as user_account_provider_52222e2ecb_enum,
             provider_user_id: profile.id,
             email: profile.email,
             refresh_token: encryptedRefreshToken ? Buffer.from(encryptedRefreshToken) : null,
@@ -272,14 +272,14 @@ export class OAuthService {
     locale: string, 
     ipAddress: string, 
     userAgent: string,
-    provider: user_account_provider_enum,
+    provider: user_account_provider_52222e2ecb_enum,
     profile: any,
     userId: number,
   ) {
     const existingAccount = await this.prisma.user_account.findFirst({
       where: {
         user_id: userId,
-        provider: String(provider).toLowerCase().replace(/-/g, '_') as user_account_provider_enum,
+        provider: String(provider).toLowerCase().replace(/-/g, '_') as user_account_provider_52222e2ecb_enum,
       },
     });
 
@@ -292,7 +292,7 @@ export class OAuthService {
     await this.prisma.user_account.create({
       data: {
         user_id: userId,
-        provider: String(provider).toLowerCase().replace(/-/g, '_') as user_account_provider_enum,
+        provider: String(provider).toLowerCase().replace(/-/g, '_') as user_account_provider_52222e2ecb_enum,
         provider_user_id: profile.id,
         email: profile.email,
         refresh_token: Buffer.from(encryptedRefreshToken),
@@ -334,11 +334,11 @@ export class OAuthService {
     return { accessToken };
   }
 
-  private async handleDisconnect(res: Response, locale: string, ipAddress: string, userAgent: string, provider: user_account_provider_enum, email: string) {
+  private async handleDisconnect(res: Response, locale: string, ipAddress: string, userAgent: string, provider: user_account_provider_52222e2ecb_enum, email: string) {
     const userAccount = await this.prisma.user_account.findFirst({
       where: {
         email,
-        provider: String(provider).toLowerCase().replace(/-/g, '_') as user_account_provider_enum,
+        provider: String(provider).toLowerCase().replace(/-/g, '_') as user_account_provider_52222e2ecb_enum,
       },
       include: { user: true }
     });

package/src/setting/setting.service.ts

@@ -1,7 +1,7 @@
 import { itemTranslations } from '@hed-hog/api';
 import { getLocaleText, LocaleService } from '@hed-hog/api-locale';
 import { PaginationDTO, PaginationService } from '@hed-hog/api-pagination';
-import { PrismaService, setting_type_enum } from '@hed-hog/api-prisma';
+import { PrismaService, setting_type_0f055cd5ea_enum } from '@hed-hog/api-prisma';
 import {
     BadRequestException,
     forwardRef,
@@ -36,7 +36,7 @@ export class SettingService {
       where: {
         ...( !includeSecrets ? {
               NOT: [
-                { type: setting_type_enum.secret },
+                { type: setting_type_0f055cd5ea_enum.secret },
               ],
         } : {}),
       },
@@ -294,6 +294,21 @@ export class SettingService {
               },
             },
           },
+          setting_subgroup: {
+            include: {
+              setting_subgroup_locale: {
+                where: {
+                  locale: {
+                    code: locale,
+                  },
+                },
+                select: {
+                  name: true,
+                  description: true,
+                },
+              },
+            },
+          },
           setting_locale: {
             where: {
               locale: {
@@ -334,6 +349,16 @@ export class SettingService {
         'setting_group_locale',
         setting.setting_group,
       );
+
+      if (setting.setting_subgroup) {
+        setting.setting_subgroup = itemTranslations(
+          'setting_subgroup_locale',
+          setting.setting_subgroup,
+        );
+      }
+
+      setting.subgroupId ??= setting.subgroup_id ?? setting.setting_subgroup?.id ?? null;
+
       return setting;
     });
 

package/src/task/task.service.ts

@@ -1,7 +1,7 @@
-import { Prisma, PrismaService } from '@hed-hog/api-prisma';
-import { Injectable, Logger } from '@nestjs/common';
-import { Cron, CronExpression } from '@nestjs/schedule';
-import { SettingService } from '../setting/setting.service';
+import { Prisma, PrismaService } from '@hed-hog/api-prisma';
+import { Injectable, Logger } from '@nestjs/common';
+import { Cron, CronExpression } from '@nestjs/schedule';
+import { SettingService } from '../setting/setting.service';
 
 @Injectable()
 export class TasksService {
@@ -225,4 +225,4 @@ export class TasksService {
       `Unverified MFA with expired challenges cleaned up in ${Date.now() - startAt}ms`,
     );
   }
-}
+}