@vitnode/core 1.2.0-canary.53 → 1.2.0-canary.54

package/dist/src/api/modules/admin/advanced/cron/routes/get.route.d.ts

@@ -0,0 +1,98 @@
+import z from "zod";
+export declare const getCronsRoute: {
+    handler: (c: import("hono").Context<import("../../../../../middlewares/global.middleware").EnvVitNode, "/", {
+        in: {
+            query: {
+                cursor?: string | undefined;
+                first?: string | undefined;
+                last?: string | undefined;
+                order?: "asc" | "desc" | undefined;
+                orderBy?: "createdAt" | "lastRun" | "nextRun" | undefined;
+            };
+        };
+        out: {
+            query: {
+                cursor?: string | undefined;
+                first?: string | undefined;
+                last?: string | undefined;
+                order?: "asc" | "desc" | undefined;
+                orderBy?: "createdAt" | "lastRun" | "nextRun" | undefined;
+            };
+        };
+    }>) => Promise<Response & import("hono").TypedResponse<{
+        edges: {
+            id: number;
+            name: string;
+            description: string | null;
+            lastRun: string | null;
+            createdAt: string;
+            pluginId: string;
+            module: string;
+            nextRun: string | null;
+            schedule: string;
+        }[];
+        pageInfo: {
+            count: number;
+            endCursor: null | number;
+            hasNextPage: boolean;
+            hasPreviousPage: boolean;
+            startCursor: null | number;
+            totalCount: number;
+        };
+    }, 200, "json">>;
+    pluginId: "@vitnode/core";
+    route: {
+        method: "get";
+        description: string;
+        path: "/";
+        request: {
+            query: z.ZodObject<{
+                cursor: z.ZodOptional<z.ZodString>;
+                first: z.ZodOptional<z.ZodString>;
+                last: z.ZodOptional<z.ZodString>;
+                order: z.ZodOptional<z.ZodEnum<{
+                    asc: "asc";
+                    desc: "desc";
+                }>>;
+                orderBy: z.ZodOptional<z.ZodEnum<{
+                    createdAt: "createdAt";
+                    lastRun: "lastRun";
+                    nextRun: "nextRun";
+                }>>;
+            }, z.core.$strip>;
+        };
+        responses: {
+            200: {
+                content: {
+                    "application/json": {
+                        schema: z.ZodObject<{
+                            edges: z.ZodArray<z.ZodObject<{
+                                id: z.ZodNumber;
+                                createdAt: z.ZodDate;
+                                name: z.ZodString;
+                                description: z.ZodNullable<z.ZodString>;
+                                pluginId: z.ZodString;
+                                module: z.ZodString;
+                                lastRun: z.ZodNullable<z.ZodDate>;
+                                nextRun: z.ZodNullable<z.ZodDate>;
+                                schedule: z.ZodString;
+                            }, z.core.$strip>>;
+                            pageInfo: z.ZodObject<{
+                                totalCount: z.ZodNumber;
+                                count: z.ZodNumber;
+                                hasNextPage: z.ZodBoolean;
+                                hasPreviousPage: z.ZodBoolean;
+                                startCursor: z.ZodNullable<z.ZodNumber>;
+                                endCursor: z.ZodNullable<z.ZodNumber>;
+                            }, z.core.$strip>;
+                        }, z.core.$strip>;
+                    };
+                };
+                description: string;
+            };
+        };
+    } & {
+        getRoutingPath: () => "/";
+    };
+};
+//# sourceMappingURL=get.route.d.ts.map

package/dist/src/api/modules/admin/advanced/cron/routes/get.route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get.route.d.ts","sourceRoot":"","sources":["../../../../../../../../src/api/modules/admin/advanced/cron/routes/get.route.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAUpB,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+DxB,CAAC"}

package/dist/src/api/modules/admin/advanced/cron/routes/get.route.js

@@ -0,0 +1,66 @@
+import z from "zod";
+import { buildRoute } from "../../../../../lib/route.js";
+import { withPagination, zodPaginationPageInfo, zodPaginationQuery } from "../../../../../lib/with-pagination.js";
+import { CONFIG_PLUGIN } from "../../../../../../config.js";
+import { core_cron } from "../../../../../../database/cron.js";
+export const getCronsRoute = buildRoute({
+    pluginId: CONFIG_PLUGIN.pluginId,
+    route: {
+        method: "get",
+        description: "Get Admin Cron Logs",
+        path: "/",
+        request: {
+            query: zodPaginationQuery.extend({
+                order: z.enum([
+                    "asc",
+                    "desc"
+                ]).optional(),
+                orderBy: z.enum([
+                    "createdAt",
+                    "lastRun",
+                    "nextRun"
+                ]).optional()
+            })
+        },
+        responses: {
+            200: {
+                content: {
+                    "application/json": {
+                        schema: z.object({
+                            edges: z.array(z.object({
+                                id: z.number(),
+                                createdAt: z.date(),
+                                name: z.string(),
+                                description: z.string().nullable(),
+                                pluginId: z.string(),
+                                module: z.string(),
+                                lastRun: z.date().nullable(),
+                                nextRun: z.date().nullable(),
+                                schedule: z.string()
+                            })),
+                            pageInfo: zodPaginationPageInfo
+                        })
+                    }
+                },
+                description: "List of cron jobs"
+            }
+        }
+    },
+    handler: async (c)=>{
+        const query = c.req.valid("query");
+        const data = await withPagination({
+            params: {
+                query
+            },
+            c,
+            primaryCursor: core_cron.id,
+            query: async ({ limit, where, orderBy })=>await c.get("db").select().from(core_cron).where(where).orderBy(orderBy).limit(limit),
+            table: core_cron,
+            orderBy: {
+                column: query.orderBy ? core_cron[query.orderBy] : core_cron.lastRun,
+                order: query.order ?? "desc"
+            }
+        });
+        return c.json(data);
+    }
+});

package/dist/src/api/modules/admin/advanced/cron/routes/run.route.d.ts

@@ -0,0 +1,70 @@
+import { z } from "zod";
+export declare const runCronRoute: {
+    handler: (c: import("hono").Context<import("../../../../../middlewares/global.middleware").EnvVitNode, "/:id", {
+        in: {
+            param: {
+                id: string;
+            };
+        };
+        out: {
+            param: {
+                id: string;
+            };
+        };
+    }>) => Promise<(Response & import("hono").TypedResponse<{
+        error: string;
+    }, 404, "json">) | (Response & import("hono").TypedResponse<{
+        message: string;
+    }, 201, "json">) | (Response & import("hono").TypedResponse<{
+        error: string;
+    }, 500, "json">)>;
+    pluginId: "@vitnode/core";
+    route: {
+        method: "post";
+        description: string;
+        path: "/{id}";
+        request: {
+            params: z.ZodObject<{
+                id: z.ZodString;
+            }, z.core.$strip>;
+        };
+        responses: {
+            201: {
+                content: {
+                    "application/json": {
+                        schema: z.ZodObject<{
+                            message: z.ZodOptional<z.ZodString>;
+                            error: z.ZodOptional<z.ZodString>;
+                        }, z.core.$strip>;
+                    };
+                };
+                description: string;
+            };
+            404: {
+                content: {
+                    "application/json": {
+                        schema: z.ZodObject<{
+                            message: z.ZodOptional<z.ZodString>;
+                            error: z.ZodOptional<z.ZodString>;
+                        }, z.core.$strip>;
+                    };
+                };
+                description: string;
+            };
+            500: {
+                content: {
+                    "application/json": {
+                        schema: z.ZodObject<{
+                            message: z.ZodOptional<z.ZodString>;
+                            error: z.ZodOptional<z.ZodString>;
+                        }, z.core.$strip>;
+                    };
+                };
+                description: string;
+            };
+        };
+    } & {
+        getRoutingPath: () => "/:id";
+    };
+};
+//# sourceMappingURL=run.route.d.ts.map

package/dist/src/api/modules/admin/advanced/cron/routes/run.route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run.route.d.ts","sourceRoot":"","sources":["../../../../../../../../src/api/modules/admin/advanced/cron/routes/run.route.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwGvB,CAAC"}

package/dist/src/api/modules/admin/advanced/cron/routes/run.route.js

@@ -0,0 +1,95 @@
+import { eq } from "drizzle-orm";
+import { z } from "zod";
+import { buildRoute } from "../../../../../lib/route.js";
+import { CONFIG_PLUGIN } from "../../../../../../config.js";
+import { core_cron } from "../../../../../../database/cron.js";
+import { getNextCronRunDate } from "../../../../../../lib/api/get-next-cron-run-date.js";
+export const runCronRoute = buildRoute({
+    pluginId: CONFIG_PLUGIN.pluginId,
+    route: {
+        method: "post",
+        description: "Run a specific cron job",
+        path: "/{id}",
+        request: {
+            params: z.object({
+                id: z.string()
+            })
+        },
+        responses: {
+            201: {
+                content: {
+                    "application/json": {
+                        schema: z.object({
+                            message: z.string().optional(),
+                            error: z.string().optional()
+                        })
+                    }
+                },
+                description: "Cron job executed successfully"
+            },
+            404: {
+                content: {
+                    "application/json": {
+                        schema: z.object({
+                            message: z.string().optional(),
+                            error: z.string().optional()
+                        })
+                    }
+                },
+                description: "Cron job not found"
+            },
+            500: {
+                content: {
+                    "application/json": {
+                        schema: z.object({
+                            message: z.string().optional(),
+                            error: z.string().optional()
+                        })
+                    }
+                },
+                description: "Internal server error"
+            }
+        }
+    },
+    handler: async (c)=>{
+        const db = c.get("db");
+        const cronJobs = c.get("core").cron;
+        const param = c.req.valid("param");
+        try {
+            const cronFromDb = await db.select().from(core_cron).where(eq(core_cron.id, +param.id)).limit(1);
+            if (cronFromDb.length === 0) {
+                return c.json({
+                    error: "Cron job not found"
+                }, 404);
+            }
+            const dbCron = cronFromDb[0];
+            const job = cronJobs.find((j)=>j.name === dbCron.name && j.pluginId === dbCron.pluginId && j.module === dbCron.module);
+            if (!job) {
+                return c.json({
+                    error: "Cron job configuration not found"
+                }, 404);
+            }
+            const now = new Date();
+            try {
+                await job.handler(c);
+                await db.update(core_cron).set({
+                    lastRun: now,
+                    nextRun: getNextCronRunDate(job.schedule, now)
+                }).where(eq(core_cron.id, dbCron.id));
+                return c.json({
+                    message: "Cron job executed successfully"
+                }, 201);
+            } catch (error) {
+                await c.get("log").error(`Error executing cron job: ${error}`);
+                return c.json({
+                    error: "Failed to execute cron job"
+                }, 500);
+            }
+        } catch (error) {
+            await c.get("log").error(`Error running cron job: ${error}`);
+            return c.json({
+                error: "Internal server error"
+            }, 500);
+        }
+    }
+});

package/dist/src/api/modules/admin/debug/debug.admin.module.js

@@ -2,7 +2,7 @@ import { CONFIG_PLUGIN } from "../../../../config.js";
 import { buildModule } from "../../../lib/module.js";
 import { logsDebugAdminRoute } from "./routes/logs.route.js";
 export const debugAdminModule = buildModule({
-    ...CONFIG_PLUGIN,
+    pluginId: CONFIG_PLUGIN.pluginId,
     name: "debug",
     routes: [
         logsDebugAdminRoute

package/dist/src/api/modules/admin/debug/routes/logs.route.js

@@ -6,7 +6,7 @@ import { core_users } from "../../../../../database/users.js";
 import { buildRoute } from "../../../../lib/route.js";
 import { withPagination, zodPaginationPageInfo, zodPaginationQuery } from "../../../../lib/with-pagination.js";
 export const logsDebugAdminRoute = buildRoute({
-    ...CONFIG_PLUGIN,
+    pluginId: CONFIG_PLUGIN.pluginId,
     route: {
         method: "get",
         description: "Get Admin Debug Logs",

package/dist/src/api/modules/admin/routes/session.route.js

@@ -3,7 +3,7 @@ import { z } from "zod";
 import { buildRoute } from "../../../lib/route.js";
 import { CONFIG_PLUGIN } from "../../../../config.js";
 export const sessionAdminRoute = buildRoute({
-    ...CONFIG_PLUGIN,
+    pluginId: CONFIG_PLUGIN.pluginId,
     route: {
         method: "get",
         description: "Verify admin session",

package/dist/src/api/modules/admin/users/routes/list.route.js

@@ -4,7 +4,7 @@ import { withPagination, zodPaginationPageInfo, zodPaginationQuery } from "../..
 import { CONFIG_PLUGIN } from "../../../../../config.js";
 import { core_users } from "../../../../../database/users.js";
 export const listUsersAdminRoute = buildRoute({
-    ...CONFIG_PLUGIN,
+    pluginId: CONFIG_PLUGIN.pluginId,
     route: {
         method: "get",
         description: "Get list of all users",

package/dist/src/api/modules/admin/users/routes/users.route.d.ts

@@ -7,7 +7,7 @@ export declare const usersAdminRoute: {
                 first?: string | undefined;
                 last?: string | undefined;
                 order?: "asc" | "desc" | undefined;
-                orderBy?: "email" | "id" | "name" | "createdAt" | undefined;
+                orderBy?: "id" | "email" | "name" | "createdAt" | undefined;
             };
         };
         out: {
@@ -16,7 +16,7 @@ export declare const usersAdminRoute: {
                 first?: string | undefined;
                 last?: string | undefined;
                 order?: "asc" | "desc" | undefined;
-                orderBy?: "email" | "id" | "name" | "createdAt" | undefined;
+                orderBy?: "id" | "email" | "name" | "createdAt" | undefined;
             };
         };
     }>) => Promise<Response & import("hono").TypedResponse<{
@@ -57,8 +57,8 @@ export declare const usersAdminRoute: {
                     desc: "desc";
                 }>>;
                 orderBy: z.ZodOptional<z.ZodEnum<{
-                    email: "email";
                     id: "id";
+                    email: "email";
                     name: "name";
                     createdAt: "createdAt";
                 }>>;

package/dist/src/api/modules/admin/users/routes/users.route.js

@@ -4,7 +4,7 @@ import { withPagination, zodPaginationPageInfo, zodPaginationQuery } from "../..
 import { CONFIG_PLUGIN } from "../../../../../config.js";
 import { core_users } from "../../../../../database/users.js";
 export const usersAdminRoute = buildRoute({
-    ...CONFIG_PLUGIN,
+    pluginId: CONFIG_PLUGIN.pluginId,
     route: {
         method: "get",
         description: "Get list of all users (Admin only)",

package/dist/src/api/modules/admin/users/users.admin.module.js

@@ -2,7 +2,7 @@ import { buildModule } from "../../../lib/module.js";
 import { CONFIG_PLUGIN } from "../../../../config.js";
 import { listUsersAdminRoute } from "./routes/list.route.js";
 export const usersAdminModule = buildModule({
-    ...CONFIG_PLUGIN,
+    pluginId: CONFIG_PLUGIN.pluginId,
     name: "users",
     routes: [
         listUsersAdminRoute

package/dist/src/api/modules/cron/cron/clean.cron.d.ts

@@ -0,0 +1,2 @@
+export declare const cleanCron: import("../../../../api/lib/cron").BuildCronReturn;
+//# sourceMappingURL=clean.cron.d.ts.map

package/dist/src/api/modules/cron/cron/clean.cron.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clean.cron.d.ts","sourceRoot":"","sources":["../../../../../../src/api/modules/cron/cron/clean.cron.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,SAAS,0CA0BpB,CAAC"}

package/dist/src/api/modules/cron/cron/clean.cron.js

@@ -0,0 +1,24 @@
+import { lt } from "drizzle-orm";
+import { buildCron } from "../../../lib/cron.js";
+import { core_admin_sessions } from "../../../../database/admins.js";
+import { core_sessions } from "../../../../database/sessions.js";
+import { core_users_forgot_password } from "../../../../database/users.js";
+export const cleanCron = buildCron({
+    name: "clean",
+    description: "Clean up expired sessions and tokens",
+    // Run every 1 hour
+    schedule: "0 * * * *",
+    handler: async (c)=>{
+        await c.get("db").transaction(async (tx)=>{
+            // Delete expired sessions
+            await tx.delete(core_sessions).where(lt(core_sessions.expiresAt, new Date()));
+            await tx.delete(core_admin_sessions).where(lt(core_admin_sessions.expiresAt, new Date()));
+            // Delete expired forgot password tokens
+            await tx.delete(core_users_forgot_password).where(lt(core_users_forgot_password.expiresAt, new Date()));
+        // // Delete expired email confirmation tokens
+        // await tx
+        //   .delete(core_users_confirm_emails)
+        //   .where(lt(core_users_confirm_emails.expiresAt, new Date()));
+        });
+    }
+});

package/dist/src/api/modules/cron/cron.module.d.ts

@@ -0,0 +1,26 @@
+export declare const cronModule: import("../../../api/lib/module").BuildModuleReturn<"@vitnode/core", "cron", [{
+    handler: (c: import("hono").Context<import("../../middlewares/global.middleware").EnvVitNode, "/", {}>) => Promise<(Response & import("hono").TypedResponse<`Cron jobs processed. Executed ${number} jobs.`, 200, "text">) | (Response & import("hono").TypedResponse<"Error processing cron jobs", 500, "text">)>;
+    pluginId: "@vitnode/core";
+    route: {
+        method: "post";
+        description: string;
+        path: "/";
+        middleware: ((c: import("hono").Context, next: import("hono").Next) => Promise<void>)[];
+        responses: {
+            200: {
+                content: {
+                    "text/plain": {
+                        schema: import("zod").ZodString;
+                    };
+                };
+                description: string;
+            };
+            403: {
+                description: string;
+            };
+        };
+    } & {
+        getRoutingPath: () => "/";
+    };
+}], import("../../../api/lib/module").BaseBuildModuleReturn<"@vitnode/core", string, import("../../lib/route").Route<"@vitnode/core", import("@hono/zod-openapi").RouteConfig, import("@hono/zod-openapi").RouteHandler<import("@hono/zod-openapi").RouteConfig>>[]>[]>;
+//# sourceMappingURL=cron.module.d.ts.map

package/dist/src/api/modules/cron/cron.module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cron.module.d.ts","sourceRoot":"","sources":["../../../../../src/api/modules/cron/cron.module.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;gQAKrB,CAAC"}

package/dist/src/api/modules/cron/cron.module.js

@@ -0,0 +1,14 @@
+import { buildModule } from "../../lib/module.js";
+import { CONFIG_PLUGIN } from "../../../config.js";
+import { cleanCron } from "./cron/clean.cron.js";
+import { runCronRoute } from "./routes/cron.route.js";
+export const cronModule = buildModule({
+    pluginId: CONFIG_PLUGIN.pluginId,
+    name: "cron",
+    routes: [
+        runCronRoute
+    ],
+    cronJobs: [
+        cleanCron
+    ]
+});

package/dist/src/api/modules/cron/helpers/process-cron-jobs.d.ts

@@ -0,0 +1,36 @@
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import type { CronJobConfig } from "../../../../api/lib/cron";
+interface CronJobFromDb {
+    id: number;
+    name: string;
+    description: string | null;
+    lastRun: Date | null;
+    nextRun: Date | null;
+    createdAt: Date;
+    pluginId: string;
+    module: string;
+    schedule: string;
+}
+export declare function cleanupOutdatedCronJobs(db: PostgresJsDatabase<Record<string, never>>, cronFromDb: CronJobFromDb[], currentCronJobs: CronJobConfig[]): Promise<void>;
+export declare function processCronJobs(cronJobs: CronJobConfig[], cronFromDb: CronJobFromDb[]): {
+    newJobs: CronJobConfig[];
+    jobsToExecute: CronJobConfig[];
+    jobsToUpdate: {
+        job: CronJobConfig;
+        existingJob: CronJobFromDb;
+        changes: {
+            description?: boolean;
+            schedule?: boolean;
+        };
+    }[];
+};
+export declare function updateCronJobs(db: PostgresJsDatabase<Record<string, never>>, jobsToUpdate: {
+    job: CronJobConfig;
+    existingJob: CronJobFromDb;
+    changes: {
+        description?: boolean;
+        schedule?: boolean;
+    };
+}[]): Promise<void>;
+export {};
+//# sourceMappingURL=process-cron-jobs.d.ts.map

package/dist/src/api/modules/cron/helpers/process-cron-jobs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"process-cron-jobs.d.ts","sourceRoot":"","sources":["../../../../../../src/api/modules/cron/helpers/process-cron-jobs.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAElE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAIpD,UAAU,aAAa;IACrB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,OAAO,EAAE,IAAI,GAAG,IAAI,CAAC;IACrB,OAAO,EAAE,IAAI,GAAG,IAAI,CAAC;IACrB,SAAS,EAAE,IAAI,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;CAClB;AA4BD,wBAAsB,uBAAuB,CAC3C,EAAE,EAAE,kBAAkB,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,EAC7C,UAAU,EAAE,aAAa,EAAE,EAC3B,eAAe,EAAE,aAAa,EAAE,iBAoBjC;AAED,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,aAAa,EAAE,EACzB,UAAU,EAAE,aAAa,EAAE;;;;aAKpB,aAAa;qBACL,aAAa;iBACjB;YAAE,WAAW,CAAC,EAAE,OAAO,CAAC;YAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;SAAE;;EA6BzD;AAED,wBAAsB,cAAc,CAClC,EAAE,EAAE,kBAAkB,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,EAC7C,YAAY,EAAE;IACZ,GAAG,EAAE,aAAa,CAAC;IACnB,WAAW,EAAE,aAAa,CAAC;IAC3B,OAAO,EAAE;QAAE,WAAW,CAAC,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;CACxD,EAAE,iBAyBJ"}

package/dist/src/api/modules/cron/helpers/process-cron-jobs.js

@@ -0,0 +1,72 @@
+import { eq, inArray } from "drizzle-orm";
+import { validate } from "node-cron";
+import { core_cron } from "../../../../database/cron.js";
+import { shouldCronJobRun } from "../../../../lib/api/should-cron-job-run.js";
+function findExistingJob(job, cronFromDb) {
+    return cronFromDb.find((dbJob)=>dbJob.name === job.name && dbJob.pluginId === job.pluginId && dbJob.module === job.module);
+}
+function getJobChanges(job, existingJob) {
+    const changes = {};
+    if (existingJob.description !== job.description) {
+        changes.description = true;
+    }
+    if (existingJob.schedule !== job.schedule) {
+        changes.schedule = true;
+    }
+    return changes;
+}
+export async function cleanupOutdatedCronJobs(db, cronFromDb, currentCronJobs) {
+    if (cronFromDb.length === 0) return;
+    const currentCronIdentifiers = currentCronJobs.map((job)=>`${job.pluginId}:${job.module}:${job.name}`);
+    const cronJobsToDelete = cronFromDb.filter((dbCron)=>!currentCronIdentifiers.includes(`${dbCron.pluginId}:${dbCron.module}:${dbCron.name}`)).map((dbCron)=>dbCron.id);
+    if (cronJobsToDelete.length > 0) {
+        await db.delete(core_cron).where(inArray(core_cron.id, cronJobsToDelete));
+    }
+}
+export function processCronJobs(cronJobs, cronFromDb) {
+    const newJobs = [];
+    const jobsToExecute = [];
+    const jobsToUpdate = [];
+    for (const job of cronJobs){
+        if (!validate(job.schedule)) {
+            // biome-ignore lint/suspicious/noConsole: needed for cron job monitoring
+            console.warn(`\x1b[34m[VitNode]\x1b[0m \x1b[33mInvalid cron schedule for job "${job.pluginId}:${job.module}:${job.name}"\x1b[0m: ${job.schedule}`);
+            continue;
+        }
+        const existingJob = findExistingJob(job, cronFromDb);
+        if (existingJob) {
+            const changes = getJobChanges(job, existingJob);
+            if (Object.keys(changes).length > 0) {
+                jobsToUpdate.push({
+                    job,
+                    existingJob,
+                    changes
+                });
+            }
+        } else {
+            newJobs.push(job);
+        }
+        if (shouldCronJobRun(job.schedule, existingJob?.lastRun || null)) {
+            jobsToExecute.push(job);
+        }
+    }
+    return {
+        newJobs,
+        jobsToExecute,
+        jobsToUpdate
+    };
+}
+export async function updateCronJobs(db, jobsToUpdate) {
+    if (jobsToUpdate.length === 0) return;
+    const updatePromises = jobsToUpdate.map(({ job, existingJob, changes })=>{
+        const updateData = {};
+        if (changes.description) {
+            updateData.description = job.description || null;
+        }
+        if (changes.schedule) {
+            updateData.schedule = job.schedule;
+        }
+        return db.update(core_cron).set(updateData).where(eq(core_cron.id, existingJob.id));
+    });
+    await Promise.all(updatePromises);
+}

package/dist/src/api/modules/cron/routes/cron.route.d.ts

@@ -0,0 +1,27 @@
+import { z } from "zod";
+export declare const runCronRoute: {
+    handler: (c: import("hono").Context<import("../../../middlewares/global.middleware").EnvVitNode, "/", {}>) => Promise<(Response & import("hono").TypedResponse<`Cron jobs processed. Executed ${number} jobs.`, 200, "text">) | (Response & import("hono").TypedResponse<"Error processing cron jobs", 500, "text">)>;
+    pluginId: "@vitnode/core";
+    route: {
+        method: "post";
+        description: string;
+        path: "/";
+        middleware: ((c: import("hono").Context, next: import("hono").Next) => Promise<void>)[];
+        responses: {
+            200: {
+                content: {
+                    "text/plain": {
+                        schema: z.ZodString;
+                    };
+                };
+                description: string;
+            };
+            403: {
+                description: string;
+            };
+        };
+    } & {
+        getRoutingPath: () => "/";
+    };
+};
+//# sourceMappingURL=cron.route.d.ts.map

package/dist/src/api/modules/cron/routes/cron.route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cron.route.d.ts","sourceRoot":"","sources":["../../../../../../src/api/modules/cron/routes/cron.route.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAYxB,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;CA4GvB,CAAC"}