GeneratePhoneNumber Class — drizzle-orm Architecture

Source Code

drizzle-seed/src/services/Generators.ts lines 1887–2081

export class GeneratePhoneNumber extends AbstractGenerator<{
	template?: string;
	prefixes?: string[];
	generatedDigitsNumbers?: number | number[];
	arraySize?: number;
}> {
	static override readonly entityKind: string = 'GeneratePhoneNumber';

	private state: {
		rng: prand.RandomGenerator;
		placeholdersCount?: number;
		prefixesArray: string[];
		generatedDigitsNumbers: number[];
		generatorsMap: Map<string, GenerateUniqueInt>;
		phoneNumbersSet: Set<string>;
	} | undefined;
	public override isUnique = true;

	override init({ count, seed }: { count: number; seed: number }) {
		super.init({ count, seed });

		let { generatedDigitsNumbers } = this.params;
		const { prefixes, template } = this.params;

		const rng = prand.xoroshiro128plus(seed);

		if (template !== undefined) {
			if (this.stringLength !== undefined && this.stringLength < template.length) {
				throw new Error(
					`Length of phone number template is shorter than db column length restriction: ${this.stringLength}. 
					Set the maximum string length to at least ${template.length}.`,
				);
			}

			const iterArray = [...template.matchAll(/#/g)];
			const placeholdersCount = iterArray.length;

			const maxUniquePhoneNumbersCount = Math.pow(10, placeholdersCount);
			if (maxUniquePhoneNumbersCount < count) {
				throw new RangeError(
					`count exceeds max number of unique phone numbers(${maxUniquePhoneNumbersCount}).`,
				);
			}

			const generatorsMap = new Map<string, GenerateUniqueInt>();
			const genObj = new GenerateUniqueInt({ minValue: 0, maxValue: maxUniquePhoneNumbersCount - 1 });
			genObj.init({
				count,
				seed,
			});

			generatorsMap.set(
				template,
				genObj,
			);

			const prefixesArray: string[] = [];
			const generatedDigitsNumbers: number[] = [];
			const phoneNumbersSet = new Set<string>();

			this.state = { rng, placeholdersCount, generatorsMap, prefixesArray, generatedDigitsNumbers, phoneNumbersSet };
			return;
		}

		let prefixesArray: string[];
		if (prefixes === undefined || prefixes.length === 0) {
			prefixesArray = phonesInfo.map((phoneInfo) => phoneInfo.split(',').slice(0, -1).join(' '));
			generatedDigitsNumbers = phonesInfo.map((phoneInfo) => {
				// tokens = ["380","99","9"] =
				// = ["country prefix", "operator prefix", "number length including operator prefix and excluding country prefix"]
				const tokens = phoneInfo.split(',');
				const operatorPrefixLength = tokens[1]!.replaceAll(' ', '').length;

				return Number(tokens[2]) - operatorPrefixLength;
			});
		} else {
			prefixesArray = prefixes;
			if (typeof generatedDigitsNumbers === 'number') {
				generatedDigitsNumbers = Array.from<number>({ length: prefixes.length }).fill(
					generatedDigitsNumbers,
				);