Seed Data Generators

Copyexport abstract class AbstractGenerator<T = {}> {
	static readonly entityKind: string = 'AbstractGenerator';
	static readonly version: number = 1;
 
	public isUnique = false;
	public notNull = false;
 
	// param for generators which have a unique version of themselves
	public uniqueVersionOfGen?: new(params: T) => AbstractGenerator<T>;
 
	public dataType?: string;
	public timeSpent?: number;
 
	//
	public arraySize?: number;
	public baseColumnDataType?: string;
 
	// param for text-like generators
	public stringLength?: number;
 
	// params for GenerateValuesFromArray
	public weightedCountSeed?: number | undefined;
	public maxRepeatedValuesCount?: number | { weight: number; count: number | number[] }[] | undefined;
 
	public params: T;
 
	constructor(params?: T) {
		this.params = params === undefined ? {} as T : params as T;
	}

Copyinit(params: { count: number | { weight: number; count: number | number[] }[]; seed: number }): void;
init() {
	this.updateParams();
}
 
updateParams() {
	if ((this.params as any).arraySize !== undefined) {
		this.arraySize = (this.params as any).arraySize;
	}
 
	if ((this.params as any).isUnique !== undefined) {
		if ((this.params as any).isUnique === false && this.isUnique === true) {
			throw new Error('specifying non unique generator to unique column.');
		}
 
		this.isUnique = (this.params as any).isUnique;
	}
}
 
abstract generate(params: { i: number }): number | string | boolean | unknown | undefined | void;
 

CopyupdateParams() {
	if ((this.params as any).arraySize !== undefined) {
		this.arraySize = (this.params as any).arraySize;
	}
 
	if ((this.params as any).isUnique !== undefined) {
		if ((this.params as any).isUnique === false && this.isUnique === true) {
			throw new Error('specifying non unique generator to unique column.');
		}
 
		this.isUnique = (this.params as any).isUnique;
	}
}

CopyreplaceIfUnique() {
	this.updateParams();
	if (
		this.uniqueVersionOfGen !== undefined
		&& this.isUnique === true
	) {
		const uniqueGen = new this.uniqueVersionOfGen({
			...this.params,
		});
 
		uniqueGen.isUnique = this.isUnique;
		uniqueGen.dataType = this.dataType;
 
		return uniqueGen;
	}
	return;
}
 
replaceIfArray() {
	this.updateParams();
	if (!(this.getEntityKind() === 'GenerateArray') && this.arraySize !== undefined) {
		const uniqueGen = this.replaceIfUnique();
		const baseColumnGen = uniqueGen === undefined ? this : uniqueGen;
		baseColumnGen.dataType = this.baseColumnDataType;
		const arrayGen = new GenerateArray(
			{
				baseColumnGen,
				size: this.arraySize,
			},
		);
 
		return arrayGen;
	}
 
	return;
}

Copyoverride init({ seed, count }: { count: { weight: number; count: number | number[] }[]; seed: number }) {
	const rng = prand.xoroshiro128plus(seed);
	const weightedIndices = getWeightedIndices(count.map((val) => val.weight));
	this.state = { rng, weightedIndices, weightedCount: count };
}
 
generate() {
	if (this.state === undefined) {
		throw new Error('state is not defined.');
	}
 
	// logic for this generator
	let idx: number;
	const weightedCount = this.state.weightedCount;
 
	[idx, this.state.rng] = prand.uniformIntDistribution(0, this.state.weightedIndices.length - 1, this.state.rng);
	const objIdx = this.state.weightedIndices[idx] as number;
 
	if (typeof weightedCount[objIdx]!.count === 'number') {
		return weightedCount[objIdx]!.count as number;
	} else {
		// typeof weightedCount[objIdx]!.count === 'object' // number[]
		const possCounts = weightedCount[objIdx]!.count as number[];
		[idx, this.state.rng] = prand.uniformIntDistribution(0, possCounts.length - 1, this.state.rng);
		return possCounts[idx]!;
	}
}

Copyexport class GeneratePoint extends AbstractGenerator<{
	isUnique?: boolean;
	minXValue?: number;
	maxXValue?: number;
	minYValue?: number;
	maxYValue?: number;
	arraySize?: number;
}> {
	static override readonly entityKind: string = 'GeneratePoint';
 
	private state: {
		xCoordinateGen: GenerateNumber;
		yCoordinateGen: GenerateNumber;
	} | undefined;
	override uniqueVersionOfGen = GenerateUniquePoint;
 
	override init({ count, seed }: { count: number; seed: number }) {
		super.init({ count, seed });
 
		const xCoordinateGen = new GenerateNumber({
			minValue: this.params.minXValue,
			maxValue: this.params.maxXValue,
			precision: 10,
		});
		xCoordinateGen.init({ count, seed });
 
		const yCoordinateGen = new GenerateNumber({
			minValue: this.params.minYValue,
			maxValue: this.params.maxYValue,
			precision: 10,
		});
		yCoordinateGen.init({ count, seed });
 
		this.state = { xCoordinateGen, yCoordinateGen };
	}
 
	generate() {
		if (this.state === undefined) {
			throw new Error('state is not defined.');
		}
 
		const x = this.state.xCoordinateGen.generate();
		const y = this.state.yCoordinateGen.generate();
 
		if (this.dataType === 'json') {
			return { x, y };
		} else if (this.dataType === 'string') {
			return `[${x}, ${y}]`;
		} else {
			// if (this.dataType === "array")
			return [x, y];
		}
	}
}
 
export class GenerateUniquePoint extends AbstractGenerator<{
	minXValue?: number;
	maxXValue?: number;
	minYValue?: number;
	maxYValue?: number;
	isUnique?: boolean;
}> {
	static override readonly entityKind: string = 'GenerateUniquePoint';
 
	private state: {
		xCoordinateGen: GenerateUniqueNumber;
		yCoordinateGen: GenerateUniqueNumber;
	} | undefined;
	public override isUnique = true;
 
	override init({ count, seed }: { count: number; seed: number }) {
		const xCoordinateGen = new GenerateUniqueNumber({
			minValue: this.params.minXValue,
			maxValue: this.params.maxXValue,
			precision: 10,
		});
		xCoordinateGen.init({ count, seed });
 
		const yCoordinateGen = new GenerateUniqueNumber({
			minValue: this.params.minYValue,

Copyexport class GenerateLine extends AbstractGenerator<{
	isUnique?: boolean;
	minAValue?: number;
	maxAValue?: number;
	minBValue?: number;
	maxBValue?: number;
	minCValue?: number;
	maxCValue?: number;
	arraySize?: number;
}> {
	static override readonly entityKind: string = 'GenerateLine';
 
	private state: {
		aCoefficientGen: GenerateNumber;
		bCoefficientGen: GenerateNumber;
		cCoefficientGen: GenerateNumber;
	} | undefined;
	override uniqueVersionOfGen = GenerateUniqueLine;
 

Copyexport class GenerateLoremIpsum extends AbstractGenerator<{
	sentencesCount?: number;
	arraySize?: number;
}> {
	static override readonly entityKind: string = 'GenerateLoremIpsum';
 
	private state: {
		rng: prand.RandomGenerator;
	} | undefined;
 
	override init({ count, seed }: { count: number; seed: number }) {
		super.init({ count, seed });
 
		const rng = prand.xoroshiro128plus(seed);
		if (this.params.sentencesCount === undefined) this.params.sentencesCount = 1;
 
		const maxLoremIpsumSentencesLength = maxLoremIpsumLength * this.params.sentencesCount + this.params.sentencesCount
			- 1;
		if (this.stringLength !== undefined && this.stringLength < maxLoremIpsumSentencesLength) {
			throw new Error(
				`You can't use lorem ipsum generator with a db column length restriction of ${this.stringLength}. Set the maximum string length to at least ${maxLoremIpsumSentencesLength}.`,
			);
		}
 
		this.state = { rng };
	}

Copy	generate() {
		if (this.state === undefined) {
			throw new Error('state is not defined.');
		}
 
		let idx, resultText: string = '';
		for (let i = 0; i < this.params.sentencesCount!; i++) {
			[idx, this.state.rng] = prand.uniformIntDistribution(0, loremIpsumSentences.length - 1, this.state.rng);
			resultText += loremIpsumSentences[idx] + ' ';
		}
 
		return resultText;
	}
}

Copyexport default [
	'Afghanistan',
	'Albania',
	'Algeria',
	'Angola',
	'Antigua and Barbuda',
	'Argentina',
	'Armenia',
	'Australia',
	'Austria',
	'Azerbaijan',
	'Bahamas',
	'Bahrain',
	'Bangladesh',
	'Barbados',
	'Belgium',
	'Belize',
	'Benin',
	'Bhutan',
	'Bolivia',
	'Bosnia and Herzegovina',
	'Botswana',
	'Brazil',
	'Brunei',
	'Bulgaria',
	'Burkina Faso',
	'Burundi',
	'Cambodia',
	'Cameroon',
	'Canada',
	'Cape Verde',
	'Central African Republic',
	'Chad',
	'Chile',
	'China',
	'Colombia',
	'Comoros',
	'Congo, Dem. Rep.',
	'Congo, Rep.',
	'Costa Rica',
	"Cote d'Ivoire",
	'Croatia',
	'Cyprus',
	'Czech Republic',
	'Denmark',
	'Dominican Republic',
	'Ecuador',
	'Egypt',
	'El Salvador',
	'Equatorial Guinea',
	'Eritrea',
	'Estonia',
	'Fiji',
	'Finland',
	'France',
	'Gabon',
	'Gambia',
	'Georgia',
	'Germany',
	'Ghana',
	'Greece',
	'Grenada',
	'Guatemala',
	'Guinea',
	'Guinea-Bissau',
	'Guyana',
	'Haiti',
	'Hungary',
	'Iceland',
	'India',
	'Indonesia',
	'Iran',
	'Iraq',
	'Ireland',
	'Israel',
	'Italy',
	'Jamaica',
	'Japan',
	'Jordan',
	'Kazakhstan',

Copyexport default [
	'gmail.com',
	'yahoo.com',
	'outlook.com',
	'msn.com',
	'hotmail.com',
	'aol.com',
	'hotmail.co.uk',
	'hotmail.fr',
	'yahoo.fr',
	'wanadoo.fr',
	'orange.fr',
	'comcast.net',
	'yahoo.co.uk',
	'yahoo.com.br',
	'yahoo.co.in',
	'live.com',
	'rediffmail.com',
	'free.fr',
	'gmx.de',
	'web.de',
	'ymail.com',
	'libero.it',
];
…
export const maxStringLength = 14;

Copyexport default [
	'Digital marketing specialist',
	'Web developer',
	'Operations manager',
	'Network engineer',
	'Event manager',
	'Software tester',
	'Teacher',
	'Ux/ui designer',
	'Wedding planner',
	'Qa analyst',
	'Litigation attorney',
	'Mechanical engineer',
	'Network administrator',
	'Account manager',
	'Brand manager',
	'Social worker',
	'Social media coordinator',
	'Email marketing specialist',
	'Hr generalist',
	'Legal assistant',
	'Nurse practitioner',
	'Account director',
	'Software engineer',
	'Purchasing agent',
	'Sales consultant',
	'Civil engineer',
	'Network security specialist',
	'Ui developer',
	'Financial planner',
	'Event planner',
	'Psychologist',
	'Electrical designer',
	'Data analyst',
	'Technical writer',
	'Tax consultant',
	'Account executive',
	'Systems administrator',
	'Database administrator',
	'Research analyst',
	'Data entry clerk',
	'Registered nurse',
	'Investment analyst',
	'Speech therapist',
	'Sales manager',
	'Landscape architect',
	'Key account manager',
	'Ux researcher',
	'Investment banker',
	'It support specialist',
	'Art director',
	'Software developer',
	'Project manager',
	'Customer service manager',
	'Procurement manager',
	'Substance abuse counselor',
	'Supply chain analyst',
	'Data engineer',
	'Accountant',
	'Sales representative',
	'Environmental consultant',
	'Electrical engineer',
	'Systems engineer',
	'Art teacher',
	'Human resources manager',
	'Inventory analyst',
	'Legal counsel',
	'Database developer',
	'Procurement specialist',
	'Systems analyst',
	'Copywriter',
	'Content writer',
	'Hr coordinator',
	'Business development manager',
	'Java developer',
	'Supply chain manager',
	'Event coordinator',
	'Family nurse practitioner',
	'Front-end engineer',
	'Customer success manager',

CopyreplaceIfUnique() {
	this.updateParams();
	if (
		this.uniqueVersionOfGen !== undefined
		&& this.isUnique === true
	) {
		const uniqueGen = new this.uniqueVersionOfGen({
			...this.params,
		});
 
		uniqueGen.isUnique = this.isUnique;
		uniqueGen.dataType = this.dataType;
 
		return uniqueGen;
	}
	return;
}

Copyoverride uniqueVersionOfGen = GenerateUniquePoint;

Copypublic override isUnique = true;
 
override init({ count, seed }: { count: number; seed: number }) {
	const xCoordinateGen = new GenerateUniqueNumber({
		minValue: this.params.minXValue,
		maxValue: this.params.maxXValue,
		precision: 10,
	});
	xCoordinateGen.init({ count, seed });
 
	const yCoordinateGen = new GenerateUniqueNumber({
		minValue: this.params.minYValue,
		maxValue: this.params.maxYValue,
		precision: 10,
	});
	yCoordinateGen.init({ count, seed });
 
	this.state = { xCoordinateGen, yCoordinateGen };
}

Copyif ((this.params as any).isUnique !== undefined) {
	if ((this.params as any).isUnique === false && this.isUnique === true) {
		throw new Error('specifying non unique generator to unique column.');
	}
 
	this.isUnique = (this.params as any).isUnique;
}

Copygenerate({ i }: { i: number }) {
	if (this.state === undefined) {
		throw new Error('state is not defined.');
	}
 
	const minStringLength = this.state.minStringLength,
		maxStringLength = this.state.maxStringLength;
	const stringChars = '1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
	let idx: number,
		strLength: number;
	let currStr: string;
 
	currStr = '';
	const uniqueStr = i.toString(16);
	[strLength, this.state.rng] = prand.uniformIntDistribution(
		minStringLength,
		maxStringLength - uniqueStr.length,
		this.state.rng,
	);
	for (let j = 0; j < strLength - uniqueStr.length; j++) {
		[idx, this.state.rng] = prand.uniformIntDistribution(
			0,
			stringChars.length - 1,
			this.state.rng,
		);
		currStr += stringChars[idx];
	}
 
	return uniqueStr + currStr;
}

Copyif (maxStringLength < count.toString(16).length) {
	throw new Error(
		`You can't generate ${count} unique strings, with a maximum string length of ${maxStringLength}.`,
	);
}

Copyprivate config: { [key: string]: { from: number; to: number } } = {
	year: {
		from: 0,
		to: 5,
	},
	month: {
		from: 0,
		to: 11,
	},
	day: {
		from: 0,
		to: 29,
	},
	hour: {
		from: 0,
		to: 23,
	},
	minute: {
		from: 0,
		to: 59,
	},
	second: {
		from: 0,
		to: 59,
	},
};
 
override init({ count, seed }: { count: number; seed: number }) {
	const allFields = ['year', 'month', 'day', 'hour', 'minute', 'second'];
	let fieldsToGenerate: string[] = allFields;
 
	if (this.params.fields !== undefined && this.params.fields?.includes(' to ')) {
		const tokens = this.params.fields.split(' to ');
		const endIdx = allFields.indexOf(tokens[1]!);
		fieldsToGenerate = allFields.slice(0, endIdx + 1);
	} else if (this.params.fields !== undefined) {
		const endIdx = allFields.indexOf(this.params.fields);
		fieldsToGenerate = allFields.slice(0, endIdx + 1);
	}
 
	let maxUniqueIntervalsNumber = 1;
	for (const field of fieldsToGenerate) {
		const from = this.config[field]!.from, to = this.config[field]!.to;
		maxUniqueIntervalsNumber *= from - to + 1;
	}
 
	if (count > maxUniqueIntervalsNumber) {
		throw new RangeError(`count exceeds max number of unique intervals(${maxUniqueIntervalsNumber})`);
	}

Copy	generate() {
		if (this.state === undefined) {
			throw new Error('state is not defined.');
		}
 
		let interval, numb: number;
 
		for (;;) {
			interval = '';
 
			for (const field of this.state.fieldsToGenerate) {
				const from = this.config[field]!.from, to = this.config[field]!.to;
				[numb, this.state.rng] = prand.uniformIntDistribution(from, to, this.state.rng);
				interval += `${numb} ${field} `;
			}
 
			if (!this.state.intervalSet.has(interval)) {
				this.state.intervalSet.add(interval);
				break;
			}
		}
 
		return interval;
	}
}

Copyoverride init({ seed, count }: { count: { weight: number; count: number | number[] }[]; seed: number }) {
	const rng = prand.xoroshiro128plus(seed);
	const weightedIndices = getWeightedIndices(count.map((val) => val.weight));
	this.state = { rng, weightedIndices, weightedCount: count };
}

Copylet idx: number;
const weightedCount = this.state.weightedCount;
 
[idx, this.state.rng] = prand.uniformIntDistribution(0, this.state.weightedIndices.length - 1, this.state.rng);
const objIdx = this.state.weightedIndices[idx] as number;
 
if (typeof weightedCount[objIdx]!.count === 'number') {
	return weightedCount[objIdx]!.count as number;
} else {
	// typeof weightedCount[objIdx]!.count === 'object' // number[]
	const possCounts = weightedCount[objIdx]!.count as number[];
	[idx, this.state.rng] = prand.uniformIntDistribution(0, possCounts.length - 1, this.state.rng);
	return possCounts[idx]!;
}

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

Copyoverride init({ count, seed }: { count: number; seed: number }) {
	const weights = this.params.map((weightedGen) => weightedGen.weight);
	const weightedIndices = getWeightedIndices(weights);
 
	let idx: number, valueIdx: number, tempRng = prand.xoroshiro128plus(seed);
	const indicesCounter: { [key: number]: number } = {};
	for (let i = 0; i < count; i++) {
		[idx, tempRng] = prand.uniformIntDistribution(0, weightedIndices.length - 1, tempRng);
		valueIdx = weightedIndices[idx]!;
		if (!Object.hasOwn(indicesCounter, valueIdx)) indicesCounter[valueIdx] = 0;
		indicesCounter[valueIdx]! += 1;
	}
 
	for (const [idx, weightedGen] of this.params.entries()) {
		weightedGen.value.isUnique = this.isUnique;
		weightedGen.value.dataType = this.dataType;
		weightedGen.value.init({ count: indicesCounter[idx]!, seed });
 

Copyfor (const [idx, weightedGen] of this.params.entries()) {
	weightedGen.value.isUnique = this.isUnique;
	weightedGen.value.dataType = this.dataType;
	weightedGen.value.init({ count: indicesCounter[idx]!, seed });
 
	if (
		weightedGen.value.uniqueVersionOfGen !== undefined
		&& weightedGen.value.isUnique === true
	) {
		const uniqueGen = new weightedGen.value.uniqueVersionOfGen({
			...weightedGen.value.params,
		});
		uniqueGen.init({
			count: indicesCounter[idx]!,
			seed,
		});
		uniqueGen.isUnique = weightedGen.value.isUnique;
		uniqueGen.dataType = weightedGen.value.dataType;
 
		weightedGen.value = uniqueGen;
	}

Copyexport abstract class AbstractGenerator<T = {}> {
	static readonly entityKind: string = 'AbstractGenerator';
	static readonly version: number = 1;
 

Copy}
 
if (this.state!.integersCount.get(numb) === undefined || this.state!.integersCount.get(numb) === 0) {
	if (numb === currMinNumb) {

Copyoverride init({ seed, count }: { seed: number; count: number }) {
	const rng = prand.xoroshiro128plus(seed);
 
	let minStringLength = 7;
	let maxStringLength = 20;
	// TODO: revise later
	if (this.stringLength !== undefined) {
		maxStringLength = this.stringLength;
		if (maxStringLength === 1 || maxStringLength < minStringLength) minStringLength = maxStringLength;
	}
 
	if (maxStringLength < count.toString(16).length) {
		throw new Error(
			`You can't generate ${count} unique strings, with a maximum string length of ${maxStringLength}.`,
		);
	}
 
	this.state = { rng, minStringLength, maxStringLength };
}

Copygenerate({ i }: { i: number }) {
	if (this.state === undefined) {
		throw new Error('state is not defined.');
	}
 
	const minStringLength = this.state.minStringLength,
		maxStringLength = this.state.maxStringLength;
	const stringChars = '1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
	let idx: number,
		strLength: number;
	let currStr: string;
 
	currStr = '';
	const uniqueStr = i.toString(16);
	[strLength, this.state.rng] = prand.uniformIntDistribution(
		minStringLength,
		maxStringLength - uniqueStr.length,
		this.state.rng,
	);
	for (let j = 0; j < strLength - uniqueStr.length; j++) {
		[idx, this.state.rng] = prand.uniformIntDistribution(
			0,
			stringChars.length - 1,
			this.state.rng,
		);
		currStr += stringChars[idx];
	}
 
	return uniqueStr + currStr;
}

Copyif (maxStringLength < count.toString(16).length) {
	throw new Error(
		`You can't generate ${count} unique strings, with a maximum string length of ${maxStringLength}.`,
	);
}