make-mp-data 2.0.18 → 2.0.21

package/lib/templates/abbreviated.d.ts

@@ -0,0 +1,158 @@
+/**
+ * A "validValue" can be a primitive, an array of primitives, 
+ * or a function that returns a primitive or an array of primitives.
+ * This is the building block for all property values in the dungeon.
+ */
+type Primitives = string | number | boolean | Date;
+type ValueValid = Primitives | Primitives[] | (() => Primitives | Primitives[]);
+
+
+/**
+ * The main configuration object for the entire data generation spec, known as a "Dungeon".
+ * This is the high-level object you will be constructing.
+ */
+export interface Dungeon {
+    /** A list of all possible events that can occur in the simulation. */
+    events?: EventConfig[];
+    
+    /** A list of event sequences that represent user journeys (e.g., sign-up, purchase). */
+    funnels?: Funnel[];
+    
+    /** Properties that are attached to every event for all users. */
+    superProps?: Record<string, ValueValid>;
+    
+    /** Properties that define the characteristics of individual users. */
+    userProps?: Record<string, ValueValid>;
+    
+    /** Properties that change for users or groups over time (Slowly Changing Dimensions). */
+    scdProps?: Record<string, SCDProp>;
+    
+    /** Defines group entities, like companies or teams, and how many of each to create. */
+    groupKeys?: [string, number, string[]?][]; // [key, numGroups, optional_events_for_group]
+    
+    /** Properties that define the characteristics of the groups defined in groupKeys. */
+    groupProps?: Record<string, Record<string, ValueValid>>;
+
+    /** Events that are attributed to a group entity rather than an individual user. */
+    groupEvents?: GroupEventConfig[];
+    
+    /** Static data tables (e.g., product catalogs) that can be referenced in events. */
+    lookupTables?: LookupTableSchema[];
+
+}
+
+
+/**
+ * Defines a single event, its properties, and its likelihood of occurring.
+ */
+interface EventConfig {
+    /** The name of the event (e.g., "Page View", "Add to Cart"). */
+    event?: string;
+    
+    /** The relative frequency of this event compared to others. Higher numbers are more frequent. */
+    weight?: number;
+    
+    /** A dictionary of properties associated with this event. */
+    properties?: Record<string, ValueValid>;
+    
+    /** If true, this event will be the first event for a new user. */
+    isFirstEvent?: boolean;
+    
+    /** If true, this event signifies that a user has churned. */
+    isChurnEvent?: boolean;
+}
+
+
+/**
+ * Defines a sequence of events that represents a meaningful user journey or workflow.
+ */
+interface Funnel {
+    /** The name of the funnel (e.g., "Purchase Funnel"). */
+    name?: string;
+
+    /** A list of event names that make up the sequence of this funnel. */
+    sequence: string[];
+    
+    /** The likelihood that a user will attempt this funnel. */
+    weight?: number;
+    
+    /** If true, this funnel is part of the initial user experience (e.g., onboarding). */
+    isFirstFunnel?: boolean;
+    
+    /** The probability (0-100) that a user who starts the funnel will complete it. */
+    conversionRate?: number;
+    
+    /** The average time (in hours) it takes a user to complete the funnel. */
+    timeToConvert?: number;
+    
+    /** * Defines the ordering of events within the funnel for a user.
+     * "sequential": Events must happen in the exact order defined in `sequence`.
+     * "random": Events can happen in any order.
+     * "first-and-last-fixed": The first and last events are fixed, but the middle ones are random.
+     */
+    order?: "sequential" | "random" | "first-and-last-fixed" | "first-fixed" | "last-fixed" | "interrupted";
+    
+    /** Properties that will be attached to every event generated within this funnel journey. */
+    props?: Record<string, ValueValid>;
+}
+
+
+/**
+ * Defines a "Slowly Changing Dimension" — a property of a user or group
+ * that changes periodically over time (e.g., subscription plan, user role).
+ */
+interface SCDProp {
+    /** The entity this property belongs to ('user' or a group key like 'company_id'). */
+    type?: string;
+    
+    /** How often the value of this property can change. */
+    frequency: "day" | "week" | "month" | "year";
+    
+    /** A list or function defining the possible values for this property. */
+    values: ValueValid;
+    
+    /** * 'fixed': Changes occur exactly on the frequency interval.
+     * 'fuzzy': Changes occur randomly around the frequency interval.
+     */
+    timing: "fixed" | "fuzzy";
+
+    /** The maximum number of times this property can change for a single entity. */
+    max?: number;
+}
+
+
+/**
+ * Defines an event that is attributed to a group and occurs on a regular schedule.
+ * (e.g., a monthly subscription charge for a company).
+ */
+interface GroupEventConfig extends EventConfig {
+    /** How often the event occurs (in days). */
+    frequency: number; 
+    
+    /** The group key this event is associated with (e.g., "company_id"). */
+    group_key: string; 
+    
+    /** If true, a random user within the group is also associated with the event. */
+    attribute_to_user: boolean; 
+    
+    /** The number of entities in this group. */
+    group_size: number; 
+}
+
+
+/**
+ * Defines the schema for a static lookup table, which can be used to enrich event data.
+ * For example, a "products" table could hold details about product IDs.
+ */
+interface LookupTableSchema {
+    /** The name of the key that will be used to join this table in an event (e.g., "product_id"). */
+    key: string;
+    
+    /** The number of unique rows to generate for this table. */
+    entries: number;
+    
+    /** A dictionary of attributes (columns) for the table and their possible values. */
+    attributes: Record<string, ValueValid>;
+}
+/**
+ 

package/lib/{data → templates}/defaults.js

@@ -4,8 +4,8 @@
  * @fileoverview Contains default values for campaigns, devices, locations, and domains
  */
 
-/** @typedef {import('../../types.d.ts').main.Dungeon} Config */
-/** @typedef {import('../../types.d.ts').main.ValueValid} ValueValid */
+/** @typedef {import('../../types.js').Dungeon} Config */
+/** @typedef {import('../../types.js').ValueValid} ValueValid */
 
 //? https://docs.mixpanel.com/docs/data-structure/property-reference#default-properties
 

package/lib/templates/dungeon-template.js

@@ -0,0 +1,110 @@
+import dayjs from "dayjs";
+import utc from "dayjs/plugin/utc.js";
+import "dotenv/config";
+import { weighNumRange, range, date, initChance, exhaust, choose, integer, decimal } from "../../lib/utils/utils.js";
+
+dayjs.extend(utc);
+
+/**
+ * Dungeon template for AI-generated configurations
+ * This template provides the structure and standard configuration
+ * AI-generated content will be injected into the placeholders
+ */
+
+export function createDungeonTemplate({
+    seed = "ai-generated-seed",
+    numUsers = 1000,
+    numDays = 100,
+    events = [],
+    funnels = [],
+    superProps = {},
+    userProps = {},
+    scdProps = {},
+    mirrorProps = {},
+    groupKeys = [],
+    groupProps = {},
+    lookupTables = [],
+    hookFunction = null
+}) {
+    const chance = u.initChance(seed);
+    const numEvents = numUsers * 100;
+
+    /** @typedef  {import("../../types.d.ts").Dungeon} Config */
+
+    /** @type {Config} */
+    const config = {
+        token: "",
+        seed: seed,
+        numDays: numDays, 
+        numEvents: numEvents, 
+        numUsers: numUsers, 
+        hasAnonIds: false, 
+        hasSessionIds: false, 
+        format: "json",
+        alsoInferFunnels: true,
+        hasLocation: true,
+        hasAndroidDevices: true,
+        hasIOSDevices: true,
+        hasDesktopDevices: true,
+        hasBrowser: true,
+        hasCampaigns: true,
+        isAnonymous: false,
+        hasAdSpend: true,
+        
+        hasAvatar: true,
+        makeChart: false,
+
+        batchSize: 1_500_000,
+        concurrency: 1,
+        writeToDisk: false,
+        
+        // AI-generated content will be injected here
+        funnels: funnels,
+        events: events,
+        superProps: superProps,
+        userProps: userProps,
+        scdProps: scdProps,
+        mirrorProps: mirrorProps,
+        groupKeys: groupKeys,
+        groupProps: groupProps,
+        lookupTables: lookupTables,
+        
+        hook: hookFunction || function (record, type, meta) {
+            // const NOW = dayjs();
+
+			// CALLED AFTER EACH EVENT IS CREATED
+            if (type === "event") {
+                // const EVENT_TIME = dayjs(record.time);
+            }
+
+			// CALLED ONCE FOR EACH USER AND DEFINES THEIR PROPS
+            if (type === "user") {
+
+            }
+
+			// CALLED AFTER FUNNELS EVENTS ARE CHOSEN
+            if (type === "funnel-post") {
+                
+            }
+
+			// CALLED BEFORE FUNNELS EVENTS ARE CHOSEN
+            if (type === "funnel-pre") {
+
+            }
+
+			// CALLED BEFORE SCD EVENTS ARE CHOSEN
+            if (type === "scd-pre") {
+
+            }
+
+			// CALLED AT THE END WHEN A USERS ENTIRE HISTORY EXISTS
+            if (type === "everything") {
+            
+            }
+
+            return record;
+        }
+    };
+
+    return config;
+}

package/lib/templates/instructions.txt

@@ -0,0 +1,77 @@
+You are an AI assistant that generates a structured JavaScript object ("Dungeon") that defines a synthetic analytics dataset designed to simulate realistic user behavior, based on a prompt describing a business or product use case.
+
+the spec you are building is a javascript object... the high level spec looks like this:
+
+--------------
+
+const my_dungeon = {
+	funnels: [],
+    events: [],
+    superProps: {},
+    userProps: {},
+    scdProps: {},
+    groupKeys: [],
+    groupProps: {},
+    lookupTables: [],
+};
+
+--------------
+
+
+here's the full typescript definition for each of the properties in the entire spec; we call the specs 'DUNGEONS' and each dungeon is a javascript object:
+
+--------------
+//types.d.ts
+
+<TYPES>
+
+--------------
+
+here is now an implementation of the dungeon spec which shows how these above features work together to create a data set that tells a story!
+
+Pay close attention to how function calls like weighNumRange(...) and chance.company() are written directly into the object without quotes. 
+
+Your output must follow this exact format:
+
+--------------
+
+//my-dungeon.js
+/** @type {import('../../types.js').Dungeon} */
+
+<VERBOSE_SCHEMA>
+
+--------------
+
+Final Instructions & Rules:
+
+Your job is to build a dungeon based on the analytics use case described in the prompt. Your only output will be a single, valid JavaScript object literal.
+
+Core Requirements:
+
+	1. Output Format: Your output must be a valid JavaScript object literal, NOT JSON. This is crucial. Your entire response should start with { and end with } and contain nothing else.
+
+	2. Mandatory Fields: You MUST create funnels, events, superProps, and userProps for every dungeon. They should be directly related to the analytics use cases stated in the prompt.
+
+	3. Optional Fields: You should include scdProps, groupKeys, groupProps, and lookupTables only if they are clearly relevant based on the use case prompt.
+		- Use groups if the prompt involves B2B, teams, companies, or organizations.
+		- Use SCD if user or group traits change over time (e.g., subscription tier).
+		- Use lookup tables if events reference external entities with their own attributes (e.g., product_id, video_id).
+
+	4. Available Functions: You have access to these built-in functions: date, weighNumRange, range, and the chance library.
+
+❌ Critical Rules to Follow:
+
+	- Do NOT wrap function calls in quotes.
+
+		Correct: amount: weighNumRange(5, 500)
+		Incorrect: amount: "weighNumRange(5, 500)"
+
+	- Do NOT output comments, explanations, or any text outside of the JavaScript object.
+
+	- Do NOT generate vague or placeholder values like "value1", "example", or "random_string".
+
+	- Do NOT leave required arrays empty (funnels, events, etc.).
+
+Your only task is to generate a single JavaScript object that follows this structure based on the user's request.
+=================
+

package/lib/templates/verbose-schema.js

@@ -0,0 +1,311 @@
+
+
+
+import Chance from "chance";
+const chance = new Chance();
+import dayjs from "dayjs";
+import utc from "dayjs/plugin/utc.js";
+dayjs.extend(utc);
+import { uid, comma } from "ak-tools";
+import { pickAWinner, weighNumRange, date, integer, weighChoices, range } from "../utils/utils.js";
+
+
+/** @type {import("../../types.js").Dungeon} */
+//SPLIT HERE
+const DUNGEON = {
+
+	/**
+	 * events are the core building blocks of the dungeon
+	 * each event has a name, a weight, and properties
+	 * the weight determines how often the event occurs relative to other events
+	 * properties are the data associated with the event
+	 * they can be simple values or functions that return a value
+	 * we have a few built-in functions to help you generate data
+	 * you MUST create events for every dungeon
+	 */
+	events: [
+		{
+			event: "checkout",
+			weight: 2,
+			properties: {
+				amount: weighNumRange(5, 500, .25), // this is ok if you need to pick a number from a range; params are min, max, skew (opt), and size (size of pool, also opt)
+				currency: ["USD", "CAD", "EUR", "BTC", "ETH", "JPY"],
+				coupon: ["none", "none", "none", "none", "10%OFF", "20%OFF", "10%OFF", "20%OFF", "30%OFF", "40%OFF", "50%OFF"],
+				numItems: weighNumRange(1, 10),
+
+			}
+		},
+		{
+			event: "add to cart",
+			weight: 4,
+			properties: {
+				amount: weighNumRange(5, 500, .25),
+				rating: weighNumRange(1, 5),
+				reviews: weighNumRange(0, 35),
+				isFeaturedItem: [true, false, false],
+				itemCategory: ["Books", "Movies", "Music", "Games", "Electronics", "Computers", "Smart Home", "Home", "Garden", "Pet", "Beauty", "Health", "Toys", "Kids", "Baby", "Handmade", "Sports", "Outdoors", "Automotive", "Industrial", "Entertainment", "Art", "Food", "Appliances", "Office", "Wedding", "Software"],
+				dateItemListed: date(30, true, "YYYY-MM-DD") // this is ok if you need to pick a date from a range; params are intheLastDays, isPast, format
+			}
+		},
+		{
+			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: {
+				videoCategory: ["funny", "educational", "inspirational", "music", "news", "sports", "cooking", "DIY", "travel", "gaming"],
+				isFeaturedItem: [true, false, false],
+				watchTimeSec: weighNumRange(10, 600, .25),
+				quality: ["2160p", "1440p", "1080p", "720p", "480p", "360p", "240p"],
+				format: ["mp4", "avi", "mov", "mpg"],
+				uploader_id: chance.guid.bind(chance), // You have access to the chance.js library for generating random data. You can assign a chance function directly to a property, like name: chance.company or uploader_id: chance.guid.
+				video_id: range(1, 1000) // SEE LOOKUP TABLES BELOW
+
+			}
+		},
+		{
+			event: "view item",
+			weight: 8,
+			properties: {
+				isFeaturedItem: [true, false, false],
+				itemCategory: ["Books", "Movies", "Music", "Games", "Electronics", "Computers", "Smart Home", "Home", "Garden", "Pet", "Beauty", "Health", "Toys", "Kids", "Baby", "Handmade", "Sports", "Outdoors", "Automotive", "Industrial", "Entertainment", "Art", "Food", "Appliances", "Office", "Wedding", "Software"],
+				dateItemListed: date(30, true, "YYYY-MM-DD"),
+				product_id: range(1, 1000) // SEE LOOKUP TABLES BELOW
+			}
+		},
+		{
+			event: "save item",
+			weight: 5,
+			properties: {
+				isFeaturedItem: [true, false, false],
+				itemCategory: ["Books", "Movies", "Music", "Games", "Electronics", "Computers", "Smart Home", "Home", "Garden", "Pet", "Beauty", "Health", "Toys", "Kids", "Baby", "Handmade", "Sports", "Outdoors", "Automotive", "Industrial", "Entertainment", "Art", "Food", "Appliances", "Office", "Wedding", "Software"],
+				dateItemListed: date(30, true, "YYYY-MM-DD"),
+			}
+		},
+		{
+			event: "sign up",
+			isFirstEvent: true,
+			weight: 0,
+			properties: {
+				variants: ["A", "B", "C", "Control"],
+				flows: ["new", "existing", "loyal", "churned"],
+				flags: ["on", "off"],
+				experiment_ids: ["1234", "5678", "9012", "3456", "7890"],
+				multiVariate: [true, false]
+			}
+		}
+	],
+	/**
+	 * superProps are properties that are attached to every event
+	 * they are selected randomly each time an event is generated
+	 * they can be simple values or functions that return a value
+	 * you will LIKELY create superProps for every dungeon
+	 */
+	superProps: {
+		theme: ["light", "dark", "custom", "light", "dark"],
+	},
+	/**
+	 * user properties work the same as event properties during the generation phase
+	 * except each user has a single set of user properties
+	 * these are properties that are attached to the user profile
+	 * they can be simple values or functions that return a value
+	 * you MUST create userProps for every dungeon
+	 */
+	userProps: {
+		title: ["Mr.", "Ms.", "Mrs.", "Dr.", "Prof.", "Sir", "Madam", "Lord", "Lady", "Dame", "Baron", "Baroness", "Count", "Countess", "Viscount", "Viscountess", "Marquis", "Marchioness"],
+		luckyNumber: weighNumRange(42, 420, .3),
+		spiritAnimal: ["duck", "dog", "otter", "penguin", "cat", "elephant", "lion", "cheetah", "giraffe", "zebra", "rhino", "hippo", "whale", "dolphin", "shark", "octopus", "squid", "jellyfish", "starfish", "seahorse", "crab", "lobster", "shrimp", "clam", "snail", "slug", "butterfly", "moth", "bee", "wasp", "ant", "beetle", "ladybug", "caterpillar", "centipede", "millipede", "scorpion", "spider", "tarantula", "tick", "mite", "mosquito", "fly", "dragonfly", "damselfly", "grasshopper", "cricket", "locust", "mantis", "cockroach", "termite", "praying mantis", "walking stick", "stick bug", "leaf insect", "lacewing", "aphid", "cicada", "thrips", "psyllid", "scale insect", "whitefly", "mealybug", "planthopper", "leafhopper", "treehopper", "flea", "louse", "bedbug", "flea beetle", "weevil", "longhorn beetle", "leaf beetle", "tiger beetle", "ground beetle", "lady beetle", "firefly", "click beetle", "rove beetle", "scarab beetle", "dung beetle", "stag beetle", "rhinoceros beetle", "hercules beetle", "goliath beetle", "jewel beetle", "tortoise beetle"]
+	},
+	/**
+	 * Funnels represent intentional user journeys (e.g., sign-up, checkout), 
+	 * composed of a sequence of events. 
+	 * You should design at least one first-time funnel (e.g., onboarding) 
+	 * and one recurring funnel (e.g., purchases or content browsing) 
+	 * unless otherwise specified in the prompt.
+	 * Funnels are the primary mechanism used to generate the example data, and it's critical sequences match events in the events array.
+	 * there are many different options for the funnels like: 
+	 * 	isFirstFunnel, conversionRate, isChurnFunnel, order, props, requireRepeats, timeToConvert, weight
+	 * 
+	 * isFirstFunnel are funnels a user will only go through once (like a sign up)
+	 * non isFirstFunnel are funnels a user will go through multiple times (like a purchase)
+	 *
+	 */
+	funnels: [
+		{
+			name: "sign up funnel",
+			description: "journey for users signing up",
+			sequence: ["page view", "page view", "sign up"],
+			isFirstFunnel: true,
+			conversionRate: 50, // 50% of users will convert		
+			order: "sequential", // events must occur in order
+			requireRepeats: false, // users can repeat events in the funnel
+			props: {}, // you can add properties to the funnel
+			timeToConvert: 1, // time to convert in hours	
+		},
+		{
+			name: "purchase funnel",
+			description: "how users purchase items",
+			sequence: ["page view", "view item", "add to cart", "checkout"],
+			isFirstFunnel: false,
+			conversionRate: 10,
+			timeToConvert: 24,
+			requireRepeats: true, // users can repeat events in the funnel
+			order: "first-and-last-fixed"
+		},
+		{
+			name: "browsing funnel",
+			description: "how users browse items",
+			sequence: ["page view", "view item", "watch video", "save item"],
+			isFirstFunnel: false,
+			conversionRate: 65,
+			timeToConvert: 2,
+			requireRepeats: true, // users can repeat events in the funnel
+			order: "random",
+			props: {
+				"browsing type": ["casual", "intentional", "exploratory"] // you can add properties to the funnel
+			}
+		}
+	],
+	/**
+	 * scdProps are used for to represent slowly changing dimensions (at both a user and group level)
+	 * these are properties that change over time, but not frequently
+	 * and importantly we care about behaviors (events) during different epochs of SCD state
+	 * you do NOT need to make SCD properties for every dungeon; only the ones with a use case for them
+	 */
+	scdProps: {
+		role: {
+			type: "user",
+			frequency: "week",
+			values: ["admin", "collaborator", "user", "view only", "no access"],
+			timing: "fuzzy",
+			max: 10
+		},
+		NPS: {
+			type: "user",
+			frequency: "day",
+			values: weighNumRange(1, 10, 2, 150),
+			timing: "fuzzy",
+			max: 10
+		},
+		MRR: {
+			type: "company_id",
+			frequency: "month",
+			values: weighNumRange(0, 10000, .15),
+			timing: "fixed",
+			max: 10
+		},
+		AccountHealthScore: {
+			type: "company_id",
+			frequency: "week",
+			values: weighNumRange(1, 10, .15),
+			timing: "fixed",
+			max: 40
+		},
+		plan: {
+			type: "company_id",
+			frequency: "month",
+			values: ["free", "basic", "premium", "enterprise"],
+			timing: "fixed",
+			max: 10
+		}
+	},
+
+
+	/**
+	 * groupKeys are used to represent entities for custom uniqueBy analysis
+	 * they are an array of arrays, where each inner array is a pair of group_key and the number of profiles for that key
+	 * this is useful for group analysis, where you want to analyze data by groups of users (by company, institution, school, etc...)
+	 * groups have props too (they can also have events) ... but there can be more than one "group entity"
+	 * you do NOT need to make groupKeys for every dungeon; only the ones with a use case for them
+	 */
+	groupKeys: [
+		["company_id", 500, []],
+		["room_id", 10000, ["save video", "comment", "watch video"]]
+	],
+	groupProps: {
+		company_id: {
+			name: () => { return chance.company(); }, // YOU CAN USE CHANCE IT"S BUILT IN!
+			email: () => { return `CSM: ${chance.pickone(["AK", "Jessica", "Michelle", "Dana", "Brian", "Dave"])}`; },
+			"# of employees": weighNumRange(3, 10000),
+			"industry": ["tech", "finance", "healthcare", "education", "government", "non-profit"],
+			"segment": ["enterprise", "SMB", "mid-market"],
+			"products": [["core"], ["core"], ["core", "add-ons"], ["core", "pro-serve"], ["core", "add-ons", "pro-serve"], ["core", "BAA", "enterprise"], ["free"], ["free"], ["free", "addons"]],
+		},
+		room_id: {
+			name: () => { return `#${chance.word({ length: integer(4, 24), capitalize: true })}`; },
+			email: ["public", "private"],
+			"room provider": ["partner", "core", "core", "core"],
+			"room capacity": weighNumRange(3, 1000000),
+			"isPublic": [true, false, false, false, false],
+			"country": chance.country.bind(chance),
+			"isVerified": [true, true, false, false, false],
+		}
+	},
+
+	/**
+	 * groupEvents are used to represent events that are associated with a group that occur
+	 * regularly (like a card charged, or a subscription renewed)
+	 * they are generally NOT attributed to a user, but rather to a group entity
+	 * you do NOT need to make groupEvents for every dungeon; only the ones with a use case for them
+	 */
+	groupEvents: [
+		{
+			attribute_to_user: false,
+			event: "card charged",
+			weight: 1,
+
+			frequency: 30,
+			group_key: "company_id",
+			group_size: 500,
+			properties: {
+				amount: weighNumRange(5, 500, .25),
+				currency: ["USD", "USD", "USD", "CAD", "EUR", "EUR", "BTC", "BTC", "ETH", "JPY"],
+				plan: ["basic", "premium", "enterprise"],
+				"payment method": []
+			}
+		}],
+
+	/**
+	 * lookupTables are used to represent static data that can be used in events
+	 * they are an array of objects, where each object is a key-value pair
+	 * this is useful for representing static data that can be used in events
+	 * like product information, user information, etc...
+	 * you do NOT need to make lookupTables for every dungeon; only the ones with a use case for them
+	 * if you DO make a lookupTable, you MUST provide a key in some events whose value will be numerical
+	 */
+	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": weighNumRange(5, 500, .25),
+			"rating": weighNumRange(1, 5),
+			"reviews": weighNumRange(0, 35)
+		}
+
+	},
+	{
+		key: "video_id",
+		entries: 50000,
+		attributes: {
+			isFlagged: [true, false, false, false, false],
+			copyright: ["all rights reserved", "creative commons", "creative commons", "public domain", "fair use"],
+			uploader_id: chance.guid.bind(chance),
+			"uploader influence": ["low", "low", "low", "medium", "medium", "high"],
+			thumbs: weighNumRange(0, 35),
+			rating: ["G", "PG", "PG-13", "R", "NC-17", "PG-13", "R", "NC-17", "R", "PG", "PG"]
+		}
+
+	}],
+};