fix(server): remove any types and tighten typings in services/tests

apps/server/src/modules/organization/organization-role.service.ts

···
 import { Injectable, Logger, NotFoundException } from "@nestjs/common";
 import { PrismaService } from "../database/prisma.service";
 import { OrganizationRole } from "./organization-role.entity";
+import { OrganizationRoleMapper } from "./organization-role.mapper";
 
 @Injectable()
 export class OrganizationRoleService {
   private readonly logger = new Logger(OrganizationRoleService.name);
 
-  constructor(private readonly prisma: PrismaService) {}
+  constructor(
+    private readonly prisma: PrismaService,
+    private readonly organizationRoleMapper: OrganizationRoleMapper,
+  ) {}
 
   async findById(id: string): Promise<OrganizationRole | null> {
     this.logger.log(`Finding organization role by id: ${id}`);
···
       where: { id },
     });
 
-    return role ? OrganizationRole.fromDomain(role) : null;
+    return this.organizationRoleMapper.toDomain(role);
   }
 
   async findByIdOrFail(id: string): Promise<OrganizationRole> {
···
     const roles = await this.prisma["organizationRole"].findMany({
       orderBy: { name: "asc" },
     });
-
-    return roles.map((role: any) => OrganizationRole.fromDomain(role));
+    return this.organizationRoleMapper.mapToDomain(roles);
   }
 
   async create(data: {
···
       },
     });
 
-    return OrganizationRole.fromDomain(role);
+    return this.organizationRoleMapper.toDomain(role);
   }
 
   async update(
···
       where: { id },
       data: {
         ...(data.name !== undefined && { name: data.name }),
-        ...(data.description !== undefined && { description: data.description }),
+        ...(data.description !== undefined && {
+          description: data.description,
+        }),
         ...(data.color !== undefined && { color: data.color }),
       },
     });
 
-    return OrganizationRole.fromDomain(role);
+    return this.organizationRoleMapper.toDomain(role);
   }
 
   async delete(id: string): Promise<boolean> {

apps/server/test/job-experience-integration.e2e-spec.ts

···
 import type { INestApplication } from "@nestjs/common";
-import { createTestReferenceData, createTestUser, makeAuthenticatedRequest, makeUnauthenticatedRequest, setupTestApp, type TestUser } from "./test-utils";
-import { 
-  CREATE_JOB_EXPERIENCE_MUTATION, 
-  UPDATE_JOB_EXPERIENCE_MUTATION, 
-  DELETE_JOB_EXPERIENCE_MUTATION, 
-  MY_EMPLOYMENT_HISTORY_QUERY, 
-  MY_EMPLOYMENT_HISTORY_SIMPLE_QUERY,
+import {
   ALL_COMPANIES_QUERY,
-  ALL_SKILLS_QUERY,
+  ALL_LEVELS_QUERY,
   ALL_ROLES_QUERY,
-  ALL_LEVELS_QUERY
+  ALL_SKILLS_QUERY,
+  CREATE_COMPANY_MUTATION,
+  CREATE_JOB_EXPERIENCE_MUTATION,
+  DELETE_JOB_EXPERIENCE_MUTATION,
+  MY_EMPLOYMENT_HISTORY_MINIMAL,
+  MY_EMPLOYMENT_HISTORY_QUERY,
+  UPDATE_JOB_EXPERIENCE_DETAILED_MUTATION,
 } from "./queries/load-queries";
+import {
+  createTestReferenceData,
+  createTestUser,
+  makeAuthenticatedRequest,
+  makeUnauthenticatedRequest,
+  setupTestApp,
+  type TestUser,
+} from "./test-utils";
 
 describe("Job Experience Integration Tests (e2e)", () => {
   let app: INestApplication;
···
 
   describe("Job Experience Management", () => {
     it("should create a job experience", async () => {
-
-      const response = await makeAuthenticatedRequest(app, testUser.accessToken)
-        .send({
-          query: CREATE_JOB_EXPERIENCE_MUTATION,
-          variables: {
-            companyId: referenceData.companyId,
-            roleId: referenceData.roleId,
-            levelId: referenceData.levelId,
-            startDate: "2023-01-01T00:00:00.000Z",
-            endDate: "2023-12-31T23:59:59.999Z",
-            description: "Worked on various projects",
-            skillIds: [referenceData.skillId],
-          },
-        });
+      const response = await makeAuthenticatedRequest(
+        app,
+        testUser.accessToken,
+      ).send({
+        query: CREATE_JOB_EXPERIENCE_MUTATION,
+        variables: {
+          companyId: referenceData.companyId,
+          roleId: referenceData.roleId,
+          levelId: referenceData.levelId,
+          startDate: "2023-01-01T00:00:00.000Z",
+          endDate: "2023-12-31T23:59:59.999Z",
+          description: "Worked on various projects",
+          skillIds: [referenceData.skillId],
+        },
+      });
 
       if (response.status !== 200) {
-        console.log('Error response:', JSON.stringify(response.body, null, 2));
-        console.log('Query:', CREATE_JOB_EXPERIENCE_MUTATION);
       }
-      
+
       expect(response.status).toBe(200);
 
       expect(response.body.data.createJobExperience).toBeDefined();
       expect(response.body.data.createJobExperience.id).toBeDefined();
-      expect(response.body.data.createJobExperience.company.id).toBe(referenceData.companyId);
-      expect(response.body.data.createJobExperience.role.id).toBe(referenceData.roleId);
-      expect(response.body.data.createJobExperience.level.id).toBe(referenceData.levelId);
+      expect(response.body.data.createJobExperience.company.id).toBe(
+        referenceData.companyId,
+      );
+      expect(response.body.data.createJobExperience.role.id).toBe(
+        referenceData.roleId,
+      );
+      expect(response.body.data.createJobExperience.level.id).toBe(
+        referenceData.levelId,
+      );
       expect(response.body.data.createJobExperience.skills).toHaveLength(1);
-      expect(response.body.data.createJobExperience.skills[0].id).toBe(referenceData.skillId);
+      expect(response.body.data.createJobExperience.skills[0].id).toBe(
+        referenceData.skillId,
+      );
     });
 
     it("should retrieve user's employment history", async () => {
       // First create a job experience
-      const createJobExperienceMutation = `
-        mutation CreateJobExperience(
-          $companyId: String!
-          $roleId: String!
-          $levelId: String!
-          $startDate: DateTime!
-        ) {
-          createJobExperience(
-            companyId: $companyId
-            roleId: $roleId
-            levelId: $levelId
-            startDate: $startDate
-          ) {
-            id
-          }
-        }
-      `;
-
       await makeAuthenticatedRequest(app, testUser.accessToken)
         .send({
-          query: createJobExperienceMutation,
+          query: CREATE_JOB_EXPERIENCE_MUTATION,
           variables: {
             companyId: referenceData.companyId,
             roleId: referenceData.roleId,
···
 
       expect(response.body.data.myEmploymentHistory).toBeDefined();
       expect(Array.isArray(response.body.data.myEmploymentHistory)).toBe(true);
-      expect(response.body.data.myEmploymentHistory.length).toBeGreaterThanOrEqual(1);
-      
+      expect(
+        response.body.data.myEmploymentHistory.length,
+      ).toBeGreaterThanOrEqual(1);
+
       // Find the experience created in the previous test
       const experience = response.body.data.myEmploymentHistory.find(
-        (exp: any) => exp.company.id === referenceData.companyId
+        (exp: {
+          id: string;
+          company: { id: string };
+          role: { id: string };
+          level: { id: string };
+        }) => exp.company.id === referenceData.companyId,
       );
       expect(experience).toBeDefined();
       expect(experience.id).toBeDefined();
···
 
     it("should update a job experience", async () => {
       // First create a job experience
-      const createResponse = await makeAuthenticatedRequest(app, testUser.accessToken)
+      const createResponse = await makeAuthenticatedRequest(
+        app,
+        testUser.accessToken,
+      )
         .send({
           query: CREATE_JOB_EXPERIENCE_MUTATION,
           variables: {
···
       const experienceId = createResponse.body.data.createJobExperience.id;
 
       // Create a new company for update
-      const createNewCompanyMutation = `
-        mutation CreateCompany($name: String!) {
-          createCompany(name: $name) {
-            id
-            name
-          }
-        }
-      `;
-
       const newCompanyResponse = await makeUnauthenticatedRequest(app)
         .send({
-          query: createNewCompanyMutation,
+          query: CREATE_COMPANY_MUTATION,
           variables: {
             name: `Updated Company ${Date.now()}`,
           },
···
       const newCompanyId = newCompanyResponse.body.data.createCompany.id;
 
       // Update the job experience
-      const updateJobExperienceMutation = `
-        mutation UpdateJobExperience(
-          $id: String!
-          $companyId: String
-          $description: String
-        ) {
-          updateJobExperience(
-            id: $id
-            companyId: $companyId
-            description: $description
-          ) {
-            id
-            description
-            company {
-              id
-              name
-            }
-          }
-        }
-      `;
-
       const response = await makeAuthenticatedRequest(app, testUser.accessToken)
         .send({
-          query: updateJobExperienceMutation,
+          query: UPDATE_JOB_EXPERIENCE_DETAILED_MUTATION,
           variables: {
             id: experienceId,
             companyId: newCompanyId,
···
 
       expect(response.body.data.updateJobExperience).toBeDefined();
       expect(response.body.data.updateJobExperience.id).toBe(experienceId);
-      expect(response.body.data.updateJobExperience.company.id).toBe(newCompanyId);
-      expect(response.body.data.updateJobExperience.description).toBe("Updated description");
+      expect(response.body.data.updateJobExperience.company.id).toBe(
+        newCompanyId,
+      );
+      expect(response.body.data.updateJobExperience.description).toBe(
+        "Updated description",
+      );
     });
 
     it("should delete a job experience", async () => {
       // First create a job experience
-      const createJobExperienceMutation = `
-        mutation CreateJobExperience(
-          $companyId: String!
-          $roleId: String!
-          $levelId: String!
-          $startDate: DateTime!
-        ) {
-          createJobExperience(
-            companyId: $companyId
-            roleId: $roleId
-            levelId: $levelId
-            startDate: $startDate
-          ) {
-            id
-          }
-        }
-      `;
-
-      const createResponse = await makeAuthenticatedRequest(app, testUser.accessToken)
+      const createResponse = await makeAuthenticatedRequest(
+        app,
+        testUser.accessToken,
+      )
         .send({
           query: CREATE_JOB_EXPERIENCE_MUTATION,
           variables: {
···
       const experienceId = createResponse.body.data.createJobExperience.id;
 
       // Delete the job experience
-      const deleteJobExperienceMutation = `
-        mutation DeleteJobExperience($id: String!) {
-          deleteJobExperience(id: $id)
-        }
-      `;
-
       const response = await makeAuthenticatedRequest(app, testUser.accessToken)
         .send({
-          query: deleteJobExperienceMutation,
+          query: DELETE_JOB_EXPERIENCE_MUTATION,
           variables: {
             id: experienceId,
           },
···
       expect(response.body.data.deleteJobExperience).toBe(true);
 
       // Verify it's deleted by checking employment history
-      const myEmploymentHistoryQuery = `
-        query MeJobExperience {
-          myEmploymentHistory {
-            id
-          }
-        }
-      `;
-
-      const historyResponse = await makeAuthenticatedRequest(app, testUser.accessToken)
+      const historyResponse = await makeAuthenticatedRequest(
+        app,
+        testUser.accessToken,
+      )
         .send({
-          query: myEmploymentHistoryQuery,
+          query: MY_EMPLOYMENT_HISTORY_MINIMAL,
         })
         .expect(200);
 
       // Check that the specific experience was deleted
-      const deletedExperience = historyResponse.body.data.myEmploymentHistory.find(
-        (exp: any) => exp.id === experienceId
-      );
+      const deletedExperience =
+        historyResponse.body.data.myEmploymentHistory.find(
+          (exp: { id: string }) => exp.id === experienceId,
+        );
       expect(deletedExperience).toBeUndefined();
     });
   });
 
   describe("Reference Data Queries", () => {
     it("should retrieve all companies", async () => {
-      const companiesQuery = `
-        query Companies {
-          companies {
-            id
-            name
-            description
-            website
-            createdAt
-            updatedAt
-          }
-        }
-      `;
-
       const response = await makeUnauthenticatedRequest(app)
         .send({
-          query: companiesQuery,
+          query: ALL_COMPANIES_QUERY,
         })
         .expect(200);
 
···
     });
 
     it("should retrieve all skills", async () => {
-      const skillsQuery = `
-        query Skills {
-          skills {
-            id
-            name
-            description
-            createdAt
-            updatedAt
-          }
-        }
-      `;
-
       const response = await makeUnauthenticatedRequest(app)
         .send({
-          query: skillsQuery,
+          query: ALL_SKILLS_QUERY,
         })
         .expect(200);
 
···
     });
 
     it("should retrieve all roles", async () => {
-      const rolesQuery = `
-        query Roles {
-          roles {
-            id
-            name
-            description
-            createdAt
-            updatedAt
-          }
-        }
-      `;
-
       const response = await makeUnauthenticatedRequest(app)
         .send({
-          query: rolesQuery,
+          query: ALL_ROLES_QUERY,
         })
         .expect(200);
 
···
     });
 
     it("should retrieve all levels", async () => {
-      const levelsQuery = `
-        query Levels {
-          levels {
-            id
-            name
-            description
-            createdAt
-            updatedAt
-          }
-        }
-      `;
-
       const response = await makeUnauthenticatedRequest(app)
         .send({
-          query: levelsQuery,
+          query: ALL_LEVELS_QUERY,
         })
         .expect(200);
 
···
 
   describe("Error Handling", () => {
     it("should handle authentication errors for protected endpoints", async () => {
-      const myEmploymentHistoryQuery = `
-        query MeJobExperience {
-          myEmploymentHistory {
-            id
-          }
-        }
-      `;
-
       const response = await makeUnauthenticatedRequest(app)
         .send({
-          query: myEmploymentHistoryQuery,
+          query: MY_EMPLOYMENT_HISTORY_MINIMAL,
         })
         .expect(200);
 
···
     });
 
     it("should handle invalid job experience creation", async () => {
-      const createJobExperienceMutation = `
-        mutation CreateJobExperience(
-          $companyId: String!
-          $roleId: String!
-          $levelId: String!
-          $startDate: DateTime!
-        ) {
-          createJobExperience(
-            companyId: $companyId
-            roleId: $roleId
-            levelId: $levelId
-            startDate: $startDate
-          ) {
-            id
-          }
-        }
-      `;
-
       const response = await makeAuthenticatedRequest(app, testUser.accessToken)
         .send({
-          query: createJobExperienceMutation,
+          query: CREATE_JOB_EXPERIENCE_MUTATION,
           variables: {
             companyId: "invalid-id",
             roleId: "invalid-id",