make-mp-data 1.5.56 → 2.0.1

package/lib/orchestrators/user-loop.js

@@ -0,0 +1,194 @@
+/**
+ * User Loop Orchestrator module
+ * Manages user generation and event creation workflow
+ */
+
+/** @typedef {import('../../types').Context} Context */
+
+import dayjs from "dayjs";
+import pLimit from 'p-limit';
+import * as u from "../utils/utils.js";
+import * as t from 'ak-tools';
+import { makeEvent } from "../generators/events.js";
+import { makeFunnel } from "../generators/funnels.js";
+import { makeUserProfile } from "../generators/profiles.js";
+import { makeSCD } from "../generators/scd.js";
+
+/**
+ * Main user generation loop that creates users, their profiles, events, and SCDs
+ * @param {Context} context - Context object containing config, defaults, storage, etc.
+ * @returns {Promise<void>}
+ */
+export async function userLoop(context) {
+    const { config, storage, defaults } = context;
+    const chance = u.getChance();
+    const concurrency = config?.concurrency || 1;
+    const USER_CONN = pLimit(concurrency);
+    
+    const {
+        verbose,
+        numUsers,
+        numEvents,
+        isAnonymous,
+        hasAvatar,
+        hasAnonIds,
+        hasSessionIds,
+        hasLocation,
+        funnels,
+        userProps,
+        scdProps,
+        numDays,
+        percentUsersBornInDataset = 5,
+    } = config;
+    
+    const { eventData, userProfilesData, scdTableData } = storage;
+    const avgEvPerUser = numEvents / numUsers;
+    const startTime = Date.now();
+
+    for (let i = 0; i < numUsers; i++) {
+        await USER_CONN(async () => {
+            context.incrementUserCount();
+            const eps = Math.floor(context.getEventCount() / ((Date.now() - startTime) / 1000));
+            
+            if (verbose) {
+                u.progress([
+                    ["users", context.getUserCount()], 
+                    ["events", context.getEventCount()], 
+                    ["eps", eps]
+                ]);
+            }
+            
+            const userId = chance.guid();
+            const user = u.generateUser(userId, { numDays, isAnonymous, hasAvatar, hasAnonIds, hasSessionIds });
+            const { distinct_id, created } = user;
+            const userIsBornInDataset = chance.bool({ likelihood: percentUsersBornInDataset });
+            let numEventsPreformed = 0;
+            
+            if (!userIsBornInDataset) delete user.created;
+            
+            // Calculate time adjustments
+            const daysShift = context.getDaysShift();
+            const adjustedCreated = userIsBornInDataset 
+                ? dayjs(created).subtract(daysShift, 'd') 
+                : dayjs.unix(global.FIXED_BEGIN);
+
+            if (hasLocation) {
+                const location = u.shuffleArray(u.choose(defaults.locationsUsers)).pop();
+                for (const key in location) {
+                    user[key] = location[key];
+                }
+            }
+
+            // Profile creation
+            const profile = await makeUserProfile(context, userProps, user);
+
+            // SCD creation
+            const scdUserTables = t.objFilter(scdProps, (scd) => scd.type === 'user' || !scd.type);
+            const scdTableKeys = Object.keys(scdUserTables);
+
+            const userSCD = {};
+            for (const [index, key] of scdTableKeys.entries()) {
+                const { max = 100 } = scdProps[key];
+                const mutations = chance.integer({ min: 1, max });
+                const changes = await makeSCD(context, scdProps[key], key, distinct_id, mutations, created);
+                userSCD[key] = changes;
+                
+                await config.hook(changes, "scd-pre", { 
+                    profile, 
+                    type: 'user', 
+                    scd: { [key]: scdProps[key] }, 
+                    config, 
+                    allSCDs: userSCD 
+                });
+            }
+
+            let numEventsThisUserWillPreform = Math.floor(chance.normal({
+                mean: avgEvPerUser,
+                dev: avgEvPerUser / u.integer(u.integer(2, 5), u.integer(2, 7))
+            }) * 0.714159265359);
+
+            // Power users and low-activity users logic
+            chance.bool({ likelihood: 20 }) ? numEventsThisUserWillPreform *= 5 : null;
+            chance.bool({ likelihood: 15 }) ? numEventsThisUserWillPreform *= 0.333 : null;
+            numEventsThisUserWillPreform = Math.round(numEventsThisUserWillPreform);
+
+            let userFirstEventTime;
+
+            const firstFunnels = funnels.filter((f) => f.isFirstFunnel).reduce(u.weighFunnels, []);
+            const usageFunnels = funnels.filter((f) => !f.isFirstFunnel).reduce(u.weighFunnels, []);
+
+            const secondsInDay = 86400;
+            const noise = () => chance.integer({ min: 0, max: secondsInDay });
+            let usersEvents = [];
+
+            if (firstFunnels.length && userIsBornInDataset) {
+                const firstFunnel = chance.pickone(firstFunnels, user);
+                const firstTime = adjustedCreated.subtract(noise(), 'seconds').unix();
+                const [data, userConverted] = await makeFunnel(context, firstFunnel, user, firstTime, profile, userSCD);
+                
+                const timeShift = context.getTimeShift();
+                userFirstEventTime = dayjs(data[0].time).subtract(timeShift, 'seconds').unix();
+                numEventsPreformed += data.length;
+                usersEvents.push(...data);
+                
+                if (!userConverted) {
+                    if (verbose) {
+                        u.progress([["users", context.getUserCount()], ["events", context.getEventCount()]]);
+                    }
+                    return;
+                }
+            } else {
+                userFirstEventTime = adjustedCreated.subtract(noise(), 'seconds').unix();
+            }
+
+            while (numEventsPreformed < numEventsThisUserWillPreform) {
+                if (usageFunnels.length) {
+                    const currentFunnel = chance.pickone(usageFunnels);
+                    const [data, userConverted] = await makeFunnel(context, currentFunnel, user, userFirstEventTime, profile, userSCD);
+                    numEventsPreformed += data.length;
+                    usersEvents.push(...data);
+                } else {
+                    const data = await makeEvent(context, distinct_id, userFirstEventTime, u.pick(config.events), user.anonymousIds, user.sessionIds, {}, config.groupKeys, true);
+                    numEventsPreformed++;
+                    usersEvents.push(data);
+                }
+            }
+
+            // Hook for processing all user events
+            if (config.hook) {
+                const newEvents = await config.hook(usersEvents, "everything", { 
+                    profile, 
+                    scd: userSCD, 
+                    config, 
+                    userIsBornInDataset 
+                });
+                if (Array.isArray(newEvents)) usersEvents = newEvents;
+            }
+
+            // Store all user data
+            await userProfilesData.hookPush(profile);
+
+            if (Object.keys(userSCD).length) {
+                for (const [key, changesArray] of Object.entries(userSCD)) {
+                    for (const changes of changesArray) {
+                        try {
+                            const target = scdTableData.filter(arr => arr.scdKey === key).pop();
+                            await target.hookPush(changes, { profile, type: 'user' });
+                        }
+                        catch (e) {
+                            // This is probably a test
+                            const target = scdTableData[0];
+                            await target.hookPush(changes, { profile, type: 'user' });
+                        }
+                    }
+                }
+            }
+            
+            await eventData.hookPush(usersEvents, { profile });
+
+            if (verbose) {
+                u.progress([["users", context.getUserCount()], ["events", context.getEventCount()]]);
+            }
+        });
+    }
+}

package/lib/orchestrators/worker-manager.js

@@ -0,0 +1,200 @@
+/**
+ * Cloud Worker Manager module
+ * Handles distributed processing across multiple cloud function workers
+ */
+
+import pLimit from 'p-limit';
+import { GoogleAuth } from 'google-auth-library';
+import { timer, uid, sLog } from 'ak-tools';
+
+const CONCURRENCY = 1_000;
+let RUNTIME_URL = "https://dm4-lmozz6xkha-uc.a.run.app";
+
+/**
+ * Spawn multiple cloud function workers to process data generation in parallel
+ * @param {number} numberWorkers - Number of worker instances to spawn
+ * @param {string} payload - Script payload to execute on each worker
+ * @param {Object} params - Parameters for the job execution
+ * @returns {Promise<Object>} Results summary with success/failure counts
+ */
+export async function spawnFileWorkers(numberWorkers, payload, params) {
+    const auth = new GoogleAuth();
+    let client;
+    
+    if (RUNTIME_URL.includes('localhost')) {
+        client = await auth.getClient();
+    } else {
+        client = await auth.getIdTokenClient(RUNTIME_URL);
+    }
+    
+    const limit = pLimit(CONCURRENCY);
+    const delay = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+
+    const requestPromises = Array.from({ length: numberWorkers }, async (_, index) => {
+        index = index + 1;
+        await delay(index * 108); // Stagger requests to avoid thundering herd
+        return limit(() => buildRequest(client, payload, index, params, numberWorkers));
+    });
+    
+    const complete = await Promise.allSettled(requestPromises);
+    const results = {
+        jobs_success: complete.filter((p) => p.status === "fulfilled").length,
+        jobs_fail: complete.filter((p) => p.status === "rejected").length
+    };
+
+    return results;
+}
+
+/**
+ * Build and execute a single worker request
+ * @param {Object} client - Authenticated Google Cloud client
+ * @param {string} payload - Script payload to send
+ * @param {number} index - Worker index number
+ * @param {Object} params - Job parameters
+ * @param {number} total - Total number of workers
+ * @returns {Promise<Object>} Worker response data
+ */
+async function buildRequest(client, payload, index, params, total) {
+    let retryAttempt = 0;
+    sLog(`DM4: summoning worker #${index} of ${total}`, params);
+    
+    try {
+        const req = await client.request({
+            url: RUNTIME_URL + `?replicate=1&is_replica=true&runId=${params.runId || "no run id"}`,
+            method: "POST",
+            data: payload,
+            headers: {
+                "Content-Type": "text/plain",
+            },
+            timeout: 3600 * 1000 * 10, // 10 hours timeout
+            retryConfig: {
+                retry: 3,
+                onRetryAttempt: (error) => {
+                    const statusCode = error?.response?.status?.toString() || "";
+                    retryAttempt++;
+                    sLog(`DM4: summon worker ${index} retry #${retryAttempt}`, { 
+                        statusCode, 
+                        message: error.message, 
+                        stack: error.stack, 
+                        ...params 
+                    }, "DEBUG");
+                },
+                retryDelay: 1000,
+                shouldRetry: (error) => {
+                    if (error.code === 'ECONNRESET') return true;
+                    const statusCode = error?.response?.status;
+                    if (statusCode >= 500) return true;
+                    if (statusCode === 429) return true;
+                    return false;
+                }
+            },
+        });
+        
+        sLog(`DM4: worker #${index} responded`, params);
+        const { data } = req;
+        return data;
+    } catch (error) {
+        sLog(`DM4: worker #${index} failed to respond`, { 
+            message: error.message, 
+            stack: error.stack, 
+            code: error.code, 
+            retries: retryAttempt, 
+            ...params 
+        }, "ERROR");
+        return {};
+    }
+}
+
+/**
+ * Handle cloud function HTTP entry point
+ * @param {Object} req - HTTP request object
+ * @param {Object} res - HTTP response object
+ * @param {Function} mainFunction - Main data generation function to execute
+ * @returns {Promise<void>}
+ */
+export async function handleCloudFunctionEntry(req, res, mainFunction) {
+    const reqTimer = timer('request');
+    reqTimer.start();
+    let response = {};
+    let script = req.body || "";
+    const params = { 
+        replicate: 1, 
+        is_replica: "false", 
+        runId: "", 
+        seed: "", 
+        ...req.query 
+    };
+    
+    const replicate = Number(params.replicate);
+    
+    // Parse boolean parameters
+    if (params?.is_replica === "true") params.is_replica = true;
+    else params.is_replica = false;
+    
+    const isReplica = params.is_replica;
+    
+    if (!params.runId) params.runId = uid(42);
+    
+    try {
+        if (!script) throw new Error("no script");
+
+        /** @type {Config} */
+        const config = eval(script);
+        
+        if (isReplica) {
+            // Generate unique seed for replica workers
+            const newSeed = (Math.random() / Math.random() / Math.random() / Math.random() / Math.random() / Math.random()).toString();
+            config.seed = newSeed;
+            params.seed = newSeed;
+        }
+
+        /** @type {Config} */
+        const optionsYouCantChange = {
+            verbose: false
+        };
+
+        if (replicate <= 1 || isReplica) {
+            if (isReplica) sLog("DM4: worker start", params);
+            
+            const { files = [], operations = 0, eventCount = 0, userCount = 0 } = await mainFunction({
+                ...config,
+                ...optionsYouCantChange,
+            });
+            
+            reqTimer.stop(false);
+            response = { files, operations, eventCount, userCount };
+        } else {
+            sLog(`DM4: job start (${replicate} workers)`, params);
+            const results = await spawnFileWorkers(replicate, script, params);
+            response = results;
+        }
+    } catch (e) {
+        sLog("DM4: error", { error: e.message, stack: e.stack }, "ERROR");
+        response = { error: e.message };
+        res.status(500);
+    } finally {
+        reqTimer.stop(false);
+        const { start, end, delta, human } = reqTimer.report(false);
+        
+        if (!isReplica) {
+            sLog(`DM4: job end (${human})`, { human, delta, ...params, ...response });
+        }
+        
+        if (isReplica) {
+            const eps = Math.floor(((response?.eventCount || 0) / delta) * 1000);
+            sLog(`DM4: worker end (${human})`, { human, delta, eps, ...params, ...response });
+        }
+        
+        response = { ...response, start, end, delta, human, ...params };
+        res.send(response);
+        return;
+    }
+}
+
+/**
+ * Set the runtime URL for the cloud function service
+ * @param {string} url - The runtime URL
+ */
+export function setRuntimeUrl(url) {
+    RUNTIME_URL = url;
+}

package/{components → lib/utils}/ai.js

@@ -1,16 +1,14 @@
-const { GoogleGenerativeAI } = require("@google/generative-ai"); 
-const u = require("ak-tools");
+import { GoogleGenerativeAI } from "@google/generative-ai";
+import * as u from "ak-tools";
 
-
-const dotenv = require("dotenv");
-dotenv.config();
+import 'dotenv/config';
 
 const { GEMINI_API_KEY: API_KEY, NODE_ENV = "unknown" } = process.env;
 if (!API_KEY) throw new Error("Please provide a Gemini API key");
 
 async function generateSchema(userInput) {
 	const gemini = new GoogleGenerativeAI(API_KEY);
-	const model = gemini.getGenerativeModel({ model: "gemini-1.5-flash" });
+	const model = gemini.getGenerativeModel({ model: "gemini-2.0-flash" });
 	const PROOMPTY = await u.load("./components/prompt.txt");
 	const prompt = `
 Given the following information about a website or app:
@@ -82,36 +80,10 @@ function validator(schema) {
 }
 
 
-if (require.main === module) {
-	generateSchema(`https://apps.apple.com/us/app/call-guardian-for-us-cellular/id1228680023  call guardian is an app for blocking spam calls made by TNS 
-		
-this is the list of events we want: 
-
-Onboarding Started
-Onboarding Completed (Basic)
-Onboarding Completed (Premium)
-Page Views (all "screens" within the app")
-Enable/Disable High Risk Blocking
-Enable/Disable Medium Risk Blocking
-Enable/Disable Neighborhood Spoof Blocking
-Call Blocked (Spam)
-Call Blocked (Custom List)
-Branded Call w/o Logo Received
-Branded Call w/ Logo Received
-Branded Call Answered
-Branded Call Blocked
-Enable/Disable Text Spam
-Reverse Number Lookup
-Report as Spam
-Report as Not Spam
-Custom Block List Number Add
-Custom Block List Number Remove
-Call Arrives Before Push
-Error Scenarios
-User Can't Authenticate
-Xfinity Services Can't Connect
-Verizon Services Can't Connect
-Deep Links into app`)
+export { generateSchema };
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+	generateSchema(`metube, a video streaming company like youutube, where users watch videos, search, like, comment, subscribe, share, create playlists, etc...`)
 		.then((result) => {
 			if (NODE_ENV === "dev") debugger;
 		})

package/{components → lib/utils}/chart.js

@@ -1,11 +1,11 @@
-const { ChartJSNodeCanvas } = require('chartjs-node-canvas');
-const fs = require('fs');
-const u = require('ak-tools');
-const dayjs = require('dayjs');
-const { openFinder } = require('./utils');
+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';
 const { existsSync } = fs;
-const path = require('path');
-require('dotenv').config();
+import path from 'path';
+import 'dotenv/config';
 const { NODE_ENV = "unknown" } = process.env;
 
 
@@ -186,11 +186,11 @@ async function generateLineChart(rawData, signupEvents = ["sign up"], fileName)
 	return file;
 }
 
-module.exports = { generateLineChart };
+export { generateLineChart };
 
 
 
-if (require.main === module) {
+if (import.meta.url === `file://${process.argv[1]}`) {
 	generateLineChart()
 	.then((result)=>{
 		if (NODE_ENV === "dev") debugger;

package/{components → lib/utils}/project.js

@@ -1,5 +1,5 @@
-require('dotenv').config();
-const akTools = require('ak-tools');
+import 'dotenv/config';
+import * as akTools from 'ak-tools';
 const { rand, makeName } = akTools;
 let { OAUTH_TOKEN = "" } = process.env;
 const { NODE_ENV = "unknown" } = process.env;
@@ -153,7 +153,7 @@ async function addGroupKeys(groupKeyDfns = [], projectId, oauthToken = OAUTH_TOK
 }
 
 
-if (require.main === module) {
+if (import.meta.url === `file://${process.argv[1]}`) {
 	main()
 	.then((result)=>{
 		if (NODE_ENV === "dev") debugger;
@@ -163,4 +163,4 @@ if (require.main === module) {
 	})
 }
 
-module.exports = main;
+export default main;

package/{components → lib/utils}/utils.js

@@ -1,24 +1,24 @@
-const fs = require('fs');
-const Chance = require('chance');
-const readline = require('readline');
-const { comma, uid, clone } = require('ak-tools');
-const { spawn } = require('child_process');
-const dayjs = require('dayjs');
-const utc = require('dayjs/plugin/utc');
-const path = require('path');
-const { mkdir, parseGCSUri } = require('ak-tools');
-const { existsSync } = require('fs');
+import fs from 'fs';
+import Chance from 'chance';
+import readline from 'readline';
+import { comma, uid, clone } from 'ak-tools';
+import { spawn } from 'child_process';
+import dayjs from 'dayjs';
+import utc from 'dayjs/plugin/utc.js';
+import path from 'path';
+import { mkdir, parseGCSUri } from 'ak-tools';
+import { existsSync } from 'fs';
 dayjs.extend(utc);
-require('dotenv').config();
-const { domainSuffix, domainPrefix } = require('./defaults');
+import 'dotenv/config';
+import { domainSuffix, domainPrefix } from '../data/defaults.js';
 
-/** @typedef {import('../types').Dungeon} Config */
-/** @typedef {import('../types').EventConfig} EventConfig */
-/** @typedef {import('../types').ValueValid} ValueValid */
-/** @typedef {import('../types').HookedArray} hookArray */
-/** @typedef {import('../types').hookArrayOptions} hookArrayOptions */
-/** @typedef {import('../types').Person} Person */
-/** @typedef {import('../types').Funnel} Funnel */
+/** @typedef {import('../../types').Dungeon} Config */
+/** @typedef {import('../../types').EventConfig} EventConfig */
+/** @typedef {import('../../types').ValueValid} ValueValid */
+/** @typedef {import('../../types').HookedArray} hookArray */
+/** @typedef {import('../../types').hookArrayOptions} hookArrayOptions */
+/** @typedef {import('../../types').Person} Person */
+/** @typedef {import('../../types').Funnel} Funnel */
 
 let globalChance;
 let chanceInitialized = false;
@@ -26,7 +26,7 @@ let chanceInitialized = false;
 const ACTUAL_NOW = dayjs.utc();
 
 
-const { Storage: cloudStorage } = require('@google-cloud/storage');
+import { Storage as cloudStorage } from '@google-cloud/storage';
 const projectId = 'YOUR_PROJECT_ID';
 const storage = new cloudStorage({ projectId });
 
@@ -192,6 +192,9 @@ function choose(value) {
 			value = value();
 		}
 
+		if (Array.isArray(value) && value.length === 0) {
+			return ""; // Return empty string if the array is empty
+		}
 
 		// [[],[],[]] should pick one
 		if (Array.isArray(value) && Array.isArray(value[0])) {
@@ -947,7 +950,15 @@ function TimeSoup(earliestTime, latestTime, peaks = 5, deviation = 2, mean = 0)
 	if (!earliestTime) earliestTime = global.FIXED_BEGIN ? global.FIXED_BEGIN : dayjs().subtract(30, 'd').unix(); // 30 days ago
 	if (!latestTime) latestTime = global.FIXED_NOW ? global.FIXED_NOW : dayjs().unix();
 	const chance = getChance();
-	const totalRange = latestTime - earliestTime;
+	let totalRange = latestTime - earliestTime;
+	if (totalRange <= 0 || earliestTime > latestTime) {
+		//just flip earliest and latest
+		let tempEarly = latestTime
+		let tempLate = earliestTime;
+		earliestTime = tempEarly;
+		latestTime = tempLate;
+		totalRange = latestTime - earliestTime;
+	}
 	const chunkSize = totalRange / peaks;
 
 	// Select a random chunk based on the number of peaks
@@ -966,6 +977,7 @@ function TimeSoup(earliestTime, latestTime, peaks = 5, deviation = 2, mean = 0)
 		offset = chance.normal({ mean: mean, dev: chunkSize / deviation });
 		isValidTime = validTime(chunkMid + offset, earliestTime, latestTime);
 		if (iterations > 25000) {
+			if (process.env?.NODE_ENV === 'dev') debugger;
 			throw `${iterations} iterations... exceeded`;
 		}
 	} while (chunkMid + offset < chunkStart || chunkMid + offset > chunkEnd);
@@ -1141,7 +1153,7 @@ function generateEmoji(max = 10, array = false) {
 
 
 
-module.exports = {
+export {
 	pick,
 	date,
 	dates,
@@ -1152,7 +1164,7 @@ module.exports = {
 	TimeSoup,
 	companyName,
 	generateEmoji,
-	haveSameKeys: hasSameKeys,
+	hasSameKeys as haveSameKeys,
 
 	initChance,
 	getChance,

package/package.json

@@ -1,7 +1,8 @@
 {
 	"name": "make-mp-data",
-	"version": "1.5.056",
+	"version": "2.0.1",
 	"description": "builds all mixpanel primitives for a given project",
+	"type": "module",
 	"main": "index.js",
 	"types": "types.d.ts",
 	"scripts": {
@@ -10,8 +11,10 @@
 		"prune": "rm -f ./data/* && rm -f ./tmp/* && rm -f vscode-profile-*",
 		"post": "npm publish",
 		"deps": "./scripts/update-deps.sh",
-		"test": "NODE_ENV=test jest --runInBand",
-		"coverage": "node --no-warnings --experimental-vm-modules node_modules/jest/bin/jest.js --coverage && open ./tests/coverage/lcov-report/index.html",
+		"test": "NODE_ENV=test vitest run",
+		"test:watch": "NODE_ENV=test vitest",
+		"test:ui": "NODE_ENV=test vitest --ui",
+		"coverage": "vitest run --coverage && open ./coverage/index.html",
 		"new:dungeon": "./scripts/new-dungeon.sh",
 		"new:project": "node ./scripts/new-project.mjs",
 		"exp:benchmark": "node --no-warnings --experimental-vm-modules ./tests/benchmark/concurrency.mjs",
@@ -47,32 +50,29 @@
 	"dependencies": {
 		"@google-cloud/functions-framework": "^3.4.2",
 		"@google-cloud/storage": "^7.14.0",
-		"@google/generative-ai": "^0.16.0",
-		"ak-fetch": "^1.0.89",
-		"ak-tools": "^1.0.68",
+		"@google/generative-ai": "^0.24.1",
+		"ak-fetch": "^2.0.1",
+		"ak-gemini": "^1.0.55",
+		"ak-tools": "^1.1.0",
 		"chance": "^1.1.11",
 		"chart.js": "^3.9.1",
 		"chartjs-node-canvas": "^4.1.6",
 		"dayjs": "^1.11.11",
 		"dotenv": "^16.4.5",
 		"google-auth-library": "^9.15.0",
-		"mixpanel-import": "^2.7.47",
+		"mixpanel-import": "^2.8.14",
 		"p-limit": "^3.1.0",
 		"yargs": "^17.7.2"
 	},
 	"devDependencies": {
-		"@types/jest": "^29.5.12",
-		"jest": "^29.7.0",
-		"nodemon": "^3.1.3"
-	},
-	"jest": {
-		"preset": "./tests/jest.config.js"
+		"@vitest/ui": "^2.1.9",
+		"nodemon": "^3.1.3",
+		"vitest": "^2.1.9"
 	},
 	"nodemonConfig": {
 		"ignore": [
 			"data/",
 			"tmp/"
-			
 		]
 	}
-}
+}