@node-c/data-typeorm 1.0.0-alpha64 → 1.0.0-beta1

package/src/entityService/typeorm.entity.service.spec.ts

@@ -0,0 +1,1180 @@
+import { ApplicationError, DataFindResults, DataOrderBy, DataSelectOperator, GenericObject } from '@node-c/core';
+import {
+  BulkCreateOptions,
+  CountOptions,
+  CreateOptions,
+  FindOneOptions,
+  FindOptions,
+  IncludeItems,
+  ParsedFilter,
+  PostgresErrorCode,
+  SQLQueryBuilderService
+} from '@node-c/data-rdb';
+import { EntityManager, EntitySchema, Repository } from 'typeorm';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { TypeORMDBEntityService } from './index';
+
+class PostgresError extends Error {
+  code: string;
+  detail: string;
+  table: string;
+  constructor(message: string, data: { code: string; detail: string; table: string }) {
+    super(message);
+    for (const key in data) {
+      this[key as keyof PostgresError] = data[key as keyof typeof data];
+    }
+  }
+}
+// Define a minimal test entity interface.
+interface TestEntity {
+  id: number;
+  name: string;
+}
+interface TransactionManagerGetter {
+  __getTransactionManager: () => EntityManager;
+}
+// Define a minimal dummy query builder interface.
+interface QueryBuilderMock {
+  execute?: () => Promise<{ affected?: number; raw?: TestEntity[] }>;
+  delete?: () => QueryBuilderMock;
+  getCount?: () => Promise<number>;
+  getMany?: () => Promise<TestEntity[]>;
+  getOne?: () => Promise<TestEntity | null>;
+  returning?: (_columns: string) => QueryBuilderMock;
+  set?: (_data: unknown) => QueryBuilderMock;
+  skip?: (_value: number) => QueryBuilderMock;
+  softDelete?: () => QueryBuilderMock;
+  take?: (_value: number) => QueryBuilderMock;
+  update?: () => QueryBuilderMock;
+}
+// Create a dummy SQLQueryBuilderService with only the needed methods.
+const createQBMock = (): SQLQueryBuilderService =>
+  ({
+    columnQuotesSymbol: '"',
+    buildQuery: vi.fn(),
+    parseFilters: vi.fn().mockImplementation(
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      (_tableName: string, _filters: unknown, _options: { operator: unknown; isTopLevel: boolean }) => {
+        // Return dummy "where" and "include" objects.
+        return {
+          where: { dummy: 'filter' } as unknown as Record<string, ParsedFilter>,
+          include: { dummyInclude: true }
+        };
+      }
+    ),
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    parseOrderBy: vi.fn().mockImplementation((_tableName: string, _orderBy: unknown) => {
+      // Return a dummy orderBy array.
+      return { orderBy: [{ column: 'id', order: 'ASC' }] as unknown as DataOrderBy[] };
+    }),
+    parseRelations: vi
+      .fn()
+      .mockImplementation(
+        (_tableName: string, _optRelations: unknown[], includeFromFilters: Record<string, unknown>) => {
+          // Merge the include from filters with extra dummy data.
+          return { ...includeFromFilters, extraRelation: true } as unknown as IncludeItems;
+        }
+      )
+  }) as unknown as SQLQueryBuilderService;
+// Create a dummy repository and transaction manager.
+const createRepositoryMock = (qbm: QueryBuilderMock): Repository<TestEntity> => {
+  const tmgm = createTransactionManagerMock(qbm);
+  return {
+    manager: {
+      transaction: vi.fn().mockImplementation(async (cb: (_tm: EntityManager) => Promise<TestEntity | null>) => {
+        return await cb(tmgm);
+      })
+    },
+    metadata: { name: 'TestEntity', tableName: 'TestEntity' },
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+    target: 'TestEntity' as unknown as Function,
+    __getTransactionManager: () => tmgm,
+    createQueryBuilder: vi.fn().mockReturnValue(qbm)
+  } as unknown as Repository<TestEntity>;
+};
+const createTransactionManagerMock = (qbm: QueryBuilderMock): EntityManager => {
+  return {
+    getRepository: vi.fn().mockImplementation(() => createRepositoryMock(qbm)),
+    query: vi.fn().mockResolvedValue(undefined)
+  } as unknown as EntityManager;
+};
+// We declare repositoryMock later since it needs the queryBuilderMock.
+// A dummy query builder that simply returns a dummy entity.
+const dummyEntity: TestEntity = { id: 1, name: 'Test' };
+let queryBuilderMock: QueryBuilderMock;
+let repositoryMock: Repository<TestEntity>;
+let transactionManagerMock: EntityManager;
+
+describe('TypeORMDBEntityService', () => {
+  describe('constructor', () => {
+    let qbMock: SQLQueryBuilderService;
+    beforeEach(() => {
+      qbMock = createQBMock();
+      vi.clearAllMocks();
+    });
+    it('should correctly set primaryKeys when a single primary key is defined', () => {
+      const dummySchema = new EntitySchema<TestEntity>({
+        name: 'TestEntity',
+        columns: {
+          id: { type: Number, primary: true },
+          name: { type: String }
+        }
+      });
+      const service = new TypeORMDBEntityService<TestEntity>(qbMock, repositoryMock, dummySchema);
+      expect(service['primaryKeys']).toEqual(['id']);
+    });
+    it('should correctly set primaryKeys when multiple primary keys are defined', () => {
+      interface CompositeEntity {
+        id: number;
+        code: string;
+        value: number;
+      }
+      const dummySchemaMulti = new EntitySchema<CompositeEntity>({
+        name: 'CompositeEntity',
+        columns: {
+          id: { type: Number, primary: true },
+          code: { type: String, primary: true },
+          value: { type: Number }
+        }
+      });
+      const repositoryMulti = {
+        metadata: { name: 'CompositeEntity', tableName: 'CompositeEntity' },
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+        target: 'CompositeEntity' as unknown as Function,
+        createQueryBuilder: vi.fn(),
+        manager: { transaction: vi.fn() }
+      } as unknown as Repository<CompositeEntity>;
+      const serviceMulti = new TypeORMDBEntityService<CompositeEntity>(qbMock, repositoryMulti, dummySchemaMulti);
+      expect(serviceMulti['primaryKeys']).toEqual(['id', 'code']);
+    });
+    it('should set primaryKeys to an empty array when no primary key is defined', () => {
+      const dummySchemaNoPK = new EntitySchema<TestEntity>({
+        name: 'NoPKEntity',
+        columns: {
+          id: { type: Number },
+          name: { type: String }
+        }
+      });
+      const repositoryNoPK = {
+        metadata: { name: 'NoPKEntity', tableName: 'NoPKEntity' },
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+        target: 'NoPKEntity' as unknown as Function,
+        createQueryBuilder: vi.fn(),
+        manager: { transaction: vi.fn() }
+      } as unknown as Repository<TestEntity>;
+      const serviceNoPK = new TypeORMDBEntityService<TestEntity>(qbMock, repositoryNoPK, dummySchemaNoPK);
+      expect(serviceNoPK['primaryKeys']).toEqual([]);
+    });
+  });
+
+  describe('buildPrimaryKeyWhereClause', () => {
+    let qbMock: SQLQueryBuilderService;
+    let service: TypeORMDBEntityService<TestEntity>;
+    beforeEach(() => {
+      // Reset mocks before each test.
+      qbMock = createQBMock();
+      queryBuilderMock = {
+        getCount: vi.fn().mockResolvedValue(5),
+        getOne: vi.fn().mockResolvedValue(dummyEntity)
+      };
+      // Create a repository mock that uses our dummy query builder.
+      repositoryMock = createRepositoryMock(queryBuilderMock);
+      transactionManagerMock = (repositoryMock as unknown as TransactionManagerGetter).__getTransactionManager();
+      // Create a dummy schema with one primary key ("id") and one extra column.
+      const dummySchema = new EntitySchema<TestEntity>({
+        name: 'TestEntity',
+        columns: {
+          id: { type: Number, primary: true },
+          name: { type: String }
+        }
+      });
+      service = new TypeORMDBEntityService<TestEntity>(qbMock, repositoryMock, dummySchema);
+      // Clear mock history.
+      vi.clearAllMocks();
+    });
+    it('should build correct clause for a single primary key', () => {
+      const testData: TestEntity[] = [
+        { id: 1, name: 'Test1' },
+        { id: 2, name: 'Test2' }
+      ];
+      // Using the service from the earlier beforeEach (with single primary key "id")
+      const result = service['buildPrimaryKeyWhereClause'](testData);
+      expect(result.field).toBe('id');
+      expect(result.value.params).toEqual({ id: [1, 2] });
+      expect(result.value.query).toBe('"TestEntity"."id" in :id');
+    });
+    it('should build correct clause for composite primary keys', () => {
+      interface CompositeEntity {
+        id: number;
+        code: string;
+        value: number;
+      }
+      const compositeSchema = new EntitySchema<CompositeEntity>({
+        name: 'CompositeEntity',
+        columns: {
+          id: { type: Number, primary: true },
+          code: { type: String, primary: true },
+          value: { type: Number }
+        }
+      });
+      const compositeRepository = {
+        metadata: { name: 'CompositeEntity', tableName: 'CompositeEntity' },
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+        target: 'CompositeEntity' as unknown as Function,
+        createQueryBuilder: vi.fn(),
+        manager: { transaction: vi.fn() }
+      } as unknown as Repository<CompositeEntity>;
+      const compositeService = new TypeORMDBEntityService<CompositeEntity>(
+        qbMock,
+        compositeRepository,
+        compositeSchema
+      );
+      const testData: CompositeEntity[] = [
+        { id: 1, code: 'A', value: 100 },
+        { id: 2, code: 'B', value: 200 }
+      ];
+      const result = compositeService['buildPrimaryKeyWhereClause'](testData);
+      expect(result.field).toBe(DataSelectOperator.Or);
+      expect(result.value.params).toEqual({
+        id0: 1,
+        code0: 'A',
+        id1: 2,
+        code1: 'B'
+      });
+      const expectedQuery =
+        '(("CompositeEntity"."id" = :id0 and "CompositeEntity"."code" = :code0) or ("CompositeEntity"."id" = :id1 and "CompositeEntity"."code" = :code1))';
+      expect(result.value.query).toBe(expectedQuery);
+    });
+  });
+
+  describe('bulkCreate', () => {
+    let dummyEntities: TestEntity[];
+    let qbMock: SQLQueryBuilderService;
+    let service: TypeORMDBEntityService<TestEntity>;
+    beforeEach(() => {
+      qbMock = createQBMock();
+      queryBuilderMock = {
+        getCount: vi.fn().mockResolvedValue(5),
+        getOne: vi.fn().mockResolvedValue(dummyEntity)
+      };
+      repositoryMock = createRepositoryMock(queryBuilderMock);
+      transactionManagerMock = (repositoryMock as unknown as TransactionManagerGetter).__getTransactionManager();
+      const dummySchema = new EntitySchema<TestEntity>({
+        name: 'TestEntity',
+        columns: {
+          id: { type: Number, primary: true },
+          name: { type: String }
+        }
+      });
+      service = new TypeORMDBEntityService<TestEntity>(qbMock, repositoryMock, dummySchema);
+      dummyEntities = [
+        { id: 1, name: 'Test1' },
+        { id: 2, name: 'Test2' }
+      ];
+    });
+    it('should call save directly when transactionManager is provided', async () => {
+      // Spy on the protected "save" method.
+      const saveSpy = vi
+        .spyOn(
+          service as unknown as {
+            save(_data: TestEntity[], _transactionManager?: EntityManager): Promise<TestEntity[]>;
+          },
+          'save'
+        )
+        .mockResolvedValue(dummyEntities);
+      const options: BulkCreateOptions = { forceTransaction: false, transactionManager: transactionManagerMock };
+      const result = await service.bulkCreate(dummyEntities, options);
+      expect(result).toEqual(dummyEntities);
+      expect(saveSpy).toHaveBeenCalledWith(dummyEntities, transactionManagerMock);
+    });
+    it('should use transaction when forceTransaction is true and transactionManager is not provided', async () => {
+      // Spy on the protected "save" method.
+      const saveSpy = vi
+        .spyOn(
+          service as unknown as {
+            save(_data: TestEntity[], _transactionManager?: EntityManager): Promise<TestEntity[]>;
+          },
+          'save'
+        )
+        .mockResolvedValue(dummyEntities);
+      // Prepare options without transactionManager and force a transaction.
+      const options: BulkCreateOptions = { forceTransaction: true };
+      const transactionSpy = repositoryMock.manager.transaction as ReturnType<typeof vi.fn>;
+      const result = await service.bulkCreate(dummyEntities, options);
+      expect(result).toEqual(dummyEntities);
+      expect(transactionSpy).toHaveBeenCalledTimes(1);
+      // The inner call of bulkCreate (triggered by the transaction) should call save with the provided transactionManager.
+      expect(saveSpy).toHaveBeenCalledWith(dummyEntities, transactionManagerMock);
+    });
+  });
+
+  describe('create', () => {
+    let dummyEntity: TestEntity;
+    let qbMock: SQLQueryBuilderService;
+    let service: TypeORMDBEntityService<TestEntity>;
+    beforeEach(() => {
+      qbMock = createQBMock();
+      queryBuilderMock = {
+        getCount: vi.fn().mockResolvedValue(5),
+        getOne: vi.fn().mockResolvedValue(dummyEntity)
+      };
+      repositoryMock = createRepositoryMock(queryBuilderMock);
+      transactionManagerMock = (repositoryMock as unknown as TransactionManagerGetter).__getTransactionManager();
+      const dummySchema = new EntitySchema<TestEntity>({
+        name: 'TestEntity',
+        columns: { id: { type: Number, primary: true }, name: { type: String } }
+      });
+      service = new TypeORMDBEntityService<TestEntity>(qbMock, repositoryMock, dummySchema);
+      dummyEntity = { id: 1, name: 'Test' };
+    });
+    it('should call save and return the entity when transactionManager is provided', async () => {
+      const saveSpy = vi
+        .spyOn(
+          service as unknown as { save(_data: TestEntity, _transactionManager?: EntityManager): Promise<TestEntity> },
+          'save'
+        )
+        .mockResolvedValue(dummyEntity);
+      const options: CreateOptions = { forceTransaction: false, transactionManager: transactionManagerMock };
+      const result = await service.create(dummyEntity, options);
+      expect(result).toEqual(dummyEntity);
+      expect(saveSpy).toHaveBeenCalledWith(dummyEntity, transactionManagerMock);
+    });
+    it('should use transaction when forceTransaction is true and no transactionManager is provided', async () => {
+      const saveSpy = vi
+        .spyOn(
+          service as unknown as { save(_data: TestEntity, _transactionManager?: EntityManager): Promise<TestEntity> },
+          'save'
+        )
+        .mockResolvedValue(dummyEntity);
+      const options: CreateOptions = { forceTransaction: true };
+      const transactionSpy = repositoryMock.manager.transaction as ReturnType<typeof vi.fn>;
+      const result = await service.create(dummyEntity, options);
+      expect(result).toEqual(dummyEntity);
+      expect(transactionSpy).toHaveBeenCalledTimes(1);
+      expect(saveSpy).toHaveBeenCalledWith(dummyEntity, transactionManagerMock);
+    });
+    it('should throw ApplicationError with specific message when unique violation occurs with matching regex', async () => {
+      const saveSpy = vi
+        .spyOn(
+          service as unknown as { save(_data: TestEntity, _transactionManager?: EntityManager): Promise<TestEntity> },
+          'save'
+        )
+        .mockImplementation(() => {
+          throw new PostgresError('err', {
+            code: PostgresErrorCode.UniqueViolation,
+            detail: 'Key (name)=Test',
+            table: 'TestEntity'
+          });
+        });
+      const options: CreateOptions = { forceTransaction: false, transactionManager: transactionManagerMock };
+      await expect(service.create(dummyEntity, options)).rejects.toEqual(
+        new ApplicationError('TestEntity: name needs to be unique')
+      );
+      expect(saveSpy).toHaveBeenCalledWith(dummyEntity, transactionManagerMock);
+    });
+    it('should throw ApplicationError with default message when unique violation occurs with non matching detail', async () => {
+      const errorObj = {
+        code: PostgresErrorCode.UniqueViolation,
+        detail: 'Non matching detail',
+        table: 'TestEntity'
+      };
+      const saveSpy = vi
+        .spyOn(
+          service as unknown as { save(_data: TestEntity, _transactionManager?: EntityManager): Promise<TestEntity> },
+          'save'
+        )
+        .mockRejectedValue(errorObj);
+      const options: CreateOptions = { forceTransaction: false, transactionManager: transactionManagerMock };
+      await expect(service.create(dummyEntity, options)).rejects.toEqual(
+        new ApplicationError('TestEntity: a column value you have provided needs to be unique')
+      );
+      expect(saveSpy).toHaveBeenCalledWith(dummyEntity, transactionManagerMock);
+    });
+    it('should rethrow error if error code is not UniqueViolation', async () => {
+      const errorObj = {
+        code: 'SomeOtherError',
+        message: 'Error occurred'
+      };
+      const saveSpy = vi
+        .spyOn(
+          service as unknown as { save(_data: TestEntity, _transactionManager?: EntityManager): Promise<TestEntity> },
+          'save'
+        )
+        .mockRejectedValue(errorObj);
+      const options: CreateOptions = { forceTransaction: false, transactionManager: transactionManagerMock };
+      await expect(service.create(dummyEntity, options)).rejects.toEqual(errorObj);
+      expect(saveSpy).toHaveBeenCalledWith(dummyEntity, transactionManagerMock);
+    });
+  });
+
+  describe('count', () => {
+    let qbMock: SQLQueryBuilderService;
+    let queryBuilderCountMock: QueryBuilderMock;
+    let service: TypeORMDBEntityService<TestEntity>;
+    beforeEach(() => {
+      // Create a qbMock with our dummy implementations.
+      qbMock = createQBMock();
+      // Create a dummy query builder for count that implements getCount.
+      queryBuilderCountMock = {
+        getCount: vi.fn().mockResolvedValue(5),
+        getOne: vi.fn().mockResolvedValue(dummyEntity)
+      };
+      // Create a repository mock that returns our count query builder.
+      repositoryMock = createRepositoryMock(queryBuilderCountMock);
+      transactionManagerMock = (repositoryMock as unknown as TransactionManagerGetter).__getTransactionManager();
+      // Build a dummy schema with a single primary key.
+      const dummySchema = new EntitySchema<TestEntity>({
+        name: 'TestEntity',
+        columns: {
+          id: { type: Number, primary: true },
+          name: { type: String }
+        }
+      });
+      service = new TypeORMDBEntityService<TestEntity>(qbMock, repositoryMock, dummySchema);
+    });
+    it('should return count when transactionManager is provided', async () => {
+      const options: CountOptions = {
+        filters: { id: 1 },
+        forceTransaction: false,
+        transactionManager: transactionManagerMock,
+        withDeleted: true
+      };
+      const count = await service.count(options);
+      expect(count).toEqual(5);
+      // Verify that parseFilters was called with correct arguments.
+      expect(qbMock.parseFilters).toHaveBeenCalledWith('TestEntity', options.filters);
+      // Verify that parseRelations is called.
+      expect(qbMock.parseRelations).toHaveBeenCalledWith('TestEntity', [], { dummyInclude: true });
+      // Verify that buildQuery is called with the proper parameters.
+      expect(qbMock.buildQuery).toHaveBeenCalledTimes(1);
+    });
+    it('should use a transaction when forceTransaction is true and transactionManager is not provided', async () => {
+      const transactionSpy = vi.spyOn(repositoryMock.manager, 'transaction');
+      const options: CountOptions = {
+        filters: { id: 1 },
+        forceTransaction: true,
+        withDeleted: false
+      };
+      const count = await service.count(options);
+      expect(count).toEqual(5);
+      expect(transactionSpy).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('delete', () => {
+    const dummyFilters = { id: 1 };
+    let qbMock: SQLQueryBuilderService;
+    let deleteQueryBuilderMock: QueryBuilderMock;
+    let dummySchema: EntitySchema<TestEntity>;
+    let service: TypeORMDBEntityService<TestEntity>;
+    beforeEach(() => {
+      qbMock = createQBMock();
+      dummySchema = new EntitySchema<TestEntity>({
+        name: 'TestEntity',
+        columns: {
+          id: { type: Number, primary: true },
+          name: { type: String }
+        }
+      });
+      // Create a dummy query builder with only an execute method.
+      deleteQueryBuilderMock = {
+        delete: vi.fn().mockReturnThis(),
+        execute: vi.fn(),
+        getMany: vi.fn().mockResolvedValue([]),
+        returning: vi.fn().mockReturnThis(),
+        set: vi.fn().mockReturnThis(),
+        skip: vi.fn().mockReturnThis(),
+        softDelete: vi.fn().mockReturnThis(),
+        take: vi.fn().mockReturnThis(),
+        update: vi.fn().mockReturnThis()
+      };
+      repositoryMock = createRepositoryMock(deleteQueryBuilderMock);
+      transactionManagerMock = (repositoryMock as unknown as TransactionManagerGetter).__getTransactionManager();
+      service = new TypeORMDBEntityService<TestEntity>(qbMock, repositoryMock, dummySchema);
+    });
+    it('should use a transaction when forceTransaction is true and no transactionManager is provided', async () => {
+      const options = { filters: dummyFilters, forceTransaction: true, softDelete: true };
+      // Stub parseFilters to return a dummy where clause with an empty include.
+      vi.spyOn(qbMock, 'parseFilters').mockReturnValue({
+        where: { dummy: { params: { a: 1 }, query: 'dummyQuery' } },
+        include: {}
+      });
+      // Stub buildQuery as no-op.
+      vi.spyOn(qbMock, 'buildQuery').mockImplementation(() => {});
+      (deleteQueryBuilderMock.execute as ReturnType<typeof vi.fn>).mockResolvedValue({ affected: 2 });
+      const result = await service.delete(options);
+      expect(repositoryMock.manager.transaction).toHaveBeenCalled();
+      expect(result).toEqual({ count: 2 });
+    });
+    it('should delete using softDelete when include is empty', async () => {
+      const options = {
+        filters: dummyFilters,
+        forceTransaction: false,
+        softDelete: true,
+        transactionManager: transactionManagerMock
+      };
+      // Stub parseFilters to return an empty include.
+      vi.spyOn(qbMock, 'parseFilters').mockReturnValue({
+        where: { dummy: { params: { a: 1 }, query: 'dummyQuery' } },
+        include: {}
+      });
+      vi.spyOn(qbMock, 'buildQuery').mockImplementation(() => {});
+      (deleteQueryBuilderMock.execute as ReturnType<typeof vi.fn>).mockResolvedValue({ affected: 3 });
+      const result = await service.delete(options);
+      expect(qbMock.parseFilters).toHaveBeenCalledWith('TestEntity', dummyFilters);
+      expect(qbMock.buildQuery).toHaveBeenCalledWith(deleteQueryBuilderMock, {
+        where: { dummy: { params: { a: 1 }, query: 'dummyQuery' } }
+      });
+      expect(result).toEqual({ count: 3 });
+    });
+    it('should delete using hard delete when softDelete is false and include is empty', async () => {
+      const options = {
+        filters: dummyFilters,
+        forceTransaction: false,
+        softDelete: false,
+        transactionManager: transactionManagerMock
+      };
+      vi.spyOn(qbMock, 'parseFilters').mockReturnValue({
+        where: { dummy: { params: { a: 2 }, query: 'dummyQuery2' } },
+        include: {}
+      });
+      vi.spyOn(qbMock, 'buildQuery').mockImplementation(() => {});
+      (deleteQueryBuilderMock.execute as ReturnType<typeof vi.fn>).mockResolvedValue({ affected: 4 });
+      const result = await service.delete(options);
+      expect(qbMock.buildQuery).toHaveBeenCalledWith(deleteQueryBuilderMock, {
+        where: { dummy: { params: { a: 2 }, query: 'dummyQuery2' } }
+      });
+      expect(result).toEqual({ count: 4 });
+    });
+    it('should delete using include branch when include is not empty', async () => {
+      const options = {
+        filters: dummyFilters,
+        forceTransaction: false,
+        softDelete: true,
+        transactionManager: transactionManagerMock
+      };
+      // Stub parseFilters to return a non-empty include.
+      vi.spyOn(qbMock, 'parseFilters').mockReturnValue({
+        where: { dummy: { params: { a: 3 }, query: 'dummyQuery3' } },
+        include: { relation: 'relationName' }
+      });
+      // Stub the find method to return a dummy find result.
+      const findResult = { items: [{ id: 1, name: 'Test' }] };
+      const findSpy = vi.spyOn(service, 'find').mockResolvedValue(findResult as DataFindResults<TestEntity>);
+      vi.spyOn(qbMock, 'buildQuery').mockImplementation(() => {});
+      (deleteQueryBuilderMock.execute as ReturnType<typeof vi.fn>).mockResolvedValue({ affected: 5 });
+      // The expected where clause is produced by buildPrimaryKeyWhereClause.
+      // For a single primary key "id", it should be:
+      // { field: "id", value: { params: { id: [1] }, query: `"TestEntity"."id" in :id` } }
+      const expectedPKClause = { field: 'id', value: { params: { id: [1] }, query: '"TestEntity"."id" in :id' } };
+      const result = await service.delete(options);
+      expect(findSpy).toHaveBeenCalledWith({ filters: dummyFilters, transactionManager: transactionManagerMock });
+      expect(qbMock.buildQuery).toHaveBeenCalledWith(deleteQueryBuilderMock, {
+        where: { [expectedPKClause.field]: expectedPKClause.value }
+      });
+      expect(result).toEqual({ count: 5 });
+    });
+  });
+
+  describe('find', () => {
+    let findQueryBuilderMock: QueryBuilderMock;
+    let service: TypeORMDBEntityService<TestEntity>;
+    let qbMock: SQLQueryBuilderService;
+    beforeEach(() => {
+      qbMock = createQBMock();
+      // Create a dummy query builder that simulates chainable skip and take, and a getMany method.
+      findQueryBuilderMock = {
+        skip: vi.fn().mockReturnThis(),
+        take: vi.fn().mockReturnThis(),
+        getMany: vi.fn().mockResolvedValue([])
+      };
+      repositoryMock = createRepositoryMock(findQueryBuilderMock);
+      transactionManagerMock = (repositoryMock as unknown as TransactionManagerGetter).__getTransactionManager();
+      const dummySchema = new EntitySchema<TestEntity>({
+        name: 'TestEntity',
+        columns: {
+          id: { type: Number, primary: true },
+          name: { type: String }
+        }
+      });
+      service = new TypeORMDBEntityService<TestEntity>(qbMock, repositoryMock, dummySchema);
+    });
+    it('should return paginated results with "more" flag true when items length equals perPage+1', async () => {
+      // If perPage is 2, then perPage + 1 is 3.
+      const dummyItems: TestEntity[] = [
+        { id: 1, name: 'A' },
+        { id: 2, name: 'B' },
+        { id: 3, name: 'C' }
+      ];
+      findQueryBuilderMock.getMany = vi.fn().mockResolvedValue(dummyItems);
+      const options = {
+        filters: { name: 'test' },
+        forceTransaction: false,
+        page: 1,
+        perPage: 2,
+        findAll: false,
+        transactionManager: transactionManagerMock,
+        withDeleted: false
+      };
+      const results = await service.find(options);
+      // With page=1 and perPage=2, skip should be called with 0 and take with 3.
+      expect(findQueryBuilderMock.skip).toHaveBeenCalledWith(0);
+      expect(findQueryBuilderMock.take).toHaveBeenCalledWith(2 + 1);
+      // The service should pop the extra item and set "more" to true.
+      expect(results.page).toBe(1);
+      expect(results.perPage).toBe(2);
+      expect(results.more).toBe(true);
+      expect(results.items).toEqual(dummyItems.slice(0, 2));
+    });
+    it('should return paginated results with "more" flag false when items length is less than perPage+1', async () => {
+      const dummyItems: TestEntity[] = [
+        { id: 1, name: 'A' },
+        { id: 2, name: 'B' }
+      ];
+      findQueryBuilderMock.getMany = vi.fn().mockResolvedValue(dummyItems);
+      const options = {
+        filters: { name: 'test' },
+        forceTransaction: false,
+        page: 1,
+        perPage: 2,
+        findAll: false,
+        transactionManager: transactionManagerMock,
+        withDeleted: false
+      };
+      const results = await service.find(options);
+      expect(findQueryBuilderMock.skip).toHaveBeenCalledWith(0);
+      expect(findQueryBuilderMock.take).toHaveBeenCalledWith(3);
+      expect(results.page).toBe(1);
+      expect(results.perPage).toBe(2);
+      expect(results.more).toBe(false);
+      expect(results.items).toEqual(dummyItems);
+    });
+    it('should process orderBy option if provided', async () => {
+      // Prepare dummy items to be returned by getMany.
+      const dummyItems: TestEntity[] = [
+        { id: 1, name: 'A' },
+        { id: 2, name: 'B' }
+      ];
+      // Simulate getMany returning our dummy items.
+      findQueryBuilderMock.getMany = vi.fn().mockResolvedValue(dummyItems);
+      // Create a fake orderBy data to be returned by parseOrderBy.
+      const orderByData = {
+        orderBy: [{ column: 'id', order: 'DESC' }] as unknown as DataOrderBy[],
+        include: { extraOrder: true } as unknown as IncludeItems
+      };
+      const parseOrderBySpy = vi.spyOn(qbMock, 'parseOrderBy').mockReturnValue(orderByData);
+      const options = {
+        filters: { name: 'test' },
+        forceTransaction: false,
+        page: 1,
+        perPage: 10,
+        findAll: false,
+        transactionManager: transactionManagerMock,
+        withDeleted: false,
+        orderBy: 'id_DESC'
+      };
+      const results = await service.find(options as unknown as FindOptions);
+      // Verify that parseOrderBy was called with the proper table name and orderBy value.
+      expect(parseOrderBySpy).toHaveBeenCalledWith('TestEntity', 'id_DESC');
+      // Verify that the overall include contains the extra include from orderBy.
+      // Also, check that qbMock.buildQuery was called with the orderBy array from orderByData.
+      expect(qbMock.buildQuery).toHaveBeenCalledWith(
+        findQueryBuilderMock,
+        expect.objectContaining({
+          orderBy: orderByData.orderBy
+        })
+      );
+      // Confirm the results remain consistent with pagination.
+      expect(results.page).toBe(1);
+      expect(results.perPage).toBe(10);
+      expect(results.items).toEqual(dummyItems);
+    });
+    it('should return all results when findAll is true and not call skip/take', async () => {
+      const dummyItems: TestEntity[] = [
+        { id: 1, name: 'A' },
+        { id: 2, name: 'B' },
+        { id: 3, name: 'C' }
+      ];
+      findQueryBuilderMock.getMany = vi.fn().mockResolvedValue(dummyItems);
+      const options = {
+        filters: { name: 'test' },
+        forceTransaction: false,
+        page: 1,
+        perPage: 2,
+        findAll: true,
+        transactionManager: transactionManagerMock,
+        withDeleted: false
+      };
+      const results = await service.find(options);
+      // In the "findAll" branch, skip() and take() should not be called.
+      expect(findQueryBuilderMock.skip).not.toHaveBeenCalled();
+      expect(findQueryBuilderMock.take).not.toHaveBeenCalled();
+      // findResults.perPage is set to the length of the returned items.
+      expect(results.page).toBe(1);
+      expect(results.perPage).toBe(dummyItems.length);
+      expect(results.more).toBe(false);
+      expect(results.items).toEqual(dummyItems);
+    });
+    it('should parse page and perPage as numbers when provided as strings', async () => {
+      const dummyItems: TestEntity[] = [
+        { id: 1, name: 'A' },
+        { id: 2, name: 'B' },
+        { id: 3, name: 'C' }
+      ];
+      findQueryBuilderMock.getMany = vi.fn().mockResolvedValue(dummyItems);
+      const options = {
+        filters: { name: 'test' },
+        forceTransaction: false,
+        page: '2', // provided as string
+        perPage: '2', // provided as string
+        findAll: false,
+        transactionManager: transactionManagerMock,
+        withDeleted: false
+      };
+      const results = await service.find(options as unknown as FindOptions);
+      // For page "2" and perPage "2": skip = (2 - 1) * 2 = 2, take = 3.
+      expect(findQueryBuilderMock.skip).toHaveBeenCalledWith(2);
+      expect(findQueryBuilderMock.take).toHaveBeenCalledWith(2 + 1);
+      expect(results.page).toBe(2);
+      expect(results.perPage).toBe(2);
+    });
+    it('should use a transaction when forceTransaction is true and no transactionManager is provided', async () => {
+      const transactionSpy = vi.spyOn(repositoryMock.manager, 'transaction');
+      // For this branch, simulate getMany returning an empty array.
+      findQueryBuilderMock.getMany = vi.fn().mockResolvedValue([]);
+      const options = {
+        filters: { name: 'test' },
+        forceTransaction: true,
+        page: 1,
+        perPage: 2,
+        findAll: false,
+        withDeleted: false
+      };
+      const results = await service.find(options);
+      expect(transactionSpy).toHaveBeenCalledTimes(1);
+      expect(results.items).toEqual([]);
+      expect(results.page).toEqual(1);
+      expect(results.perPage).toEqual(2);
+    });
+  });
+
+  describe('findOne', () => {
+    let qbMock: SQLQueryBuilderService;
+    let service: TypeORMDBEntityService<TestEntity>;
+    beforeEach(() => {
+      // Reset mocks before each test.
+      qbMock = createQBMock();
+      // Create a repository mock that uses our dummy query builder.
+      repositoryMock = createRepositoryMock(queryBuilderMock);
+      transactionManagerMock = (repositoryMock as unknown as TransactionManagerGetter).__getTransactionManager();
+      // Create a dummy schema with one primary key ("id") and one extra column.
+      const dummySchema = new EntitySchema<TestEntity>({
+        name: 'TestEntity',
+        columns: {
+          id: { type: Number, primary: true },
+          name: { type: String }
+        }
+      });
+      service = new TypeORMDBEntityService<TestEntity>(qbMock, repositoryMock, dummySchema);
+      // Clear mock history.
+      vi.clearAllMocks();
+    });
+    it('should return the entity when found without forceTransaction and without orderBy', async () => {
+      const options: FindOneOptions = {
+        filters: { id: 1 },
+        forceTransaction: false,
+        transactionManager: transactionManagerMock,
+        withDeleted: false
+      };
+      const result = await service.findOne(options);
+      expect(result).toEqual(dummyEntity);
+      // Verify that parseFilters was called with the correct arguments.
+      expect(qbMock.parseFilters).toHaveBeenCalledWith('TestEntity', options.filters, {
+        operator: undefined,
+        isTopLevel: true
+      });
+      // When no relations are passed, the optRelations defaults to an empty array.
+      expect(qbMock.parseRelations).toHaveBeenCalledWith('TestEntity', [], { dummyInclude: true });
+      // Since no orderBy option is provided, the orderBy array should be empty.
+      expect(qbMock.buildQuery).toHaveBeenCalledWith(queryBuilderMock, {
+        where: { dummy: 'filter' },
+        include: { dummyInclude: true, extraRelation: true },
+        orderBy: [],
+        withDeleted: false
+      });
+    });
+    it('should return the entity when found with orderBy provided', async () => {
+      const options: FindOneOptions = {
+        filters: { id: 1 },
+        forceTransaction: false,
+        transactionManager: transactionManagerMock,
+        orderBy: 'id_ASC' as unknown as GenericObject<string>,
+        withDeleted: true
+      };
+      const result = await service.findOne(options);
+      expect(result).toEqual(dummyEntity);
+      expect(qbMock.parseFilters).toHaveBeenCalledWith('TestEntity', options.filters, {
+        operator: undefined,
+        isTopLevel: true
+      });
+      expect(qbMock.parseRelations).toHaveBeenCalledWith('TestEntity', [], { dummyInclude: true });
+      expect(qbMock.parseOrderBy).toHaveBeenCalledWith('TestEntity', options.orderBy);
+      expect(qbMock.buildQuery).toHaveBeenCalledWith(queryBuilderMock, {
+        where: { dummy: 'filter' },
+        include: { dummyInclude: true, extraRelation: true },
+        orderBy: [{ column: 'id', order: 'ASC' }],
+        withDeleted: true
+      });
+    });
+    it('should pass selectOperator to parseFilters if provided', async () => {
+      // Here we cast the string to unknown and then to the expected type.
+      const options: FindOneOptions = {
+        filters: { id: 1 },
+        forceTransaction: false,
+        transactionManager: transactionManagerMock,
+        selectOperator: 'customOperator' as unknown as FindOneOptions['selectOperator'],
+        withDeleted: false
+      };
+      const result = await service.findOne(options);
+      expect(result).toEqual(dummyEntity);
+      expect(qbMock.parseFilters).toHaveBeenCalledWith('TestEntity', options.filters, {
+        operator: 'customOperator',
+        isTopLevel: true
+      });
+    });
+    it('should use a transaction when forceTransaction is true and transactionManager is not provided', async () => {
+      const options: FindOneOptions = {
+        filters: { id: 1 },
+        forceTransaction: true,
+        withDeleted: false
+      };
+      const result = await service.findOne(options);
+      expect(result).toEqual(dummyEntity);
+      expect(repositoryMock.manager.transaction).toHaveBeenCalledTimes(1);
+      // qb.buildQuery should be called in the recursive call.
+      expect(qbMock.buildQuery).toHaveBeenCalled();
+    });
+  });
+
+  describe('getEntityTarget', () => {
+    it('should return the repository target', () => {
+      const qbMock = createQBMock();
+      // Create a dummy entity target (can be a function or string)
+      const dummyTarget = 'TestEntityTarget';
+      // Create a dummy schema for our test entity.
+      const dummySchema = new EntitySchema<TestEntity>({
+        name: 'TestEntity',
+        columns: {
+          id: { type: Number, primary: true },
+          name: { type: String }
+        }
+      });
+      // Create a dummy repository that includes the target.
+      const repositoryForTarget = {
+        metadata: { name: 'TestEntity', tableName: 'TestEntity' },
+        target: dummyTarget,
+        createQueryBuilder: vi.fn(),
+        manager: { transaction: vi.fn() }
+      } as unknown as Repository<TestEntity>;
+      // Instantiate the service with the dummy repository.
+      const service = new TypeORMDBEntityService<TestEntity>(qbMock, repositoryForTarget, dummySchema);
+      // Verify that getEntityTarget returns the repository's target.
+      expect(service.getEntityTarget()).toEqual(dummyTarget);
+    });
+  });
+
+  describe('getRepository', () => {
+    let qbMock: SQLQueryBuilderService;
+    let repositoryForTest: Repository<TestEntity>;
+    let service: TypeORMDBEntityService<TestEntity>;
+    beforeEach(() => {
+      qbMock = createQBMock();
+      // Create a dummy repository with a target.
+      repositoryForTest = {
+        metadata: { name: 'TestEntity', tableName: 'TestEntity' },
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+        target: 'TestEntityTarget' as unknown as Function,
+        createQueryBuilder: vi.fn(),
+        manager: { transaction: vi.fn() }
+      } as unknown as Repository<TestEntity>;
+      const dummySchema = new EntitySchema<TestEntity>({
+        name: 'TestEntity',
+        columns: {
+          id: { type: Number, primary: true },
+          name: { type: String }
+        }
+      });
+      service = new TypeORMDBEntityService<TestEntity>(qbMock, repositoryForTest, dummySchema);
+    });
+    it('should return the repository when no transactionManager is provided', () => {
+      const result = service['getRepository']();
+      expect(result).toEqual(repositoryForTest);
+    });
+    it('should return the repository from the transactionManager when provided', () => {
+      const dummyRepoFromTM = { ...repositoryForTest, extraProp: 'dummy' };
+      const transactionManager: EntityManager = {
+        getRepository: vi.fn().mockReturnValue(dummyRepoFromTM)
+      } as unknown as EntityManager;
+      const result = service['getRepository'](transactionManager);
+      expect(transactionManager.getRepository).toHaveBeenCalledWith(repositoryForTest.target);
+      expect(result).toEqual(dummyRepoFromTM);
+    });
+  });
+
+  describe('processManyToMany', () => {
+    let qbMock: SQLQueryBuilderService;
+    let service: TypeORMDBEntityService<TestEntity>;
+    // Use a simple dummy schema; the entity type details are not important for this test.
+    const dummySchema = new EntitySchema<TestEntity>({
+      name: 'TestEntity',
+      columns: {
+        id: { type: Number, primary: true },
+        name: { type: String }
+      }
+    });
+    beforeEach(() => {
+      // Create a qbMock with a defined columnQuotesSymbol.
+      qbMock = createQBMock();
+      qbMock.columnQuotesSymbol = '"';
+      // Create a dummy repository (its methods won't be used except for transaction handling).
+      // repositoryMock = createRepositoryMock({} as FindQueryBuilderMock, 'TestEntity');
+      repositoryMock = createRepositoryMock(queryBuilderMock);
+      transactionManagerMock = (repositoryMock as unknown as TransactionManagerGetter).__getTransactionManager();
+      // Instantiate the service.
+      service = new TypeORMDBEntityService<TestEntity>(qbMock, repositoryMock, dummySchema);
+    });
+    it('should use a transaction when no transactionManager is provided', async () => {
+      // Create a fake transaction manager with a spy on the query method.
+      const data = {
+        counterpartColumn: 'counterpart',
+        currentEntityColumn: 'current',
+        id: 42,
+        tableName: 'TestTable',
+        items: [] // no items
+      };
+      await service['processManyToMany'](data);
+      expect(repositoryMock.manager.transaction).toHaveBeenCalledTimes(1);
+      // With no items, no query should be executed.
+      expect(transactionManagerMock.query).not.toHaveBeenCalled();
+    });
+    it('should execute both delete and insert queries for mixed items', async () => {
+      const data = {
+        counterpartColumn: 'counterpart',
+        currentEntityColumn: 'current',
+        id: 42,
+        tableName: 'TestTable',
+        items: [
+          { deleted: true, value: 10 },
+          { deleted: false, value: 20 }
+        ]
+      };
+      await service['processManyToMany'](data, { transactionManager: transactionManagerMock });
+      // Expected delete query:
+      // Initially: deleteQuery = `delete from "TestTable" where `
+      // After first (deleted) item: becomes `delete from "TestTable" where ("current" = 42 and "counterpart" = 10)`
+      const expectedDeleteQuery = 'delete from "TestTable" where ("current" = 42 and "counterpart" = 10)';
+      // Expected insert query:
+      // insertQuery = `insert into "TestTable" ("current", "counterpart") values (42, 20) on conflict do nothing`
+      const expectedInsertQuery =
+        'insert into "TestTable" ("current", "counterpart") values (42, 20) on conflict do nothing';
+      // Expect query to be called twice in order: first delete then insert.
+      expect(transactionManagerMock.query).toHaveBeenNthCalledWith(1, expectedDeleteQuery);
+      expect(transactionManagerMock.query).toHaveBeenNthCalledWith(2, expectedInsertQuery);
+    });
+    it('should execute only a delete query when all items are deleted', async () => {
+      const data = {
+        counterpartColumn: 'counterpart',
+        currentEntityColumn: 'current',
+        id: 42,
+        tableName: 'TestTable',
+        items: [
+          { deleted: true, value: 10 },
+          { deleted: true, value: 15 }
+        ]
+      };
+      await service['processManyToMany'](data, { transactionManager: transactionManagerMock });
+      // Expected delete query:
+      // After first item: `delete from "TestTable" where ("current" = 42 and "counterpart" = 10)`
+      // After second item: appended with ` or ("current" = 42 and "counterpart" = 15)`
+      const expectedDeleteQuery =
+        'delete from "TestTable" where ("current" = 42 and "counterpart" = 10) or ("current" = 42 and "counterpart" = 15)';
+      expect(transactionManagerMock.query).toHaveBeenCalledTimes(1);
+      expect(transactionManagerMock.query).toHaveBeenCalledWith(expectedDeleteQuery);
+    });
+    it('should execute only an insert query when all items are not deleted', async () => {
+      const data = {
+        counterpartColumn: 'counterpart',
+        currentEntityColumn: 'current',
+        id: 42,
+        tableName: 'TestTable',
+        items: [
+          { deleted: false, value: 20 },
+          { deleted: false, value: 30 }
+        ]
+      };
+      await service['processManyToMany'](data, { transactionManager: transactionManagerMock });
+      // Expected insert query:
+      // For first item: `insert into "TestTable" ("current", "counterpart") values (42, 20)`
+      // For second item: appended with `, (42, 30)`
+      // Final query with on conflict clause:
+      const expectedInsertQuery =
+        'insert into "TestTable" ("current", "counterpart") values (42, 20), (42, 30) on conflict do nothing';
+      expect(transactionManagerMock.query).toHaveBeenCalledTimes(1);
+      expect(transactionManagerMock.query).toHaveBeenCalledWith(expectedInsertQuery);
+    });
+    it('should not execute any queries when items array is empty', async () => {
+      const data = {
+        counterpartColumn: 'counterpart',
+        currentEntityColumn: 'current',
+        id: 42,
+        tableName: 'TestTable',
+        items: [] as { deleted: boolean; value: number }[]
+      };
+      await service['processManyToMany'](data, { transactionManager: transactionManagerMock });
+      expect(transactionManagerMock.query).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('save', () => {
+    let dummyData: TestEntity;
+    let dummySchema: EntitySchema<TestEntity>;
+    let qbMock: SQLQueryBuilderService;
+    let repositoryForSave: Repository<TestEntity>;
+    let service: TypeORMDBEntityService<TestEntity>;
+    beforeEach(() => {
+      qbMock = createQBMock();
+      dummyData = { id: 1, name: 'Test' };
+      // Create a dummy repository that includes a save method.
+      repositoryForSave = {
+        metadata: { name: 'TestEntity', tableName: 'TestEntity' },
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+        target: 'TestEntityTarget' as unknown as Function,
+        save: vi.fn().mockResolvedValue(dummyData),
+        createQueryBuilder: vi.fn(),
+        manager: { transaction: vi.fn() }
+      } as unknown as Repository<TestEntity>;
+      dummySchema = new EntitySchema<TestEntity>({
+        name: 'TestEntity',
+        columns: {
+          id: { type: Number, primary: true },
+          name: { type: String }
+        }
+      });
+      service = new TypeORMDBEntityService<TestEntity>(qbMock, repositoryForSave, dummySchema);
+    });
+    it('should call transactionManager.save when transactionManager is provided', async () => {
+      // Create a dummy transaction manager with a save method.
+      const tmSaveSpy = vi.fn().mockResolvedValue(dummyData);
+      const dummyTransactionManager: EntityManager = { save: tmSaveSpy } as unknown as EntityManager;
+      const result = await service['save'](dummyData, dummyTransactionManager);
+      expect(tmSaveSpy).toHaveBeenCalledWith(repositoryForSave.target, dummyData);
+      expect(result).toEqual(dummyData);
+    });
+    it('should call repository.save when no transactionManager is provided', async () => {
+      const repoSaveSpy = repositoryForSave.save as ReturnType<typeof vi.fn>;
+      const result = await service['save'](dummyData);
+      expect(repoSaveSpy).toHaveBeenCalledWith(dummyData);
+      expect(result).toEqual(dummyData);
+    });
+  });
+
+  describe('update', () => {
+    let dummySchema: EntitySchema<TestEntity>;
+    let dummyEntity: TestEntity;
+    let qbMock: SQLQueryBuilderService;
+    let service: TypeORMDBEntityService<TestEntity>;
+    let updateQueryBuilderMock: QueryBuilderMock;
+    beforeEach(() => {
+      qbMock = createQBMock();
+      updateQueryBuilderMock = {
+        execute: vi.fn(),
+        getMany: vi.fn().mockResolvedValue([]),
+        returning: vi.fn().mockReturnThis(),
+        set: vi.fn().mockReturnThis(),
+        skip: vi.fn().mockReturnThis(),
+        take: vi.fn().mockReturnThis(),
+        update: vi.fn().mockReturnThis()
+      };
+      repositoryMock = createRepositoryMock(updateQueryBuilderMock);
+      transactionManagerMock = (repositoryMock as unknown as TransactionManagerGetter).__getTransactionManager();
+      dummyEntity = { id: 1, name: 'Test' };
+      dummySchema = new EntitySchema<TestEntity>({
+        columns: {
+          id: { type: Number, primary: true },
+          name: { type: String }
+        },
+        name: 'TestEntity'
+      });
+      service = new TypeORMDBEntityService<TestEntity>(qbMock, repositoryMock, dummySchema);
+      vi.clearAllMocks();
+    });
+    it('should use a transaction when forceTransaction is true and no transactionManager is provided', async () => {
+      (updateQueryBuilderMock.execute as ReturnType<typeof vi.fn>).mockResolvedValue({ affected: 1 });
+      const options = { filters: { name: 'Test' }, forceTransaction: true, returnData: false };
+      const result = await service.update(dummyEntity, options);
+      expect(repositoryMock.manager.transaction).toHaveBeenCalled();
+      expect(result).toEqual({ count: 1 });
+    });
+    it('should update and return count when returnData is false and no include is returned', async () => {
+      const parsedWhere = { dummy: { params: { a: 1 }, query: 'dummy' } };
+      vi.spyOn(qbMock, 'buildQuery').mockImplementation(() => {});
+      vi.spyOn(qbMock, 'parseFilters').mockReturnValue({ where: parsedWhere, include: {} });
+      (updateQueryBuilderMock.execute as ReturnType<typeof vi.fn>).mockResolvedValue({ affected: 2 });
+      const options = {
+        filters: { name: 'Test' },
+        forceTransaction: false,
+        returnData: false,
+        transactionManager: transactionManagerMock
+      };
+      const result = await service.update(dummyEntity, options);
+      expect(qbMock.parseFilters).toHaveBeenCalledWith('TestEntity', { name: 'Test' });
+      expect(qbMock.buildQuery).toHaveBeenCalledWith(updateQueryBuilderMock, { where: parsedWhere });
+      expect(result).toEqual({ count: 2 });
+    });
+    it('should update and return data when returnData is true', async () => {
+      const parsedWhere = { dummy: { params: { a: 1 }, query: 'dummy' } };
+      vi.spyOn(qbMock, 'buildQuery').mockImplementation(() => {});
+      vi.spyOn(qbMock, 'parseFilters').mockReturnValue({ where: parsedWhere, include: {} });
+      // Simulate the returning branch.
+      (updateQueryBuilderMock.returning as ReturnType<typeof vi.fn>).mockReturnThis();
+      const fakeRaw: TestEntity[] = [dummyEntity];
+      (updateQueryBuilderMock.execute as ReturnType<typeof vi.fn>).mockResolvedValue({ raw: fakeRaw });
+      const options = {
+        filters: { name: 'Test' },
+        forceTransaction: false,
+        returnData: true,
+        transactionManager: transactionManagerMock
+      };
+      const result = await service.update(dummyEntity, options);
+      expect(qbMock.buildQuery).toHaveBeenCalledWith(updateQueryBuilderMock, { where: parsedWhere });
+      expect(result).toEqual({ items: fakeRaw });
+    });
+    it('should update using include branch by calling find and buildPrimaryKeyWhereClause', async () => {
+      // Simulate a non-empty include.
+      const includeObj = { related: true };
+      const parsedWhere = { dummy: { params: { a: 1 }, query: 'dummy' } };
+      vi.spyOn(qbMock, 'parseFilters').mockReturnValue({
+        where: parsedWhere,
+        include: includeObj as unknown as IncludeItems
+      });
+      // Stub the find method to return a dummy result.
+      const findResult = { items: [dummyEntity] };
+      vi.spyOn(service, 'find').mockResolvedValue(findResult as unknown as DataFindResults<TestEntity>);
+      vi.spyOn(qbMock, 'buildQuery').mockImplementation(() => {});
+      (updateQueryBuilderMock.execute as ReturnType<typeof vi.fn>).mockResolvedValue({ affected: 3 });
+      const options = {
+        filters: { name: 'Test' },
+        forceTransaction: false,
+        returnData: false,
+        transactionManager: transactionManagerMock
+      };
+      const result = await service.update(dummyEntity, options);
+      // Use the actual buildPrimaryKeyWhereClause to compute expected where clause.
+      const expectedPKClause = service['buildPrimaryKeyWhereClause'](findResult.items);
+      const expectedWhere = { [expectedPKClause.field]: expectedPKClause.value };
+      expect(qbMock.buildQuery).toHaveBeenCalledWith(updateQueryBuilderMock, { where: expectedWhere });
+      expect(result).toEqual({ count: 3 });
+    });
+  });
+});