@vitnode/core 0.0.1-canary.0

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

@@ -0,0 +1 @@
+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({pluginId:CONFIG_PLUGIN.pluginId,route:{method:"post",description:"Change user password",path:"/change-password",request:{body:{required:true,content:{"application/json":{schema:zodChangePasswordSchema}}}},responses:{201:{description:"Password changed"},400:{description:"Invalid or expired token"}}},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/devices.route.d.ts

@@ -0,0 +1,34 @@
+import { z } from "zod";
+export declare const listDevicesRoute: import("../../../../api/lib/route").Route<"@vitnode/core", {
+    method: "get";
+    description: string;
+    path: "/devices";
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        devices: z.ZodArray<z.ZodObject<{
+                            publicId: z.ZodString;
+                            ipAddress: z.ZodString;
+                            os: z.ZodString;
+                            browser: z.ZodString;
+                            deviceType: z.ZodEnum<{
+                                desktop: "desktop";
+                                mobile: "mobile";
+                                tablet: "tablet";
+                            }>;
+                            lastSeen: z.ZodDate;
+                            expiresAt: z.ZodDate;
+                            isCurrent: z.ZodBoolean;
+                        }, z.core.$strip>>;
+                    }, z.core.$strip>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>;
+//# sourceMappingURL=devices.route.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"devices.route.d.ts","sourceRoot":"","sources":["../../../../../../src/api/modules/users/routes/devices.route.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAUxB,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkF3B,CAAC"}

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

@@ -0,0 +1 @@
+import{and,desc,eq,gt}from"drizzle-orm";import{getCookie}from"hono/cookie";import{HTTPException}from"hono/http-exception";import{z}from"zod";import{buildRoute}from"../../../lib/route.js";import{CONFIG_PLUGIN}from"../../../../config.js";import{core_sessions,core_sessions_known_devices}from"../../../../database/sessions.js";import{parseUserAgent}from"../../../../lib/api/parse-user-agent.js";export const listDevicesRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,route:{method:"get",description:"List the devices the current user is signed in on.",path:"/devices",responses:{200:{content:{"application/json":{schema:z.object({devices:z.array(z.object({publicId:z.string(),ipAddress:z.string(),os:z.string(),browser:z.string(),deviceType:z.enum(["desktop","tablet","mobile"]),lastSeen:z.date(),expiresAt:z.date(),isCurrent:z.boolean()}))})}},description:"List of the current user's devices"}}},handler:async c=>{const user=c.get("user");if(!user){throw new HTTPException(401,{message:"Unauthorized"})}const currentPublicId=getCookie(c,c.get("core").authorization.deviceCookieName);const rows=await c.get("db").select({publicId:core_sessions_known_devices.publicId,ipAddress:core_sessions_known_devices.ipAddress,userAgent:core_sessions_known_devices.userAgent,lastSeen:core_sessions_known_devices.lastSeen,expiresAt:core_sessions.expiresAt}).from(core_sessions).innerJoin(core_sessions_known_devices,eq(core_sessions.deviceId,core_sessions_known_devices.id)).where(and(eq(core_sessions.userId,user.id),gt(core_sessions.expiresAt,new Date))).orderBy(desc(core_sessions_known_devices.lastSeen));const byPublicId=new Map;for(const row of rows){const existing=byPublicId.get(row.publicId);if(!existing||row.expiresAt>existing.expiresAt){byPublicId.set(row.publicId,row)}}const devices=[...byPublicId.values()].map(({userAgent,publicId,...device})=>({...device,publicId,...parseUserAgent(userAgent),isCurrent:publicId===currentPublicId}));return c.json({devices})}});

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

@@ -0,0 +1,26 @@
+import { z } from "zod";
+export declare const permissionsRoute: import("../../../../api/lib/route").Route<"@vitnode/core", {
+    method: "get";
+    description: string;
+    path: "/permissions";
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        root: z.ZodBoolean;
+                        permissions: z.ZodArray<z.ZodObject<{
+                            plugin: z.ZodString;
+                            module: z.ZodString;
+                            permission: z.ZodString;
+                        }, z.core.$strip>>;
+                    }, z.core.$strip>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>;
+//# sourceMappingURL=permissions.route.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"permissions.route.d.ts","sourceRoot":"","sources":["../../../../../../src/api/modules/users/routes/permissions.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;EAwC3B,CAAC"}

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

@@ -0,0 +1 @@
+import{z}from"zod";import{resolveStaffPermissions}from"../../../lib/check-staff-permission.js";import{buildRoute}from"../../../lib/route.js";import{CONFIG_PLUGIN}from"../../../../config.js";export const permissionsRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,route:{method:"get",description:"Get the current user's effective moderator permissions (public site)",path:"/permissions",responses:{200:{content:{"application/json":{schema:z.object({root:z.boolean(),permissions:z.array(z.object({plugin:z.string(),module:z.string(),permission:z.string()}))})}},description:"Effective moderator permissions"}}},handler:async c=>{const user=c.get("user");if(!user){return c.json({root:false,permissions:[]},200)}const permissions=await resolveStaffPermissions(c,{type:"moderator",user});return c.json(permissions,200)}});

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

@@ -0,0 +1,27 @@
+import { z } from "zod";
+export declare const resetPasswordRoute: import("../../../../api/lib/route").Route<"@vitnode/core", {
+    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;
+        };
+    };
+} & {
+    path: string;
+}>;
+//# 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;;;;;;;;;;;;;;;;;;;;;;;;EAgH7B,CAAC"}

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

@@ -0,0 +1 @@
+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({pluginId:CONFIG_PLUGIN.pluginId,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(findLastRecord?.createdAt>new Date(Date.now()-1e3*60*5)){return RESPONSE_TEXT}const EXPIRES_AT=new Date(Date.now()+1e3*60*30);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})}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/revoke-device.route.d.ts

@@ -0,0 +1,42 @@
+import { z } from "@hono/zod-openapi";
+export declare const revokeDeviceRoute: import("../../../../api/lib/route").Route<"@vitnode/core", {
+    method: "delete";
+    description: string;
+    path: "/devices/{publicId}";
+    request: {
+        params: z.ZodObject<{
+            publicId: z.ZodString;
+        }, z.core.$strip>;
+    };
+    responses: {
+        200: {
+            description: string;
+        };
+        400: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        error: z.ZodString;
+                    }, z.core.$strip>;
+                };
+            };
+            description: string;
+        };
+        401: {
+            description: string;
+        };
+        404: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        error: z.ZodString;
+                    }, z.core.$strip>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>;
+//# sourceMappingURL=revoke-device.route.d.ts.map

package/dist/src/api/modules/users/routes/revoke-device.route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"revoke-device.route.d.ts","sourceRoot":"","sources":["../../../../../../src/api/modules/users/routes/revoke-device.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AAgBtC,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmF5B,CAAC"}

package/dist/src/api/modules/users/routes/revoke-device.route.js

@@ -0,0 +1 @@
+import{z}from"@hono/zod-openapi";import{and,eq}from"drizzle-orm";import{getCookie}from"hono/cookie";import{HTTPException}from"hono/http-exception";import{buildRoute}from"../../../lib/route.js";import{adminSessionCacheKey,sessionCacheKey}from"../../../models/session-cache.js";import{CONFIG_PLUGIN}from"../../../../config.js";import{core_sessions,core_sessions_known_devices}from"../../../../database/sessions.js";export const revokeDeviceRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,route:{method:"delete",description:"Sign out one of the current user's devices.",path:"/devices/{publicId}",request:{params:z.object({publicId:z.string().openapi({example:"a1b2c3"})})},responses:{200:{description:"Device signed out"},400:{content:{"application/json":{schema:z.object({error:z.string()})}},description:"Cannot revoke the current device"},401:{description:"Not signed in"},404:{content:{"application/json":{schema:z.object({error:z.string()})}},description:"Device not found"}}},handler:async c=>{const user=c.get("user");if(!user){throw new HTTPException(401,{message:"Unauthorized"})}const{publicId}=c.req.valid("param");const currentPublicId=getCookie(c,c.get("core").authorization.deviceCookieName);if(publicId===currentPublicId){return c.json({error:"Cannot revoke the current device"},400)}const db=c.get("db");const[device]=await db.select({id:core_sessions_known_devices.id}).from(core_sessions_known_devices).where(eq(core_sessions_known_devices.publicId,publicId));if(!device){return c.json({error:"Device not found"},404)}const where=and(eq(core_sessions.userId,user.id),eq(core_sessions.deviceId,device.id));const sessions=await db.select({token:core_sessions.token}).from(core_sessions).where(where);await db.delete(core_sessions).where(where);const cache=c.get("cache");await cache.deleteSystem(sessions.flatMap(({token})=>[sessionCacheKey(token,device.id),adminSessionCacheKey(token,device.id)]));return c.body(null,200)}});

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

@@ -0,0 +1,41 @@
+import { z } from "zod";
+export declare const sessionRoute: import("../../../../api/lib/route").Route<"@vitnode/core", {
+    method: "get";
+    description: string;
+    path: "/session";
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        ai: z.ZodObject<{
+                            models: z.ZodArray<z.ZodObject<{
+                                id: z.ZodString;
+                                model: z.ZodString;
+                                name: z.ZodString;
+                            }, z.core.$strip>>;
+                        }, z.core.$strip>;
+                        user: z.ZodNullable<z.ZodObject<{
+                            id: z.ZodNumber;
+                            email: z.ZodString;
+                            name: z.ZodString;
+                            nameCode: z.ZodString;
+                            createdAt: z.ZodDate;
+                            newsletter: z.ZodBoolean;
+                            avatarColor: z.ZodString;
+                            emailVerified: z.ZodBoolean;
+                            roleId: z.ZodNumber;
+                            birthday: z.ZodNullable<z.ZodDate>;
+                            isAdmin: z.ZodBoolean;
+                            isModerator: z.ZodBoolean;
+                        }, z.core.$strip>>;
+                    }, z.core.$strip>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>;
+//# sourceMappingURL=session.route.d.ts.map

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

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

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

@@ -0,0 +1 @@
+import{z}from"zod";import{buildRoute}from"../../../lib/route.js";import{SessionAdminModel}from"../../../models/session-admin.js";import{CONFIG_PLUGIN}from"../../../../config.js";export const sessionRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,route:{method:"get",description:"Verify session",path:"/session",responses:{200:{content:{"application/json":{schema:z.object({ai:z.object({models:z.array(z.object({id:z.string(),model:z.string(),name:z.string()}))}),user:z.object({id:z.number(),email:z.string(),name:z.string(),nameCode:z.string(),createdAt:z.date(),newsletter:z.boolean(),avatarColor:z.string(),emailVerified:z.boolean(),roleId:z.number(),birthday:z.date().nullable(),isAdmin:z.boolean(),isModerator:z.boolean()}).nullable()})}},description:"User"}}},handler:async c=>{const user=c.get("user");const admin=new SessionAdminModel(c);return c.json({ai:{models:c.get("ai").models()},user:user?{...user,isAdmin:await admin.checkIfUserIsAdmin(user.id),isModerator:false}:null})}});

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

@@ -0,0 +1,44 @@
+import { z } from "zod";
+export declare const zodSignInSchema: z.ZodObject<{
+    email: z.ZodEmail;
+    password: z.ZodString;
+    isAdmin: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const signInRoute: import("../../../../api/lib/route").Route<"@vitnode/core", {
+    method: "post";
+    description: string;
+    path: "/sign_in";
+    request: {
+        body: {
+            required: true;
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        email: z.ZodEmail;
+                        password: z.ZodString;
+                        isAdmin: z.ZodOptional<z.ZodBoolean>;
+                    }, z.core.$strip>;
+                };
+            };
+        };
+    };
+    responses: {
+        403: {
+            description: string;
+        };
+        201: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        id: z.ZodNumber;
+                        token: z.ZodString;
+                    }, z.core.$strip>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>;
+//# sourceMappingURL=sign-in.route.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sign-in.route.d.ts","sourceRoot":"","sources":["../../../../../../src/api/modules/users/routes/sign-in.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB,eAAO,MAAM,eAAe;;;;iBAU1B,CAAC;AAEH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoDtB,CAAC"}

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

@@ -0,0 +1 @@
+import{z}from"zod";import{buildRoute}from"../../../lib/route.js";import{SessionModel}from"../../../models/session.js";import{SessionAdminModel}from"../../../models/session-admin.js";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"}),password:z.string().openapi({example:"Test123!"}),isAdmin:z.boolean().optional().openapi({example:false})});export const signInRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,route:{method:"post",description:"Sign in with email and password",path:"/sign_in",request:{body:{required:true,content:{"application/json":{schema:zodSignInSchema}}}},responses:{403:{description:"Access Denied"},201:{content:{"application/json":{schema:z.object({id:z.number(),token:z.string()})}},description:"User signed in"}}},handler:async c=>{const{password,isAdmin,email}=c.req.valid("json");const data=await new UserModel().signInWithPassword({password,email,c});if(isAdmin){const{token}=await new SessionAdminModel(c).createSessionByUserId(data.id);return c.json({id:data.id,token},201)}const{token}=await new SessionModel(c).createSessionByUserId(data.id);return c.json({id:data.id,token},201)}});

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

@@ -0,0 +1,28 @@
+import { z } from "@hono/zod-openapi";
+export declare const signOutRoute: import("../../../../api/lib/route").Route<"@vitnode/core", {
+    method: "delete";
+    description: string;
+    path: "/sign_out";
+    request: {
+        body: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        isAdmin: z.ZodOptional<z.ZodBoolean>;
+                    }, z.core.$strip>;
+                };
+            };
+        };
+    };
+    responses: {
+        200: {
+            description: string;
+        };
+        403: {
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>;
+//# sourceMappingURL=sign-out.route.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sign-out.route.d.ts","sourceRoot":"","sources":["../../../../../../src/api/modules/users/routes/sign-out.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AAOtC,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;EAuCvB,CAAC"}

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

@@ -0,0 +1 @@
+import{z}from"@hono/zod-openapi";import{buildRoute}from"../../../lib/route.js";import{SessionModel}from"../../../models/session.js";import{SessionAdminModel}from"../../../models/session-admin.js";import{CONFIG_PLUGIN}from"../../../../config.js";export const signOutRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,route:{method:"delete",description:"Sign out the current admin",path:"/sign_out",request:{body:{content:{"application/json":{schema:z.object({isAdmin:z.boolean().optional().openapi({example:false})})}}}},responses:{200:{description:"User signed out"},403:{description:"Access Denied"}}},handler:async c=>{const{isAdmin}=c.req.valid("json");if(isAdmin){await new SessionAdminModel(c).deleteSession();return c.json({})}await new SessionModel(c).deleteSession();return c.json({})}});

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

@@ -0,0 +1,51 @@
+import { z } from "zod";
+export declare const zodSignUpSchema: z.ZodObject<{
+    email: z.ZodEmail;
+    name: z.ZodString;
+    password: z.ZodString;
+    newsletter: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+}, z.core.$strip>;
+export declare const signUpRoute: import("../../../../api/lib/route").Route<"@vitnode/core", {
+    method: "post";
+    description: string;
+    path: "/sign_up";
+    withCaptcha: true;
+    request: {
+        body: {
+            required: true;
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        email: z.ZodEmail;
+                        name: z.ZodString;
+                        password: z.ZodString;
+                        newsletter: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+                    }, z.core.$strip>;
+                };
+            };
+        };
+    };
+    responses: {
+        201: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        id: z.ZodNumber;
+                        emailVerified: z.ZodBoolean;
+                        email: z.ZodEmail;
+                    }, z.core.$strip>;
+                };
+            };
+            description: string;
+        };
+        400: {
+            description: string;
+        };
+        409: {
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>;
+//# sourceMappingURL=sign-up.route.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sign-up.route.d.ts","sourceRoot":"","sources":["../../../../../../src/api/modules/users/routes/sign-up.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAWxB,eAAO,MAAM,eAAe;;;;;iBAe1B,CAAC;AAEH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8DtB,CAAC"}

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

@@ -0,0 +1 @@
+import{z}from"zod";import{buildRoute}from"../../../lib/route.js";import{PasswordModel}from"../../../models/password.js";import{UserModel}from"../../../models/user.js";import{CONFIG_PLUGIN}from"../../../../config.js";import{SessionModel}from"../../../models/session.js";const nameRegex=/^(?!.* {2})[\p{L}\p{N}._@ -]*$/u;export const zodSignUpSchema=z.object({email:z.email().toLowerCase().openapi({example:"test@test.com"}),name:z.string().openapi({example:"test"}).min(3).refine(val=>nameRegex.test(val),{message:"Invalid name"}),password:z.string().min(8).openapi({example:"Test123!"}),newsletter:z.boolean().default(false).optional()});export const signUpRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,route:{method:"post",description:"Create a new user",path:"/sign_up",withCaptcha:true,request:{body:{required:true,content:{"application/json":{schema:zodSignUpSchema}}}},responses:{201:{content:{"application/json":{schema:z.object({id:z.number(),emailVerified:z.boolean(),email:z.email()})}},description:"User created"},400:{description:"Bad Request"},409:{description:"Email or name already exists"}}},handler:async c=>{const hashedPassword=await new PasswordModel().encryptPassword(c.req.valid("json").password);const data=await new UserModel().signUp({...c.req.valid("json"),hashedPassword},c);if(data.emailVerified){await new SessionModel(c).createSessionByUserId(data.id)}else{}return c.json({id:data.id,emailVerified:data.emailVerified,email:data.email},201)}});

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

@@ -0,0 +1,27 @@
+import { z } from "zod";
+export declare const testRoute: import("../../../../api/lib/route").Route<"@vitnode/core", {
+    method: "post";
+    description: string;
+    path: "/test";
+    responses: {
+        200: {
+            content: {
+                "text/plain": {
+                    schema: z.ZodString;
+                };
+            };
+            description: string;
+        };
+        201: {
+            content: {
+                "text/plain": {
+                    schema: z.ZodString;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>;
+//# sourceMappingURL=test.route.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"test.route.d.ts","sourceRoot":"","sources":["../../../../../../src/api/modules/users/routes/test.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;EA8BpB,CAAC"}

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

@@ -0,0 +1 @@
+import{z}from"zod";import{buildRoute}from"../../../lib/route.js";import{CONFIG_PLUGIN}from"../../../../config.js";export const testRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,route:{method:"post",description:"Test route",path:"/test",responses:{200:{content:{"text/plain":{schema:z.string()}},description:"User"},201:{content:{"text/plain":{schema:z.string()}},description:"User"}}},handler:async c=>{await c.get("log").warn("This is a test warn log");return c.text("test")}});

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

@@ -0,0 +1,34 @@
+import { z } from "zod";
+export declare const callbackRoute: import("../../../../../api/lib/route").Route<"@vitnode/core", {
+    method: "get";
+    description: string;
+    path: "/{providerId}/callback";
+    request: {
+        params: z.ZodObject<{
+            providerId: z.ZodString;
+        }, z.core.$strip>;
+        query: z.ZodObject<{
+            code: z.ZodString;
+            state: z.ZodString;
+        }, z.core.$strip>;
+    };
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        id: z.ZodNumber;
+                        token: z.ZodString;
+                    }, z.core.$strip>;
+                };
+            };
+            description: string;
+        };
+        409: {
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>;
+//# sourceMappingURL=callback.route.d.ts.map

package/dist/src/api/modules/users/sso/routes/callback.route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"callback.route.d.ts","sourceRoot":"","sources":["../../../../../../../src/api/modules/users/sso/routes/callback.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0CxB,CAAC"}

package/dist/src/api/modules/users/sso/routes/callback.route.js

@@ -0,0 +1 @@
+import{z}from"zod";import{buildRoute}from"../../../../lib/route.js";import{SessionModel}from"../../../../models/session.js";import{SSOModel}from"../../../../models/sso.js";import{CONFIG_PLUGIN}from"../../../../../config.js";export const callbackRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,route:{method:"get",description:"SSO Callback",path:"/{providerId}/callback",request:{params:z.object({providerId:z.string()}),query:z.object({code:z.string(),state:z.string()})},responses:{200:{content:{"application/json":{schema:z.object({id:z.number(),token:z.string()})}},description:"URL"},409:{description:"Email already exists"}}},handler:async c=>{const{providerId}=c.req.valid("param");const{code,state}=c.req.valid("query");const sso=await new SSOModel(c).callback({providerId,code,state});const{token}=await new SessionModel(c).createSessionByUserId(sso.userId);return c.json({id:sso.userId,token})}});

package/dist/src/api/modules/users/sso/routes/create-url.route.d.ts

@@ -0,0 +1,26 @@
+import { z } from "zod";
+export declare const createUrlRoute: import("../../../../../api/lib/route").Route<"@vitnode/core", {
+    method: "post";
+    description: string;
+    path: "/{providerId}";
+    request: {
+        params: z.ZodObject<{
+            providerId: z.ZodString;
+        }, z.core.$strip>;
+    };
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        url: z.ZodString;
+                    }, z.core.$strip>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>;
+//# sourceMappingURL=create-url.route.d.ts.map

package/dist/src/api/modules/users/sso/routes/create-url.route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-url.route.d.ts","sourceRoot":"","sources":["../../../../../../../src/api/modules/users/sso/routes/create-url.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;EA8BzB,CAAC"}

package/dist/src/api/modules/users/sso/routes/create-url.route.js

@@ -0,0 +1 @@
+import{z}from"zod";import{buildRoute}from"../../../../lib/route.js";import{SSOModel}from"../../../../models/sso.js";import{CONFIG_PLUGIN}from"../../../../../config.js";export const createUrlRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,route:{method:"post",description:"Generate SSO URL",path:"/{providerId}",request:{params:z.object({providerId:z.string()})},responses:{200:{content:{"application/json":{schema:z.object({url:z.string()})}},description:"URL"}}},handler:async c=>{const{providerId}=c.req.valid("param");const url=await new SSOModel(c).getUrl(providerId);return c.json({url})}});

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

@@ -0,0 +1,56 @@
+export declare const ssoUserModule: import("../../../../api/lib/module").BuildModuleReturn<"@vitnode/core", "sso", [import("../../../lib/route").Route<"@vitnode/core", {
+    method: "get";
+    description: string;
+    path: "/{providerId}/callback";
+    request: {
+        params: import("zod").ZodObject<{
+            providerId: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+        query: import("zod").ZodObject<{
+            code: import("zod").ZodString;
+            state: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+    };
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        id: import("zod").ZodNumber;
+                        token: import("zod").ZodString;
+                    }, import("zod/v4/core").$strip>;
+                };
+            };
+            description: string;
+        };
+        409: {
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>, import("../../../lib/route").Route<"@vitnode/core", {
+    method: "post";
+    description: string;
+    path: "/{providerId}";
+    request: {
+        params: import("zod").ZodObject<{
+            providerId: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+    };
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        url: import("zod").ZodString;
+                    }, import("zod/v4/core").$strip>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>], import("../../../../api/lib/module").BaseBuildModuleReturn<"@vitnode/core", string, import("../../../lib/route").Route<"@vitnode/core", import("@hono/zod-openapi").RouteConfig>[]>[]>;
+//# sourceMappingURL=sso.module.d.ts.map

package/dist/src/api/modules/users/sso/sso.module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sso.module.d.ts","sourceRoot":"","sources":["../../../../../../src/api/modules/users/sso/sso.module.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iLAIxB,CAAC"}

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

@@ -0,0 +1 @@
+import{buildModule}from"../../../lib/module.js";import{CONFIG_PLUGIN}from"../../../../config.js";import{callbackRoute}from"./routes/callback.route.js";import{createUrlRoute}from"./routes/create-url.route.js";export const ssoUserModule=buildModule({pluginId:CONFIG_PLUGIN.pluginId,name:"sso",routes:[callbackRoute,createUrlRoute]});