@hed-hog/core 0.0.300 → 0.0.302

package/src/integration/services/integration-link.service.ts

@@ -14,13 +14,81 @@ export interface CreateIntegrationLinkDto {
 }
 
 export interface IntegrationLinkPersistenceClient {
-  integrationLink: PrismaService['integrationLink'];
+  integrationLink?: PrismaService['integrationLink'];
+  integration_link?: PrismaService['integration_link'];
 }
 
+type IntegrationLinkRecord = {
+  id: number | string;
+  source_module?: string;
+  source_entity_type?: string;
+  source_entity_id?: string;
+  target_module?: string;
+  target_entity_type?: string;
+  target_entity_id?: string;
+  link_type?: LinkType | string;
+  created_at?: Date;
+  updated_at?: Date;
+  sourceModule?: string;
+  sourceEntityType?: string;
+  sourceEntityId?: string;
+  targetModule?: string;
+  targetEntityType?: string;
+  targetEntityId?: string;
+  linkType?: LinkType | string;
+  metadata?: Record<string, any> | null;
+  createdAt?: Date;
+  updatedAt?: Date;
+};
+
 @Injectable()
 export class IntegrationLinkService {
   constructor(private readonly prisma: PrismaService) {}
 
+  private resolvePersistence(
+    persistenceClient?: IntegrationLinkPersistenceClient,
+  ) {
+    const client = (persistenceClient ?? this.prisma) as PrismaService &
+      IntegrationLinkPersistenceClient;
+    const delegate = client.integration_link ?? client.integrationLink;
+    const useSnakeCase = !!client.integration_link;
+
+    if (!delegate) {
+      throw new Error(
+        'Integration link delegate is not available on the Prisma client.',
+      );
+    }
+
+    return { delegate, useSnakeCase };
+  }
+
+  private toDomainLink(record: IntegrationLinkRecord): IntegrationLink {
+    return {
+      id: String(record.id),
+      sourceModule: record.source_module ?? record.sourceModule ?? '',
+      sourceEntityType:
+        record.source_entity_type ?? record.sourceEntityType ?? '',
+      sourceEntityId: record.source_entity_id ?? record.sourceEntityId ?? '',
+      targetModule: record.target_module ?? record.targetModule ?? '',
+      targetEntityType:
+        record.target_entity_type ?? record.targetEntityType ?? '',
+      targetEntityId: record.target_entity_id ?? record.targetEntityId ?? '',
+      linkType: (record.link_type ?? record.linkType ?? LinkType.REFERENCE) as LinkType,
+      metadata: record.metadata ?? null,
+      createdAt: record.created_at ?? record.createdAt ?? new Date(),
+      updatedAt: record.updated_at ?? record.updatedAt ?? new Date(),
+    };
+  }
+
+  private toDatabaseId(linkId: string | number) {
+    if (typeof linkId === 'number') {
+      return linkId;
+    }
+
+    const numericId = Number(linkId);
+    return Number.isNaN(numericId) ? linkId : numericId;
+  }
+
   /**
    * Create a link between entities from different modules
    */
@@ -28,20 +96,33 @@ export class IntegrationLinkService {
     dto: CreateIntegrationLinkDto,
     persistenceClient?: IntegrationLinkPersistenceClient,
   ): Promise<IntegrationLink> {
-    const client = persistenceClient ?? this.prisma;
-
-    return client.integrationLink.create({
-      data: {
-        sourceModule: dto.sourceModule,
-        sourceEntityType: dto.sourceEntityType,
-        sourceEntityId: dto.sourceEntityId,
-        targetModule: dto.targetModule,
-        targetEntityType: dto.targetEntityType,
-        targetEntityId: dto.targetEntityId,
-        linkType: dto.linkType,
-        metadata: dto.metadata || null,
-      },
+    const { delegate, useSnakeCase } = this.resolvePersistence(persistenceClient);
+
+    const record = await delegate.create({
+      data: useSnakeCase
+        ? {
+            source_module: dto.sourceModule,
+            source_entity_type: dto.sourceEntityType,
+            source_entity_id: dto.sourceEntityId,
+            target_module: dto.targetModule,
+            target_entity_type: dto.targetEntityType,
+            target_entity_id: dto.targetEntityId,
+            link_type: dto.linkType,
+            metadata: dto.metadata || null,
+          }
+        : {
+            sourceModule: dto.sourceModule,
+            sourceEntityType: dto.sourceEntityType,
+            sourceEntityId: dto.sourceEntityId,
+            targetModule: dto.targetModule,
+            targetEntityType: dto.targetEntityType,
+            targetEntityId: dto.targetEntityId,
+            linkType: dto.linkType,
+            metadata: dto.metadata || null,
+          },
     });
+
+    return this.toDomainLink(record as IntegrationLinkRecord);
   }
 
   /**
@@ -52,13 +133,24 @@ export class IntegrationLinkService {
     sourceEntityType: string,
     sourceEntityId: string,
   ): Promise<IntegrationLink[]> {
-    return this.prisma.integrationLink.findMany({
-      where: {
-        sourceModule,
-        sourceEntityType,
-        sourceEntityId,
-      },
+    const { delegate, useSnakeCase } = this.resolvePersistence();
+    const records = await delegate.findMany({
+      where: useSnakeCase
+        ? {
+            source_module: sourceModule,
+            source_entity_type: sourceEntityType,
+            source_entity_id: sourceEntityId,
+          }
+        : {
+            sourceModule,
+            sourceEntityType,
+            sourceEntityId,
+          },
     });
+
+    return records.map((record: IntegrationLinkRecord) =>
+      this.toDomainLink(record),
+    );
   }
 
   /**
@@ -69,40 +161,62 @@ export class IntegrationLinkService {
     targetEntityType: string,
     targetEntityId: string,
   ): Promise<IntegrationLink[]> {
-    return this.prisma.integrationLink.findMany({
-      where: {
-        targetModule,
-        targetEntityType,
-        targetEntityId,
-      },
+    const { delegate, useSnakeCase } = this.resolvePersistence();
+    const records = await delegate.findMany({
+      where: useSnakeCase
+        ? {
+            target_module: targetModule,
+            target_entity_type: targetEntityType,
+            target_entity_id: targetEntityId,
+          }
+        : {
+            targetModule,
+            targetEntityType,
+            targetEntityId,
+          },
     });
+
+    return records.map((record: IntegrationLinkRecord) =>
+      this.toDomainLink(record),
+    );
   }
 
   /**
    * Find links of a specific type
    */
   async findByLinkType(linkType: LinkType): Promise<IntegrationLink[]> {
-    return this.prisma.integrationLink.findMany({
-      where: { linkType },
+    const { delegate, useSnakeCase } = this.resolvePersistence();
+    const records = await delegate.findMany({
+      where: useSnakeCase ? { link_type: linkType } : { linkType },
     });
+
+    return records.map((record: IntegrationLinkRecord) =>
+      this.toDomainLink(record),
+    );
   }
 
   /**
    * Delete a link
    */
   async deleteLink(linkId: string): Promise<IntegrationLink> {
-    return this.prisma.integrationLink.delete({
-      where: { id: linkId },
+    const { delegate } = this.resolvePersistence();
+    const record = await delegate.delete({
+      where: { id: this.toDatabaseId(linkId) },
     });
+
+    return this.toDomainLink(record as IntegrationLinkRecord);
   }
 
   /**
    * Get link by ID
    */
   async getById(linkId: string): Promise<IntegrationLink | null> {
-    return this.prisma.integrationLink.findUnique({
-      where: { id: linkId },
+    const { delegate } = this.resolvePersistence();
+    const record = await delegate.findUnique({
+      where: { id: this.toDatabaseId(linkId) },
     });
+
+    return record ? this.toDomainLink(record as IntegrationLinkRecord) : null;
   }
 
   /**
@@ -116,39 +230,60 @@ export class IntegrationLinkService {
     entity2Type: string,
     entity2Id: string,
   ): Promise<IntegrationLink | null> {
-    // Look for forward or reverse direction
-    const link = await this.prisma.integrationLink.findFirst({
+    const { delegate, useSnakeCase } = this.resolvePersistence();
+
+    const record = await delegate.findFirst({
       where: {
-        OR: [
-          {
-            sourceModule: module1,
-            sourceEntityType: entity1Type,
-            sourceEntityId: entity1Id,
-            targetModule: module2,
-            targetEntityType: entity2Type,
-            targetEntityId: entity2Id,
-          },
-          {
-            sourceModule: module2,
-            sourceEntityType: entity2Type,
-            sourceEntityId: entity2Id,
-            targetModule: module1,
-            targetEntityType: entity1Type,
-            targetEntityId: entity1Id,
-          },
-        ],
+        OR: useSnakeCase
+          ? [
+              {
+                source_module: module1,
+                source_entity_type: entity1Type,
+                source_entity_id: entity1Id,
+                target_module: module2,
+                target_entity_type: entity2Type,
+                target_entity_id: entity2Id,
+              },
+              {
+                source_module: module2,
+                source_entity_type: entity2Type,
+                source_entity_id: entity2Id,
+                target_module: module1,
+                target_entity_type: entity1Type,
+                target_entity_id: entity1Id,
+              },
+            ]
+          : [
+              {
+                sourceModule: module1,
+                sourceEntityType: entity1Type,
+                sourceEntityId: entity1Id,
+                targetModule: module2,
+                targetEntityType: entity2Type,
+                targetEntityId: entity2Id,
+              },
+              {
+                sourceModule: module2,
+                sourceEntityType: entity2Type,
+                sourceEntityId: entity2Id,
+                targetModule: module1,
+                targetEntityType: entity1Type,
+                targetEntityId: entity1Id,
+              },
+            ],
       },
     });
 
-    return link;
+    return record ? this.toDomainLink(record as IntegrationLinkRecord) : null;
   }
 
   /**
    * Count links from a module
    */
   async countFromModule(sourceModule: string): Promise<number> {
-    return this.prisma.integrationLink.count({
-      where: { sourceModule },
+    const { delegate, useSnakeCase } = this.resolvePersistence();
+    return delegate.count({
+      where: useSnakeCase ? { source_module: sourceModule } : { sourceModule },
     });
   }
 }

package/src/mail/mail.service.ts

@@ -10,8 +10,10 @@ import {
   Injectable,
   Logger,
   NotFoundException,
+  OnModuleInit,
 } from '@nestjs/common';
 import * as Handlebars from 'handlebars';
+import { IntegrationDeveloperApiService } from '../integration/services/integration-developer-api.service';
 import { SettingService } from '../setting/setting.service';
 import { CreateDTO } from './dto/create.dto';
 import { ImportDTO } from './dto/import.dto';
@@ -20,7 +22,7 @@ import { TestMailDTO } from './dto/test-mail.dto';
 import { UpdateDTO } from './dto/update.dto';
 
 @Injectable()
-export class MailService {
+export class MailService implements OnModuleInit {
   private readonly logger = new Logger(MailService.name);
   private readonly modelName = 'mail';
 
@@ -33,8 +35,70 @@ export class MailService {
     private readonly localeService: LocaleService,
     @Inject(forwardRef(() => SettingService))
     private readonly setting: SettingService,
+    @Inject(forwardRef(() => IntegrationDeveloperApiService))
+    private readonly integrationApi: IntegrationDeveloperApiService,
   ) { }
 
+  onModuleInit(): void {
+    this.integrationApi.subscribe({
+      eventName: 'core.setting.changed',
+      consumerName: 'core.mail-config-validator',
+      priority: 0,
+      handler: async (event) => {
+        const slug = String(event.payload?.slug || '').trim();
+
+        if (!this.isMailConfigSlug(slug)) {
+          return;
+        }
+
+        await this.syncConfiguredMailFlag();
+      },
+    });
+
+    void this.syncConfiguredMailFlag();
+  }
+
+  private isMailConfigSlug(slug: string) {
+    return slug.startsWith('mail-');
+  }
+
+  private isSettingEnabled(value: unknown) {
+    return value === true || value === 'true';
+  }
+
+  private async syncConfiguredMailFlag() {
+    try {
+      const settings = await this.setting.getSettingValues([
+        'mail-provider',
+        'mail-from',
+      ]);
+
+      const provider = String(settings['mail-provider'] || '').trim();
+      const from = String(settings['mail-from'] || '').trim();
+
+      if (!provider || !from) {
+        await this.setting.setValue('configured-mail', 'false');
+        return;
+      }
+
+      await this.reloadConfig();
+
+      await this.mailMainService.send({
+        to: from,
+        from,
+        subject: '[HedHog] Mail configuration validation',
+        body: `This is an automatic validation email for the configured provider "${provider}".`,
+      });
+
+      await this.setting.setValue('configured-mail', 'true');
+    } catch (error) {
+      this.logger.warn(
+        `Mail configuration validation failed: ${error instanceof Error ? error.message : String(error)}`,
+      );
+      await this.setting.setValue('configured-mail', 'false');
+    }
+  }
+
   /**
    * Reload mail configuration from database and update MailMainService
    */
@@ -333,7 +397,7 @@ export class MailService {
       'mail-from'
     ]);
 
-    if (!settings['configured-mail']) {
+    if (!this.isSettingEnabled(settings['configured-mail'])) {
       this.logger.warn('Mail service is not configured. Aborting sending email.');
       return;
     }
@@ -422,7 +486,7 @@ export class MailService {
       'mail-from'
     ]);
 
-    if (!settings['configured-mail']) {
+    if (!this.isSettingEnabled(settings['configured-mail'])) {
       throw new BadRequestException('Mail service is not configured.');
     }