make-mp-data 2.1.11 → 3.0.1

package/lib/generators/product-lookup.js

@@ -0,0 +1,262 @@
+/**
+ * Product Lookup Table Generator
+ * Creates a comprehensive product catalog with unique IDs
+ * @module product-lookup
+ */
+
+import Chance from 'chance';
+import { GENERATION_PATTERNS } from '../templates/phrases.js';
+
+/**
+ * Generate a unique product lookup table
+ * @param {number} count - Number of products to generate
+ * @param {string} seed - Seed for reproducible results
+ * @returns {Map<string, Object>} Map of product_id to product details
+ */
+export function generateProductLookup(count = 10000, seed = 'product-catalog') {
+	const chance = new Chance(seed);
+	const productMap = new Map();
+	
+	// Get all product categories
+	const categories = GENERATION_PATTERNS.store_products;
+	const categoryNames = Object.keys(categories);
+	
+	// Flatten all products with their categories
+	const allProducts = [];
+	for (const [categoryKey, products] of Object.entries(categories)) {
+		const categoryName = getCategoryDisplayName(categoryKey);
+		products.forEach(productName => {
+			allProducts.push({
+				name: productName,
+				category: categoryName,
+				categoryKey: categoryKey
+			});
+		});
+	}
+	
+	// Brand names for variety
+	const brands = [
+		"TechPro", "HomeEssentials", "FitLife", "StyleCo", "BeautyPlus",
+		"OfficeMax", "EcoGoods", "PremiumChoice", "ValueBrand", "GenericCo",
+		"ProGear", "UltraLife", "SmartHome", "ActiveWear", "LuxeBeauty",
+		"WorkSpace", "GreenLiving", "EliteChoice", "BudgetBuy", "QualityFirst",
+		"TechnoEdge", "HomeComfort", "FitnessPro", "FashionForward", "GlowUp",
+		"OfficeElite", "EarthFriendly", "PremiumPro", "SmartBuy", "TopTier",
+		"InnoTech", "CozyHome", "PowerFit", "TrendSet", "PureBeauty",
+		"DeskMaster", "NaturalChoice", "LuxuryLine", "BestValue", "PrimeSelect"
+	];
+	
+	// Generate products
+	for (let i = 0; i < count; i++) {
+		const productId = `PROD-${String(i + 1).padStart(6, '0')}`;
+		
+		// Select a base product (reuse and vary)
+		const baseProduct = chance.pickone(allProducts);
+		
+		// Add variation to product name for uniqueness
+		let productName = baseProduct.name;
+		if (chance.bool({ likelihood: 30 })) {
+			// Add color/size/model variations
+			const variations = [
+				` - ${chance.pickone(['Black', 'White', 'Blue', 'Red', 'Gray', 'Silver', 'Gold', 'Rose Gold', 'Navy', 'Green'])}`,
+				` - ${chance.pickone(['Small', 'Medium', 'Large', 'X-Large', 'One Size'])}`,
+				` - ${chance.pickone(['Pro', 'Plus', 'Lite', 'Max', 'Mini', 'Ultra', 'Premium', 'Basic', 'Deluxe'])}`,
+				` (${chance.pickone(['2024 Model', '2025 Edition', 'Updated Version', 'Gen 2', 'v2.0', 'Series 2'])})`,
+				` - ${chance.integer({ min: 1, max: 50 })} Pack`
+			];
+			
+			if (chance.bool({ likelihood: 60 })) {
+				productName += chance.pickone(variations);
+			}
+		}
+		
+		// Generate price based on category
+		const priceRange = getPriceRange(baseProduct.categoryKey);
+		const basePrice = chance.floating({ 
+			min: priceRange.min, 
+			max: priceRange.max, 
+			fixed: 2 
+		});
+		
+		// Generate rating
+		const rating = chance.weighted(
+			[5, 4.5, 4, 3.5, 3, 2.5, 2, 1.5, 1],
+			[35, 25, 20, 10, 5, 3, 1, 0.5, 0.5]
+		);
+		
+		// Stock levels
+		const stockLevel = chance.weighted(
+			[500, 250, 100, 50, 25, 0],
+			[40, 25, 20, 10, 4, 1]
+		);
+		
+		const product = {
+			product_id: productId,
+			name: productName,
+			brand: chance.pickone(brands),
+			category: baseProduct.category,
+			subcategory: baseProduct.categoryKey,
+			price: basePrice,
+			msrp: chance.bool({ likelihood: 40 }) ? basePrice * chance.floating({ min: 1.1, max: 1.5, fixed: 2 }) : basePrice,
+			rating: rating,
+			review_count: chance.integer({ min: 0, max: 5000 }),
+			stock_level: stockLevel,
+			stock_status: getStockStatus(stockLevel),
+			sku: `SKU-${chance.string({ length: 8, pool: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789' })}`,
+			weight_oz: chance.floating({ min: 0.5, max: 50, fixed: 2 }),
+			is_featured: chance.bool({ likelihood: 10 }),
+			is_bestseller: chance.bool({ likelihood: 15 }),
+			is_new_arrival: chance.bool({ likelihood: 20 }),
+			is_on_sale: chance.bool({ likelihood: 25 }),
+			discount_percent: chance.bool({ likelihood: 25 }) ? chance.integer({ min: 5, max: 50 }) : 0,
+			shipping_eligible: chance.bool({ likelihood: 90 }),
+			free_shipping: chance.bool({ likelihood: 40 }),
+			prime_eligible: chance.bool({ likelihood: 60 }),
+			returnable: chance.bool({ likelihood: 85 }),
+			warranty_months: chance.pickone([0, 3, 6, 12, 24, 36]),
+			release_date: chance.date({ 
+				year: chance.integer({ min: 2020, max: 2025 })
+			}).toISOString().split('T')[0],
+			supplier_id: `SUP-${chance.integer({ min: 1, max: 500 })}`,
+			tags: generateTags(baseProduct.categoryKey, chance)
+		};
+		
+		productMap.set(productId, product);
+	}
+	
+	return productMap;
+}
+
+/**
+ * Convert a product lookup Map to a plain object for export
+ */
+export function productLookupToObject(productMap) {
+	const obj = {};
+	for (const [id, product] of productMap.entries()) {
+		obj[id] = product;
+	}
+	return obj;
+}
+
+/**
+ * Get a random product from the lookup
+ */
+export function getRandomProduct(productMap, chance) {
+	const keys = Array.from(productMap.keys());
+	const randomKey = chance.pickone(keys);
+	return productMap.get(randomKey);
+}
+
+/**
+ * Get products by category
+ */
+export function getProductsByCategory(productMap, category) {
+	return Array.from(productMap.values()).filter(p => p.category === category);
+}
+
+/**
+ * Get products by price range
+ */
+export function getProductsByPriceRange(productMap, minPrice, maxPrice) {
+	return Array.from(productMap.values()).filter(p => p.price >= minPrice && p.price <= maxPrice);
+}
+
+/**
+ * Search products by name
+ */
+export function searchProducts(productMap, query) {
+	const lowerQuery = query.toLowerCase();
+	return Array.from(productMap.values()).filter(p => 
+		p.name.toLowerCase().includes(lowerQuery) ||
+		p.brand.toLowerCase().includes(lowerQuery) ||
+		p.category.toLowerCase().includes(lowerQuery)
+	);
+}
+
+// Helper functions
+
+function getCategoryDisplayName(categoryKey) {
+	const displayNames = {
+		electronics: 'Electronics',
+		home_kitchen: 'Home & Kitchen',
+		clothing: 'Clothing',
+		beauty: 'Beauty & Personal Care',
+		sports: 'Sports & Outdoors',
+		books: 'Books & Media',
+		toys: 'Toys & Games',
+		pet_supplies: 'Pet Supplies',
+		office: 'Office Supplies',
+		baby: 'Baby Products',
+		automotive: 'Automotive',
+		garden: 'Garden & Outdoor'
+	};
+	return displayNames[categoryKey] || categoryKey;
+}
+
+function getPriceRange(categoryKey) {
+	const ranges = {
+		electronics: { min: 9.99, max: 799.99 },
+		home_kitchen: { min: 4.99, max: 399.99 },
+		clothing: { min: 9.99, max: 199.99 },
+		beauty: { min: 3.99, max: 89.99 },
+		sports: { min: 7.99, max: 299.99 },
+		books: { min: 4.99, max: 49.99 },
+		toys: { min: 5.99, max: 149.99 },
+		pet_supplies: { min: 3.99, max: 99.99 },
+		office: { min: 1.99, max: 499.99 },
+		baby: { min: 4.99, max: 299.99 },
+		automotive: { min: 9.99, max: 199.99 },
+		garden: { min: 5.99, max: 249.99 }
+	};
+	return ranges[categoryKey] || { min: 9.99, max: 99.99 };
+}
+
+function getStockStatus(stockLevel) {
+	if (stockLevel === 0) return 'Out of Stock';
+	if (stockLevel < 10) return 'Low Stock';
+	if (stockLevel < 50) return 'Limited Stock';
+	return 'In Stock';
+}
+
+function generateTags(categoryKey, chance) {
+	const commonTags = ['popular', 'trending', 'recommended', 'verified', 'quality'];
+	const categoryTags = {
+		electronics: ['tech', 'gadget', 'smart', 'wireless', 'digital'],
+		home_kitchen: ['home', 'kitchen', 'cooking', 'storage', 'organization'],
+		clothing: ['fashion', 'apparel', 'style', 'comfort', 'casual'],
+		beauty: ['skincare', 'makeup', 'grooming', 'wellness', 'organic'],
+		sports: ['fitness', 'outdoor', 'active', 'training', 'exercise'],
+		books: ['reading', 'literature', 'educational', 'entertainment'],
+		toys: ['kids', 'fun', 'educational', 'creative', 'play'],
+		pet_supplies: ['pets', 'animals', 'care', 'feeding', 'play'],
+		office: ['work', 'productivity', 'organization', 'supplies'],
+		baby: ['infant', 'nursery', 'feeding', 'safety', 'care'],
+		automotive: ['car', 'vehicle', 'maintenance', 'accessories'],
+		garden: ['outdoor', 'plants', 'gardening', 'landscaping']
+	};
+	
+	const tags = [];
+	const catTags = categoryTags[categoryKey] || [];
+	
+	// Add 2-4 category tags
+	for (let i = 0; i < chance.integer({ min: 2, max: 4 }); i++) {
+		const tag = chance.pickone(catTags);
+		if (!tags.includes(tag)) tags.push(tag);
+	}
+	
+	// Maybe add a common tag
+	if (chance.bool({ likelihood: 40 })) {
+		tags.push(chance.pickone(commonTags));
+	}
+	
+	return tags;
+}
+
+export default {
+	generateProductLookup,
+	productLookupToObject,
+	getRandomProduct,
+	getProductsByCategory,
+	getProductsByPriceRange,
+	searchProducts
+};

package/lib/generators/product-names.js

@@ -0,0 +1,195 @@
+/**
+ * E-commerce Product Name Generator
+ * Generates realistic product names for store inventories, reviews, and search queries
+ * @module product-names
+ */
+
+import { createTextGenerator } from './text.js';
+
+// Product Review Generator - For customer reviews mentioning specific products
+export const productReviewGen = createTextGenerator({
+	style: "review",
+	tone: "pos",
+	intensity: "medium",
+	formality: "casual",
+	keywords: {
+		products: [
+			// Electronics
+			"Wireless Bluetooth Headphones", "USB-C Charging Cable", "Portable Power Bank 20000mAh",
+			"Smart Watch Series 7", "Wireless Gaming Mouse", "4K Webcam Pro",
+			"Bluetooth Speaker Waterproof", "Ring Light for Streaming",
+			
+			// Home & Kitchen
+			"Stainless Steel Cookware Set", "Air Fryer 6 Quart Digital", "Instant Pot 8 Quart",
+			"Coffee Maker Programmable", "Blender High Speed 1200W",
+			
+			// Clothing
+			"Men's Cotton T-Shirt Basic", "Women's Yoga Pants High Waist", "Athletic Shorts",
+			"Sneakers Running Lightweight", "Fleece Jacket Zip Up"
+		],
+		features: [
+			"battery life", "sound quality", "build quality", "comfort", "durability",
+			"ease of use", "design", "value for money", "performance", "fit",
+			"material quality", "charging speed", "connectivity", "portability",
+			"warranty", "customer service", "packaging", "instructions",
+			"compatibility", "functionality", "aesthetics", "weight",
+			"size options", "color accuracy", "temperature control", "noise level"
+		],
+		positive_aspects: [
+			"works great", "perfect for my needs", "exceeded expectations",
+			"highly recommend", "best purchase ever", "worth every penny",
+			"can't live without it", "game changer", "solid quality",
+			"does exactly what it claims", "super reliable", "love it so far",
+			"impressed with quality", "fast shipping too", "great value"
+		],
+		negative_aspects: [
+			"a bit pricey", "could be better", "takes getting used to",
+			"wish it had more features", "broke after a month", "not as advertised",
+			"quality could be improved", "too bulky", "battery drains quickly",
+			"doesn't fit well", "cheaply made", "stopped working"
+		]
+	},
+	mixedSentiment: true,
+	authenticityLevel: 0.6,
+	typos: true,
+	typoRate: 0.03,
+	min: 50,
+	max: 200,
+	includeMetadata: false
+});
+
+// Product Search Query Generator - For realistic search terms
+export const productSearchGen = createTextGenerator({
+	style: "search",
+	tone: "neu",
+	formality: "casual",
+	keywords: {
+		products: [
+			"headphones", "charging cable", "power bank", "smart watch", "gaming mouse",
+			"webcam", "speaker", "ring light", "cookware set", "air fryer",
+			"instant pot", "coffee maker", "blender", "yoga pants", "running shoes",
+			"fleece jacket", "facial cleanser", "moisturizer", "shampoo", "toothbrush",
+			"yoga mat", "dumbbells", "water bottle", "camping tent", "sleeping bag",
+			"notebook", "pens", "desk chair", "monitor stand", "baby monitor"
+		],
+		attributes: [
+			"wireless", "bluetooth", "USB-C", "waterproof", "portable", "lightweight",
+			"rechargeable", "adjustable", "foldable", "compact", "ergonomic",
+			"stainless steel", "non-stick", "organic", "eco-friendly", "sustainable",
+			"durable", "heavy duty", "professional", "premium", "budget",
+			"best rated", "top seller", "on sale", "discounted", "clearance"
+		],
+		modifiers: [
+			"cheap", "affordable", "best", "good quality", "reliable",
+			"for beginners", "professional grade", "commercial", "industrial",
+			"for small spaces", "travel size", "family size", "bulk",
+			"name brand", "generic", "off brand", "authentic", "genuine",
+			"refurbished", "open box", "like new", "gently used"
+		]
+	},
+	typos: true,
+	typoRate: 0.05,
+	min: 2,
+	max: 40,
+	includeMetadata: false
+});
+
+// Product Comparison Generator - For side-by-side product comparisons
+export const productComparisonGen = createTextGenerator({
+	style: "feedback",
+	tone: "neu",
+	formality: "business",
+	keywords: {
+		products: [
+			"Wireless Bluetooth Headphones", "Air Fryer 6 Quart Digital",
+			"Smart Watch Series 7", "Coffee Maker Programmable",
+			"Yoga Mat Non-Slip 6mm", "Instant Pot 8 Quart"
+		],
+		comparison_terms: [
+			"compared to", "versus", "better than", "not as good as",
+			"similar to", "different from", "cheaper alternative to",
+			"premium version of", "budget option for", "upgraded from"
+		],
+		metrics: [
+			"price point", "durability", "features", "warranty coverage",
+			"brand reputation", "user reviews", "availability",
+			"customer support", "build quality", "performance metrics"
+		]
+	},
+	authenticityLevel: 0.7,
+	specificityLevel: 0.8,
+	min: 100,
+	max: 300,
+	includeMetadata: false
+});
+
+// Product Question Generator - For Q&A sections
+export const productQuestionGen = createTextGenerator({
+	style: "forum",
+	tone: "neu",
+	formality: "casual",
+	keywords: {
+		products: [
+			"Smart Watch Series 7", "Air Fryer 6 Quart", "Wireless Headphones",
+			"Yoga Mat", "Power Bank", "Instant Pot", "Bluetooth Speaker"
+		],
+		question_starters: [
+			"Does this work with", "Is this compatible with", "Can I use this for",
+			"Will this fit", "How long does", "What's the difference between",
+			"Is this better than", "Should I get", "Any recommendations for",
+			"Has anyone tried", "Is it worth", "Does anyone know if"
+		],
+		concerns: [
+			"battery life", "warranty", "return policy", "shipping time",
+			"compatibility", "size", "color options", "durability",
+			"maintenance", "cleaning", "storage", "safety",
+			"noise level", "power consumption", "assembly required"
+		]
+	},
+	typos: true,
+	typoRate: 0.04,
+	min: 20,
+	max: 100,
+	includeMetadata: false
+});
+
+// Product Description Generator - For store listings
+export const productDescriptionGen = createTextGenerator({
+	style: "feedback",
+	tone: "pos",
+	formality: "business",
+	keywords: {
+		products: [
+			"Premium Wireless Headphones", "Professional Air Fryer", "Advanced Smart Watch",
+			"Deluxe Coffee Maker", "Ultra Comfort Yoga Mat", "Multi-Function Instant Pot"
+		],
+		features: [
+			"state-of-the-art technology", "innovative design", "superior quality",
+			"advanced features", "user-friendly interface", "premium materials",
+			"long-lasting durability", "exceptional performance", "modern aesthetics",
+			"versatile functionality", "energy efficient", "space-saving design",
+			"easy maintenance", "comprehensive warranty", "fast setup",
+			"multiple settings", "customizable options", "safety certified"
+		],
+		benefits: [
+			"saves time", "improves efficiency", "enhances experience",
+			"provides convenience", "offers flexibility", "ensures reliability",
+			"delivers results", "maximizes value", "simplifies tasks",
+			"reduces effort", "increases productivity", "optimizes performance"
+		]
+	},
+	authenticityLevel: 0.5,
+	specificityLevel: 0.7,
+	min: 80,
+	max: 250,
+	includeMetadata: false
+});
+
+// Export all generators
+export default {
+	productReviewGen,
+	productSearchGen,
+	productComparisonGen,
+	productQuestionGen,
+	productDescriptionGen
+};

package/lib/generators/profiles.js

@@ -6,6 +6,7 @@
 /** @typedef {import('../../types').Context} Context */
 
 import * as u from "../utils/utils.js";
+import { dataLogger as logger } from "../utils/logger.js";
 
 /**
  * Creates a user or group profile by choosing from available property values
@@ -31,7 +32,7 @@ export async function makeProfile(context, props = {}, defaults = {}) {
         try {
             profile[key] = u.choose(profile[key]);
         } catch (e) {
-            console.error(`Error processing default property ${key}:`, e);
+            logger.error({ err: e, key }, `Error processing default property ${key}`);
             // Keep original value on error
         }
     }
@@ -41,7 +42,7 @@ export async function makeProfile(context, props = {}, defaults = {}) {
         try {
             profile[key] = u.choose(props[key]);
         } catch (e) {
-            console.error(`Error processing property ${key}:`, e);
+            logger.error({ err: e, key }, `Error processing property ${key}`);
             // Keep original value on error
         }
     }
@@ -86,7 +87,6 @@ export async function makeGroupProfile(context, groupKey, groupProps = {}, baseP
     const combinedProps = {
         ...configGroupProps,
         ...groupProps,
-        groupKey // Always include the group key
     };
     
     return makeProfile(context, combinedProps, baseProfile);

package/lib/generators/scd.js

@@ -32,7 +32,13 @@ export async function makeSCD(context, scdProp, scdKey, distinct_id, mutations,
     }
 	if (typeof created === 'number') created = dayjs.unix(created).toISOString();
     
-    const { frequency, max, timing, values, type = "user" } = scdProp;
+    const {
+        frequency = 'day',     // Default to daily frequency
+        max = 10,             // Default max mutations
+        timing = 'fuzzy',     // Default to fuzzy timing
+        values,
+        type = "user"
+    } = scdProp;
     
     // Return empty array if no values provided
     if (JSON.stringify(values) === "{}" || JSON.stringify(values) === "[]") {
@@ -56,7 +62,8 @@ export async function makeSCD(context, scdProp, scdKey, distinct_id, mutations,
             ...scd,
             [uuidKeyName]: scd.distinct_id || distinct_id,
             startTime: null,
-            insertTime: null
+            insertTime: null,
+            time: null // Required field for Mixpanel SCD import
         };
 
         // Set start time based on timing strategy
@@ -82,8 +89,11 @@ export async function makeSCD(context, scdProp, scdKey, distinct_id, mutations,
         const insertTime = lastInserted.add(u.integer(1, 9000), "seconds");
         scdEntry.insertTime = insertTime.toISOString();
 
+        // Set the time field for Mixpanel SCD import (uses startTime)
+        scdEntry.time = scdEntry.startTime;
+
         // Only add entry if all required properties are set
-        if (scdEntry.hasOwnProperty('insertTime') && scdEntry.hasOwnProperty('startTime')) {
+        if (scdEntry.hasOwnProperty('insertTime') && scdEntry.hasOwnProperty('startTime') && scdEntry.hasOwnProperty('time')) {
             scdEntries.push(scdEntry);
         }
 

package/lib/generators/text.js

@@ -846,7 +846,17 @@ class OrganicTextGenerator {
         return this.enhance(simple);
     }
     
+    stripUnfilledPlaceholders(text) {
+        // Remove tracery's unfilled placeholders: ((pattern))
+        // These occur when a pattern like #TITLE# is used but not defined
+        return text.replace(/\(\([a-zA-Z_]+\)\)/g, '').replace(/\s{2,}/g, ' ').trim();
+    }
+
     enhance(text) {
+        // Layer 0: Remove unfilled placeholders (from tracery)
+        // Tracery wraps undefined patterns in (( )) - strip these out
+        text = this.stripUnfilledPlaceholders(text);
+
         // Layer 1: Mixed sentiment
         if (this.config.mixedSentiment && chance(0.3)) {
             text = this.addMixedSentiment(text);
@@ -1134,11 +1144,11 @@ class OrganicTextGenerator {
      * @returns {TextGeneratorStats} Performance statistics
      */
     getStats() {
-        const avgTime = this.stats.generated > 0 ? 
+        const avgTime = this.stats.generated > 0 ?
             this.stats.totalTime / this.stats.generated : 0;
-        
+
         return {
-            config: this.config,
+            config: /** @type {import('../../types.d.ts').TextGeneratorConfig} */ (this.config),
             generatedCount: this.stats.generated,
             duplicateCount: this.stats.duplicates,
             failedCount: this.stats.failures,
@@ -1155,10 +1165,13 @@ class OrganicTextGenerator {
  * @param {TextGeneratorConfig} [config={}] - Configuration options for the generator
  * @returns {OrganicTextGenerator} Text generator instance
  */
-export function createGenerator(config = {}) {
+export function createTextGenerator(config = {}) {
     return new OrganicTextGenerator(config);
 }
 
+// Alias for backwards compatibility
+export const createGenerator = createTextGenerator;
+
 /**
  * Generate a batch of text items directly (standalone function)
  * @param {TextGeneratorConfig & TextBatchOptions} options - Combined generator config and batch options