GenerateUniqueInt Class — drizzle-orm Architecture

Source Code

drizzle-seed/src/services/Generators.ts lines 643–813

export class GenerateUniqueInt extends AbstractGenerator<{
	minValue?: number | bigint;
	maxValue?: number | bigint;
	isUnique?: boolean;
}> {
	static override readonly entityKind: string = 'GenerateUniqueInt';

	public genMaxRepeatedValuesCount: GenerateDefault | GenerateWeightedCount | undefined;
	public skipCheck?: boolean = false;
	public state: {
		rng: prand.RandomGenerator;
		minValue: number | bigint;
		maxValue: number | bigint;
		intervals: (number | bigint)[][];
		integersCount: Map<number | bigint, number>;
	} | undefined;
	public override isUnique = true;
	public override timeSpent = 0;

	override init({ count, seed }: { count: number; seed: number }) {
		const rng = prand.xoroshiro128plus(seed);
		let { minValue, maxValue } = this.params;

		if (maxValue === undefined) {
			maxValue = count * 10;
		}
		if (minValue === undefined) {
			minValue = -maxValue;
		}

		const intervals = [[minValue, maxValue]];

		const integersCount = new Map();

		if (typeof minValue === 'bigint' && typeof maxValue === 'bigint') {
			if (this.skipCheck === false && maxValue - minValue + BigInt(1) < count) {
				throw new Error(
					'count exceeds max number of unique integers in given range(min, max), try to make range wider.',
				);
			}
		} else if (typeof minValue === 'number' && typeof maxValue === 'number') {
			minValue = minValue >= 0 ? Math.ceil(minValue) : Math.floor(minValue);
			maxValue = maxValue >= 0 ? Math.floor(maxValue) : Math.ceil(maxValue);
			if (this.skipCheck === false && maxValue - minValue + 1 < count) {
				throw new Error(
					'count exceeds max number of unique integers in given range(min, max), try to make range wider.',
				);
			}
		} else {
			throw new Error(
				'minValue and maxValue should be the same type.',
			);
		}

		this.state = { rng, minValue, maxValue, intervals, integersCount };
	}

	generate() {
		if (this.state === undefined) {
			throw new Error('state is not defined.');
		}

		let intervalIdx: number,
			numb: number | bigint | undefined;

		const intervalsToAdd: (number | bigint)[][] = [];

		if (this.state.intervals.length === 0) {
			if (this.skipCheck === false) {
				throw new RangeError(
					'generateUniqueInt: count exceeds max number of unique integers in given range(min, max), try to increase range.',
				);
			} else {
				return;
			}
		}

		[intervalIdx, this.state.rng] = prand.uniformIntDistribution(
			0,
			this.state.intervals.length - 1,
			this.state.rng,