zerra-core 1.2.1 → 1.2.2

package/index.d.ts

@@ -12,12 +12,15 @@ export interface ZerraRequest extends IncomingMessage {
     buffer: Buffer;
   }>;
   params: Record<string, string>;
+  cookies: Record<string, string>; // Feature 1: Parsed Cookies
 }
 
 export interface ZerraResponse extends ServerResponse {
   status(code: number): ZerraResponse;
   json(data: any): void;
   cors(options?: { origin?: string; methods?: string }): ZerraResponse;
+  sendFile(filePath: string): void; // Feature 2: Send File helper
+  redirect(url: string, status?: number): void; // Feature 3: Redirect helper
 }
 
 export type ZerraHandler = (req: ZerraRequest, res: ZerraResponse) => void | Promise<void>;
@@ -28,12 +31,16 @@ export interface ZerraConfig {
   features: {
     logging?: boolean;
     dynamicRouting?: boolean;
+    
     middleware?: boolean;
     dotenv?: boolean;
     validation?: boolean;
     multipart?: boolean;
     errors?: boolean;
     dashboard?: boolean;
+    static?: boolean; // Feature 4: Static File Serving
+    rateLimiting?: boolean | { max: number; windowMs: number }; // Feature 5: Built-in Rate Limiting
+    cron?: boolean; // Feature 6: Built-in Cron Job Scheduler
   };
   plugins?: string[];
 }

package/index.js

@@ -3,6 +3,7 @@ const fs = require("fs");
 const path = require("path");
 
 function startServer(port = 3000) {
+  const isDev = process.env.NODE_ENV !== 'production';
   const jiti = require("jiti")(__filename);
   const configPath = path.join(process.cwd(), 'zerra.config.json');
   let config = {
@@ -14,7 +15,10 @@ function startServer(port = 3000) {
       validation: true,
       multipart: true,
       errors: true,
-      dashboard: true
+      dashboard: true,
+      static: true, // Feature 4: Static File Serving
+      rateLimiting: false, // Feature 5: Built-in Rate Limiting
+      cron: true, // Feature 6: Built-in Cron Job Scheduler
     },
     plugins: []
   };
@@ -27,6 +31,23 @@ function startServer(port = 3000) {
     }
   }
 
+  // 1. Optimized module caching mechanism
+  const moduleCache = new Map();
+  const getModule = (modulePath) => {
+    if (isDev) {
+      try {
+        delete require.cache[require.resolve(modulePath)];
+      } catch (e) {}
+      return jiti(modulePath);
+    }
+    if (moduleCache.has(modulePath)) {
+      return moduleCache.get(modulePath);
+    }
+    const mod = jiti(modulePath);
+    moduleCache.set(modulePath, mod);
+    return mod;
+  };
+
   const customEnvKeys = new Set();
   const recentRequests = [];
   const MAX_LOGS = 20;
@@ -71,7 +92,7 @@ function startServer(port = 3000) {
   if (config.plugins && Array.isArray(config.plugins)) {
     config.plugins.forEach(pluginPath => {
       try {
-        const plugin = jiti(path.isAbsolute(pluginPath) ? pluginPath : path.join(process.cwd(), pluginPath));
+        const plugin = getModule(path.isAbsolute(pluginPath) ? pluginPath : path.join(process.cwd(), pluginPath));
         if (typeof plugin === 'function') plugin(zerra);
       } catch (e) {
         console.error(`❌ Failed to load plugin: ${pluginPath}`, e);
@@ -81,6 +102,86 @@ function startServer(port = 3000) {
 
   const apiDir = path.join(process.cwd(), "api");
 
+  // In-memory Route Table for fast production route resolution
+  let routeTable = [];
+  
+  function buildRouteTable(dir, base = '') {
+    let results = [];
+    if (!fs.existsSync(dir)) return results;
+    const list = fs.readdirSync(dir);
+    list.forEach(file => {
+      const filePath = path.join(dir, file);
+      const stat = fs.statSync(filePath);
+      if (stat && stat.isDirectory()) {
+        results = results.concat(buildRouteTable(filePath, path.join(base, file)));
+      } else if ((file.endsWith('.js') || file.endsWith('.ts')) && !file.startsWith('_')) {
+        const relRoute = path.join(base, file).replace(/\\/g, '/').replace(/\.(js|ts)$/, '');
+        const segments = relRoute.split('/').filter(Boolean);
+        
+        // Resolve middleware paths for this route
+        const middlewarePaths = [];
+        if (config.features.middleware) {
+          let currentPath = path.dirname(filePath);
+          while (currentPath.length >= apiDir.length && currentPath.startsWith(apiDir)) {
+            let mwPath = path.join(currentPath, '_middleware.js');
+            if (!fs.existsSync(mwPath)) mwPath = path.join(currentPath, '_middleware.ts');
+            if (fs.existsSync(mwPath)) {
+              middlewarePaths.unshift(mwPath);
+            }
+            if (currentPath === apiDir) break;
+            currentPath = path.dirname(currentPath);
+          }
+        }
+        
+        results.push({
+          filePath,
+          segments,
+          middlewarePaths
+        });
+      }
+    });
+    return results;
+  }
+
+  if (!isDev) {
+    routeTable = buildRouteTable(apiDir);
+    // Sort exact segments before dynamic parameter segments, and longer paths first
+    routeTable.sort((a, b) => {
+      const minLen = Math.min(a.segments.length, b.segments.length);
+      for (let i = 0; i < minLen; i++) {
+        const aSec = a.segments[i];
+        const bSec = b.segments[i];
+        const aDyn = aSec.startsWith('[');
+        const bDyn = bSec.startsWith('[');
+        if (aDyn !== bDyn) {
+          return aDyn ? 1 : -1;
+        }
+      }
+      return b.segments.length - a.segments.length;
+    });
+  }
+
+  // Pre-cached static files set for production static serving
+  const publicFilesSet = new Set();
+  
+  function scanPublicFiles(dir) {
+    if (!fs.existsSync(dir)) return;
+    const list = fs.readdirSync(dir);
+    list.forEach(file => {
+      const filePath = path.join(dir, file);
+      const stat = fs.statSync(filePath);
+      if (stat && stat.isDirectory()) {
+        scanPublicFiles(filePath);
+      } else {
+        publicFilesSet.add(filePath);
+      }
+    });
+  }
+
+  if (!isDev && config.features.static) {
+    scanPublicFiles(path.join(process.cwd(), "public"));
+  }
+
   const server = http.createServer(async (req, res) => {
     const { url, method } = req;
     const startTime = Date.now();
@@ -129,6 +230,30 @@ function startServer(port = 3000) {
     req.query = Object.fromEntries(parsedUrl.searchParams);
     req.path = parsedUrl.pathname;
 
+    // Feature 1: Auto-parsed Cookies
+    req.cookies = {};
+    if (req.headers.cookie) {
+      req.headers.cookie.split(';').forEach(cookie => {
+        const parts = cookie.split('=');
+        req.cookies[parts.shift().trim()] = decodeURI(parts.join('='));
+      });
+    }
+
+    // Feature 2: res.sendFile helper
+    res.sendFile = (filePath) => {
+       const absolutePath = path.isAbsolute(filePath) ? filePath : path.join(process.cwd(), filePath);
+       if (fs.existsSync(absolutePath)) {
+         return fs.createReadStream(absolutePath).pipe(res);
+       }
+       res.status(404).json({ error: "File not found" });
+    };
+
+    // Feature 3: res.redirect helper
+    res.redirect = (redirectUrl, status = 302) => {
+      res.writeHead(status, { Location: redirectUrl });
+      res.end();
+    };
+
     // Apply Decorators
     Object.entries(resDecorators).forEach(([name, fn]) => { res[name] = fn.bind(res); });
     Object.entries(reqDecorators).forEach(([name, fn]) => { req[name] = fn.bind(req); });
@@ -191,9 +316,15 @@ function startServer(port = 3000) {
       });
     };
 
-    const parsedData = await parseBody();
-    req.body = parsedData.body;
-    req.files = parsedData.files;
+    // Conditional body parsed execution (optimization)
+    if (['GET', 'HEAD', 'OPTIONS'].includes(method)) {
+      req.body = null;
+      req.files = [];
+    } else {
+      const parsedData = await parseBody();
+      req.body = parsedData.body;
+      req.files = parsedData.files;
+    }
 
     // Handle OPTIONS requests automatically for CORS if requested
     if (method === 'OPTIONS') {
@@ -205,6 +336,45 @@ function startServer(port = 3000) {
     req.params = {};
     const cleanPath = req.path === "/" ? "/index" : req.path;
 
+    // Feature 4: Built-in Rate Limiting
+    if (config.features.rateLimiting) {
+      if (!global.rateLimitStore) global.rateLimitStore = {};
+      const ip = req.socket.remoteAddress || 'unknown';
+      const now = Date.now();
+      
+      const rlConfig = typeof config.features.rateLimiting === 'object' ? config.features.rateLimiting : { max: 100, windowMs: 60000 };
+      
+      if (!global.rateLimitStore[ip] || now > global.rateLimitStore[ip].resetTime) {
+        global.rateLimitStore[ip] = { count: 1, resetTime: now + rlConfig.windowMs };
+      } else {
+        global.rateLimitStore[ip].count++;
+      }
+      
+      if (global.rateLimitStore[ip].count > rlConfig.max) {
+        return res.status(429).json({ error: "Too Many Requests", message: "Rate limit exceeded. Try again later." });
+      }
+    }
+
+    // Feature 5: Static File Serving (optimized via Set lookup in production)
+    if (config.features.static && method === 'GET') {
+      const publicDir = path.join(process.cwd(), "public");
+      const publicPath = path.join(publicDir, cleanPath === "/index" ? "/" : cleanPath);
+      
+      let isStaticFile = false;
+      if (!isDev) {
+        isStaticFile = publicFilesSet.has(publicPath);
+      } else {
+        isStaticFile = fs.existsSync(publicDir) && publicPath.startsWith(publicDir) && fs.existsSync(publicPath) && fs.statSync(publicPath).isFile();
+      }
+
+      if (isStaticFile) {
+         const ext = path.extname(publicPath);
+         const mimeTypes = { '.html': 'text/html', '.js': 'text/javascript', '.css': 'text/css', '.json': 'application/json', '.png': 'image/png', '.jpg': 'image/jpeg', '.svg': 'image/svg+xml' };
+         res.setHeader('Content-Type', mimeTypes[ext] || 'application/octet-stream');
+         return fs.createReadStream(publicPath).pipe(res);
+      }
+    }
+
     // 10. Enhanced DX: Dev Dashboard
     if (config.features.dashboard && cleanPath === '/__zerra') {
       const getRoutes = (dir, base = '') => {
@@ -223,7 +393,7 @@ function startServer(port = 3000) {
             // Try to extract schema for playground presets
             let schema = null;
             try {
-              const mod = jiti(filePath);
+              const mod = getModule(filePath);
               schema = mod.schema || (mod.default && mod.default.schema);
             } catch (e) {}
 
@@ -371,7 +541,7 @@ function startServer(port = 3000) {
                           <input type="text" id="body-${r.path}" value='${sampleBody}' placeholder='{"key": "value"}' style="flex-grow: 1; padding: 4px 10px; border-radius: 4px; border: 1px solid var(--border); font-family: monospace; font-size: 0.8rem;">
                           <button onclick="testRoute('${r.path}')" style="background: var(--primary); color: #fff; border: none; padding: 5px 15px; border-radius: 4px; cursor: pointer; font-weight: bold; font-size: 0.8rem;">SEND</button>
                         </div>
-
+ 
                         <div id="res-${r.path}" style="display: none; background: #1e1e1e; color: #d4d4d4; padding: 12px; border-radius: 6px; font-family: monospace; font-size: 0.85rem; overflow-x: auto; margin-top: 10px; position: relative;">
                           <div id="status-${r.path}" style="position: absolute; top: 8px; right: 8px; font-size: 0.7rem; font-weight: bold;"></div>
                           <pre style="margin: 0;"></pre>
@@ -380,7 +550,7 @@ function startServer(port = 3000) {
                     `}).join('') : '<div style="color:#999">No routes found in /api</div>'}
                   </div>
                 </section>
-
+ 
                 <section>
                   <h2>⚙️ Features</h2>
                   <div style="display: flex; flex-direction: column; gap: 12px;">
@@ -393,7 +563,7 @@ function startServer(port = 3000) {
                   </div>
                 </section>
               </div>
-
+ 
               <section style="margin-bottom: 20px;">
                 <h2>📊 Recent Activity</h2>
                 <table>
@@ -422,7 +592,7 @@ function startServer(port = 3000) {
                   </tbody>
                 </table>
               </section>
-
+ 
               <section>
                 <h2>🔐 Environment</h2>
                 <div style="display: flex; flex-wrap: wrap; gap: 10px;">
@@ -440,7 +610,7 @@ function startServer(port = 3000) {
                 </div>
               </section>
             </main>
-
+ 
             <script>
               async function testRoute(path) {
                 const method = document.getElementById('method-' + path).value;
@@ -474,12 +644,12 @@ function startServer(port = 3000) {
                   pre.innerText = err.message;
                 }
               }
-
+ 
               // Soft refresh every 5 seconds
               let refreshTimeout = setTimeout(() => {
                 window.location.reload();
               }, 5000);
-
+ 
               // Pause refresh if user is interacting with playground
               document.addEventListener('mousedown', () => {
                 clearTimeout(refreshTimeout);
@@ -491,75 +661,107 @@ function startServer(port = 3000) {
       `);
     }
 
-    let filePath = path.join(apiDir, `${cleanPath}.js`);
-    if (!fs.existsSync(filePath)) {
-      filePath = path.join(apiDir, `${cleanPath}.ts`);
-    }
+    let filePath = null;
+    let middlewarePaths = [];
 
-    // 6. Enhanced DX: Dynamic Routing ([id].js)
-    if (config.features.dynamicRouting && !fs.existsSync(filePath)) {
-      const parts = cleanPath.split('/').filter(Boolean);
-      let currentDir = apiDir;
-      let matchedFile = null;
+    if (!isDev) {
+      // 1. Production Mode: Ultra-fast O(1)/O(N) in-memory route lookup
+      const reqSegments = cleanPath.split('/').filter(Boolean);
+      for (const route of routeTable) {
+        if (route.segments.length !== reqSegments.length) continue;
 
-      for (let i = 0; i < parts.length; i++) {
-        const part = parts[i];
-        const isLast = i === parts.length - 1;
-        
-        if (fs.existsSync(currentDir)) {
-          const files = fs.readdirSync(currentDir);
-          
-          // Look for exact match first
-          let match = files.find(f => isLast ? f === `${part}.js` : f === part && fs.statSync(path.join(currentDir, f)).isDirectory());
+        let isMatch = true;
+        const tempParams = {};
+
+        for (let i = 0; i < route.segments.length; i++) {
+          const routeSec = route.segments[i];
+          const reqSec = reqSegments[i];
+
+          if (routeSec.startsWith('[') && routeSec.endsWith(']')) {
+            const paramName = routeSec.slice(1, -1);
+            tempParams[paramName] = reqSec;
+          } else if (routeSec !== reqSec) {
+            isMatch = false;
+            break;
+          }
+        }
+
+        if (isMatch) {
+          filePath = route.filePath;
+          req.params = tempParams;
+          middlewarePaths = route.middlewarePaths;
+          break;
+        }
+      }
+    } else {
+      // 2. Development Mode: Dynamic Filesystem Walk for instant hot-reloading
+      filePath = path.join(apiDir, `${cleanPath}.js`);
+      if (!fs.existsSync(filePath)) {
+        filePath = path.join(apiDir, `${cleanPath}.ts`);
+      }
+
+      if (config.features.dynamicRouting && !fs.existsSync(filePath)) {
+        const parts = cleanPath.split('/').filter(Boolean);
+        let currentDir = apiDir;
+        let matchedFile = null;
+
+        for (let i = 0; i < parts.length; i++) {
+          const part = parts[i];
+          const isLast = i === parts.length - 1;
           
-          // Look for dynamic parameter [param]
-          if (!match) {
-            match = files.find(f => isLast ? (f.startsWith('[') && (f.endsWith('].js') || f.endsWith('].ts'))) : (f.startsWith('[') && f.endsWith(']') && fs.statSync(path.join(currentDir, f)).isDirectory()));
-            if (match) {
-              const paramName = isLast ? match.slice(1, match.lastIndexOf('].')) : match.slice(1, -1);
-              req.params[paramName] = part;
+          if (fs.existsSync(currentDir)) {
+            const files = fs.readdirSync(currentDir);
+            
+            // Look for exact match first
+            let match = files.find(f => isLast ? f === `${part}.js` : f === part && fs.statSync(path.join(currentDir, f)).isDirectory());
+            
+            // Look for dynamic parameter [param]
+            if (!match) {
+              match = files.find(f => isLast ? (f.startsWith('[') && (f.endsWith('].js') || f.endsWith('].ts'))) : (f.startsWith('[') && f.endsWith(']') && fs.statSync(path.join(currentDir, f)).isDirectory()));
+              if (match) {
+                const paramName = isLast ? match.slice(1, match.lastIndexOf('].')) : match.slice(1, -1);
+                req.params[paramName] = part;
+              }
             }
-          }
 
-          if (match) {
-            if (isLast) {
-              matchedFile = path.join(currentDir, match);
+            if (match) {
+              if (isLast) {
+                matchedFile = path.join(currentDir, match);
+              } else {
+                currentDir = path.join(currentDir, match);
+              }
             } else {
-              currentDir = path.join(currentDir, match);
+              break;
             }
           } else {
             break;
           }
-        } else {
-          break;
+        }
+        
+        if (matchedFile) {
+          filePath = matchedFile;
         }
       }
-      
-      if (matchedFile) {
-        filePath = matchedFile;
-      }
-    }
 
-    if (fs.existsSync(filePath)) {
-      try {
-        // 7. Enhanced DX: Middleware (_middleware.js)
+      // Populate middleware chain for dev mode dynamically
+      if (filePath && fs.existsSync(filePath) && config.features.middleware) {
         const targetDir = path.dirname(filePath);
         let currentPath = targetDir;
-        const middlewarePaths = [];
-        
-        if (config.features.middleware) {
-          while (currentPath.length >= apiDir.length && currentPath.startsWith(apiDir)) {
-            let mwPath = path.join(currentPath, '_middleware.js');
-            if (!fs.existsSync(mwPath)) mwPath = path.join(currentPath, '_middleware.ts');
-            
-            if (fs.existsSync(mwPath)) {
-              middlewarePaths.unshift(mwPath); // Run top-down
-            }
-            if (currentPath === apiDir) break;
-            currentPath = path.dirname(currentPath);
+        while (currentPath.length >= apiDir.length && currentPath.startsWith(apiDir)) {
+          let mwPath = path.join(currentPath, '_middleware.js');
+          if (!fs.existsSync(mwPath)) mwPath = path.join(currentPath, '_middleware.ts');
+          
+          if (fs.existsSync(mwPath)) {
+            middlewarePaths.unshift(mwPath);
           }
+          if (currentPath === apiDir) break;
+          currentPath = path.dirname(currentPath);
         }
+      }
+    }
 
+    if (filePath && fs.existsSync(filePath)) {
+      try {
         let middlewareIndex = 0;
         let responseSent = false;
         
@@ -575,8 +777,7 @@ function startServer(port = 3000) {
 
           if (middlewareIndex < middlewarePaths.length) {
             const mwPath = middlewarePaths[middlewareIndex++];
-            delete require.cache[require.resolve(mwPath)];
-            const mw = jiti(mwPath);
+            const mw = getModule(mwPath);
             if (typeof mw === 'function' || (mw && typeof mw.default === 'function')) {
                const actualMw = mw.default || mw;
                await actualMw(req, res, runNext);
@@ -584,30 +785,61 @@ function startServer(port = 3000) {
                await runNext();
             }
           } else {
-            delete require.cache[require.resolve(filePath)];
-            const handler = jiti(filePath);
+            const handler = getModule(filePath);
 
             if (typeof handler === "function" || (handler && typeof handler.default === "function")) {
               const actualHandler = handler.default || handler;
               
-              // 9. Enhanced DX: Input Validation
-              const schema = handler.schema;
-              if (config.features.validation && schema) {
-                if (!req.body || typeof req.body !== 'object') {
-                  return res.status(400).json({ 
-                    error: "Validation Failed", 
-                    details: ["Request body is required for this route."] 
-                  });
+              // 9. Enhanced DX: Input Validation (Zod Support)
+              const schemaDef = handler.schema;
+              if (config.features.validation && schemaDef) {
+                let validationErrors = [];
+
+                const validateZod = (zodSchema, data) => {
+                  const result = zodSchema.safeParse(data);
+                  if (!result.success) {
+                    return { error: true, details: result.error.errors };
+                  }
+                  return { error: false, data: result.data };
+                };
+
+                if (schemaDef.safeParse) {
+                  // Direct Zod schema for body
+                  const result = validateZod(schemaDef, req.body);
+                  if (result.error) validationErrors.push(...result.details);
+                  else req.body = result.data;
+                } else if (schemaDef.body || schemaDef.query || schemaDef.params) {
+                  // Advanced schema object: { body: ZodSchema, query: ZodSchema }
+                  if (schemaDef.body && schemaDef.body.safeParse) {
+                    const res = validateZod(schemaDef.body, req.body);
+                    if (res.error) validationErrors.push({ target: 'body', errors: res.details });
+                    else req.body = res.data;
+                  }
+                  if (schemaDef.query && schemaDef.query.safeParse) {
+                    const res = validateZod(schemaDef.query, req.query);
+                    if (res.error) validationErrors.push({ target: 'query', errors: res.details });
+                    else req.query = res.data;
+                  }
+                  if (schemaDef.params && schemaDef.params.safeParse) {
+                    const res = validateZod(schemaDef.params, req.params);
+                    if (res.error) validationErrors.push({ target: 'params', errors: res.details });
+                    else req.params = res.data;
+                  }
+                } else {
+                  // Fallback to legacy basic typeof validation
+                  if (!req.body || typeof req.body !== 'object') {
+                    validationErrors.push("Request body is required for this route.");
+                  } else {
+                    for (const [key, type] of Object.entries(schemaDef)) {
+                       if (typeof req.body[key] !== type) {
+                         validationErrors.push(`Expected '${key}' to be '${type}', got '${typeof req.body[key]}'`);
+                       }
+                    }
+                  }
                 }
 
-                const errors = [];
-                for (const [key, type] of Object.entries(schema)) {
-                   if (typeof req.body[key] !== type) {
-                     errors.push(`Expected '${key}' to be '${type}', got '${typeof req.body[key]}'`);
-                   }
-                }
-                if (errors.length > 0) {
-                  return res.status(400).json({ error: "Validation Failed", details: errors });
+                if (validationErrors.length > 0) {
+                  return res.status(400).json({ error: "Validation Failed", details: validationErrors });
                 }
               }
 
@@ -636,8 +868,7 @@ function startServer(port = 3000) {
           const errorHandlerPath = path.join(apiDir, '_error.js');
           if (fs.existsSync(errorHandlerPath)) {
             try {
-              delete require.cache[require.resolve(errorHandlerPath)];
-              const errorHandler = jiti(errorHandlerPath);
+              const errorHandler = getModule(errorHandlerPath);
               const actualErrorHandler = errorHandler.default || errorHandler;
               if (typeof actualErrorHandler === 'function') {
                 return await actualErrorHandler(err, req, res);
@@ -668,6 +899,30 @@ function startServer(port = 3000) {
   server.listen(port, () => {
     console.log(`\n🚀 Zerra Engine started on http://localhost:${port}`);
     console.log(`📁 Mapping routes from: ${apiDir}\n`);
+
+    // Feature 6: Built-in Cron Job Scheduler
+    if (config.features.cron) {
+      try {
+        const nodeCron = require('node-cron');
+        const jobsDir = path.join(process.cwd(), "jobs");
+        if (fs.existsSync(jobsDir)) {
+          const jobFiles = fs.readdirSync(jobsDir).filter(f => f.endsWith('.js') || f.endsWith('.ts'));
+          jobFiles.forEach(file => {
+            const filePath = path.join(jobsDir, file);
+            const job = getModule(filePath);
+            const schedule = job.schedule || (job.default && job.default.schedule);
+            const task = job.task || job.default || (job.default && job.default.task);
+            
+            if (schedule && typeof task === 'function') {
+              nodeCron.schedule(schedule, task);
+              console.log(`⏰ Scheduled job: ${file} [${schedule}]`);
+            }
+          });
+        }
+      } catch (e) {
+        console.warn("⚠️ Failed to initialize Cron Jobs. Make sure 'node-cron' is installed.");
+      }
+    }
   });
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zerra-core",
-  "version": "1.2.1",
+  "version": "1.2.2",
   "description": "",
   "main": "index.js",
   "scripts": {
@@ -12,6 +12,10 @@
   "type": "commonjs",
   "dependencies": {
     "busboy": "^1.6.0",
-    "jiti": "^2.6.1"
+    "jiti": "^2.6.1",
+    "node-cron": "^4.2.1"
+  },
+  "devDependencies": {
+    "@types/node-cron": "^3.0.11"
   }
 }