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

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

@@ -4,29 +4,29 @@ 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)',
-        path: '/list',
+        method: "get",
+        description: "Get list of all users (Admin only)",
+        path: "/list",
         request: {
             query: zodPaginationQuery.extend({
                 order: z.enum([
-                    'asc',
-                    'desc'
+                    "asc",
+                    "desc"
                 ]).optional(),
                 orderBy: z.enum([
-                    'id',
-                    'name',
-                    'email',
-                    'createdAt'
+                    "id",
+                    "name",
+                    "email",
+                    "createdAt"
                 ]).optional()
             })
         },
         responses: {
             200: {
                 content: {
-                    'application/json': {
+                    "application/json": {
                         schema: z.object({
                             edges: z.array(z.object({
                                 id: z.number(),
@@ -45,21 +45,21 @@ export const usersAdminRoute = buildRoute({
                         })
                     }
                 },
-                description: 'List of users'
+                description: "List of users"
             },
             403: {
-                description: 'Access Denied'
+                description: "Access Denied"
             }
         }
     },
     handler: async (c)=>{
-        const query = c.req.valid('query');
+        const query = c.req.valid("query");
         const data = await withPagination({
             params: {
                 query
             },
             primaryCursor: core_users.id,
-            query: async ({ limit, where, orderBy })=>await c.get('db').select({
+            query: async ({ limit, where, orderBy })=>await c.get("db").select({
                     id: core_users.id,
                     name: core_users.name,
                     email: core_users.email,
@@ -75,7 +75,7 @@ export const usersAdminRoute = buildRoute({
             table: core_users,
             orderBy: {
                 column: query.orderBy ? core_users[query.orderBy] : core_users.createdAt,
-                order: query.order ?? 'desc'
+                order: query.order ?? "desc"
             },
             c
         });

package/dist/src/api/modules/admin/users/users.admin.module.d.ts

@@ -64,7 +64,7 @@ export declare const usersAdminModule: import("../../../../api/lib/module").Buil
         responses: {
             200: {
                 content: {
-                    'application/json': {
+                    "application/json": {
                         schema: import("zod").ZodObject<{
                             edges: import("zod").ZodArray<import("zod").ZodObject<{
                                 id: import("zod").ZodNumber;

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

@@ -2,8 +2,8 @@ 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,
-    name: 'users',
+    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"}

package/dist/src/api/modules/cron/routes/cron.route.js

@@ -0,0 +1,95 @@
+import { eq } from "drizzle-orm";
+import { z } from "zod";
+import { buildRoute } from "../../../lib/route.js";
+import { cronAuthMiddleware } from "../../../middlewares/cron-auth.middleware.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";
+import { cleanupOutdatedCronJobs, processCronJobs, updateCronJobs } from "../helpers/process-cron-jobs.js";
+export const runCronRoute = buildRoute({
+    pluginId: CONFIG_PLUGIN.pluginId,
+    route: {
+        method: "post",
+        description: "Run cron job",
+        path: "/",
+        middleware: [
+            cronAuthMiddleware()
+        ],
+        responses: {
+            200: {
+                content: {
+                    "text/plain": {
+                        schema: z.string()
+                    }
+                },
+                description: "Cron started successfully"
+            },
+            403: {
+                description: "Access Denied"
+            }
+        }
+    },
+    handler: async (c)=>{
+        const db = c.get("db");
+        const cronJobs = c.get("core").cron;
+        try {
+            const cronFromDb = await db.select().from(core_cron);
+            await cleanupOutdatedCronJobs(db, cronFromDb, cronJobs);
+            const now = new Date();
+            let executedJobs = 0;
+            const { newJobs, jobsToExecute, jobsToUpdate } = processCronJobs(cronJobs, cronFromDb);
+            if (newJobs.length > 0) {
+                try {
+                    const newJobsValues = newJobs.map((job)=>({
+                            name: job.name,
+                            description: job.description || null,
+                            lastRun: null,
+                            nextRun: null,
+                            pluginId: job.pluginId,
+                            module: job.module,
+                            schedule: job.schedule
+                        }));
+                    await db.insert(core_cron).values(newJobsValues);
+                } catch (error) {
+                    await c.get("log").error(`Error inserting new cron jobs: ${error}`);
+                }
+            }
+            try {
+                await updateCronJobs(db, jobsToUpdate);
+            } catch (error) {
+                await c.get("log").error(`Error updating cron jobs: ${error}`);
+            }
+            if (jobsToExecute.length > 0) {
+                const executionPromises = jobsToExecute.map(async (job)=>{
+                    try {
+                        await job.handler(c);
+                        const dbJob = cronFromDb.find((dbJob)=>dbJob.name === job.name && dbJob.pluginId === job.pluginId && dbJob.module === job.module);
+                        if (dbJob) {
+                            await db.update(core_cron).set({
+                                lastRun: now,
+                                nextRun: getNextCronRunDate(job.schedule, now)
+                            }).where(eq(core_cron.id, dbJob.id));
+                        }
+                        return {
+                            success: true,
+                            jobName: job.name
+                        };
+                    } catch (error) {
+                        await c.get("log").error(`Error executing cron job "${job.pluginId}:${job.module}:${job.name}": ${error}`);
+                        return {
+                            success: false,
+                            jobName: job.name,
+                            error
+                        };
+                    }
+                });
+                const results = await Promise.allSettled(executionPromises);
+                executedJobs = results.filter((result)=>result.status === "fulfilled" && result.value.success).length;
+            }
+            return c.text(`Cron jobs processed. Executed ${executedJobs} jobs.`, 200);
+        } catch (error) {
+            await c.get("log").error(`Error processing cron jobs: ${error}`);
+            return c.text("Error processing cron jobs", 500);
+        }
+    }
+});

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

@@ -18,7 +18,7 @@ export declare const middlewareModule: import("../../../api/lib/module").BuildMo
         responses: {
             200: {
                 content: {
-                    'application/json': {
+                    "application/json": {
                         schema: import("zod").ZodObject<{
                             sso: import("zod").ZodArray<import("zod").ZodObject<{
                                 id: import("zod").ZodString;

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

@@ -2,8 +2,8 @@ import { buildModule } from "../../lib/module.js";
 import { CONFIG_PLUGIN } from "../../../config.js";
 import { routeMiddleware } from "./route.js";
 export const middlewareModule = buildModule({
-    ...CONFIG_PLUGIN,
-    name: 'middleware',
+    pluginId: CONFIG_PLUGIN.pluginId,
+    name: "middleware",
     routes: [
         routeMiddleware
     ]

package/dist/src/api/modules/middleware/route.d.ts

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import { z } from "zod";
 export declare const routeMiddlewareSchema: z.ZodObject<{
     sso: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
@@ -33,7 +33,7 @@ export declare const routeMiddleware: {
         responses: {
             200: {
                 content: {
-                    'application/json': {
+                    "application/json": {
                         schema: z.ZodObject<{
                             sso: z.ZodArray<z.ZodObject<{
                                 id: z.ZodString;

package/dist/src/api/modules/middleware/route.js

@@ -10,39 +10,39 @@ export const routeMiddlewareSchema = z.object({
     captcha: z.object({
         siteKey: z.string(),
         type: z.enum([
-            'cloudflare_turnstile',
-            'recaptcha_v3'
+            "cloudflare_turnstile",
+            "recaptcha_v3"
         ])
     }).optional()
 });
 export const routeMiddleware = buildRoute({
-    ...CONFIG_PLUGIN,
+    pluginId: CONFIG_PLUGIN.pluginId,
     route: {
-        path: '/',
-        method: 'get',
-        description: 'Middleware route with user authentication',
+        path: "/",
+        method: "get",
+        description: "Middleware route with user authentication",
         responses: {
             200: {
                 content: {
-                    'application/json': {
+                    "application/json": {
                         schema: routeMiddlewareSchema
                     }
                 },
-                description: 'Middleware route'
+                description: "Middleware route"
             }
         }
     },
     handler: (c)=>{
-        const sso = c.get('core').authorization.ssoAdapters;
+        const sso = c.get("core").authorization.ssoAdapters;
         return c.json({
-            isEmail: !!c.get('core').email?.adapter,
+            isEmail: !!c.get("core").email?.adapter,
             sso: sso.map((s)=>({
                     id: s.id,
                     name: s.name
                 })),
-            captcha: c.get('core').captcha ? {
-                siteKey: c.get('core').captcha?.siteKey ?? '',
-                type: c.get('core').captcha?.type ?? 'cloudflare_turnstile'
+            captcha: c.get("core").captcha ? {
+                siteKey: c.get("core").captcha?.siteKey ?? "",
+                type: c.get("core").captcha?.type ?? "cloudflare_turnstile"
             } : undefined
         }, 200);
     }

package/dist/src/api/modules/users/routes/change-password.route.d.ts

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import { z } from "zod";
 export declare const zodChangePasswordSchema: z.ZodObject<{
     password: z.ZodString;
     userId: z.ZodNumber;
@@ -30,7 +30,7 @@ export declare const changePasswordRoute: {
             body: {
                 required: true;
                 content: {
-                    'application/json': {
+                    "application/json": {
                         schema: z.ZodObject<{
                             password: z.ZodString;
                             userId: z.ZodNumber;

package/dist/src/api/modules/users/routes/change-password.route.js

@@ -7,26 +7,26 @@ import { CONFIG_PLUGIN } from "../../../../config.js";
 import { core_users, core_users_forgot_password } from "../../../../database/users.js";
 export const zodChangePasswordSchema = z.object({
     password: z.string().min(8).openapi({
-        example: 'Test123!'
+        example: "Test123!"
     }),
     userId: z.number().openapi({
         example: 123456
     }),
     token: z.string().openapi({
-        example: 'abcdefg12345'
+        example: "abcdefg12345"
     })
 });
 export const changePasswordRoute = buildRoute({
-    ...CONFIG_PLUGIN,
+    pluginId: CONFIG_PLUGIN.pluginId,
     route: {
-        method: 'post',
-        description: 'Change user password',
-        path: '/change-password',
+        method: "post",
+        description: "Change user password",
+        path: "/change-password",
         request: {
             body: {
                 required: true,
                 content: {
-                    'application/json': {
+                    "application/json": {
                         schema: zodChangePasswordSchema
                     }
                 }
@@ -34,25 +34,25 @@ export const changePasswordRoute = buildRoute({
         },
         responses: {
             201: {
-                description: 'Password changed'
+                description: "Password changed"
             }
         }
     },
     handler: async (c)=>{
-        const { password, userId, token } = c.req.valid('json');
-        const [user] = await c.get('db').select().from(core_users_forgot_password).where(and(eq(core_users_forgot_password.userId, userId), eq(core_users_forgot_password.token, token), gt(core_users_forgot_password.expiresAt, new Date()))).limit(1);
+        const { password, userId, token } = c.req.valid("json");
+        const [user] = await c.get("db").select().from(core_users_forgot_password).where(and(eq(core_users_forgot_password.userId, userId), eq(core_users_forgot_password.token, token), gt(core_users_forgot_password.expiresAt, new Date()))).limit(1);
         if (!user) {
             throw new HTTPException(400, {
-                message: 'Invalid token'
+                message: "Invalid token"
             });
         }
         const hashPassword = await new PasswordModel().encryptPassword(password);
         await Promise.all([
-            c.get('db').update(core_users).set({
+            c.get("db").update(core_users).set({
                 password: hashPassword
             }).where(eq(core_users.id, userId)),
-            c.get('db').delete(core_users_forgot_password).where(eq(core_users_forgot_password.id, user.id))
+            c.get("db").delete(core_users_forgot_password).where(eq(core_users_forgot_password.id, user.id))
         ]);
-        return c.text('Password changed', 201);
+        return c.text("Password changed", 201);
     }
 });

package/dist/src/api/modules/users/routes/reset-passowrd.route.d.ts

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import { z } from "zod";
 export declare const resetPasswordRoute: {
     handler: (c: import("hono").Context<import("../../../middlewares/global.middleware").EnvVitNode, "/reset-password", {
         in: {
@@ -22,7 +22,7 @@ export declare const resetPasswordRoute: {
             body: {
                 required: true;
                 content: {
-                    'application/json': {
+                    "application/json": {
                         schema: z.ZodObject<{
                             email: z.ZodEmail;
                         }, z.core.$strip>;