make-mp-data 1.1.19 → 1.2.0

package/.vscode/settings.json

@@ -1,5 +1,6 @@
 {
 	"cSpell.words": [
+		"timesoup",
 		"unparse"
 	],
 	"jest.runMode": "on-demand",

package/cli.js

@@ -35,7 +35,7 @@ DATA MODEL: https://github.com/ak--47/make-mp-data/blob/main/default.js
 			type: 'string'
 		})
 		.option("seed", {
-			demandOption: false,			
+			demandOption: false,
 			alias: 's',
 			describe: 'randomness seed; used to create distinct_ids',
 			type: 'string'
@@ -72,6 +72,24 @@ DATA MODEL: https://github.com/ak--47/make-mp-data/blob/main/default.js
 			describe: 'either US or EU',
 			type: 'string'
 		})
+		.options("complex", {
+			demandOption: false,
+			default: false,
+			describe: 'use complex data model (model all entities)',
+			alias: 'c',
+			type: 'boolean',
+			coerce: (value) => {
+				if (typeof value === 'boolean') return value;
+				if (value === 'true') {
+					return true;
+				}
+				if (value === 'false') {
+					return false;
+				}
+
+				return true;
+			}
+		})
 		.option("writeToDisk", {
 			demandOption: false,
 			default: true,

package/index.js

@@ -14,23 +14,8 @@ const Chance = require("chance");
 const chance = new Chance();
 const { touch, comma, bytesHuman, mkdir } = require("ak-tools");
 const Papa = require("papaparse");
-const {
-	weightedRange,
-	pick,
-	day,
-	integer,
-	makeProducts,
-	date,
-	progress,
-	choose,
-	range,
-	exhaust,
-	openFinder,
-	applySkew,
-	boxMullerRandom,
-	getUniqueKeys,
-	person
-} = require("./utils.js");
+const u = require("./utils.js");
+const AKsTimeSoup = require("./timesoup.js");
 const dayjs = require("dayjs");
 const utc = require("dayjs/plugin/utc");
 dayjs.extend(utc);
@@ -42,20 +27,6 @@ let VERBOSE = false;
 /** @typedef {import('./types.d.ts').Config} Config */
 /** @typedef {import('./types.d.ts').EventConfig} EventConfig */
 
-
-const PEAK_DAYS = [
-	dayjs().subtract(2, "day").unix(),
-	dayjs().subtract(3, "day").unix(),
-	dayjs().subtract(5, "day").unix(),
-	dayjs().subtract(7, "day").unix(),
-	dayjs().subtract(11, "day").unix(),
-	dayjs().subtract(13, "day").unix(),
-	dayjs().subtract(17, "day").unix(),
-	dayjs().subtract(19, "day").unix(),
-	dayjs().subtract(23, "day").unix(),
-	dayjs().subtract(29, "day").unix(),
-];
-
 /**
  * generates fake mixpanel data
  * @param  {Config} config
@@ -72,7 +43,7 @@ async function main(config) {
 			favoriteColor: ["red", "green", "blue", "yellow"],
 			spiritAnimal: chance.animal,
 		},
-		scdProps = { NPS: weightedRange(0, 10, 150, 1.6) },
+		scdProps = { NPS: u.weightedRange(0, 10, 150, 1.6) },
 		groupKeys = [],
 		groupProps = {},
 		lookupTables = [],
@@ -86,7 +57,7 @@ async function main(config) {
 	} = config;
 	VERBOSE = verbose;
 	config.simulationName = makeName();
-	global.config = config;
+	global.MP_SIMULATION_CONFIG = config;
 	const uuidChance = new Chance(seed);
 	log(`------------------SETUP------------------`);
 	log(`\nyour data simulation will heretofore be known as: \n\n\t${config.simulationName.toUpperCase()}...\n`);
@@ -97,18 +68,18 @@ async function main(config) {
 	//the function which generates $distinct_id + $anonymous_ids, $session_ids, and $created, skewing towards the present
 	function generateUser() {
 		const distinct_id = uuidChance.guid();
-		let z = boxMullerRandom();
+		let z = u.boxMullerRandom();
 		const skew = chance.normal({ mean: 10, dev: 3 });
-		z = applySkew(z, skew);
+		z = u.applySkew(z, skew);
 
 		// Scale and shift the normally distributed value to fit the range of days
-		const maxZ = integer(2, 4);
+		const maxZ = u.integer(2, 4);
 		const scaledZ = (z / maxZ + 1) / 2;
 		const daysAgoBorn = Math.round(scaledZ * (numDays - 1)) + 1;
 
 		return {
 			distinct_id,
-			...person(daysAgoBorn),
+			...u.person(daysAgoBorn),
 		};
 	}
 
@@ -134,16 +105,16 @@ async function main(config) {
 	const avgEvPerUser = Math.floor(numEvents / numUsers);
 
 	//user loop
-	log(`---------------SIMULATION----------------`, `\n\n`);
+	log(`---------------SIMULATION----------------`, "\n\n");
 	for (let i = 1; i < numUsers + 1; i++) {
-		progress("users", i);
+		u.progress("users", i);
 		const user = generateUser();
 		const { distinct_id, $created, anonymousIds, sessionIds } = user;
 		userProfilesData.push(makeProfile(userProps, user));
 		const mutations = chance.integer({ min: 1, max: 10 });
 		scdTableData.push(makeSCD(scdProps, distinct_id, mutations, $created));
 		const numEventsThisUser = Math.round(
-			chance.normal({ mean: avgEvPerUser, dev: avgEvPerUser / integer(3, 7) })
+			chance.normal({ mean: avgEvPerUser, dev: avgEvPerUser / u.integer(3, 7) })
 		);
 
 		if (firstEvents.length) {
@@ -187,7 +158,7 @@ async function main(config) {
 		const groupCardinality = groupPair[1];
 		const groupProfiles = [];
 		for (let i = 1; i < groupCardinality + 1; i++) {
-			progress("groups", i);
+			u.progress("groups", i);
 			const group = {
 				[groupKey]: i,
 				...makeProfile(groupProps[groupKey]),
@@ -204,7 +175,7 @@ async function main(config) {
 		const { key, entries, attributes } = lookupTable;
 		const data = [];
 		for (let i = 1; i < entries + 1; i++) {
-			progress("lookups", i);
+			u.progress("lookups", i);
 			const item = {
 				[key]: i,
 				...makeProfile(attributes),
@@ -236,17 +207,19 @@ async function main(config) {
 	log(`-----------------WRITES------------------`, `\n\n`);
 	//write the files
 	if (writeToDisk) {
-		if (verbose) log(`writing files... for ${config.simulationName}`);
-		for (const pair of pairs) {
+		if (verbose) log(`writing files... for ${config.simulationName}\n`);
+		loopFiles: for (const pair of pairs) {
 			const [paths, data] = pair;
+			if (!data.length) continue loopFiles;
 			for (const path of paths) {
 				let datasetsToWrite;
 				if (data?.[0]?.["key"]) datasetsToWrite = data.map((d) => d.data);
 				else datasetsToWrite = [data];
 				for (const writeData of datasetsToWrite) {
-					if (format === "csv") {
+					//if it's a lookup table, it's always a CSV
+					if (format === "csv" || path.includes("-LOOKUP.csv")) {
 						log(`writing ${path}`);
-						const columns = getUniqueKeys(writeData);
+						const columns = u.getUniqueKeys(writeData);
 						//papa parse needs nested JSON stringified
 						writeData.forEach((e) => {
 							for (const key in e) {
@@ -348,6 +321,7 @@ function makeProfile(props, defaults) {
 }
 
 function makeSCD(props, distinct_id, mutations, $created) {
+	if (JSON.stringify(props) === "{}") return [];
 	const scdEntries = [];
 	let lastInserted = dayjs($created);
 	const deltaDays = dayjs().diff(lastInserted, "day");
@@ -356,12 +330,12 @@ function makeSCD(props, distinct_id, mutations, $created) {
 		if (lastInserted.isAfter(dayjs())) break;
 		const scd = makeProfile(props, { distinct_id });
 		scd.startTime = lastInserted.toISOString();
-		lastInserted = lastInserted.add(integer(1, 1000), "seconds");
+		lastInserted = lastInserted.add(u.integer(1, 1000), "seconds");
 		scd.insertTime = lastInserted.toISOString();
 		scdEntries.push({ ...scd });
 		lastInserted = lastInserted
-			.add(integer(0, deltaDays), "day")
-			.subtract(integer(1, 1000), "seconds");
+			.add(u.integer(0, deltaDays), "day")
+			.subtract(u.integer(1, 1000), "seconds");
 	}
 
 	return scdEntries;
@@ -394,11 +368,11 @@ function makeEvent(distinct_id, anonymousIds, sessionIds, earliestTime, events,
 
 	//event time
 	if (isFirstEvent) event.time = dayjs.unix(earliestTime).toISOString();
-	if (!isFirstEvent) event.time = AKsTimeSoup(earliestTime, NOW, PEAK_DAYS);
+	if (!isFirstEvent) event.time = AKsTimeSoup(earliestTime, NOW);
 
 	// anonymous and session ids
-	if (global?.config.anonIds) event.$device_id = chance.pickone(anonymousIds);
-	if (global?.config.sessionIds) event.$session_id = chance.pickone(sessionIds);
+	if (global.MP_SIMULATION_CONFIG?.anonIds) event.$device_id = chance.pickone(anonymousIds);
+	if (global.MP_SIMULATION_CONFIG?.sessionIds) event.$session_id = chance.pickone(sessionIds);
 
 	//sometimes have a $user_id
 	if (!isFirstEvent && chance.bool({ likelihood: 42 })) event.$user_id = distinct_id;
@@ -411,7 +385,7 @@ function makeEvent(distinct_id, anonymousIds, sessionIds, earliestTime, events,
 	//iterate through custom properties
 	for (const key in props) {
 		try {
-			event[key] = choose(props[key]);
+			event[key] = u.choose(props[key]);
 		} catch (e) {
 			console.error(`error with ${key} in ${chosenEvent.event} event`, e);
 			debugger;
@@ -423,7 +397,7 @@ function makeEvent(distinct_id, anonymousIds, sessionIds, earliestTime, events,
 		const groupKey = groupPair[0];
 		const groupCardinality = groupPair[1];
 
-		event[groupKey] = pick(weightedRange(1, groupCardinality))
+		event[groupKey] = u.pick(u.weightedRange(1, groupCardinality));
 	}
 
 	//make $insert_id
@@ -441,9 +415,9 @@ function buildFileNames(config) {
 	if (config.writeToDisk) writeDir = mkdir("./data");
 
 	const writePaths = {
-		eventFiles: [path.join(writeDir, `events-${simName}.${extension}`)],
-		userFiles: [path.join(writeDir, `users-${simName}.${extension}`)],
-		scdFiles: [path.join(writeDir, `scd-${simName}.${extension}`)],
+		eventFiles: [path.join(writeDir, `${simName}-EVENTS.${extension}`)],
+		userFiles: [path.join(writeDir, `${simName}-USERS.${extension}`)],
+		scdFiles: [path.join(writeDir, `${simName}-SCD.${extension}`)],
 		groupFiles: [],
 		lookupFiles: [],
 		folder: writeDir,
@@ -452,90 +426,28 @@ function buildFileNames(config) {
 	for (const groupPair of groupKeys) {
 		const groupKey = groupPair[0];
 		writePaths.groupFiles.push(
-			path.join(writeDir, `group-${groupKey}-${simName}.${extension}`)
+			path.join(writeDir, `${simName}-${groupKey}-GROUP.${extension}`)
 		);
 	}
 
 	for (const lookupTable of lookupTables) {
 		const { key } = lookupTable;
 		writePaths.lookupFiles.push(
-			path.join(writeDir, `lookup-${key}-${simName}.${extension}`)
+			//lookups are always CSVs
+			path.join(writeDir, `${simName}-${key}-LOOKUP.csv`)
 		);
 	}
 
 	return writePaths;
 }
 
-/**
- * essentially, a timestamp generator with a twist
- * @param {number} earliestTime - The earliest timestamp in Unix format.
- * @param {number} latestTime - The latest timestamp in Unix format.
- * @param {Array} peakDays - Array of Unix timestamps representing the start of peak days.
- * @returns {number} - The generated event timestamp in Unix format.
- */
-function AKsTimeSoup(earliestTime, latestTime = NOW, peakDays = PEAK_DAYS) {
-	let chosenTime;
-	let eventTime;
-	let validTime = false;
-
-	if (typeof earliestTime !== "number") {
-		if (parseInt(earliestTime) > 0) earliestTime = parseInt(earliestTime);
-		if (dayjs(earliestTime).isValid()) earliestTime = dayjs(earliestTime).unix();
-	}
-
-	while (!validTime) {
-
-		// Define business hours
-		const peakStartHour = 4; // 4 AM
-		const peakEndHour = 23; // 11 PM
-		const likelihoodOfPeakDay = chance.integer({ min: integer(5, 42), max: integer(43, 69) }); // Randomize likelihood with CHAOS!~~
-
-		// Select a day, with a preference for peak days
-		let selectedDay;
-		if (chance.bool({ likelihood: likelihoodOfPeakDay })) { // Randomized likelihood to pick a peak day
-			selectedDay = peakDays.length > 0 ? chance.pickone(peakDays) : integer(earliestTime, latestTime);
-		} else {
-			// Introduce minor peaks by allowing some events to still occur during business hours
-			selectedDay = chance.bool({ likelihood: integer(1, 42) })
-				? chance.pickone(peakDays)
-				: integer(earliestTime, latestTime);
-		}
-
-		// Normalize selectedDay to the start of the day
-		selectedDay = dayjs.unix(selectedDay).startOf('day').unix();
-
-		// Generate a random time within business hours with a higher concentration in the middle of the period
-		const businessStart = dayjs.unix(selectedDay).hour(peakStartHour).minute(0).second(0).unix();
-		const businessEnd = dayjs.unix(selectedDay).hour(peakEndHour).minute(0).second(0).unix();
-
-		if (selectedDay === peakDays[0]) {
-			// Use a skewed distribution for peak days
-			eventTime = chance.normal({ mean: (businessEnd + businessStart) / integer(1, 4), dev: (businessEnd - businessStart) / integer(2, 8) });
-		} else {
-			// For non-peak days, use a uniform distribution to add noise
-			eventTime = integer(integer(businessStart, businessEnd), integer(businessStart, businessEnd));
-		}
-
-		// usually, ensure the event time is within business hours
-		if (chance.bool({ likelihood: 42 })) eventTime = Math.min(Math.max(eventTime, businessStart), businessEnd);
-
-		if (eventTime > 0) validTime = true;
-		const parsedTime = dayjs.unix(eventTime).toISOString();
-		if (!parsedTime.startsWith('20')) validTime = false;
-
-	}
-	chosenTime = dayjs.unix(eventTime).toISOString();
-	if (eventTime < 0) debugger;
-	if (!chosenTime.startsWith('20')) debugger;
-	return chosenTime;
-}
 
 
 
 // this is for CLI
 if (require.main === module) {
 	const args = cliParams();
-	const { token, seed, format, numDays, numUsers, numEvents, region, writeToDisk } = args;
+	const { token, seed, format, numDays, numUsers, numEvents, region, writeToDisk, complex = false } = args;
 	const suppliedConfig = args._[0];
 
 	//if the user specifics an separate config file
@@ -543,9 +455,18 @@ if (require.main === module) {
 	if (suppliedConfig) {
 		log(`using ${suppliedConfig} for data\n`);
 		config = require(path.resolve(suppliedConfig));
-	} else {
-		log(`... using default configuration ...\n`);
-		config = require("./default.js");
+	}
+	else {
+		if (complex) {
+			log(`... using default COMPLEX configuration [everything] ...\n`);
+			log(`... for more simple data, don't use the --complex flag ...\n`);
+			config = require("./examples/complex.js");
+		}
+		else {
+			log(`... using default SIMPLE configuration [events + users] ...\n`);
+			log(`... for more complex data, use the --complex flag ...\n`);
+			config = require("./examples/simple.js");
+		}
 	}
 
 	//override config with cli params
@@ -592,9 +513,10 @@ if (require.main === module) {
 		})
 		.finally(() => {
 			log("have a wonderful day :)");
-			openFinder(path.resolve("./data"));
+			u.openFinder(path.resolve("./data"));
 		});
 } else {
+	main.utils = { ...u };
 	main.timeSoup = AKsTimeSoup;
 	module.exports = main;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "make-mp-data",
-  "version": "1.1.19",
+  "version": "1.2.0",
   "description": "builds all mixpanel primitives for a given project",
   "main": "index.js",
   "types": "types.d.ts",
@@ -9,7 +9,7 @@
     "prune": "rm ./data/*",
     "go": "sh ./scripts/go.sh",
     "post": "npm publish",
-    "test": "jest",
+    "test": "jest --runInBand",
     "deps": "sh ./scripts/deps.sh"
   },
   "repository": {

package/tests/e2e.test.js

@@ -9,65 +9,93 @@ const { execSync } = require("child_process");
 const u = require('ak-tools');
 
 const simple = require('../examples/simple');
+const complex = require('../examples/complex');
+const deep = require('../examples/deepNest');
 
 const timeout = 60000;
 const testToken = process.env.TEST_TOKEN;
 
+describe('module', () => {
 
-describe('e2e', () => {
-
-	test('works as module', async () => {
+	test('works as module (no config)', async () => {
 		console.log('MODULE TEST');
-		const results = await generate({ verbose: false, writeToDisk: false, numEvents: 1100, numUsers: 100, seed: "deal with it" });
+		const results = await generate({ verbose: true, writeToDisk: false, numEvents: 1100, numUsers: 100, seed: "deal with it" });
 		const { eventData, groupProfilesData, lookupTableData, scdTableData, userProfilesData } = results;
 		expect(eventData.length).toBeGreaterThan(980);
 		expect(groupProfilesData.length).toBe(0);
 		expect(lookupTableData.length).toBe(0);
 		expect(scdTableData.length).toBeGreaterThan(200);
+		expect(userProfilesData.length).toBe(100);		
+
+	}, timeout);
+
+	test('works as module (simple)', async () => {
+		console.log('MODULE TEST: SIMPLE');
+		const results = await generate({ ...simple, verbose: true, writeToDisk: false, numEvents: 1100, numUsers: 100, seed: "deal with it" });
+		const { eventData, groupProfilesData, lookupTableData, scdTableData, userProfilesData } = results;
+		expect(eventData.length).toBeGreaterThan(980);
+		expect(groupProfilesData.length).toBe(0);
+		expect(lookupTableData.length).toBe(0);
+		expect(scdTableData.length).toBe(0);
 		expect(userProfilesData.length).toBe(100);
 
 	}, timeout);
 
-	test('works as CLI', async () => {
-		console.log('CLI TEST');
-		const run = execSync(`node ./index.js --numEvents 1000 --numUsers 100 --seed "deal with it" --verbose false`);
-		expect(run.toString().trim().includes('have a wonderful day :)')).toBe(true);
-		const csvs = (await u.ls('./data')).filter(a => a.includes('.csv'));
-		expect(csvs.length).toBe(5);
+	test('works as module (complex)', async () => {
+		console.log('MODULE TEST: COMPLEX');
+		const results = await generate({ ...complex, verbose: true, writeToDisk: false, numEvents: 1100, numUsers: 100, seed: "deal with it" });
+		const { eventData, groupProfilesData, lookupTableData, scdTableData, userProfilesData } = results;
+		expect(eventData.length).toBeGreaterThan(980);
+		expect(groupProfilesData[0]?.data?.length).toBe(350);
+		expect(lookupTableData.length).toBe(1);
+		expect(lookupTableData[0].data.length).toBe(1000);
+		expect(scdTableData.length).toBeGreaterThan(200);
+		expect(userProfilesData.length).toBe(100);
+
 	}, timeout);
 
-	test('sends data to mixpanel', async () => {
-		console.log('NETWORK TEST');
-		const results = await generate({verbose: false, writeToDisk: false, numEvents: 1100, numUsers: 100, seed: "deal with it", token: testToken });
-		const { events, users, groups } = results.import;
-		expect(events.success).toBeGreaterThan(980);
-		expect(users.success).toBe(100);
-		expect(groups.length).toBe(0);
+	test('works as module (deep nest)', async () => {
+		console.log('MODULE TEST: DEEP NEST');
+		const results = await generate({ ...deep, verbose: true, writeToDisk: false, numEvents: 1100, numUsers: 100, seed: "deal with it" });
+		const { eventData, groupProfilesData, lookupTableData, scdTableData, userProfilesData } = results;
+		expect(eventData.length).toBeGreaterThan(980);
+		expect(groupProfilesData.length).toBe(0);
+		expect(lookupTableData.length).toBe(0);
+		expect(scdTableData.length).toBeGreaterThan(200);
+		expect(userProfilesData.length).toBe(100);
+
 	}, timeout);
 
-	test('every record is valid', async () => {
-		console.log('VALIDATION TEST');
-		const results = await generate({verbose: false, writeToDisk: false, numEvents: 10000, numUsers: 500 });
-		const { eventData, userProfilesData } = results;
-		const areEventsValid = eventData.every(validateEvent);
-		const areUsersValid = userProfilesData.every(validateUser);
 
-		const invalidEvents = eventData.filter(e => !validateEvent(e));
-		const invalidUsers = userProfilesData.filter(u => !validateUser(u));
+});
 
-		expect(areEventsValid).toBe(true);
-		expect(areUsersValid).toBe(true);
+describe('cli', () => {
+	test('works as CLI (complex)', async () => {
+		console.log('COMPLEX CLI TEST');
+		const run = execSync(`node ./index.js --numEvents 1000 --numUsers 100 --seed "deal with it" --complex`);
+		expect(run.toString().trim().includes('have a wonderful day :)')).toBe(true);
+		const csvs = (await u.ls('./data')).filter(a => a.includes('.csv'));
+		expect(csvs.length).toBe(5);
+		clearData();
 	}, timeout);
 
-	test('every date is valid', async () => {
-		console.log('DATE TEST');
-		const results = await generate({ ...simple, writeToDisk: false, verbose: false });
-		const { eventData } = results;
-		const invalidDates = eventData.filter(e => !validateTime(e.time));
-		expect(eventData.every(e => validateTime(e.time))).toBe(true);
+	test('works as CLI (simple)', async () => {
+		console.log('simple CLI TEST');
+		const run = execSync(`node ./index.js --numEvents 1000 --numUsers 100 --seed "deal with it"`);
+		expect(run.toString().trim().includes('have a wonderful day :)')).toBe(true);
+		const csvs = (await u.ls('./data')).filter(a => a.includes('.csv'));
+		expect(csvs.length).toBe(2);
+		clearData();
+	}, timeout);
 
-		
-	}, timeout)
+	test('works as CLI (custom)', async () => {
+		console.log('custom CLI TEST');
+		const run = execSync(`node ./index.js ./examples/deepNest.js`);
+		expect(run.toString().trim().includes('have a wonderful day :)')).toBe(true);
+		const csvs = (await u.ls('./data')).filter(a => a.includes('.csv'));
+		expect(csvs.length).toBe(3);
+		clearData();
+	}, timeout);
 
 });
 
@@ -102,16 +130,47 @@ describe('options + tweaks', () => {
 		expect(anonIds.length).toBe(0);
 	}, timeout);
 
+	test('sends data to mixpanel', async () => {
+		console.log('NETWORK TEST');
+		const results = await generate({ verbose: true, writeToDisk: false, numEvents: 1100, numUsers: 100, seed: "deal with it", token: testToken });
+		const { events, users, groups } = results.import;
+		expect(events.success).toBeGreaterThan(980);
+		expect(users.success).toBe(100);
+		expect(groups.length).toBe(0);
+	}, timeout);
 
-});
+	test('every record is valid', async () => {
+		console.log('VALIDATION TEST');
+		const results = await generate({ verbose: true, writeToDisk: false, numEvents: 10000, numUsers: 500 });
+		const { eventData, userProfilesData } = results;
+		const areEventsValid = eventData.every(validateEvent);
+		const areUsersValid = userProfilesData.every(validateUser);
 
+		const invalidEvents = eventData.filter(e => !validateEvent(e));
+		const invalidUsers = userProfilesData.filter(u => !validateUser(u));
 
+		expect(areEventsValid).toBe(true);
+		expect(areUsersValid).toBe(true);
+	}, timeout);
 
-afterEach(() => {
+	test('every date is valid', async () => {
+		console.log('DATE TEST');
+		const results = await generate({ ...simple, writeToDisk: false, verbose: true });
+		const { eventData } = results;
+		const invalidDates = eventData.filter(e => !validateTime(e.time));
+		expect(eventData.every(e => validateTime(e.time))).toBe(true);
+
+	}, timeout);
 
 });
 
 afterAll(() => {
+	clearData();
+});
+
+//helpers
+
+function clearData() {
 	try {
 		console.log('clearing...');
 		execSync(`npm run prune`);
@@ -120,9 +179,7 @@ afterAll(() => {
 	catch (err) {
 		console.log('error clearing files');
 	}
-});
-
-//helpers
+}
 
 function validateEvent(event) {
 	if (!event.event) return false;

package/tests/unit.test.js

@@ -7,6 +7,7 @@ const { timeSoup } = generate;
 require('dotenv').config();
 
 
+
 describe('timeSoup', () => {
 	test('always positive dates', () => {
 		const dates = [];
@@ -21,3 +22,157 @@ describe('timeSoup', () => {
 
 	});
 });
+
+
+
+const { applySkew, boxMullerRandom, choose, date, dates, day, exhaust, generateEmoji, getUniqueKeys, integer, makeHashTags, makeProducts, mapToRange, person, pick, range, weighList, weightedRange } = require('../utils');
+
+describe('utils', () => {
+
+	test('pick: works', () => {
+		const array = [1, 2, 3];
+		const item = pick(array);
+		expect(array).toContain(item);
+	});
+
+	test('pick: null', () => {
+		expect(pick(123)).toBe(123);
+	});
+
+
+
+	test('integer: diff', () => {
+		const min = 5;
+		const max = 10;
+		const result = integer(min, max);
+		expect(result).toBeGreaterThanOrEqual(min);
+		expect(result).toBeLessThanOrEqual(max);
+	});
+
+	test('integer: same', () => {
+		expect(integer(7, 7)).toBe(7);
+	});
+
+
+
+	test('hashtags', () => {
+		const hashtags = makeHashTags();
+		expect(hashtags).toBeInstanceOf(Array);
+		expect(hashtags).not.toHaveLength(0);
+		hashtags.forEach(tag => {
+			expect(tag).toMatch(/^#/);
+		});
+	});
+
+
+
+	test('person: fields', () => {
+		const generatedPerson = person();
+		expect(generatedPerson).toHaveProperty('$name');
+		expect(generatedPerson).toHaveProperty('$email');
+		expect(generatedPerson).toHaveProperty('$avatar');
+		expect(generatedPerson).toHaveProperty('anonymousIds');
+		expect(generatedPerson.anonymousIds).toBeInstanceOf(Array);
+	});
+
+
+	test('date: past date', () => {
+		const pastDate = date(10, true, 'YYYY-MM-DD')();
+		expect(dayjs(pastDate, 'YYYY-MM-DD').isValid()).toBeTruthy();
+		expect(dayjs(pastDate).isBefore(dayjs())).toBeTruthy();
+	});
+
+	test('date: future date', () => {
+		const futureDate = date(10, false, 'YYYY-MM-DD')();
+		expect(dayjs(futureDate, 'YYYY-MM-DD').isValid()).toBeTruthy();
+		expect(dayjs(futureDate).isAfter(dayjs())).toBeTruthy();
+	});
+
+	test('dates: returns pairs of dates', () => {
+		const datePairs = dates(10, 3, 'YYYY-MM-DD');
+		expect(datePairs).toBeInstanceOf(Array);
+		expect(datePairs).toHaveLength(3);
+		datePairs.forEach(pair => {
+			expect(pair).toHaveLength(2);
+		});
+	});
+
+	test('choose: choose from array', () => {
+		const options = ['apple', 'banana', 'cherry'];
+		const choice = choose(options);
+		expect(options).toContain(choice);
+	});
+
+	test('choose: execute function', () => {
+		const result = choose(() => 'test');
+		expect(result).toBe('test');
+	});
+
+	test('exhaust: exhaust array elements', () => {
+		const arr = [1, 2, 3];
+		const exhaustFn = exhaust([...arr]);
+		expect(exhaustFn()).toBe(1);
+		expect(exhaustFn()).toBe(2);
+		expect(exhaustFn()).toBe(3);
+		expect(exhaustFn()).toBeUndefined();
+	});
+
+	test('generateEmoji: returns string of emojis', () => {
+		const emojis = generateEmoji(5)();
+		expect(typeof emojis).toBe('string');
+		expect(emojis.split(', ').length).toBeLessThanOrEqual(5);
+	});
+
+	test('getUniqueKeys: find unique keys', () => {
+		const objects = [{ a: 1, b: 2 }, { a: 3, c: 4 }, { a: 5, b: 6 }];
+		const uniqueKeys = getUniqueKeys(objects);
+		expect(uniqueKeys).toEqual(expect.arrayContaining(['a', 'b', 'c']));
+	});
+
+
+	test('date: generates a valid date', () => {
+		const result = date();
+		expect(dayjs(result()).isValid()).toBe(true);
+	});
+
+	test('dates: generates an array of date pairs', () => {
+		const result = dates();
+		expect(result).toBeInstanceOf(Array);
+		expect(result.length).toBe(5); // Assuming default numPairs is 5
+		result.forEach(pair => {
+			expect(pair).toBeInstanceOf(Array);
+			expect(pair.length).toBe(2);
+			expect(dayjs(pair[0]()).isValid()).toBe(true);
+			expect(dayjs(pair[1]()).isValid()).toBe(true);
+		});
+	});
+
+	test('day: generates a day within range', () => {
+		const start = '2020-01-01';
+		const end = '2020-01-30';
+		const result = day(start, end);
+		const dayResult = result(0, 9);
+		expect(dayjs(dayResult.day).isAfter(dayjs(dayResult.start))).toBe(true);
+		expect(dayjs(dayResult.day).isBefore(dayjs(dayResult.end))).toBe(true);
+	});
+
+	test('exhaust: sequentially removes items from array', () => {
+		const arr = [1, 2, 3];
+		const next = exhaust(arr);
+		expect(next()).toBe(1);
+		expect(next()).toBe(2);
+		expect(next()).toBe(3);
+		expect(next()).toBe(undefined); // or whatever your implementation does after array is exhausted
+	});
+
+	test('generateEmoji: generates correct format and length', () => {
+		const result = generateEmoji();
+		const emojis = result();
+		expect(typeof emojis).toBe('string');
+		const emojiArray = emojis.split(', ');
+		expect(emojiArray.length).toBeLessThanOrEqual(10); // Assuming max default is 10
+		
+	});
+
+
+});

package/timesoup.js

@@ -0,0 +1,92 @@
+const Chance = require("chance");
+const chance = new Chance();
+const dayjs = require("dayjs");
+const utc = require("dayjs/plugin/utc");
+dayjs.extend(utc);
+const { integer } = require('./utils');
+const NOW = dayjs().unix();
+
+const PEAK_DAYS = [
+	dayjs().subtract(2, "day").unix(),
+	dayjs().subtract(3, "day").unix(),
+	dayjs().subtract(5, "day").unix(),
+	dayjs().subtract(7, "day").unix(),
+	dayjs().subtract(11, "day").unix(),
+	dayjs().subtract(13, "day").unix(),
+	dayjs().subtract(17, "day").unix(),
+	dayjs().subtract(19, "day").unix(),
+	dayjs().subtract(23, "day").unix(),
+	dayjs().subtract(29, "day").unix(),
+];
+
+
+/**
+ * essentially, a timestamp generator with a twist
+ * @param {number} earliestTime - The earliest timestamp in Unix format.
+ * @param {number} latestTime - The latest timestamp in Unix format.
+ * @param {Array} peakDays - Array of Unix timestamps representing the start of peak days.
+ * @returns {number} - The generated event timestamp in Unix format.
+ */
+function AKsTimeSoup(earliestTime, latestTime = NOW, peakDays = PEAK_DAYS) {
+	let chosenTime;
+	let eventTime;
+	let validTime = false;
+
+	if (typeof earliestTime !== "number") {
+		if (parseInt(earliestTime) > 0) earliestTime = parseInt(earliestTime);
+		if (dayjs(earliestTime).isValid()) earliestTime = dayjs(earliestTime).unix();
+	}
+
+	while (!validTime) {
+
+		// Define business hours
+		const peakStartHour = 4; // 4 AM
+		const peakEndHour = 23; // 11 PM
+		const likelihoodOfPeakDay = chance.integer({ min: integer(5, 42), max: integer(43, 69) }); // Randomize likelihood with CHAOS!~~
+
+		// Select a day, with a preference for peak days
+		let selectedDay;
+		if (chance.bool({ likelihood: likelihoodOfPeakDay })) { // Randomized likelihood to pick a peak day
+			selectedDay = peakDays.length > 0 ? chance.pickone(peakDays) : integer(earliestTime, latestTime);
+		} else {
+			// Introduce minor peaks by allowing some events to still occur during business hours
+			selectedDay = chance.bool({ likelihood: integer(1, 42) })
+				? chance.pickone(peakDays)
+				: integer(earliestTime, latestTime);
+		}
+
+		// Normalize selectedDay to the start of the day
+		selectedDay = dayjs.unix(selectedDay).startOf('day').unix();
+
+		// Generate a random time within business hours with a higher concentration in the middle of the period
+		const businessStart = dayjs.unix(selectedDay).hour(peakStartHour).minute(0).second(0).unix();
+		const businessEnd = dayjs.unix(selectedDay).hour(peakEndHour).minute(0).second(0).unix();
+
+		if (selectedDay === peakDays[0]) {
+			// Use a skewed distribution for peak days
+			eventTime = chance.normal({ mean: (businessEnd + businessStart) / integer(1, 4), dev: (businessEnd - businessStart) / integer(2, 8) });
+		} else {
+			// For non-peak days, use a uniform distribution to add noise
+			eventTime = integer(integer(businessStart, businessEnd), integer(businessStart, businessEnd));
+		}
+
+		// usually, ensure the event time is within business hours
+		if (chance.bool({ likelihood: 42 })) eventTime = Math.min(Math.max(eventTime, businessStart), businessEnd);
+
+		if (eventTime > 0) validTime = true;
+		const parsedTime = dayjs.unix(eventTime).toISOString();
+		if (!parsedTime.startsWith('20')) validTime = false;
+
+	}
+	chosenTime = dayjs.unix(eventTime).toISOString();
+
+	//should never get here
+	if (eventTime < 0) debugger;
+	if (!chosenTime.startsWith('20')) debugger;
+
+
+	return chosenTime;
+}
+
+
+module.exports = AKsTimeSoup;

package/utils.js

@@ -9,16 +9,20 @@ dayjs.extend(utc);
 
 function pick(items) {
 	if (!Array.isArray(items)) {
-		try {
-			const choice = chance.pickone(this);
-			return choice;
-		}
-		catch (e) {
-			return null;
+		if (typeof items === 'function') {
+			const selection = items();
+			if (Array.isArray(selection)) {
+				return chance.pickone(selection);
+			}
+			else {
+				return selection;
+			}
 		}
+		return items;
+
 	}
 	return chance.pickone(items);
-}
+};
 
 function date(inTheLast = 30, isPast = true, format = 'YYYY-MM-DD') {
 	const now = dayjs.utc();
@@ -48,7 +52,7 @@ function date(inTheLast = 30, isPast = true, format = 'YYYY-MM-DD') {
 			if (!format) return now?.toISOString();
 		}
 	};
-}
+};
 
 function dates(inTheLast = 30, numPairs = 5, format = 'YYYY-MM-DD') {
 	const pairs = [];
@@ -57,7 +61,7 @@ function dates(inTheLast = 30, numPairs = 5, format = 'YYYY-MM-DD') {
 	}
 	return pairs;
 
-}
+};
 
 function day(start, end) {
 	const format = 'YYYY-MM-DD';
@@ -74,7 +78,7 @@ function day(start, end) {
 		};
 	};
 
-}
+};
 
 function choose(value) {
 	if (typeof value === 'function') {
@@ -85,13 +89,13 @@ function choose(value) {
 	}
 
 	return value;
-}
+};
 
 function exhaust(arr) {
 	return function () {
 		return arr.shift();
 	};
-}
+};
 
 
 function integer(min, max) {
@@ -114,7 +118,7 @@ function integer(min, max) {
 	}
 
 	return 0;
-}
+};
 
 function makeHashTags() {
 	const popularHashtags = [
@@ -138,7 +142,7 @@ function makeHashTags() {
 		hashtags.push(chance.pickone(popularHashtags));
 	}
 	return hashtags;
-}
+};
 
 function makeProducts() {
 	let categories = ["Device Accessories", "eBooks", "Automotive", "Baby Products", "Beauty", "Books", "Camera & Photo", "Cell Phones & Accessories", "Collectible Coins", "Consumer Electronics", "Entertainment Collectibles", "Fine Art", "Grocery & Gourmet Food", "Health & Personal Care", "Home & Garden", "Independent Design", "Industrial & Scientific", "Accessories", "Major Appliances", "Music", "Musical Instruments", "Office Products", "Outdoors", "Personal Computers", "Pet Supplies", "Software", "Sports", "Sports Collectibles", "Tools & Home Improvement", "Toys & Games", "Video, DVD & Blu-ray", "Video Games", "Watches"];
@@ -172,7 +176,7 @@ function makeProducts() {
 	}
 
 	return data;
-}
+};
 
 // Box-Muller transform to generate standard normally distributed values
 function boxMullerRandom() {
@@ -180,7 +184,7 @@ function boxMullerRandom() {
 	while (u === 0) u = Math.random();
 	while (v === 0) v = Math.random();
 	return Math.sqrt(-2.0 * Math.log(u)) * Math.cos(2.0 * Math.PI * v);
-}
+};
 
 // Apply skewness to the value
 function applySkew(value, skew) {
@@ -188,12 +192,12 @@ function applySkew(value, skew) {
 	// Adjust the value based on skew
 	let sign = value < 0 ? -1 : 1;
 	return sign * Math.pow(Math.abs(value), skew);
-}
+};
 
 // Map standard normal value to our range
 function mapToRange(value, mean, sd) {
 	return Math.round(value * sd + mean);
-}
+};
 
 function weightedRange(min, max, size = 100, skew = 1) {
 	const mean = (max + min) / 2;
@@ -214,14 +218,12 @@ function weightedRange(min, max, size = 100, skew = 1) {
 	}
 
 	return array;
-}
+};
 
 function progress(thing, p) {
 	readline.cursorTo(process.stdout, 0);
 	process.stdout.write(`${thing} processed ... ${comma(p)}`);
-}
-
-
+};
 
 function range(a, b, step = 1) {
 	step = !step ? 1 : step;
@@ -241,7 +243,7 @@ function openFinder(path, callback) {
 		p.kill();
 		return callback(err);
 	});
-}
+};
 
 function getUniqueKeys(data) {
 	const keysSet = new Set();
@@ -249,7 +251,7 @@ function getUniqueKeys(data) {
 		Object.keys(item).forEach(key => keysSet.add(key));
 	});
 	return Array.from(keysSet);
-}
+};
 
 //makes a random-sized array of emojis
 function generateEmoji(max = 10, array = false) {
@@ -264,74 +266,8 @@ function generateEmoji(max = 10, array = false) {
 		if (!array) return arr.join(', ');
 		return "🤷";
 	};
-}
-
-function generateName() {
-	var adjs = [
-		"autumn", "hidden", "bitter", "misty", "silent", "empty", "dry", "dark",
-		"summer", "icy", "delicate", "quiet", "white", "cool", "spring", "winter",
-		"patient", "twilight", "dawn", "crimson", "wispy", "weathered", "blue",
-		"billowing", "broken", "cold", "damp", "falling", "frosty", "green",
-		"long", "late", "lingering", "bold", "little", "morning", "muddy", "old",
-		"red", "rough", "still", "small", "sparkling", "throbbing", "shy",
-		"wandering", "withered", "wild", "black", "young", "holy", "solitary",
-		"fragrant", "aged", "snowy", "proud", "floral", "restless", "divine",
-		"polished", "ancient", "purple", "lively", "nameless", "gentle", "gleaming", "furious", "luminous", "obscure", "poised", "shimmering", "swirling",
-		"sombre", "steamy", "whispering", "jagged", "melodic", "moonlit", "starry", "forgotten",
-		"peaceful", "restive", "rustling", "sacred", "ancient", "haunting", "solitary", "mysterious",
-		"silver", "dusky", "earthy", "golden", "hallowed", "misty", "roaring", "serene", "vibrant",
-		"stalwart", "whimsical", "timid", "tranquil", "vast", "youthful", "zephyr", "raging",
-		"sapphire", "turbulent", "whirling", "sleepy", "ethereal", "tender", "unseen", "wistful"
-	];
-
-	var nouns = [
-		"waterfall", "river", "breeze", "moon", "rain", "wind", "sea", "morning",
-		"snow", "lake", "sunset", "pine", "shadow", "leaf", "dawn", "glitter",
-		"forest", "hill", "cloud", "meadow", "sun", "glade", "bird", "brook",
-		"butterfly", "bush", "dew", "dust", "field", "fire", "flower", "firefly",
-		"feather", "grass", "haze", "mountain", "night", "pond", "darkness",
-		"snowflake", "silence", "sound", "sky", "shape", "surf", "thunder",
-		"violet", "water", "wildflower", "wave", "water", "resonance", "sun",
-		"wood", "dream", "cherry", "tree", "fog", "frost", "voice", "paper",
-		"frog", "smoke", "star", "glow", "wave", "riverbed", "cliff", "deluge", "prairie", "creek", "ocean",
-		"peak", "valley", "starlight", "quartz", "woodland", "marsh", "earth", "canopy",
-		"petal", "stone", "orb", "gale", "bay", "canyon", "watercourse", "vista", "raindrop",
-		"boulder", "grove", "plateau", "sand", "mist", "tide", "blossom", "leaf", "flame",
-		"shade", "coil", "grotto", "pinnacle", "scallop", "serenity", "abyss", "skyline",
-		"drift", "echo", "nebula", "horizon", "crest", "wreath", "twilight", "balm", "glimmer"
-	];
-
-	var verbs = [
-		"dancing", "whispering", "flowing", "shimmering", "swirling", "echoing", "sparkling", "glistening",
-		"cascading", "drifting", "glowing", "rippling", "quivering", "singing", "twinkling", "radiating",
-		"enveloping", "enchanting", "captivating", "embracing", "embracing", "illuminating", "pulsating", "gliding",
-		"soaring", "wandering", "meandering", "dazzling", "cuddling", "embracing", "caressing", "twisting",
-		"twirling", "tumbling", "surging", "glimmering", "gushing", "splashing", "rolling", "splintering",
-		"splintering", "crescendoing", "whirling", "bursting", "shining", "gushing", "emerging", "revealing",
-		"emerging", "unfolding", "unveiling", "emerging", "surrounding", "unveiling", "materializing", "revealing"
-	];
-
-	var adverbs = [
-		"gracefully", "softly", "smoothly", "gently", "tenderly", "quietly", "serenely", "peacefully",
-		"delicately", "effortlessly", "subtly", "tranquilly", "majestically", "silently", "calmly", "harmoniously",
-		"elegantly", "luminously", "ethereally", "mysteriously", "sublimely", "radiantly", "dreamily", "ethereally",
-		"mesmerizingly", "hypnotically", "mystically", "enigmatically", "spellbindingly", "enchantingly", "fascinatingly",
-		"bewitchingly", "captivatingly", "entrancingly", "alluringly", "rapturously", "seductively", "charismatically",
-		"seductively", "envelopingly", "ensnaringly", "entrancingly", "intoxicatingly", "irresistibly", "transcendentally",
-		"envelopingly", "rapturously", "intimately", "intensely", "tangibly", "vividly", "intensely", "deeply"
-	];
-
-
-	// ? http://stackoverflow.com/a/17516862/103058
-	var adj = adjs[Math.floor(Math.random() * adjs.length)];
-	var noun = nouns[Math.floor(Math.random() * nouns.length)];
-	var verb = verbs[Math.floor(Math.random() * verbs.length)];
-	var adverb = adverbs[Math.floor(Math.random() * adverbs.length)];
-
-
-	return adj + '-' + noun + '-' + verb + '-' + adverb;
+};
 
-}
 
 function person(bornDaysAgo = 30) {
 	//names and photos
@@ -373,25 +309,55 @@ function person(bornDaysAgo = 30) {
 		anonymousIds,
 		sessionIds
 	};
+};
+
+
+function weighList(items, mostChosenIndex) {
+	if (mostChosenIndex > items.length) mostChosenIndex = items.length;
+	return function () {
+		const weighted = [];
+		for (let i = 0; i < 10; i++) {
+			if (chance.bool({ likelihood: integer(10, 35) })) {
+				if (chance.bool({ likelihood: 50 })) {
+					weighted.push(items[mostChosenIndex]);
+				}
+				else {
+					const rand = chance.d10();
+					const addOrSubtract = chance.bool({ likelihood: 50 }) ? -rand : rand;
+					let newIndex = mostChosenIndex + addOrSubtract;
+					if (newIndex < 0) newIndex = 0;
+					if (newIndex > items.length) newIndex = items.length;
+					weighted.push(items[newIndex]);
+				}
+			}
+			else {
+				weighted.push(chance.pickone(items));
+			}
+		}
+		return weighted;
+
+	};
 }
 
 module.exports = {
-	weightedRange,
 	pick,
+	date,
+	dates,
 	day,
+	choose,
+	exhaust,
 	integer,
+	makeHashTags,
 	makeProducts,
-	date,
+	boxMullerRandom,
+	applySkew,
+	mapToRange,
+	weightedRange,
 	progress,
-	choose,
 	range,
-	exhaust,
 	openFinder,
-	applySkew,
-	boxMullerRandom,
-	generateEmoji,
 	getUniqueKeys,
-	makeHashTags,
-	generateName,
-	person
+	generateEmoji,
+	person,
+	weighList
 };

package/default.js

@@ -1,177 +0,0 @@
-/**
- * This is the default configuration file for the data generator
- * notice how the config object is structured, and see it's type definition in ./types.d.ts
- * feel free to modify this file to customize the data you generate
- * see helper functions in utils.js for more ways to generate data
- */
-
-
-const Chance = require('chance');
-const chance = new Chance();
-const { weightedRange, makeProducts, date, generateEmoji, makeHashTags } = require('./utils.js');
-
-/** @type {import('./types.d.ts').Config} */
-const config = {
-	token: "",
-	seed: "foo bar baz",
-	numDays: 30, //how many days worth of data
-	numEvents: 100000, //how many events
-	numUsers: 1000, //how many users	
-	format: 'csv', //csv or json
-	region: "US",
-	anonIds: true, //if true, anonymousIds are created for each user
-	sessionIds: true, //if true, sessionIds are created for each user
-
-	events: [
-		{
-			"event": "checkout",
-			"weight": 2,
-			"properties": {
-				amount: weightedRange(5, 500, 1000, .25),
-				currency: ["USD", "CAD", "EUR", "BTC", "ETH", "JPY"],
-				cart: makeProducts,
-			}
-		},
-		{
-			"event": "add to cart",
-			"weight": 4,
-			"properties": {
-				isFeaturedItem: [true, false, false],
-				amount: weightedRange(5, 500, 1000, .25),
-				rating: weightedRange(1, 5),
-				reviews: weightedRange(0, 35),
-				product_id: weightedRange(1, 1000)
-			}
-		},
-		{
-			"event": "page view",
-			"weight": 10,
-			"properties": {
-				page: ["/", "/", "/help", "/account", "/watch", "/listen", "/product", "/people", "/peace"],
-				utm_source: ["$organic", "$organic", "$organic", "$organic", "google", "google", "google", "facebook", "facebook", "twitter", "linkedin"],
-			}
-		},
-		{
-			"event": "watch video",
-			"weight": 8,
-			"properties": {
-				category: ["funny", "educational", "inspirational", "music", "news", "sports", "cooking", "DIY", "travel", "gaming"],
-				hashTags: makeHashTags,
-				watchTimeSec: weightedRange(10, 600, 1000, .25),
-				quality: ["2160p", "1440p", "1080p", "720p", "480p", "360p", "240p"],
-				format: ["mp4", "avi", "mov", "mpg"],
-				uploader_id: chance.guid.bind(chance)
-
-			}
-		},
-		{
-			"event": "view item",
-			"weight": 8,
-			"properties": {
-				product_id: weightedRange(1, 1000),
-				colors: ["light", "dark", "custom", "dark"]
-			}
-		},
-		{
-			"event": "save item",
-			"weight": 5,
-			"properties": {
-				product_id: weightedRange(1, 1000),
-				colors: ["light", "dark", "custom", "dark"]
-			}
-		},
-		{
-			"event": "sign up",
-			"isFirstEvent": true,
-			"weight": 0,
-			"properties": {
-				variant: ["A", "B", "C", "Control"],
-				experiment: ["no password", "social sign in", "new tutorial"],
-			}
-		}
-	],
-	superProps: {
-		platform: ["web", "mobile", "web", "mobile", "web", "kiosk", "smartTV"],
-		// emotions: generateEmoji(),
-
-	},
-	/*
-	user properties work the same as event properties
-	each key should be an array or function reference
-	*/
-	userProps: {
-		title: chance.profession.bind(chance),
-		luckyNumber: weightedRange(42, 420),
-		// vibe: generateEmoji(),
-		spiritAnimal: chance.animal.bind(chance)
-	},
-
-	scdProps: {
-		plan: ["free", "free", "free", "free", "basic", "basic", "basic", "premium", "premium", "enterprise"],
-		MRR: weightedRange(0, 10000, 1000, .15),
-		NPS: weightedRange(0, 10, 150, 2),
-		marketingOptIn: [true, true, false],
-		dateOfRenewal: date(100, false),
-	},
-
-	/*
-	for group analytics keys, we need an array of arrays [[],[],[]] 
-	each pair represents a group_key and the number of profiles for that key
-	*/
-	groupKeys: [
-		['company_id', 350],
-
-	],
-	groupProps: {
-		company_id: {
-			$name: () => { return chance.company(); },
-			$email: () => { return `CSM: ${chance.pickone(["AK", "Jessica", "Michelle", "Dana", "Brian", "Dave"])}`; },
-			"# of employees": weightedRange(3, 10000),
-			"sector": ["tech", "finance", "healthcare", "education", "government", "non-profit"],
-			"segment": ["enterprise", "SMB", "mid-market"],
-		}
-	},
-
-	lookupTables: [
-		{
-			key: "product_id",
-			entries: 1000,
-			attributes: {
-				category: [
-					"Books",
-					"Movies",
-					"Music",
-					"Games",
-					"Electronics",
-					"Computers",
-					"Smart Home",
-					"Home",
-					"Garden & Tools",
-					"Pet Supplies",
-					"Food & Grocery",
-					"Beauty",
-					"Health",
-					"Toys",
-					"Kids",
-					"Baby",
-					"Handmade",
-					"Sports",
-					"Outdoors",
-					"Automotive",
-					"Industrial",
-					"Entertainment",
-					"Art"
-				],
-				"demand": ["high", "medium", "medium", "low"],
-				"supply": ["high", "medium", "medium", "low"],
-				"manufacturer": chance.company.bind(chance),
-				"price": weightedRange(5, 500, 1000, .25),
-				"rating": weightedRange(1, 5),
-				"reviews": weightedRange(0, 35)
-			}
-
-		}
-	],
-};
-
-module.exports = config;