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

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

@@ -0,0 +1,11 @@
+import { buildModule } from "../../../lib/module.js";
+import { CONFIG_PLUGIN } from "../../../../config.js";
+import { cronAdminModule } from "./cron/cron.admin.module.js";
+export const advancedAdminModule = buildModule({
+    pluginId: CONFIG_PLUGIN.pluginId,
+    name: "advanced",
+    routes: [],
+    modules: [
+        cronAdminModule
+    ]
+});

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

@@ -0,0 +1,164 @@
+export declare const cronAdminModule: import("../../../../../api/lib/module").BuildModuleReturn<"@vitnode/core", "cron", [{
+    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: import("zod").ZodObject<{
+                cursor: import("zod").ZodOptional<import("zod").ZodString>;
+                first: import("zod").ZodOptional<import("zod").ZodString>;
+                last: import("zod").ZodOptional<import("zod").ZodString>;
+                order: import("zod").ZodOptional<import("zod").ZodEnum<{
+                    asc: "asc";
+                    desc: "desc";
+                }>>;
+                orderBy: import("zod").ZodOptional<import("zod").ZodEnum<{
+                    createdAt: "createdAt";
+                    lastRun: "lastRun";
+                    nextRun: "nextRun";
+                }>>;
+            }, import("zod/v4/core").$strip>;
+        };
+        responses: {
+            200: {
+                content: {
+                    "application/json": {
+                        schema: import("zod").ZodObject<{
+                            edges: import("zod").ZodArray<import("zod").ZodObject<{
+                                id: import("zod").ZodNumber;
+                                createdAt: import("zod").ZodDate;
+                                name: import("zod").ZodString;
+                                description: import("zod").ZodNullable<import("zod").ZodString>;
+                                pluginId: import("zod").ZodString;
+                                module: import("zod").ZodString;
+                                lastRun: import("zod").ZodNullable<import("zod").ZodDate>;
+                                nextRun: import("zod").ZodNullable<import("zod").ZodDate>;
+                                schedule: import("zod").ZodString;
+                            }, import("zod/v4/core").$strip>>;
+                            pageInfo: import("zod").ZodObject<{
+                                totalCount: import("zod").ZodNumber;
+                                count: import("zod").ZodNumber;
+                                hasNextPage: import("zod").ZodBoolean;
+                                hasPreviousPage: import("zod").ZodBoolean;
+                                startCursor: import("zod").ZodNullable<import("zod").ZodNumber>;
+                                endCursor: import("zod").ZodNullable<import("zod").ZodNumber>;
+                            }, import("zod/v4/core").$strip>;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+                description: string;
+            };
+        };
+    } & {
+        getRoutingPath: () => "/";
+    };
+}, {
+    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: import("zod").ZodObject<{
+                id: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>;
+        };
+        responses: {
+            201: {
+                content: {
+                    "application/json": {
+                        schema: import("zod").ZodObject<{
+                            message: import("zod").ZodOptional<import("zod").ZodString>;
+                            error: import("zod").ZodOptional<import("zod").ZodString>;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+                description: string;
+            };
+            404: {
+                content: {
+                    "application/json": {
+                        schema: import("zod").ZodObject<{
+                            message: import("zod").ZodOptional<import("zod").ZodString>;
+                            error: import("zod").ZodOptional<import("zod").ZodString>;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+                description: string;
+            };
+            500: {
+                content: {
+                    "application/json": {
+                        schema: import("zod").ZodObject<{
+                            message: import("zod").ZodOptional<import("zod").ZodString>;
+                            error: import("zod").ZodOptional<import("zod").ZodString>;
+                        }, import("zod/v4/core").$strip>;
+                    };
+                };
+                description: string;
+            };
+        };
+    } & {
+        getRoutingPath: () => "/:id";
+    };
+}], 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.admin.module.d.ts.map

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

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

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

@@ -0,0 +1,12 @@
+import { buildModule } from "../../../../lib/module.js";
+import { CONFIG_PLUGIN } from "../../../../../config.js";
+import { getCronsRoute } from "./routes/get.route.js";
+import { runCronRoute } from "./routes/run.route.js";
+export const cronAdminModule = buildModule({
+    pluginId: CONFIG_PLUGIN.pluginId,
+    name: "cron",
+    routes: [
+        getCronsRoute,
+        runCronRoute
+    ]
+});

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;AAWpB,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;AASxB,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0GvB,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":"AAOA,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()));
+        });
+    }
+});