make-mp-data 1.2.21 → 1.3.0

package/tests/unit.test.js

@@ -55,38 +55,28 @@ describe('utils', () => {
 
 
 
-	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('$avatar');
 	});
 
 
-	test('date: past date', () => {
+	test('date: past', () => {
 		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', () => {
+	test('date: future', () => {
 		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', () => {
+	test('dates: pairs', () => {
 		const datePairs = dates(10, 3, 'YYYY-MM-DD');
 		expect(datePairs).toBeInstanceOf(Array);
 		expect(datePairs).toHaveLength(3);
@@ -95,18 +85,50 @@ describe('utils', () => {
 		});
 	});
 
-	test('choose: choose from array', () => {
+	test('choose: array', () => {
 		const options = ['apple', 'banana', 'cherry'];
 		const choice = choose(options);
 		expect(options).toContain(choice);
 	});
 
-	test('choose: execute function', () => {
+	test('choose: function', () => {
 		const result = choose(() => 'test');
 		expect(result).toBe('test');
 	});
 
-	test('exhaust: exhaust array elements', () => {
+	test('choose: non-function / non-array', () => {
+		expect(choose('test')).toBe('test');
+		expect(choose(123)).toBe(123);
+	});
+
+	test('choose: nested functions', () => {
+		const result = choose(() => () => () => 'nested');
+		expect(result).toBe('nested');
+	});
+
+	test('weightedRange:  within range', () => {
+		const values = weightedRange(5, 15, 100);
+		expect(values.every(v => v >= 5 && v <= 15)).toBe(true);
+		expect(values.length).toBe(100);
+	});
+
+	test('applySkew: skews', () => {
+		const value = boxMullerRandom();
+		const skewedValue = applySkew(value, .25);
+		expect(Math.abs(skewedValue)).toBeGreaterThanOrEqual(Math.abs(value));
+	});
+
+	test('mapToRange: works', () => {
+		const value = 0;
+		const mean = 10;
+		const sd = 5;
+		const mappedValue = mapToRange(value, mean, sd);
+		expect(mappedValue).toBe(10);
+	  });
+	  
+
+
+	test('exhaust: elements', () => {
 		const arr = [1, 2, 3];
 		const exhaustFn = exhaust([...arr]);
 		expect(exhaustFn()).toBe(1);
@@ -115,25 +137,21 @@ describe('utils', () => {
 		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', () => {
+
+	test('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', () => {
+	test('date', () => {
 		const result = date();
 		expect(dayjs(result()).isValid()).toBe(true);
 	});
 
-	test('dates: generates an array of date pairs', () => {
+	test('dates', () => {
 		const result = dates();
 		expect(result).toBeInstanceOf(Array);
 		expect(result.length).toBe(5); // Assuming default numPairs is 5
@@ -145,7 +163,7 @@ describe('utils', () => {
 		});
 	});
 
-	test('day: generates a day within range', () => {
+	test('day', () => {
 		const start = '2020-01-01';
 		const end = '2020-01-30';
 		const result = day(start, end);
@@ -154,7 +172,7 @@ describe('utils', () => {
 		expect(dayjs(dayResult.day).isBefore(dayjs(dayResult.end))).toBe(true);
 	});
 
-	test('exhaust: sequentially removes items from array', () => {
+	test('exhaust', () => {
 		const arr = [1, 2, 3];
 		const next = exhaust(arr);
 		expect(next()).toBe(1);
@@ -163,13 +181,19 @@ describe('utils', () => {
 		expect(next()).toBe(undefined); // or whatever your implementation does after array is exhausted
 	});
 
-	test('generateEmoji: generates correct format and length', () => {
+	test('emoji: works', () => {
+		const emojis = generateEmoji(5)();
+		expect(typeof emojis).toBe('string');
+		expect(emojis.split(', ').length).toBeLessThanOrEqual(5);
+	});
+
+	test('emoji: 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/types.d.ts

@@ -1,82 +1,114 @@
 declare namespace main {
-
-type primitives = string | number | boolean | Date | Object;
-type valueValid = primitives | primitives[] | (() => primitives | primitives[]);
-
-export interface Config {
-  token?: string;
-  seed?: string;
-  numDays?: number;
-  numEvents?: number;
-  numUsers?: number;
-  format?: "csv" | "json";
-  region?: string;
-  events?: EventConfig[];
-  superProps?: Record<string, valueValid>; 
-  userProps?: Record<string, valueValid>; 
-  scdProps?: Record<string, valueValid>;
-  groupKeys?: [string, number][];
-  groupProps?: Record<string, GroupProperty>; // Adjust according to usage
-  lookupTables?: LookupTable[];
-  writeToDisk?: boolean;
-  simulationName?: string;
-  verbose?: boolean;
-  anonIds?: boolean;
-  sessionIds?: boolean;
-}
-
-interface EventConfig {
-  event?: string;
-  weight?: number;
-  properties?: {
-    [key: string]: valueValid; // Consider refining based on actual properties used
-  };
-  isFirstEvent?: boolean;
-}
-
-interface GroupProperty {
-  [key?: string]: valueValid;
-}
-
-interface LookupTable {
-  key: string;
-  entries: number;
-  attributes: {
-    [key?: string]: valueValid;
-  };
-}
-
-type Result = {
-    eventData: {
-        event: any;
-        $source: string;
-    }[];
-    userProfilesData: any[];
-    scdTableData: any[];
-    groupProfilesData: {
-        key: string;
-        data: any[];
-    }[];
-    lookupTableData: {
-        key: string;
-        data: any[];
-    }[];
-    import?: undefined;
-    files?: undefined;
-}
-
-}
-
-
-/**
- * Mixpanel Data Generator
- * model events, users, groups, and lookup tables (and SCD props!)
- * @example
- * const gen = require('make-mp-data')
- * const dta = gen({writeToDisk: false})
- */
-declare function main(
-	config: main.Config
-  ): Promise<main.Result>;
+	type Primitives = string | number | boolean | Date | Record<string, any>;
+  
+	// Recursive type to handle functions returning functions that eventually return Primitives or arrays of Primitives
+	type ValueValid =
+	  | Primitives
+	  | ValueValid[]
+	  | (() => ValueValid);
+  
+	// MAIN CONFIGURATION OBJECT
+	export interface Config {
+	  token?: string;
+	  seed?: string;
+	  numDays?: number;
+	  numEvents?: number;
+	  numUsers?: number;
+	  format?: "csv" | "json";
+	  region?: string;
+	  events?: EventConfig[];
+	  superProps?: Record<string, ValueValid>;
+	  userProps?: Record<string, ValueValid>;
+	  scdProps?: Record<string, ValueValid>;
+	  mirrorProps?: Record<string, MirrorProps>;
+	  groupKeys?: [string, number][];
+	  groupProps?: Record<string, Record<string, ValueValid>>;
+	  lookupTables?: LookupTable[];
+	  writeToDisk?: boolean;
+	  simulationName?: string;
+	  verbose?: boolean;
+	  anonIds?: boolean;
+	  sessionIds?: boolean;
+	  hook?: Hook;
+	}
+  
+	export type Hook = (record: any, type: string, meta: any) => any;
+  
+	export interface EventConfig {
+	  event?: string;
+	  weight?: number;
+	  properties?: Record<string, ValueValid>;
+	  isFirstEvent?: boolean;
+	}
+  
+	export interface MirrorProps {
+	  events: string[] | "*";
+	  values: ValueValid[];
+	}
+  
+	export interface LookupTable {
+	  key: string;
+	  entries: number;
+	  attributes: Record<string, ValueValid>;
+	}
+  
+	export interface SCDTable {
+	  distinct_id: string;
+	  insertTime: string;
+	  startTime: string;
+	  [key: string]: ValueValid;
+	}
+  
+	export type Result = {
+	  eventData: EventData[];
+	  userProfilesData: any[];
+	  scdTableData: any[];
+	  groupProfilesData: GroupProfilesData[];
+	  lookupTableData: LookupTableData[];
+	  import?: ImportResults;
+	  files?: string[];
+	};
+  
+	export interface EventData {
+	  event: string;
+	  $source: string;
+	  time: string;
+	  $device_id?: string;
+	  $session_id?: string;
+	  $user_id?: string;
+	  [key: string]: any;
+	}
+  
+	export interface GroupProfilesData {
+	  key: string;
+	  data: any[];
+	}
+  
+	export interface LookupTableData {
+	  key: string;
+	  data: any[];
+	}
+  
+	export interface ImportResults {
+	  events: ImportResult;
+	  users: ImportResult;
+	  groups: ImportResult[];
+	}
+  
+	export interface ImportResult {
+	  success: number;
+	  bytes: number;
+	}
+  }
+  
+  /**
+   * Mixpanel Data Generator
+   * model events, users, groups, and lookup tables (and SCD props!)
+   * @example
+   * const gen = require('make-mp-data')
+   * const dta = gen({writeToDisk: false})
+   */
+  declare function main(config: main.Config): Promise<main.Result>;
+  
   export = main;
   

package/utils.js

@@ -92,10 +92,15 @@ function choose(value) {
 			return chance.pickone(value);
 		}
 
+		if (typeof value === 'string') {
+			return value;
+		}
+
 		// If it's not a function or array, return it as is
 		return value;
 	}
 	catch (e) {
+		console.error(`\n\nerror on value: ${value};\n\n`,e, '\n\n');
 		return '';
 	}
 }
@@ -128,63 +133,6 @@ function integer(min, max) {
 	return 0;
 };
 
-function makeHashTags() {
-	const popularHashtags = [
-		'#GalacticAdventures',
-		'#EnchantedExplorations',
-		'#MagicalMoments',
-		'#EpicQuests',
-		'#WonderfulWorlds',
-		'#FantasyFrenzy',
-		'#MysticalMayhem',
-		'#MythicalMarvels',
-		'#LegendaryLegends',
-		'#DreamlandDiaries',
-		'#WhimsicalWonders',
-		'#FabledFables'
-	];
-
-	const numHashtags = integer(integer(1, 5), integer(5, 10));
-	const hashtags = [];
-	for (let i = 0; i < numHashtags; i++) {
-		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"];
-	let slugs = ['/sale/', '/featured/', '/home/', '/search/', '/wishlist/', '/'];
-	let assetExtension = ['.png', '.jpg', '.jpeg', '.heic', '.mp4', '.mov', '.avi'];
-	let data = [];
-	let numOfItems = integer(1, 12);
-
-	for (var i = 0; i < numOfItems; i++) {
-
-		let category = chance.pickone(categories);
-		let slug = chance.pickone(slugs);
-		let asset = chance.pickone(assetExtension);
-		let product_id = chance.guid();
-		let price = integer(1, 300);
-		let quantity = integer(1, 5);
-
-		let item = {
-			product_id: product_id,
-			sku: integer(11111, 99999),
-			amount: price,
-			quantity: quantity,
-			value: price * quantity,
-			featured: chance.pickone([true, false]),
-			category: category,
-			urlSlug: slug + category,
-			asset: `${category}-${integer(1, 20)}${asset}`
-		};
-
-		data.push(item);
-	}
-
-	return data;
-};
 
 // Box-Muller transform to generate standard normally distributed values
 function boxMullerRandom() {
@@ -207,7 +155,7 @@ function mapToRange(value, mean, sd) {
 	return Math.round(value * sd + mean);
 };
 
-function weightedRange(min, max, size = 100, skew = 1) {
+function unOptimizedWeightedRange(min, max, size = 100, skew = 1) {
 	const mean = (max + min) / 2;
 	const sd = (max - min) / 4;
 	let array = [];
@@ -228,6 +176,23 @@ function weightedRange(min, max, size = 100, skew = 1) {
 	return array;
 };
 
+// optimized weighted range
+function weightedRange(min, max, size = 100, skew = 1) {
+    const mean = (max + min) / 2;
+    const sd = (max - min) / 4;
+    const array = [];
+    while (array.length < size) {
+        const normalValue = boxMullerRandom();
+        const skewedValue = applySkew(normalValue, skew);
+        const mappedValue = mapToRange(skewedValue, mean, sd);
+        if (mappedValue >= min && mappedValue <= max) {
+            array.push(mappedValue);
+        }
+    }
+    return array;
+}
+
+
 function progress(thing, p) {
 	readline.cursorTo(process.stdout, 0);
 	process.stdout.write(`${thing} processed ... ${comma(p)}`);
@@ -359,8 +324,7 @@ module.exports = {
 	choose,
 	exhaust,
 	integer,
-	makeHashTags,
-	makeProducts,
+
 	boxMullerRandom,
 	applySkew,
 	mapToRange,