@hed-hog/core 0.0.301 → 0.0.303

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/menu/menu.service.ts

@@ -3,11 +3,11 @@ import { getLocaleText } from '@hed-hog/api-locale';
 import { PaginationDTO, PaginationService } from '@hed-hog/api-pagination';
 import { PrismaService } from '@hed-hog/api-prisma';
 import {
-  BadRequestException,
-  Inject,
-  Injectable,
-  NotFoundException,
-  forwardRef,
+    BadRequestException,
+    Inject,
+    Injectable,
+    NotFoundException,
+    forwardRef,
 } from '@nestjs/common';
 import { DeleteDTO } from '../dto/delete.dto';
 import { UpdateIdsDTO } from '../dto/update-ids.dto';
@@ -24,6 +24,67 @@ export class MenuService {
     private readonly paginationService: PaginationService,
   ) {}
 
+  private async ensureValidParent(
+    locale: string,
+    currentMenuId: number | null,
+    parentId?: number | null,
+  ): Promise<void> {
+    if (parentId == null) {
+      return;
+    }
+
+    const parent = await this.prismaService.menu.findUnique({
+      where: { id: parentId },
+      select: { id: true, menu_id: true },
+    });
+
+    if (!parent) {
+      throw new BadRequestException(
+        getLocaleText('menuNotFound', locale, 'Menu not found.'),
+      );
+    }
+
+    if (currentMenuId != null && parentId === currentMenuId) {
+      throw new BadRequestException(
+        getLocaleText(
+          'menuInvalidParent',
+          locale,
+          'A menu cannot be its own parent.',
+        ),
+      );
+    }
+
+    if (currentMenuId == null) {
+      return;
+    }
+
+    const visited = new Set<number>([currentMenuId]);
+    let cursor: { id: number; menu_id: number | null } | null = parent;
+
+    while (cursor) {
+      if (visited.has(cursor.id)) {
+        throw new BadRequestException(
+          getLocaleText(
+            'menuInvalidParent',
+            locale,
+            'You cannot move a menu inside itself or one of its descendants.',
+          ),
+        );
+      }
+
+      visited.add(cursor.id);
+
+      if (cursor.menu_id == null) {
+        break;
+      }
+
+      cursor = await this.prismaService.menu.findUnique({
+        where: { id: cursor.menu_id },
+        select: { id: true, menu_id: true },
+      });
+    }
+  }
+
   async updateScreens(locale:string,menuId: number, data: UpdateIdsDTO): Promise<{count:number}> {
 
     const menuExists = await this.prismaService.menu.count({
@@ -170,6 +231,26 @@ export class MenuService {
               menu_id: true,
             },
           },
+          role_user: {
+            select: {
+              user_id: true,
+              user: {
+                select: {
+                  id: true,
+                  name: true,
+                  user_identifier: {
+                    where: {
+                      type: 'email',
+                    },
+                    select: {
+                      value: true,
+                    },
+                    take: 1,
+                  },
+                },
+              },
+            },
+          },
         },
       },
       'role_locale',
@@ -252,6 +333,11 @@ export class MenuService {
           where: { locale: { code: locale } },
           select: { name: true },
         },
+        _count: {
+          select: {
+            role_menu: true,
+          },
+        },
       },
     });
     return menus.map((m: any) => itemTranslations('menu_locale', m));
@@ -293,6 +379,11 @@ export class MenuService {
               name: true,
             },
           },
+          _count: {
+            select: {
+              role_menu: true,
+            },
+          },
         },
       },
       'menu_locale',
@@ -323,6 +414,8 @@ export class MenuService {
   }
 
   async create(_locale: string, { slug, url, icon, order, menu_id, locale }: CreateDTO) {
+    await this.ensureValidParent(_locale, null, menu_id);
+
     const created = await this.prismaService.menu.create({
       data: { slug, url, icon, order, menu_id },
     });
@@ -355,6 +448,8 @@ export class MenuService {
       },
     });
 
+    await this.ensureValidParent(locale, id, data.menu_id);
+
     if (!menuExists) {
       throw new BadRequestException(
         getLocaleText('menuNotFound', locale, 'Menu not found.'),