import 'reflect-metadata';
import { expect } from 'chai';
import { DataSource } from '../../../src/data-source/DataSource';
import {
	closeTestingConnections,
	createTestingConnections,
	reloadTestingDatabases,
} from '../../utils/test-utils';
import { TestEntity } from './entity/TestEntity';

describe('github issues > #9341 "bigNumberStrings:false" is not working for postgres', () => {
	let connections: DataSource[];
	before(
		async () =>
			(connections = await createTestingConnections({
				entities: [__dirname + '/entity/*{.js,.ts}'],
				enabledDrivers: ['postgres'],
				driverSpecific: {
					parseInt8: true,
				},
			})),
	);
	beforeEach(() => reloadTestingDatabases(connections));
	after(() => closeTestingConnections(connections));

	it('should fetch big int as number not string when using parseInt8=true', async () => {
		for (const connection of connections) {
			const origin = await connection.getRepository(TestEntity).save({
				big_int: Number.MAX_SAFE_INTEGER,
				big_decimal: 1.23456789,
			});

			const result = await connection.getRepository(TestEntity).findOne({
				where: { id: origin.id },
			});

			// count also returns bigint (as string by default)
			const [{ count }] = await connection.query(
				`select count(*) from (VALUES (1), (2), (3)) as tmp`,
			);

			// big int should be number
			expect(typeof result?.big_int).to.eq('number');
			expect(result?.big_int).to.eq(Number.MAX_SAFE_INTEGER);
			// big decimal should remain string, only int8 is parsed
			expect(typeof result?.big_decimal).to.eq('string');
			expect(result?.big_decimal).to.eq('1.23456789');
			// count should be number (it is int8)
			expect(typeof count).to.eq('number');
			expect(count).to.eq(3);
		}
	});
});