make-mp-data 2.1.11 → 3.0.2

package/dungeons/mil.js

@@ -4,7 +4,7 @@ import dayjs from 'dayjs';
 import utc from 'dayjs/plugin/utc.js';
 dayjs.extend(utc);
 import 'dotenv/config';
-import * as u from '../lib/utils/utils.js';
+import * as u from "../lib/utils/utils.js";
 import * as v from 'ak-tools';
 const chance = u.initChance(SEED);
 const num_users = 10_000;
@@ -44,10 +44,11 @@ const config = {
 	hasAdSpend: false,
 
 	hasAvatar: false,
+	makeChart: false,
 
-	batchSize: 1_500_000,
+	batchSize: 2_500_000,
 	concurrency: 10,
-	writeToDisk: true,
+	writeToDisk: false,
 
 	funnels: [],
 
@@ -289,6 +290,33 @@ const config = {
 	groupProps: {},
 	lookupTables: [],
 	hook: function (record, type, meta) {
+		// event hook: tag events by frequency tier and enrich booleans
+		if (type === "event") {
+			const highFreq = ["foo", "bar", "baz"];
+			const lowFreq = ["crumn", "yak"];
+			if (highFreq.includes(record.event)) {
+				record.frequency_tier = "high";
+			} else if (lowFreq.includes(record.event)) {
+				record.frequency_tier = "low";
+			} else {
+				record.frequency_tier = "medium";
+			}
+			// boolean super prop drives a derived field
+			if (record.boolean === true) {
+				record.flag_status = "active";
+			}
+		}
+
+		// everything hook: users with very few events are marked as churned
+		if (type === "everything") {
+			if (record.length <= 3) {
+				for (const e of record) {
+					e.is_churned_user = true;
+				}
+			}
+			return record;
+		}
+
 		return record;
 	}
 };

package/dungeons/mirror.js

@@ -14,7 +14,7 @@ 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 } from '../lib/utils/utils.js';
+import { pickAWinner, weighNumRange, date, integer } from "../lib/utils/utils.js";
 
 
 /** @type {import('../types').Dungeon} */
@@ -120,6 +120,38 @@ const config = {
 	groupProps: {},
 	lookupTables: [],
 	hook: function (record, type, meta) {
+		// --- user hook: segment users by spirit animal ---
+		if (type === "user") {
+			const aquatic = ["whale", "dolphin", "shark", "octopus", "squid", "jellyfish", "seahorse", "crab", "lobster", "shrimp"];
+			record.segment = aquatic.includes(record.spiritAnimal) ? "aquatic" : "terrestrial";
+			return record;
+		}
+
+		// --- event hook: color-based property boost ---
+		if (type === "event") {
+			// warm-colored events get a higher updateMe value
+			const warmColors = ["red", "orange", "yellow"];
+			if (warmColors.includes(record.color)) {
+				record.updateMe = (record.updateMe || 5) + 10;
+			}
+			return record;
+		}
+
+		// --- everything hook: inject a "milestone" event for users with 8+ events ---
+		if (type === "everything") {
+			if (record.length >= 8) {
+				const lastEvent = record[record.length - 1];
+				record.push({
+					event: "milestone_reached",
+					time: lastEvent.time,
+					user_id: lastEvent.user_id,
+					color: lastEvent.color,
+					milestone: record.length
+				});
+			}
+			return record;
+		}
+
 		return record;
 	}
 };

package/dungeons/retention-cadence.js

@@ -0,0 +1,211 @@
+
+const SEED = "kurby-retention";
+import dayjs from 'dayjs';
+import utc from 'dayjs/plugin/utc.js';
+dayjs.extend(utc);
+import * as u from "../lib/utils/utils.js";
+import * as v from 'ak-tools';
+const chance = u.initChance(SEED);
+
+const num_users = 100;
+const days = 360;
+
+/** @typedef {import("../types.js").Dungeon} Config */
+
+// Churn rates by favorite color per behavior type (percentage likelihood)
+const CHURN_RATES = {
+	red:    { hourly: 15, daily: 40, weekly: 15, monthly: 10 },
+	blue:   { hourly: 15, daily: 15, weekly: 40, monthly: 10 },
+	green:  { hourly: 5,  daily: 5,  weekly: 5,  monthly: 5 },
+	yellow: { hourly: 15, daily: 15, weekly: 15, monthly: 40 },
+	purple: { hourly: 40, daily: 15, weekly: 15, monthly: 10 },
+};
+
+// Behavior cadence definitions: [intervalAmount, intervalUnit, jitterMax, jitterUnit]
+const BEHAVIORS = {
+	hourly:  { interval: 1,  unit: 'hour',  jitterMax: 10, jitterUnit: 'minute' },
+	daily:   { interval: 1,  unit: 'day',   jitterMax: 2,  jitterUnit: 'hour' },
+	weekly:  { interval: 7,  unit: 'day',   jitterMax: 12, jitterUnit: 'hour' },
+	monthly: { interval: 30, unit: 'day',   jitterMax: 2,  jitterUnit: 'day' },
+};
+
+function generateCadencedEvents(behaviorName, cadence, startTime, endTime, churnTime, userId) {
+	const events = [];
+	let cursor = dayjs(startTime);
+	const end = dayjs(endTime);
+
+	while (cursor.isBefore(end)) {
+		if (churnTime && cursor.isAfter(churnTime)) break;
+
+		const jitter = chance.integer({ min: -cadence.jitterMax, max: cadence.jitterMax });
+		const eventTime = cursor.add(jitter, cadence.jitterUnit);
+
+		if (eventTime.isBefore(end) && eventTime.isAfter(startTime)) {
+			events.push({
+				event: `${behaviorName} behavior`,
+				time: eventTime.toISOString(),
+				user_id: userId,
+				insert_id: v.uid(12),
+			});
+		}
+
+		cursor = cursor.add(cadence.interval, cadence.unit);
+	}
+
+	// Insert churn event if user churns on this behavior
+	if (churnTime && dayjs(churnTime).isBefore(end)) {
+		events.push({
+			event: `churn - ${behaviorName} behavior`,
+			time: dayjs(churnTime).toISOString(),
+			user_id: userId,
+			insert_id: v.uid(12),
+		});
+	}
+
+	return events;
+}
+
+/** @type {Config} */
+const config = {
+	token: "",
+	seed: "lets go",
+	numDays: days,
+	numEvents: num_users * 50,
+	numUsers: num_users,
+	hasAnonIds: false,
+	hasSessionIds: false,
+	format: "json",
+	alsoInferFunnels: false,
+	hasLocation: false,
+	hasAndroidDevices: false,
+	hasIOSDevices: false,
+	hasDesktopDevices: false,
+	hasBrowser: false,
+	hasCampaigns: false,
+	isAnonymous: false,
+	hasAdSpend: false,
+	hasAvatar: false,
+	makeChart: false,
+	batchSize: 5_500_000,
+	concurrency: 10,
+	writeToDisk: false,
+	percentUsersBornInDataset: 100,
+
+	funnels: [],
+
+	events: [
+		{
+			event: "first behavior",
+			weight: 1,
+			isFirstEvent: true,
+			properties: {},
+		},
+		{
+			event: "hourly behavior",
+			weight: 40,
+			properties: {},
+		},
+		{
+			event: "daily behavior",
+			weight: 30,
+			properties: {},
+		},
+		{
+			event: "weekly behavior",
+			weight: 15,
+			properties: {},
+		},
+		{
+			event: "monthly behavior",
+			weight: 10,
+			properties: {},
+		},
+		{
+			event: "placeholder",
+			weight: 50,
+			properties: {},
+		},
+	],
+
+	superProps: {},
+
+	userProps: {
+		"favorite color": ["red", "blue", "green", "yellow", "purple"],
+	},
+
+	scdProps: {},
+	mirrorProps: {},
+	groupKeys: [],
+	groupProps: {},
+	lookupTables: [],
+
+	hook: function (record, type, meta) {
+		if (type === "everything") {
+			if (!record.length) return record;
+
+			const userId = record[0].user_id || record[0].device_id;
+			if (!userId) return record;
+
+			const favoriteColor = meta.profile?.["favorite color"] || "green";
+			const colorChurnRates = CHURN_RATES[favoriteColor] || CHURN_RATES.green;
+
+			// Find the time range from the raw events
+			const times = record.map(e => new Date(e.time).getTime()).filter(t => !isNaN(t));
+			if (!times.length) return record;
+			const startTime = dayjs(Math.min(...times));
+			const endTime = dayjs(Math.max(...times));
+			const totalSpanHours = endTime.diff(startTime, 'hour');
+
+			if (totalSpanHours < 1) return record;
+
+			// Keep the "first behavior" event from the original stream
+			const firstBehavior = record.find(e => e.event === "first behavior");
+			const newEvents = [];
+
+			if (firstBehavior) {
+				newEvents.push(firstBehavior);
+			} else {
+				// Create a first behavior event at the start
+				newEvents.push({
+					event: "first behavior",
+					time: startTime.toISOString(),
+					user_id: userId,
+					insert_id: v.uid(12),
+				});
+			}
+
+			// For each behavior type, determine churn and generate cadenced events
+			for (const [behaviorKey, cadence] of Object.entries(BEHAVIORS)) {
+				const churnRate = colorChurnRates[behaviorKey];
+				let churnTime = null;
+
+				if (chance.bool({ likelihood: churnRate })) {
+					// Pick churn time between 20% and 80% into the active period
+					const churnOffsetHours = chance.integer({
+						min: Math.floor(totalSpanHours * 0.2),
+						max: Math.floor(totalSpanHours * 0.8),
+					});
+					churnTime = startTime.add(churnOffsetHours, 'hour');
+				}
+
+				const behaviorEvents = generateCadencedEvents(
+					behaviorKey,
+					cadence,
+					startTime,
+					endTime,
+					churnTime,
+					userId
+				);
+				newEvents.push(...behaviorEvents);
+			}
+
+			// Sort all events by time
+			newEvents.sort((a, b) => new Date(a.time) - new Date(b.time));
+			return newEvents;
+		}
+
+		return record;
+	},
+};
+
+export default config;