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

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

@@ -6,25 +6,25 @@ import { core_users } from "../../../../../database/users.js";
 export const listUsersAdminRoute = buildRoute({
     ...CONFIG_PLUGIN,
     route: {
-        method: 'get',
-        description: 'Get list of all users',
-        path: '/list',
+        method: "get",
+        description: "Get list of all users",
+        path: "/list",
         request: {
             query: zodPaginationQuery.extend({
                 order: z.enum([
-                    'asc',
-                    'desc'
+                    "asc",
+                    "desc"
                 ]).optional(),
                 orderBy: z.enum([
-                    'name',
-                    'createdAt'
+                    "name",
+                    "createdAt"
                 ]).optional()
             })
         },
         responses: {
             200: {
                 content: {
-                    'application/json': {
+                    "application/json": {
                         schema: z.object({
                             edges: z.array(z.object({
                                 id: z.number(),
@@ -43,18 +43,18 @@ export const listUsersAdminRoute = buildRoute({
                         })
                     }
                 },
-                description: 'List of users'
+                description: "List of users"
             }
         }
     },
     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,
@@ -70,7 +70,7 @@ export const listUsersAdminRoute = 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/routes/users.route.d.ts

@@ -1,4 +1,4 @@
-import { z } from '@hono/zod-openapi';
+import { z } from "@hono/zod-openapi";
 export declare const usersAdminRoute: {
     handler: (c: import("hono").Context<import("../../../../middlewares/global.middleware").EnvVitNode, "/list", {
         in: {
@@ -67,7 +67,7 @@ export declare const usersAdminRoute: {
         responses: {
             200: {
                 content: {
-                    'application/json': {
+                    "application/json": {
                         schema: z.ZodObject<{
                             edges: z.ZodArray<z.ZodObject<{
                                 id: z.ZodNumber;

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

@@ -6,27 +6,27 @@ import { core_users } from "../../../../../database/users.js";
 export const usersAdminRoute = buildRoute({
     ...CONFIG_PLUGIN,
     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

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

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

@@ -3,7 +3,7 @@ import { CONFIG_PLUGIN } from "../../../config.js";
 import { routeMiddleware } from "./route.js";
 export const middlewareModule = buildModule({
     ...CONFIG_PLUGIN,
-    name: 'middleware',
+    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,
     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

@@ -0,0 +1,52 @@
+import { z } from "zod";
+export declare const zodChangePasswordSchema: z.ZodObject<{
+    password: z.ZodString;
+    userId: z.ZodNumber;
+    token: z.ZodString;
+}, z.core.$strip>;
+export declare const changePasswordRoute: {
+    handler: (c: import("hono").Context<import("../../../middlewares/global.middleware").EnvVitNode, "/change-password", {
+        in: {
+            json: {
+                password: string;
+                userId: number;
+                token: string;
+            };
+        };
+        out: {
+            json: {
+                password: string;
+                userId: number;
+                token: string;
+            };
+        };
+    }>) => Promise<Response & import("hono").TypedResponse<"Password changed", 201, "text">>;
+    pluginId: "@vitnode/core";
+    route: {
+        method: "post";
+        description: string;
+        path: "/change-password";
+        request: {
+            body: {
+                required: true;
+                content: {
+                    "application/json": {
+                        schema: z.ZodObject<{
+                            password: z.ZodString;
+                            userId: z.ZodNumber;
+                            token: z.ZodString;
+                        }, z.core.$strip>;
+                    };
+                };
+            };
+        };
+        responses: {
+            201: {
+                description: string;
+            };
+        };
+    } & {
+        getRoutingPath: () => "/change-password";
+    };
+};
+//# sourceMappingURL=change-password.route.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"change-password.route.d.ts","sourceRoot":"","sources":["../../../../../../src/api/modules/users/routes/change-password.route.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,uBAAuB;;;;iBAMlC,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyD9B,CAAC"}

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

@@ -0,0 +1,58 @@
+import { and, eq, gt } from "drizzle-orm";
+import { HTTPException } from "hono/http-exception";
+import { z } from "zod";
+import { buildRoute } from "../../../lib/route.js";
+import { PasswordModel } from "../../../models/password.js";
+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!"
+    }),
+    userId: z.number().openapi({
+        example: 123456
+    }),
+    token: z.string().openapi({
+        example: "abcdefg12345"
+    })
+});
+export const changePasswordRoute = buildRoute({
+    ...CONFIG_PLUGIN,
+    route: {
+        method: "post",
+        description: "Change user password",
+        path: "/change-password",
+        request: {
+            body: {
+                required: true,
+                content: {
+                    "application/json": {
+                        schema: zodChangePasswordSchema
+                    }
+                }
+            }
+        },
+        responses: {
+            201: {
+                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);
+        if (!user) {
+            throw new HTTPException(400, {
+                message: "Invalid token"
+            });
+        }
+        const hashPassword = await new PasswordModel().encryptPassword(password);
+        await Promise.all([
+            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))
+        ]);
+        return c.text("Password changed", 201);
+    }
+});

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

@@ -0,0 +1,42 @@
+import { z } from "zod";
+export declare const resetPasswordRoute: {
+    handler: (c: import("hono").Context<import("../../../middlewares/global.middleware").EnvVitNode, "/reset-password", {
+        in: {
+            json: {
+                email: string;
+            };
+        };
+        out: {
+            json: {
+                email: string;
+            };
+        };
+    }>) => Promise<Response & import("hono").TypedResponse<"Email sent", 201, "text">>;
+    pluginId: "@vitnode/core";
+    route: {
+        method: "post";
+        description: string;
+        path: "/reset-password";
+        withCaptcha: true;
+        request: {
+            body: {
+                required: true;
+                content: {
+                    "application/json": {
+                        schema: z.ZodObject<{
+                            email: z.ZodEmail;
+                        }, z.core.$strip>;
+                    };
+                };
+            };
+        };
+        responses: {
+            201: {
+                description: string;
+            };
+        };
+    } & {
+        getRoutingPath: () => "/reset-password";
+    };
+};
+//# sourceMappingURL=reset-passowrd.route.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"reset-passowrd.route.d.ts","sourceRoot":"","sources":["../../../../../../src/api/modules/users/routes/reset-passowrd.route.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AASxB,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgH7B,CAAC"}

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

@@ -0,0 +1,91 @@
+import { eq } from "drizzle-orm";
+import { createTranslator } from "use-intl";
+import { z } from "zod";
+import { buildRoute } from "../../../lib/route.js";
+import { ForgotPasswordTokenModel } from "../../../models/password.js";
+import { CONFIG_PLUGIN } from "../../../../config.js";
+import { core_users, core_users_forgot_password } from "../../../../database/users.js";
+import ResetPasswordEmailTemplate from "../../../../emails/reset-password.js";
+import { CONFIG } from "../../../../lib/config.js";
+export const resetPasswordRoute = buildRoute({
+    ...CONFIG_PLUGIN,
+    route: {
+        method: "post",
+        description: "Request a password reset",
+        path: "/reset-password",
+        withCaptcha: true,
+        request: {
+            body: {
+                required: true,
+                content: {
+                    "application/json": {
+                        schema: z.object({
+                            email: z.email().toLowerCase().openapi({
+                                example: "test@test.com"
+                            })
+                        })
+                    }
+                }
+            }
+        },
+        responses: {
+            201: {
+                description: "Email sent"
+            }
+        }
+    },
+    handler: async (c)=>{
+        const RESPONSE_TEXT = c.text("Email sent", 201);
+        const { email } = c.req.valid("json");
+        const [findUser] = await c.get("db").select({
+            email: core_users.email,
+            id: core_users.id,
+            language: core_users.language
+        }).from(core_users).where(eq(core_users.email, email)).limit(1);
+        if (!findUser) {
+            return RESPONSE_TEXT;
+        }
+        const hashToken = new ForgotPasswordTokenModel().generateResetToken();
+        const [findLastRecord] = await c.get("db").select().from(core_users_forgot_password).where(eq(core_users_forgot_password.userId, findUser.id)).limit(1);
+        // If a record will be found with createdAt in the last 5 minutes, skip
+        if (findLastRecord?.createdAt > new Date(Date.now() - 1000 * 60 * 5)) {
+            return RESPONSE_TEXT;
+        }
+        const EXPIRES_AT = new Date(Date.now() + 1000 * 60 * 30); // 30 minutes
+        if (findLastRecord) {
+            await c.get("db").update(core_users_forgot_password).set({
+                createdAt: new Date(),
+                expiresAt: EXPIRES_AT,
+                token: hashToken,
+                ipAddress: c.get("ipAddress")
+            }).where(eq(core_users_forgot_password.id, findLastRecord.id));
+        } else {
+            await c.get("db").insert(core_users_forgot_password).values({
+                token: hashToken,
+                ipAddress: c.get("ipAddress"),
+                userId: findUser.id,
+                expiresAt: EXPIRES_AT
+            });
+        }
+        // Send email
+        const resetUrlNative = new URL(`login/reset-password?token=${hashToken}&userId=${findUser.id}`, CONFIG.web.href);
+        await c.get("email").send({
+            user: {
+                id: findUser.id,
+                email: findUser.email,
+                language: findUser.language
+            },
+            content: (props)=>ResetPasswordEmailTemplate({
+                    ...props,
+                    resetUrl: resetUrlNative.href,
+                    expiryDate: EXPIRES_AT,
+                    userIpAddress: c.get("ipAddress")
+                }),
+            subject: ({ i18n })=>{
+                const t = createTranslator(i18n);
+                return t("core.auth.reset_password.email.subject");
+            }
+        });
+        return RESPONSE_TEXT;
+    }
+});

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

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import { z } from "zod";
 export declare const sessionRoute: {
     handler: (c: import("hono").Context<import("../../../middlewares/global.middleware").EnvVitNode, "/session", {}>) => Promise<Response & import("hono").TypedResponse<{
         user: {
@@ -23,7 +23,7 @@ export declare const sessionRoute: {
         responses: {
             200: {
                 content: {
-                    'application/json': {
+                    "application/json": {
                         schema: z.ZodObject<{
                             user: z.ZodNullable<z.ZodObject<{
                                 id: z.ZodNumber;

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

@@ -5,13 +5,13 @@ import { CONFIG_PLUGIN } from "../../../../config.js";
 export const sessionRoute = buildRoute({
     ...CONFIG_PLUGIN,
     route: {
-        method: 'get',
-        description: 'Verify session',
-        path: '/session',
+        method: "get",
+        description: "Verify session",
+        path: "/session",
         responses: {
             200: {
                 content: {
-                    'application/json': {
+                    "application/json": {
                         schema: z.object({
                             user: z.object({
                                 id: z.number(),
@@ -29,12 +29,12 @@ export const sessionRoute = buildRoute({
                         })
                     }
                 },
-                description: 'User'
+                description: "User"
             }
         }
     },
     handler: async (c)=>{
-        const user = c.get('user');
+        const user = c.get("user");
         const admin = new SessionAdminModel(c);
         return c.json({
             user: user ? {

package/dist/src/api/modules/users/routes/sign-in.route.d.ts

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import { z } from "zod";
 export declare const zodSignInSchema: z.ZodObject<{
     email: z.ZodEmail;
     password: z.ZodString;
@@ -33,7 +33,7 @@ export declare const signInRoute: {
             body: {
                 required: true;
                 content: {
-                    'application/json': {
+                    "application/json": {
                         schema: z.ZodObject<{
                             email: z.ZodEmail;
                             password: z.ZodString;
@@ -49,7 +49,7 @@ export declare const signInRoute: {
             };
             201: {
                 content: {
-                    'application/json': {
+                    "application/json": {
                         schema: z.ZodObject<{
                             id: z.ZodNumber;
                             token: z.ZodString;

package/dist/src/api/modules/users/routes/sign-in.route.js

@@ -6,10 +6,10 @@ import { UserModel } from "../../../models/user.js";
 import { CONFIG_PLUGIN } from "../../../../config.js";
 export const zodSignInSchema = z.object({
     email: z.email().toLowerCase().openapi({
-        example: 'test@test.com'
+        example: "test@test.com"
     }),
     password: z.string().openapi({
-        example: 'Test123!'
+        example: "Test123!"
     }),
     isAdmin: z.boolean().optional().openapi({
         example: false
@@ -18,14 +18,14 @@ export const zodSignInSchema = z.object({
 export const signInRoute = buildRoute({
     ...CONFIG_PLUGIN,
     route: {
-        method: 'post',
-        description: 'Sign in with email and password',
-        path: '/sign_in',
+        method: "post",
+        description: "Sign in with email and password",
+        path: "/sign_in",
         request: {
             body: {
                 required: true,
                 content: {
-                    'application/json': {
+                    "application/json": {
                         schema: zodSignInSchema
                     }
                 }
@@ -33,23 +33,23 @@ export const signInRoute = buildRoute({
         },
         responses: {
             403: {
-                description: 'Access Denied'
+                description: "Access Denied"
             },
             201: {
                 content: {
-                    'application/json': {
+                    "application/json": {
                         schema: z.object({
                             id: z.number(),
                             token: z.string()
                         })
                     }
                 },
-                description: 'User signed in'
+                description: "User signed in"
             }
         }
     },
     handler: async (c)=>{
-        const { password, isAdmin, email } = c.req.valid('json');
+        const { password, isAdmin, email } = c.req.valid("json");
         const data = await new UserModel().signInWithPassword({
             password,
             email,