make-mp-data 2.1.6 → 3.0.1

package/lib/utils/chart.js

@@ -0,0 +1,210 @@
+/** @typedef {import('../../types.js').EventSchema} EventSchema */
+/** @typedef {import('../../types.js').Result} Result */
+/** @typedef {import('../../types.js').Context} Context */
+
+// import { ChartJSNodeCanvas } from 'chartjs-node-canvas';
+import fs from 'fs';
+import * as u from 'ak-tools';
+import dayjs from 'dayjs';
+import { openFinder } from './utils.js';
+import { dataLogger as logger } from './logger.js';
+const { existsSync } = fs;
+import path from 'path';
+import 'dotenv/config';
+const { NODE_ENV = "unknown" } = process.env;
+
+
+let tempDir;
+const dataFolder = path.resolve("./data");
+if (existsSync(dataFolder)) tempDir = dataFolder;
+else tempDir = path.resolve("./");
+
+
+// Function to count events per day
+function countDailyEvents(eventData) {
+	const dailyCounts = {};
+
+	eventData.forEach(event => {
+		const date = dayjs(event.time).format('YYYY-MM-DD');
+		if (!dailyCounts[date]) {
+			dailyCounts[date] = 0;
+		}
+		dailyCounts[date]++;
+	});
+
+	return dailyCounts;
+}
+
+// Function to count daily users
+function countDailyUsers(eventData) {
+	const dailyUsers = {};
+
+	eventData.forEach(event => {
+		const date = dayjs(event.time).format('YYYY-MM-DD');
+		if (!dailyUsers[date]) {
+			dailyUsers[date] = new Set();
+		}
+		dailyUsers[date].add(event.user_id);
+	});
+
+	return dailyUsers;
+}
+
+// Function to count daily new users based on signup events
+function countDailyNewUsers(eventData, signupEvents) {
+	const dailyNewUsers = {};
+	const seenUsers = new Set();
+
+	eventData.forEach(event => {
+		const date = dayjs(event.time).format('YYYY-MM-DD');
+		if (!dailyNewUsers[date]) {
+			dailyNewUsers[date] = new Set();
+		}
+		if (signupEvents.includes(event.event) && !seenUsers.has(event.user_id)) {
+			dailyNewUsers[date].add(event.user_id);
+			seenUsers.add(event.user_id);
+		}
+	});
+
+	return dailyNewUsers;
+}
+
+// Function to generate line chart
+async function generateLineChart(rawData, signupEvents = ["sign up"], fileName) {
+	// COMMENTED OUT: Canvas dependency removed
+	throw new Error("Chart generation is temporarily disabled - canvas dependency removed");
+	
+	// const width = 1600;
+	// const height = 1200;
+	// const chartJSNodeCanvas = new ChartJSNodeCanvas({ width, height, backgroundColour: 'black' });
+	const eventData = countDailyEvents(rawData);
+	const userData = countDailyUsers(rawData);
+	const newUserData = countDailyNewUsers(rawData, signupEvents);
+
+	// @ts-ignore
+	const sortedEventEntries = Object.entries(eventData).sort((a, b) => new Date(a[0]) - new Date(b[0]));
+	const eventLabels = sortedEventEntries.map(entry => entry[0]);
+	const eventValues = sortedEventEntries.map(entry => entry[1]);
+
+	// @ts-ignore
+	const sortedUserEntries = Object.entries(userData).sort((a, b) => new Date(a[0]) - new Date(b[0]));
+	const userLabels = sortedUserEntries.map(entry => entry[0]);
+	const userValues = sortedUserEntries.map(entry => entry[1].size);
+
+	// @ts-ignore
+	const sortedNewUserEntries = Object.entries(newUserData).sort((a, b) => new Date(a[0]) - new Date(b[0]));
+	const newUserLabels = sortedNewUserEntries.map(entry => entry[0]);
+	const newUserValues = sortedNewUserEntries.map(entry => entry[1].size);
+
+	const configuration = {
+		type: 'line',
+		data: {
+			labels: eventLabels,
+			datasets: [
+				{
+					label: '# EVENTS',
+					data: eventValues,
+					yAxisID: 'y1',
+					fill: true,
+					borderColor: '#4F44E0',
+					tension: 0.1
+				},
+				// {
+				// 	label: '# USERS',
+				// 	data: userValues,
+				// 	yAxisID: 'y2',
+				// 	fill: true,
+				// 	borderColor: '#E34F2F',
+				// 	tension: 0.1
+				// },
+				{
+				    label: '# NEW',
+				    data: newUserValues,
+				    yAxisID: 'y3',
+				    fill: true,
+				    borderColor: '#219464',
+				    tension: 0.1
+				}
+			]
+		},
+		options: {
+			scales: {
+				x: {
+					title: {
+						display: true,
+						text: 'Date',
+						color: 'white'
+					},
+					ticks: {
+						color: 'white'
+					}
+				},
+				y1: {
+					type: 'linear',
+					display: true,
+					position: 'left',
+					title: {
+						display: true,
+						text: 'Count of Events',
+						color: '#4F44E0'
+					},
+					ticks: {
+						color: '#4F44E0'
+					}
+				},
+				y3: {
+					type: 'linear',
+					display: true,
+					position: 'right',
+					offset: true,
+					title: {
+						display: true,
+						text: 'Count of New Users',
+						color: '#219464'
+					},
+					ticks: {
+						color: '#219464'
+					},
+					grid: {
+						drawOnChartArea: false
+					}
+				}
+			},
+			plugins: {
+				legend: {
+					labels: {
+						color: 'white'
+					}
+				}
+			}
+		}
+	};
+
+	// @ts-ignore
+	if (typeof fileName === undefined) fileName = 'chart';
+	if (typeof fileName !== 'string') fileName = 'chart';
+	// @ts-ignore
+	// const imageBuffer = await chartJSNodeCanvas.renderToBuffer(configuration);
+	// const filePath = path.join(tempDir, `${fileName}.png`);
+	// const removed = await u.rm(filePath);
+	// @ts-ignore - imageBuffer is a Buffer but touch accepts it
+	// const file = await u.touch(filePath, imageBuffer);
+
+	// logger.info({ filename: `${fileName}.png` }, `📊 Chart saved as ${fileName}.png`);
+	// openFinder(path)
+	// return file;
+}
+
+export { generateLineChart };
+
+
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+	generateLineChart()
+	.then((result)=>{
+		if (NODE_ENV === "dev") debugger;
+	})
+	.catch((error)=>{
+		if (NODE_ENV === "dev") debugger;
+	})
+}

package/lib/utils/function-registry.js

@@ -0,0 +1,285 @@
+/**
+ * Registry of valid functions that can be called in dungeon configurations
+ * This replaces the old string-based function parsing with a clean JSON structure
+ */
+
+import { dataLogger as logger } from './logger.js';
+
+export const FUNCTION_REGISTRY = {
+	// Utility functions from utils.js
+	weighNumRange: {
+		minArgs: 2,
+		maxArgs: 3,
+		description: 'Generate weighted random number in range'
+	},
+	range: {
+		minArgs: 2,
+		maxArgs: 2,
+		description: 'Generate array of numbers in range'
+	},
+	date: {
+		minArgs: 1,
+		maxArgs: 3,
+		description: 'Generate date string'
+	},
+	choose: {
+		minArgs: 1,
+		maxArgs: 1,
+		description: 'Choose from array'
+	},
+	integer: {
+		minArgs: 1,
+		maxArgs: 2,
+		description: 'Generate random integer'
+	},
+	exhaust: {
+		minArgs: 1,
+		maxArgs: 1,
+		description: 'Exhaust values from array'
+	},
+
+	// Additional utility functions
+	maybe: {
+		minArgs: 1,
+		maxArgs: 2,
+		description: 'Return value or null based on probability'
+	},
+	takeSome: {
+		minArgs: 1,
+		maxArgs: 3,
+		description: 'Take random subset from array'
+	},
+	randomElement: {
+		minArgs: 1,
+		maxArgs: 1,
+		description: 'Return random element from array'
+	},
+	randomInt: {
+		minArgs: 2,
+		maxArgs: 2,
+		description: 'Generate random integer'
+	},
+
+	// Text generation functions
+	createTextGenerator: {
+		minArgs: 1,
+		maxArgs: 1,
+		description: 'Create text generator with config'
+	},
+	generateBatch: {
+		minArgs: 2,
+		maxArgs: 2,
+		description: 'Generate batch of text'
+	},
+
+	// Chance.js functions (using dot notation)
+	'chance.word': {
+		minArgs: 0,
+		maxArgs: 1,
+		description: 'Generate random word'
+	},
+	'chance.sentence': {
+		minArgs: 0,
+		maxArgs: 1,
+		description: 'Generate random sentence'
+	},
+	'chance.paragraph': {
+		minArgs: 0,
+		maxArgs: 1,
+		description: 'Generate random paragraph'
+	},
+	'chance.name': {
+		minArgs: 0,
+		maxArgs: 1,
+		description: 'Generate random name'
+	},
+	'chance.first': {
+		minArgs: 0,
+		maxArgs: 1,
+		description: 'Generate random first name'
+	},
+	'chance.last': {
+		minArgs: 0,
+		maxArgs: 1,
+		description: 'Generate random last name'
+	},
+	'chance.email': {
+		minArgs: 0,
+		maxArgs: 1,
+		description: 'Generate random email'
+	},
+	'chance.company': {
+		minArgs: 0,
+		maxArgs: 0,
+		description: 'Generate random company name'
+	},
+	'chance.profession': {
+		minArgs: 0,
+		maxArgs: 0,
+		description: 'Generate random profession'
+	},
+	'chance.industry': {
+		minArgs: 0,
+		maxArgs: 0,
+		description: 'Generate random industry'
+	},
+	'chance.country': {
+		minArgs: 0,
+		maxArgs: 1,
+		description: 'Generate random country'
+	},
+	'chance.city': {
+		minArgs: 0,
+		maxArgs: 0,
+		description: 'Generate random city'
+	},
+	'chance.state': {
+		minArgs: 0,
+		maxArgs: 1,
+		description: 'Generate random state'
+	},
+	'chance.address': {
+		minArgs: 0,
+		maxArgs: 1,
+		description: 'Generate random address'
+	},
+	'chance.phone': {
+		minArgs: 0,
+		maxArgs: 1,
+		description: 'Generate random phone number'
+	},
+	'chance.url': {
+		minArgs: 0,
+		maxArgs: 1,
+		description: 'Generate random URL'
+	},
+	'chance.domain': {
+		minArgs: 0,
+		maxArgs: 1,
+		description: 'Generate random domain'
+	},
+	'chance.ip': {
+		minArgs: 0,
+		maxArgs: 0,
+		description: 'Generate random IP address'
+	},
+	'chance.guid': {
+		minArgs: 0,
+		maxArgs: 1,
+		description: 'Generate random GUID'
+	},
+	'chance.hash': {
+		minArgs: 0,
+		maxArgs: 1,
+		description: 'Generate random hash'
+	},
+	'chance.integer': {
+		minArgs: 0,
+		maxArgs: 1,
+		description: 'Generate random integer with options'
+	},
+	'chance.floating': {
+		minArgs: 0,
+		maxArgs: 1,
+		description: 'Generate random float'
+	},
+	'chance.bool': {
+		minArgs: 0,
+		maxArgs: 1,
+		description: 'Generate random boolean'
+	},
+	'chance.character': {
+		minArgs: 0,
+		maxArgs: 1,
+		description: 'Generate random character'
+	},
+	'chance.string': {
+		minArgs: 0,
+		maxArgs: 1,
+		description: 'Generate random string'
+	},
+	'chance.pick': {
+		minArgs: 1,
+		maxArgs: 2,
+		description: 'Pick random element from array'
+	},
+	'chance.pickone': {
+		minArgs: 1,
+		maxArgs: 1,
+		description: 'Pick one random element from array'
+	},
+	'chance.pickset': {
+		minArgs: 2,
+		maxArgs: 2,
+		description: 'Pick set of random elements from array'
+	},
+	'chance.cc': {
+		minArgs: 0,
+		maxArgs: 1,
+		description: 'Generate credit card number'
+	},
+	'chance.android_id': {
+		minArgs: 0,
+		maxArgs: 0,
+		description: 'Generate Android device ID'
+	},
+
+	// Special function for arrow functions
+	arrow: {
+		minArgs: 1,
+		maxArgs: 1,
+		description: 'Raw arrow function with body',
+		special: true
+	}
+};
+
+/**
+ * Validate a function call structure
+ * @param {Object} funcCall - The function call object with functionName and args
+ * @returns {boolean} - Whether the function call is valid
+ */
+export function validateFunctionCall(funcCall) {
+	if (!funcCall || typeof funcCall !== 'object') {
+		return false;
+	}
+
+	const { functionName, args, body } = funcCall;
+
+	if (!functionName || typeof functionName !== 'string') {
+		return false;
+	}
+
+	// Special handling for arrow functions
+	if (functionName === 'arrow') {
+		return typeof body === 'string' && body.length > 0;
+	}
+
+	const funcDef = FUNCTION_REGISTRY[functionName];
+	if (!funcDef) {
+		logger.warn({ functionName }, `Unknown function: ${functionName}`);
+		return false;
+	}
+
+	// Check args
+	if (!Array.isArray(args)) {
+		if (funcDef.minArgs === 0 && !args) {
+			return true; // No args required and none provided
+		}
+		return false;
+	}
+
+	if (args.length < funcDef.minArgs || args.length > funcDef.maxArgs) {
+		logger.warn({ functionName, expected: `${funcDef.minArgs}-${funcDef.maxArgs}`, actual: args.length }, `Function ${functionName} expects ${funcDef.minArgs}-${funcDef.maxArgs} args, got ${args.length}`);
+		return false;
+	}
+
+	return true;
+}
+
+/**
+ * Get list of all valid function names
+ * @returns {string[]} Array of function names
+ */
+export function getValidFunctionNames() {
+	return Object.keys(FUNCTION_REGISTRY);
+}

package/lib/utils/json-evaluator.js

@@ -0,0 +1,172 @@
+/**
+ * JSON Evaluator for converting JSON function call format to JavaScript
+ * Replaces the old regex-based string parsing approach
+ */
+
+import { validateFunctionCall } from './function-registry.js';
+
+/**
+ * Evaluate a value that might contain function calls
+ * @param {any} value - The value to evaluate (could be object with functionName, array, or primitive)
+ * @returns {string} - JavaScript code string
+ */
+export function evaluateValue(value) {
+	// Handle function call objects
+	if (typeof value === 'object' && value !== null && 'functionName' in value) {
+		return evaluateFunctionCall(value);
+	}
+
+	// Handle arrays (return as-is)
+	if (Array.isArray(value)) {
+		return JSON.stringify(value);
+	}
+
+	// Handle nested objects (recursively evaluate)
+	if (typeof value === 'object' && value !== null) {
+		const entries = Object.entries(value).map(([key, val]) => {
+			const evaluatedVal = evaluateValue(val);
+			// Use quotes for keys that need them
+			const quotedKey = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key) ? key : `"${key}"`;
+			return `${quotedKey}: ${evaluatedVal}`;
+		});
+		return `{${entries.join(', ')}}`;
+	}
+
+	// Handle primitives
+	return JSON.stringify(value);
+}
+
+/**
+ * Evaluate a function call object to JavaScript code
+ * @param {Object} funcCall - Object with functionName and args/body
+ * @returns {string} - JavaScript function call string
+ */
+export function evaluateFunctionCall(funcCall) {
+	if (!validateFunctionCall(funcCall)) {
+		throw new Error(`Invalid function call: ${JSON.stringify(funcCall)}`);
+	}
+
+	const { functionName, args, body } = funcCall;
+
+	// Special handling for arrow functions
+	if (functionName === 'arrow') {
+		return `() => ${body}`;
+	}
+
+	// Handle chance.* functions
+	if (functionName.startsWith('chance.')) {
+		const method = functionName.split('.')[1];
+		if (!args || args.length === 0) {
+			return `chance.${method}.bind(chance)`;
+		} else if (args.length === 1 && typeof args[0] === 'object') {
+			// For methods that take an options object
+			return `() => chance.${method}(${JSON.stringify(args[0])})`;
+		} else {
+			// For methods with regular arguments
+			const argsStr = args.map(arg => evaluateValue(arg)).join(', ');
+			return `() => chance.${method}(${argsStr})`;
+		}
+	}
+
+	// Handle regular functions
+	if (!args || args.length === 0) {
+		return `${functionName}()`;
+	}
+
+	// Evaluate each argument
+	const evaluatedArgs = args.map(arg => {
+		// If arg is an object with functionName, evaluate it as a function call
+		if (typeof arg === 'object' && arg !== null && 'functionName' in arg) {
+			return evaluateFunctionCall(arg);
+		}
+		// For primitive values (strings, numbers, booleans), use JSON.stringify
+		// but strings need special handling to avoid double-escaping
+		if (typeof arg === 'string') {
+			return `"${arg}"`;
+		}
+		// For other primitives and arrays, use JSON.stringify
+		return JSON.stringify(arg);
+	});
+
+	return `${functionName}(${evaluatedArgs.join(', ')})`;
+}
+
+/**
+ * Convert a complete dungeon config from JSON to JavaScript
+ * @param {Object} config - The dungeon configuration object
+ * @returns {Object} - Configuration with function strings
+ */
+export function convertDungeonConfig(config) {
+	const converted = {};
+
+	for (const [key, value] of Object.entries(config)) {
+		// Skip certain keys that shouldn't be processed
+		if (key === 'seed' || key === 'name' || typeof value === 'number' || typeof value === 'boolean' || typeof value === 'string') {
+			converted[key] = value;
+			continue;
+		}
+
+		// Special handling for groupKeys - preserve as array of arrays
+		if (key === 'groupKeys' && Array.isArray(value)) {
+			converted[key] = value;
+			continue;
+		}
+
+		// Process arrays of objects (like events)
+		if (Array.isArray(value)) {
+			converted[key] = value.map(item => {
+				if (typeof item === 'object' && item !== null) {
+					return processConfigObject(item);
+				}
+				return item;
+			});
+		}
+		// Process objects
+		else if (typeof value === 'object' && value !== null) {
+			converted[key] = processConfigObject(value);
+		}
+		else {
+			converted[key] = value;
+		}
+	}
+
+	return converted;
+}
+
+/**
+ * Process a configuration object, converting function calls
+ * @param {Object} obj - Object to process
+ * @returns {Object} - Processed object
+ */
+function processConfigObject(obj) {
+	const processed = {};
+
+	for (const [key, value] of Object.entries(obj)) {
+		// Check if this is a function call
+		if (typeof value === 'object' && value !== null && 'functionName' in value) {
+			// Store as string for the JS file generation
+			processed[key] = evaluateFunctionCall(value);
+		}
+		// Process nested arrays
+		else if (Array.isArray(value)) {
+			processed[key] = value.map(item => {
+				if (typeof item === 'object' && item !== null && 'functionName' in item) {
+					return evaluateFunctionCall(item);
+				}
+				if (typeof item === 'object' && item !== null) {
+					return processConfigObject(item);
+				}
+				return item;
+			});
+		}
+		// Process nested objects
+		else if (typeof value === 'object' && value !== null) {
+			processed[key] = processConfigObject(value);
+		}
+		else {
+			processed[key] = value;
+		}
+	}
+
+	return processed;
+}

package/lib/utils/logger.js

@@ -0,0 +1,38 @@
+/**
+ * Structured logger using Pino
+ *
+ * Pretty-printed in development, JSON in production for Cloud Run
+ */
+
+import pino from 'pino';
+
+const isDev = process.env.NODE_ENV !== 'production';
+const isTest = process.env.NODE_ENV === 'test';
+
+// Create the logger with appropriate transport
+// In production, use 'message' instead of 'msg' for GCP Cloud Logging compatibility
+const logger = pino({
+    level: process.env.LOG_LEVEL || (isTest ? 'silent' : isDev ? 'warn' : 'info'),
+    // Use 'message' instead of 'msg' for GCP Cloud Logging
+    messageKey: isDev ? 'msg' : 'message',
+    transport: isDev
+        ? {
+            target: 'pino-pretty',
+            options: {
+                colorize: true,
+                translateTime: 'HH:MM:ss.l',
+                ignore: 'pid,hostname',
+                messageFormat: '{msg}',
+                errorLikeObjectKeys: ['err', 'error']
+            }
+        }
+        : undefined // JSON output in production for Cloud Run
+});
+
+// Add child loggers for different components
+export const serverLogger = logger.child({ component: 'server' });
+export const aiLogger = logger.child({ component: 'ai' });
+export const dataLogger = logger.child({ component: 'data' });
+export const importLogger = logger.child({ component: 'import' });
+
+export default logger;