@vitnode/core 1.2.0-canary.75 → 1.2.0-canary.77

package/dist/src/api/modules/admin/staff/routes/create.route.js

@@ -1 +1 @@
-import{z}from"@hono/zod-openapi";import{eq,or}from"drizzle-orm";import{assertStaffPermission}from"../../../../lib/check-staff-permission.js";import{buildRoute}from"../../../../lib/route.js";import{CONFIG_PLUGIN}from"../../../../../config.js";import{core_admin_permissions}from"../../../../../database/admins.js";import{core_moderators_permissions}from"../../../../../database/moderators.js";import{staffPermissionModuleByType,staffTypeSchema}from"../lib/schema.js";const tableByType={admin:core_admin_permissions,moderator:core_moderators_permissions};export const createStaffAdminRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,route:{method:"post",description:"Create a staff entry for a role or a user (Admin only)",path:"/entry/{type}",request:{params:z.object({type:staffTypeSchema}),body:{content:{"application/json":{schema:z.object({roleId:z.number().nullable().optional(),userId:z.number().nullable().optional()}).refine(value=>Boolean(value.roleId)!==Boolean(value.userId),{message:"Provide exactly one of roleId or userId"})}}}},responses:{201:{content:{"application/json":{schema:z.object({id:z.number()})}},description:"Staff entry created"},403:{description:"Access Denied"},409:{content:{"application/json":{schema:z.object({error:z.string()})}},description:"Staff entry already exists"}}},handler:async c=>{const{type}=c.req.valid("param");await assertStaffPermission(c,{type:"admin",plugin:CONFIG_PLUGIN.pluginId,module:staffPermissionModuleByType[type],permission:"can_create"});const{roleId,userId}=c.req.valid("json");const table=tableByType[type];const[existing]=await c.get("db").select({id:table.id}).from(table).where(or(roleId?eq(table.roleId,roleId):undefined,userId?eq(table.userId,userId):undefined)).limit(1);if(existing){return c.json({error:"Staff entry already exists"},409)}const[created]=await c.get("db").insert(table).values({roleId:roleId??null,userId:userId??null,data:{unrestricted:false,permissions:[]}}).returning({id:table.id});return c.json({id:created.id},201)}});
+import{z}from"@hono/zod-openapi";import{eq,or}from"drizzle-orm";import{assertStaffPermission}from"../../../../lib/check-staff-permission.js";import{buildRoute}from"../../../../lib/route.js";import{CONFIG_PLUGIN}from"../../../../../config.js";import{core_admin_permissions}from"../../../../../database/admins.js";import{core_moderators_permissions}from"../../../../../database/moderators.js";import{staffPermissionModuleByType,staffTypeSchema}from"../lib/schema.js";const tableByType={admin:core_admin_permissions,moderator:core_moderators_permissions};export const createStaffAdminRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,route:{method:"post",description:"Create a staff entry for a role or a user (Admin only)",path:"/entry/{type}",request:{params:z.object({type:staffTypeSchema}),body:{content:{"application/json":{schema:z.object({roleId:z.number().nullable().optional(),userId:z.number().nullable().optional()}).refine(value=>Boolean(value.roleId)!==Boolean(value.userId),{message:"Provide exactly one of roleId or userId"})}}}},responses:{201:{content:{"application/json":{schema:z.object({id:z.number()})}},description:"Staff entry created"},403:{description:"Access Denied"},409:{content:{"application/json":{schema:z.object({error:z.string()})}},description:"Staff entry already exists"}}},handler:async c=>{const{type}=c.req.valid("param");await assertStaffPermission(c,{type:"admin",plugin:CONFIG_PLUGIN.pluginId,module:staffPermissionModuleByType[type],permission:"can_create"});const{roleId,userId}=c.req.valid("json");const table=tableByType[type];const[existing]=await c.get("db").select({id:table.id}).from(table).where(or(roleId?eq(table.roleId,roleId):undefined,userId?eq(table.userId,userId):undefined)).limit(1);if(existing){return c.json({error:"Staff entry already exists"},409)}const[created]=await c.get("db").insert(table).values({roleId:roleId??null,userId:userId??null}).returning({id:table.id});return c.json({id:created.id},201)}});

package/dist/src/api/modules/admin/staff/routes/moderators.route.js

@@ -1 +1 @@
-import{buildRoute}from"../../../../lib/route.js";import{withPagination}from"../../../../lib/with-pagination.js";import{CONFIG_PLUGIN}from"../../../../../config.js";import{core_moderators_permissions}from"../../../../../database/moderators.js";import{resolveStaffEdges}from"../lib/resolve-staff-edges.js";import{staffListAdminQuery,staffListAdminSchema}from"../lib/schema.js";export const listModeratorsStaffAdminRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,adminStaffPermission:{module:"staff_moderators",permission:"can_view"},route:{method:"get",description:"Get list of moderators staff (Admin only)",path:"/moderators",request:{query:staffListAdminQuery},responses:{200:{content:{"application/json":{schema:staffListAdminSchema}},description:"List of moderators staff"},403:{description:"Access Denied"}}},handler:async c=>{const query=c.req.valid("query");const data=await withPagination({params:{query},primaryCursor:core_moderators_permissions.id,query:async({limit,where,orderBy})=>await c.get("db").select({id:core_moderators_permissions.id,roleId:core_moderators_permissions.roleId,userId:core_moderators_permissions.userId,createdAt:core_moderators_permissions.createdAt,updatedAt:core_moderators_permissions.updatedAt,data:core_moderators_permissions.data,protected:core_moderators_permissions.protected}).from(core_moderators_permissions).where(where).orderBy(orderBy).limit(limit),table:core_moderators_permissions,orderBy:{column:query.orderBy?core_moderators_permissions[query.orderBy]:core_moderators_permissions.updatedAt,order:query.order??"desc"},c});return c.json({pageInfo:data.pageInfo,edges:await resolveStaffEdges(c,data.edges)})}});
+import{buildRoute}from"../../../../lib/route.js";import{withPagination}from"../../../../lib/with-pagination.js";import{CONFIG_PLUGIN}from"../../../../../config.js";import{core_moderators_permissions}from"../../../../../database/moderators.js";import{resolveStaffEdges}from"../lib/resolve-staff-edges.js";import{staffListAdminQuery,staffListAdminSchema}from"../lib/schema.js";export const listModeratorsStaffAdminRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,adminStaffPermission:{module:"staff_moderators",permission:"can_view"},route:{method:"get",description:"Get list of moderators staff (Admin only)",path:"/moderators",request:{query:staffListAdminQuery},responses:{200:{content:{"application/json":{schema:staffListAdminSchema}},description:"List of moderators staff"},403:{description:"Access Denied"}}},handler:async c=>{const query=c.req.valid("query");const data=await withPagination({params:{query},primaryCursor:core_moderators_permissions.id,query:async({limit,where,orderBy})=>await c.get("db").select({id:core_moderators_permissions.id,roleId:core_moderators_permissions.roleId,userId:core_moderators_permissions.userId,createdAt:core_moderators_permissions.createdAt,updatedAt:core_moderators_permissions.updatedAt,unrestricted:core_moderators_permissions.unrestricted,protected:core_moderators_permissions.protected}).from(core_moderators_permissions).where(where).orderBy(orderBy).limit(limit),table:core_moderators_permissions,orderBy:{column:query.orderBy?core_moderators_permissions[query.orderBy]:core_moderators_permissions.updatedAt,order:query.order??"desc"},c});return c.json({pageInfo:data.pageInfo,edges:await resolveStaffEdges(c,data.edges)})}});

package/dist/src/api/modules/admin/staff/routes/show-permissions.route.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"show-permissions.route.d.ts","sourceRoot":"","sources":["../../../../../../../src/api/modules/admin/staff/routes/show-permissions.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AAsBtC,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiFzC,CAAC"}
+{"version":3,"file":"show-permissions.route.d.ts","sourceRoot":"","sources":["../../../../../../../src/api/modules/admin/staff/routes/show-permissions.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AAsBtC,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkFzC,CAAC"}

package/dist/src/api/modules/admin/staff/routes/show-permissions.route.js

@@ -1 +1 @@
-import{z}from"@hono/zod-openapi";import{eq}from"drizzle-orm";import{assertStaffPermission}from"../../../../lib/check-staff-permission.js";import{buildRoute}from"../../../../lib/route.js";import{CONFIG_PLUGIN}from"../../../../../config.js";import{core_admin_permissions}from"../../../../../database/admins.js";import{core_moderators_permissions}from"../../../../../database/moderators.js";import{resolveStaffEdges}from"../lib/resolve-staff-edges.js";import{permissionsStaffArgsSchema,staffEntrySchema,staffPermissionModuleByType,staffTypeSchema}from"../lib/schema.js";const tableByType={admin:core_admin_permissions,moderator:core_moderators_permissions};export const showPermissionsStaffAdminRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,route:{method:"get",description:"Get a single staff entry with its granted permissions (Admin only)",path:"/entry/{type}/{id}",request:{params:z.object({type:staffTypeSchema,id:z.string().openapi({example:"1"})})},responses:{200:{content:{"application/json":{schema:staffEntrySchema.extend({permissions:z.array(permissionsStaffArgsSchema)})}},description:"Staff entry"},403:{description:"Access Denied"},404:{content:{"application/json":{schema:z.object({error:z.string()})}},description:"Staff entry not found"}}},handler:async c=>{const{type,id}=c.req.valid("param");await assertStaffPermission(c,{type:"admin",plugin:CONFIG_PLUGIN.pluginId,module:staffPermissionModuleByType[type],permission:"can_edit"});const entryId=Number(id);if(!Number.isInteger(entryId)){return c.json({error:"Staff entry not found"},404)}const table=tableByType[type];const[entry]=await c.get("db").select({id:table.id,roleId:table.roleId,userId:table.userId,createdAt:table.createdAt,updatedAt:table.updatedAt,data:table.data,protected:table.protected}).from(table).where(eq(table.id,entryId)).limit(1);if(!entry){return c.json({error:"Staff entry not found"},404)}const[resolved]=await resolveStaffEdges(c,[entry]);return c.json({...resolved,permissions:entry.data?.permissions??[]},200)}});
+import{z}from"@hono/zod-openapi";import{eq}from"drizzle-orm";import{assertStaffPermission}from"../../../../lib/check-staff-permission.js";import{buildRoute}from"../../../../lib/route.js";import{CONFIG_PLUGIN}from"../../../../../config.js";import{core_admin_permissions}from"../../../../../database/admins.js";import{core_moderators_permissions}from"../../../../../database/moderators.js";import{resolveStaffEdges}from"../lib/resolve-staff-edges.js";import{permissionsStaffArgsSchema,staffEntrySchema,staffPermissionModuleByType,staffTypeSchema}from"../lib/schema.js";const tableByType={admin:core_admin_permissions,moderator:core_moderators_permissions};export const showPermissionsStaffAdminRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,route:{method:"get",description:"Get a single staff entry with its granted permissions (Admin only)",path:"/entry/{type}/{id}",request:{params:z.object({type:staffTypeSchema,id:z.string().openapi({example:"1"})})},responses:{200:{content:{"application/json":{schema:staffEntrySchema.extend({permissions:z.array(permissionsStaffArgsSchema)})}},description:"Staff entry"},403:{description:"Access Denied"},404:{content:{"application/json":{schema:z.object({error:z.string()})}},description:"Staff entry not found"}}},handler:async c=>{const{type,id}=c.req.valid("param");await assertStaffPermission(c,{type:"admin",plugin:CONFIG_PLUGIN.pluginId,module:staffPermissionModuleByType[type],permission:"can_edit"});const entryId=Number(id);if(!Number.isInteger(entryId)){return c.json({error:"Staff entry not found"},404)}const table=tableByType[type];const[entry]=await c.get("db").select({id:table.id,roleId:table.roleId,userId:table.userId,createdAt:table.createdAt,updatedAt:table.updatedAt,unrestricted:table.unrestricted,permissions:table.permissions,protected:table.protected}).from(table).where(eq(table.id,entryId)).limit(1);if(!entry){return c.json({error:"Staff entry not found"},404)}const[resolved]=await resolveStaffEdges(c,[entry]);return c.json({...resolved,permissions:entry.permissions??[]},200)}});

package/dist/src/api/modules/admin/staff/routes/update-permissions.route.js

@@ -1 +1 @@
-import{z}from"@hono/zod-openapi";import{eq}from"drizzle-orm";import{HTTPException}from"hono/http-exception";import{assertStaffPermission,getUserRoleIds}from"../../../../lib/check-staff-permission.js";import{buildRoute}from"../../../../lib/route.js";import{staffPermissionKey}from"../../../../lib/staff-permission.js";import{CONFIG_PLUGIN}from"../../../../../config.js";import{core_admin_permissions}from"../../../../../database/admins.js";import{core_moderators_permissions}from"../../../../../database/moderators.js";import{permissionsStaffArgsSchema,staffPermissionModuleByType,staffTypeSchema}from"../lib/schema.js";const tableByType={admin:core_admin_permissions,moderator:core_moderators_permissions};export const updatePermissionsStaffAdminRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,route:{method:"patch",description:"Update the granted permissions of a staff entry (Admin only)",path:"/entry/{type}/{id}",request:{params:z.object({type:staffTypeSchema,id:z.string().openapi({example:"1"})}),body:{content:{"application/json":{schema:z.object({unrestricted:z.boolean(),permissions:z.array(permissionsStaffArgsSchema)})}}}},responses:{200:{content:{"application/json":{schema:z.object({unrestricted:z.boolean(),permissions:z.array(permissionsStaffArgsSchema)})}},description:"Updated permissions"},403:{description:"Access Denied"},404:{content:{"application/json":{schema:z.object({error:z.string()})}},description:"Staff entry not found"}}},handler:async c=>{const{type,id}=c.req.valid("param");await assertStaffPermission(c,{type:"admin",plugin:CONFIG_PLUGIN.pluginId,module:staffPermissionModuleByType[type],permission:"can_edit"});const{unrestricted,permissions}=c.req.valid("json");const entryId=Number(id);if(!Number.isInteger(entryId)){return c.json({error:"Staff entry not found"},404)}const table=tableByType[type];const[entry]=await c.get("db").select({protected:table.protected,userId:table.userId,roleId:table.roleId}).from(table).where(eq(table.id,entryId)).limit(1);if(!entry){return c.json({error:"Staff entry not found"},404)}if(entry.protected){throw new HTTPException(403,{message:"Forbidden"})}const currentUser=c.get("admin")?.user;const currentUserRoleIds=currentUser?await getUserRoleIds(c,currentUser):[];const isSelf=currentUser!=null&&(entry.userId!=null&&entry.userId===currentUser.id||entry.roleId!=null&&currentUserRoleIds.includes(entry.roleId));if(isSelf){throw new HTTPException(403,{message:"You cannot edit your own staff permissions."})}const allowed=new Set;const dependencies=new Map;for(const plugin of c.get("core").permissionStaff){for(const[module,modulePermissions]of Object.entries(plugin[type])){for(const entry of modulePermissions){const key=staffPermissionKey({plugin:plugin.pluginId,module,permission:entry.permission});allowed.add(key);dependencies.set(key,entry.dependsOn.map(dependency=>staffPermissionKey({plugin:plugin.pluginId,module,permission:dependency})))}}}const seen=new Set;const granted=new Map;if(!unrestricted){for(const permission of permissions){const key=staffPermissionKey(permission);if(!allowed.has(key)||seen.has(key))continue;seen.add(key);granted.set(key,permission)}let changed=true;while(changed){changed=false;for(const key of granted.keys()){const deps=dependencies.get(key)??[];if(deps.some(dependency=>!granted.has(dependency))){granted.delete(key);changed=true}}}}const sanitized=[...granted.values()];const[updated]=await c.get("db").update(table).set({data:{unrestricted,permissions:sanitized}}).where(eq(table.id,entryId)).returning({id:table.id});if(!updated){return c.json({error:"Staff entry not found"},404)}return c.json({unrestricted,permissions:sanitized},200)}});
+import{z}from"@hono/zod-openapi";import{eq}from"drizzle-orm";import{HTTPException}from"hono/http-exception";import{assertStaffPermission,getUserRoleIds}from"../../../../lib/check-staff-permission.js";import{buildRoute}from"../../../../lib/route.js";import{staffPermissionKey}from"../../../../lib/staff-permission.js";import{CONFIG_PLUGIN}from"../../../../../config.js";import{core_admin_permissions}from"../../../../../database/admins.js";import{core_moderators_permissions}from"../../../../../database/moderators.js";import{permissionsStaffArgsSchema,staffPermissionModuleByType,staffTypeSchema}from"../lib/schema.js";const tableByType={admin:core_admin_permissions,moderator:core_moderators_permissions};export const updatePermissionsStaffAdminRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,route:{method:"patch",description:"Update the granted permissions of a staff entry (Admin only)",path:"/entry/{type}/{id}",request:{params:z.object({type:staffTypeSchema,id:z.string().openapi({example:"1"})}),body:{content:{"application/json":{schema:z.object({unrestricted:z.boolean(),permissions:z.array(permissionsStaffArgsSchema)})}}}},responses:{200:{content:{"application/json":{schema:z.object({unrestricted:z.boolean(),permissions:z.array(permissionsStaffArgsSchema)})}},description:"Updated permissions"},403:{description:"Access Denied"},404:{content:{"application/json":{schema:z.object({error:z.string()})}},description:"Staff entry not found"}}},handler:async c=>{const{type,id}=c.req.valid("param");await assertStaffPermission(c,{type:"admin",plugin:CONFIG_PLUGIN.pluginId,module:staffPermissionModuleByType[type],permission:"can_edit"});const{unrestricted,permissions}=c.req.valid("json");const entryId=Number(id);if(!Number.isInteger(entryId)){return c.json({error:"Staff entry not found"},404)}const table=tableByType[type];const[entry]=await c.get("db").select({protected:table.protected,userId:table.userId,roleId:table.roleId}).from(table).where(eq(table.id,entryId)).limit(1);if(!entry){return c.json({error:"Staff entry not found"},404)}if(entry.protected){throw new HTTPException(403,{message:"Forbidden"})}const currentUser=c.get("admin")?.user;const currentUserRoleIds=currentUser?await getUserRoleIds(c,currentUser):[];const isSelf=currentUser!=null&&(entry.userId!=null&&entry.userId===currentUser.id||entry.roleId!=null&&currentUserRoleIds.includes(entry.roleId));if(isSelf){throw new HTTPException(403,{message:"You cannot edit your own staff permissions."})}const allowed=new Set;const dependencies=new Map;for(const plugin of c.get("core").permissionStaff){for(const[module,modulePermissions]of Object.entries(plugin[type])){for(const entry of modulePermissions){const key=staffPermissionKey({plugin:plugin.pluginId,module,permission:entry.permission});allowed.add(key);dependencies.set(key,entry.dependsOn.map(dependency=>staffPermissionKey({plugin:plugin.pluginId,module,permission:dependency})))}}}const seen=new Set;const granted=new Map;if(!unrestricted){for(const permission of permissions){const key=staffPermissionKey(permission);if(!allowed.has(key)||seen.has(key))continue;seen.add(key);granted.set(key,permission)}let changed=true;while(changed){changed=false;for(const key of granted.keys()){const deps=dependencies.get(key)??[];if(deps.some(dependency=>!granted.has(dependency))){granted.delete(key);changed=true}}}}const sanitized=[...granted.values()];const[updated]=await c.get("db").update(table).set({unrestricted,permissions:sanitized}).where(eq(table.id,entryId)).returning({id:table.id});if(!updated){return c.json({error:"Staff entry not found"},404)}return c.json({unrestricted,permissions:sanitized},200)}});

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

@@ -1 +1 @@
-{"version":3,"file":"update.route.d.ts","sourceRoot":"","sources":["../../../../../../../src/api/modules/admin/users/routes/update.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AAetC,eAAO,MAAM,wBAAwB;;;;;;iBA0BjC,CAAC;AAEL,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqN/B,CAAC"}
+{"version":3,"file":"update.route.d.ts","sourceRoot":"","sources":["../../../../../../../src/api/modules/admin/users/routes/update.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AAetC,eAAO,MAAM,wBAAwB;;;;;;iBA0BjC,CAAC;AAEL,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkO/B,CAAC"}

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

@@ -1 +1 @@
-import{z}from"@hono/zod-openapi";import{and,eq,inArray,ne}from"drizzle-orm";import{buildRoute}from"../../../../lib/route.js";import{CONFIG_PLUGIN}from"../../../../../config.js";import{core_roles}from"../../../../../database/roles.js";import{core_users,core_users_secondary_roles}from"../../../../../database/users.js";import{assertCanAssignPrimaryRole,assertCanEditAdminTarget}from"../lib/assert-edit-user-permission.js";const nameRegex=/^(?!.* {2})[\p{L}\p{N}._@ -]*$/u;export const zodUpdateUserAdminSchema=z.object({email:z.email().toLowerCase().openapi({example:"test@test.com"}),name:z.string().min(3).refine(val=>nameRegex.test(val),{message:"Invalid name"}).openapi({example:"test"}),nameCode:z.string().min(3).max(255).regex(/^[a-zA-Z0-9-]+$/,{message:"Invalid name code"}).openapi({example:"test"}),roleId:z.number().int().positive().openapi({example:1}),secondaryRoleIds:z.array(z.number().int().positive()).openapi({example:[2,3]})}).partial().refine(body=>Object.values(body).some(value=>value!==undefined),{message:"At least one field is required"});export const updateUserAdminRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,adminStaffPermission:{module:"users",permission:"can_edit"},route:{method:"patch",description:"Update a user's name or email by id (Admin only)",path:"/{id}",request:{params:z.object({id:z.string().openapi({example:"1"})}),body:{required:true,content:{"application/json":{schema:zodUpdateUserAdminSchema}}}},responses:{200:{content:{"application/json":{schema:z.object({id:z.number(),name:z.string(),email:z.email(),nameCode:z.string()})}},description:"User updated"},400:{content:{"application/json":{schema:z.object({error:z.string()})}},description:"Invalid role"},403:{description:"Access Denied"},404:{content:{"application/json":{schema:z.object({error:z.string()})}},description:"User not found"},409:{content:{"application/json":{schema:z.object({error:z.string()})}},description:"Email or name already exists"}}},handler:async c=>{const{id}=c.req.valid("param");const body=c.req.valid("json");const db=c.get("db");const userId=Number(id);if(!Number.isInteger(userId)){return c.json({error:"User not found"},404)}const[user]=await db.select({id:core_users.id,roleId:core_users.roleId}).from(core_users).where(eq(core_users.id,userId)).limit(1);if(!user){return c.json({error:"User not found"},404)}await assertCanEditAdminTarget(c,userId);const values={};if(body.email!==undefined){const[existing]=await db.select({id:core_users.id}).from(core_users).where(and(eq(core_users.email,body.email),ne(core_users.id,user.id))).limit(1);if(existing){return c.json({error:"Email already exists"},409)}values.email=body.email}if(body.name!==undefined){const[existing]=await db.select({id:core_users.id}).from(core_users).where(and(eq(core_users.name,body.name),ne(core_users.id,user.id))).limit(1);if(existing){return c.json({error:"Name already exists"},409)}values.name=body.name}if(body.nameCode!==undefined){const[existing]=await db.select({id:core_users.id}).from(core_users).where(and(eq(core_users.nameCode,body.nameCode),ne(core_users.id,user.id))).limit(1);if(existing){return c.json({error:"Name code already exists"},409)}values.nameCode=body.nameCode}const effectivePrimaryId=body.roleId??user.roleId;const secondaryRoleIds=body.secondaryRoleIds!==undefined?[...new Set(body.secondaryRoleIds)].filter(id=>id!==effectivePrimaryId):undefined;const roleIdsToValidate=[...body.roleId!==undefined?[body.roleId]:[],...secondaryRoleIds??[]];if(roleIdsToValidate.length>0){const existingRoles=await db.select({id:core_roles.id,guest:core_roles.guest}).from(core_roles).where(inArray(core_roles.id,roleIdsToValidate));const assignableRoleIds=new Set(existingRoles.filter(role=>!role.guest).map(role=>role.id));if(roleIdsToValidate.some(id=>!assignableRoleIds.has(id))){return c.json({error:"Invalid role"},400)}}if(body.roleId!==undefined){await assertCanAssignPrimaryRole(c,body.roleId);values.roleId=body.roleId}if(secondaryRoleIds!==undefined){await db.delete(core_users_secondary_roles).where(eq(core_users_secondary_roles.userId,user.id));if(secondaryRoleIds.length>0){await db.insert(core_users_secondary_roles).values(secondaryRoleIds.map(roleId=>({userId:user.id,roleId})))}}if(Object.keys(values).length>0){const[updated]=await db.update(core_users).set(values).where(eq(core_users.id,user.id)).returning({id:core_users.id,name:core_users.name,email:core_users.email,nameCode:core_users.nameCode});return c.json(updated,200)}const[current]=await db.select({id:core_users.id,name:core_users.name,email:core_users.email,nameCode:core_users.nameCode}).from(core_users).where(eq(core_users.id,user.id)).limit(1);return c.json(current,200)}});
+import{z}from"@hono/zod-openapi";import{and,eq,inArray,ne}from"drizzle-orm";import{buildRoute}from"../../../../lib/route.js";import{CONFIG_PLUGIN}from"../../../../../config.js";import{core_roles}from"../../../../../database/roles.js";import{core_users,core_users_secondary_roles}from"../../../../../database/users.js";import{assertCanAssignPrimaryRole,assertCanEditAdminTarget}from"../lib/assert-edit-user-permission.js";const nameRegex=/^(?!.* {2})[\p{L}\p{N}._@ -]*$/u;export const zodUpdateUserAdminSchema=z.object({email:z.email().toLowerCase().openapi({example:"test@test.com"}),name:z.string().min(3).refine(val=>nameRegex.test(val),{message:"Invalid name"}).openapi({example:"test"}),nameCode:z.string().min(3).max(255).regex(/^[a-zA-Z0-9-]+$/,{message:"Invalid name code"}).openapi({example:"test"}),roleId:z.number().int().positive().openapi({example:1}),secondaryRoleIds:z.array(z.number().int().positive()).openapi({example:[2,3]})}).partial().refine(body=>Object.values(body).some(value=>value!==undefined),{message:"At least one field is required"});export const updateUserAdminRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,adminStaffPermission:{module:"users",permission:"can_edit"},route:{method:"patch",description:"Update a user's name or email by id (Admin only)",path:"/{id}",request:{params:z.object({id:z.string().openapi({example:"1"})}),body:{required:true,content:{"application/json":{schema:zodUpdateUserAdminSchema}}}},responses:{200:{content:{"application/json":{schema:z.object({id:z.number(),name:z.string(),email:z.email(),nameCode:z.string()})}},description:"User updated"},400:{content:{"application/json":{schema:z.object({error:z.string()})}},description:"Invalid role"},403:{description:"Access Denied"},404:{content:{"application/json":{schema:z.object({error:z.string()})}},description:"User not found"},409:{content:{"application/json":{schema:z.object({error:z.string()})}},description:"Email or name already exists"}}},handler:async c=>{const{id}=c.req.valid("param");const body=c.req.valid("json");const db=c.get("db");const userId=Number(id);if(!Number.isInteger(userId)){return c.json({error:"User not found"},404)}const[user]=await db.select({id:core_users.id,roleId:core_users.roleId}).from(core_users).where(eq(core_users.id,userId)).limit(1);if(!user){return c.json({error:"User not found"},404)}await assertCanEditAdminTarget(c,userId);const values={};if(body.email!==undefined){const[existing]=await db.select({id:core_users.id}).from(core_users).where(and(eq(core_users.email,body.email),ne(core_users.id,user.id))).limit(1);if(existing){return c.json({error:"Email already exists"},409)}values.email=body.email}if(body.name!==undefined){const[existing]=await db.select({id:core_users.id}).from(core_users).where(and(eq(core_users.name,body.name),ne(core_users.id,user.id))).limit(1);if(existing){return c.json({error:"Name already exists"},409)}values.name=body.name}if(body.nameCode!==undefined){const[existing]=await db.select({id:core_users.id}).from(core_users).where(and(eq(core_users.nameCode,body.nameCode),ne(core_users.id,user.id))).limit(1);if(existing){return c.json({error:"Name code already exists"},409)}values.nameCode=body.nameCode}const effectivePrimaryId=body.roleId??user.roleId;const secondaryRoleIds=body.secondaryRoleIds!==undefined?[...new Set(body.secondaryRoleIds)].filter(id=>id!==effectivePrimaryId):undefined;const roleIdsToValidate=[...body.roleId!==undefined?[body.roleId]:[],...secondaryRoleIds??[]];if(roleIdsToValidate.length>0){const existingRoles=await db.select({id:core_roles.id,guest:core_roles.guest}).from(core_roles).where(inArray(core_roles.id,roleIdsToValidate));const assignableRoleIds=new Set(existingRoles.filter(role=>!role.guest).map(role=>role.id));if(roleIdsToValidate.some(id=>!assignableRoleIds.has(id))){return c.json({error:"Invalid role"},400)}}if(body.roleId!==undefined){await assertCanAssignPrimaryRole(c,body.roleId);values.roleId=body.roleId}if(secondaryRoleIds!==undefined){await db.delete(core_users_secondary_roles).where(eq(core_users_secondary_roles.userId,user.id));if(secondaryRoleIds.length>0){await db.insert(core_users_secondary_roles).values(secondaryRoleIds.map(roleId=>({userId:user.id,roleId})))}}if(Object.keys(values).length>0){const[updated]=await db.update(core_users).set(values).where(eq(core_users.id,user.id)).returning({id:core_users.id,name:core_users.name,email:core_users.email,nameCode:core_users.nameCode});await c.get("events").emit("user.updated",{userId:updated.id,email:updated.email,name:updated.name});return c.json(updated,200)}const[current]=await db.select({id:core_users.id,name:core_users.name,email:core_users.email,nameCode:core_users.nameCode}).from(core_users).where(eq(core_users.id,user.id)).limit(1);await c.get("events").emit("user.updated",{userId:current.id,email:current.email,name:current.name});return c.json(current,200)}});

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

@@ -13,9 +13,9 @@ export declare const usersAdminRoute: import("../../../../../api/lib/route").Rou
                 desc: "desc";
             }>>;
             orderBy: z.ZodOptional<z.ZodEnum<{
+                name: "name";
                 id: "id";
                 email: "email";
-                name: "name";
                 createdAt: "createdAt";
             }>>;
         }, z.core.$strip>;

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

@@ -0,0 +1,4 @@
+import type { drizzle } from "drizzle-orm/postgres-js";
+import type { CronJobConfig } from "../../../../api/lib/cron";
+export declare function registerCronJobs(db: ReturnType<typeof drizzle>, cronJobs: CronJobConfig[]): Promise<void>;
+//# sourceMappingURL=register-cron-jobs.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"register-cron-jobs.d.ts","sourceRoot":"","sources":["../../../../../../src/api/modules/cron/helpers/register-cron-jobs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAC;AAEvD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAUpD,wBAAsB,gBAAgB,CACpC,EAAE,EAAE,UAAU,CAAC,OAAO,OAAO,CAAC,EAC9B,QAAQ,EAAE,aAAa,EAAE,iBAsB1B"}

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

@@ -0,0 +1 @@
+import{core_cron}from"../../../../database/cron.js";import{cleanupOutdatedCronJobs,processCronJobs,updateCronJobs}from"./process-cron-jobs.js";export async function registerCronJobs(db,cronJobs){const cronFromDb=await db.select().from(core_cron);await cleanupOutdatedCronJobs(db,cronFromDb,cronJobs);const{newJobs,jobsToUpdate}=processCronJobs(cronJobs,cronFromDb);if(newJobs.length>0){await db.insert(core_cron).values(newJobs.map(job=>({name:job.name,description:job.description??null,lastRun:null,nextRun:null,pluginId:job.pluginId,module:job.module,schedule:job.schedule})))}await updateCronJobs(db,jobsToUpdate)}

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

@@ -0,0 +1,91 @@
+import { z } from "@hono/zod-openapi";
+export declare const zodSearchHitSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    pluginId: z.ZodString;
+    itemType: z.ZodString;
+    itemId: z.ZodNumber;
+    languageCode: z.ZodString;
+    authorId: z.ZodNullable<z.ZodNumber>;
+    title: z.ZodString;
+    content: z.ZodString;
+    containerType: z.ZodNullable<z.ZodString>;
+    containerId: z.ZodNullable<z.ZodNumber>;
+    url: z.ZodNullable<z.ZodString>;
+    metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    createdAt: z.ZodDate;
+    score: z.ZodNullable<z.ZodNumber>;
+    author: z.ZodNullable<z.ZodObject<{
+        id: z.ZodNumber;
+        name: z.ZodString;
+        nameCode: z.ZodString;
+        avatarColor: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const searchRoute: import("../../../lib/route").Route<"@vitnode/core", {
+    method: "get";
+    description: string;
+    path: "/";
+    request: {
+        query: z.ZodObject<{
+            cursor: z.ZodOptional<z.ZodString>;
+            first: z.ZodOptional<z.ZodString>;
+            last: z.ZodOptional<z.ZodString>;
+            search: z.ZodOptional<z.ZodString>;
+            types: z.ZodOptional<z.ZodString>;
+            authorId: z.ZodOptional<z.ZodString>;
+            containerId: z.ZodOptional<z.ZodString>;
+            sort: z.ZodOptional<z.ZodEnum<{
+                newest: "newest";
+                oldest: "oldest";
+                relevance: "relevance";
+            }>>;
+            from: z.ZodOptional<z.ZodString>;
+            to: z.ZodOptional<z.ZodString>;
+            lang: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    };
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        edges: z.ZodArray<z.ZodObject<{
+                            id: z.ZodNumber;
+                            pluginId: z.ZodString;
+                            itemType: z.ZodString;
+                            itemId: z.ZodNumber;
+                            languageCode: z.ZodString;
+                            authorId: z.ZodNullable<z.ZodNumber>;
+                            title: z.ZodString;
+                            content: z.ZodString;
+                            containerType: z.ZodNullable<z.ZodString>;
+                            containerId: z.ZodNullable<z.ZodNumber>;
+                            url: z.ZodNullable<z.ZodString>;
+                            metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                            createdAt: z.ZodDate;
+                            score: z.ZodNullable<z.ZodNumber>;
+                            author: z.ZodNullable<z.ZodObject<{
+                                id: z.ZodNumber;
+                                name: z.ZodString;
+                                nameCode: z.ZodString;
+                                avatarColor: z.ZodString;
+                            }, z.core.$strip>>;
+                        }, 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;
+        };
+    };
+} & {
+    path: string;
+}>;
+//# sourceMappingURL=search.route.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"search.route.d.ts","sourceRoot":"","sources":["../../../../../../src/api/modules/search/routes/search.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AAUtC,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;iBAuB7B,CAAC;AAEH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqDtB,CAAC"}

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

@@ -0,0 +1 @@
+import{z}from"@hono/zod-openapi";import{CONFIG_PLUGIN}from"../../../../config.js";import{buildRoute}from"../../../lib/route.js";import{zodPaginationPageInfo,zodPaginationQuery}from"../../../lib/with-pagination.js";export const zodSearchHitSchema=z.object({id:z.number(),pluginId:z.string(),itemType:z.string(),itemId:z.number(),languageCode:z.string(),authorId:z.number().nullable(),title:z.string(),content:z.string(),containerType:z.string().nullable(),containerId:z.number().nullable(),url:z.string().nullable(),metadata:z.record(z.string(),z.unknown()),createdAt:z.date(),score:z.number().nullable(),author:z.object({id:z.number(),name:z.string(),nameCode:z.string(),avatarColor:z.string()}).nullable()});export const searchRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,route:{method:"get",description:"Search and browse indexed community content.",path:"/",request:{query:zodPaginationQuery.extend({search:z.string().optional(),types:z.string().optional(),authorId:z.string().optional(),containerId:z.string().optional(),sort:z.enum(["newest","oldest","relevance"]).optional(),from:z.string().optional(),to:z.string().optional(),lang:z.string().optional()})},responses:{200:{content:{"application/json":{schema:z.object({edges:z.array(zodSearchHitSchema),pageInfo:zodPaginationPageInfo})}},description:"Search results"}}},handler:async c=>{const query=c.req.valid("query");const result=await c.get("search").search({term:query.search,itemTypes:query.types?query.types.split(",").filter(Boolean):undefined,authorId:query.authorId?Number(query.authorId):undefined,containerId:query.containerId?Number(query.containerId):undefined,sort:query.sort,dateFrom:query.from?new Date(query.from):undefined,dateTo:query.to?new Date(query.to):undefined,first:query.first?Number(query.first):undefined,cursor:query.cursor,languageCode:query.lang,includePrivate:false});return c.json(result)}});

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

@@ -0,0 +1,68 @@
+export declare const searchModule: import("../../../api/lib/module").BuildModuleReturn<"@vitnode/core", "search", [import("../../lib/route").Route<"@vitnode/core", {
+    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>;
+            search: import("zod").ZodOptional<import("zod").ZodString>;
+            types: import("zod").ZodOptional<import("zod").ZodString>;
+            authorId: import("zod").ZodOptional<import("zod").ZodString>;
+            containerId: import("zod").ZodOptional<import("zod").ZodString>;
+            sort: import("zod").ZodOptional<import("zod").ZodEnum<{
+                newest: "newest";
+                oldest: "oldest";
+                relevance: "relevance";
+            }>>;
+            from: import("zod").ZodOptional<import("zod").ZodString>;
+            to: import("zod").ZodOptional<import("zod").ZodString>;
+            lang: import("zod").ZodOptional<import("zod").ZodString>;
+        }, 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;
+                            pluginId: import("zod").ZodString;
+                            itemType: import("zod").ZodString;
+                            itemId: import("zod").ZodNumber;
+                            languageCode: import("zod").ZodString;
+                            authorId: import("zod").ZodNullable<import("zod").ZodNumber>;
+                            title: import("zod").ZodString;
+                            content: import("zod").ZodString;
+                            containerType: import("zod").ZodNullable<import("zod").ZodString>;
+                            containerId: import("zod").ZodNullable<import("zod").ZodNumber>;
+                            url: import("zod").ZodNullable<import("zod").ZodString>;
+                            metadata: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+                            createdAt: import("zod").ZodDate;
+                            score: import("zod").ZodNullable<import("zod").ZodNumber>;
+                            author: import("zod").ZodNullable<import("zod").ZodObject<{
+                                id: import("zod").ZodNumber;
+                                name: import("zod").ZodString;
+                                nameCode: import("zod").ZodString;
+                                avatarColor: import("zod").ZodString;
+                            }, import("zod/v4/core").$strip>>;
+                        }, 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;
+        };
+    };
+} & {
+    path: string;
+}>], import("../../../api/lib/module").BaseBuildModuleReturn<"@vitnode/core", string, import("../../lib/route").Route<"@vitnode/core", import("@hono/zod-openapi").RouteConfig>[]>[]>;
+//# sourceMappingURL=search.module.d.ts.map

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

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

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

@@ -0,0 +1 @@
+import{buildModule}from"../../lib/module.js";import{CONFIG_PLUGIN}from"../../../config.js";import{searchRoute}from"./routes/search.route.js";import{rebuildSearchIndexTask}from"./tasks/rebuild-index.task.js";export const searchModule=buildModule({pluginId:CONFIG_PLUGIN.pluginId,name:"search",routes:[searchRoute],queueTasks:[rebuildSearchIndexTask]});

package/dist/src/api/modules/search/tasks/rebuild-index.task.d.ts

@@ -0,0 +1,2 @@
+export declare const rebuildSearchIndexTask: import("../../../../api/lib/queue").BuildQueueTaskReturn;
+//# sourceMappingURL=rebuild-index.task.d.ts.map

package/dist/src/api/modules/search/tasks/rebuild-index.task.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rebuild-index.task.d.ts","sourceRoot":"","sources":["../../../../../../src/api/modules/search/tasks/rebuild-index.task.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,sBAAsB,gDA+BjC,CAAC"}

package/dist/src/api/modules/search/tasks/rebuild-index.task.js

@@ -0,0 +1 @@
+import{buildQueueTask}from"../../../lib/queue.js";const PAGE_SIZE=200;export const rebuildSearchIndexTask=buildQueueTask({name:"rebuild-search-index",description:"Clear and rebuild the content search index. With no `itemType` payload it rebuilds every registered indexer; with one it rebuilds just that collection.",handler:async(c,payload)=>{const search=c.get("search");const itemType=typeof payload.itemType==="string"?payload.itemType:undefined;const indexers=c.get("core").searchIndexers.filter(indexer=>!itemType||indexer.itemType===itemType);await search.clear(itemType);for(const indexer of indexers){for(let page=0;;page++){const docs=await indexer.load(c,page*PAGE_SIZE,PAGE_SIZE);if(docs.length===0)break;await search.bulkIndex(docs)}}}});

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

@@ -0,0 +1,124 @@
+export declare const userFilesModule: import("../../../../api/lib/module").BuildModuleReturn<"@vitnode/core", "files", [import("../../../lib/route").Route<"@vitnode/core", {
+    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<{
+                name: "name";
+                createdAt: "createdAt";
+                size: "size";
+            }>>;
+            search: import("zod").ZodOptional<import("zod").ZodString>;
+        }, 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;
+                            name: import("zod").ZodString;
+                            folder: import("zod").ZodString;
+                            mimeType: import("zod").ZodNullable<import("zod").ZodString>;
+                            size: import("zod").ZodNumber;
+                            metadata: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+                            createdAt: import("zod").ZodDate;
+                            dimensions: import("zod").ZodNullable<import("zod").ZodObject<{
+                                width: import("zod").ZodNumber;
+                                height: import("zod").ZodNumber;
+                            }, import("zod/v4/core").$strip>>;
+                            url: import("zod").ZodNullable<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;
+        };
+        401: {
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>, import("../../../lib/route").Route<"@vitnode/core", {
+    method: "get";
+    description: string;
+    path: "/{id}/download";
+    request: {
+        params: import("zod").ZodObject<{
+            id: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+    };
+    responses: {
+        200: {
+            content: {
+                "application/octet-stream": {
+                    schema: import("zod").ZodString;
+                };
+            };
+            description: string;
+        };
+        401: {
+            description: string;
+        };
+        404: {
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        error: import("zod").ZodString;
+                    }, import("zod/v4/core").$strip>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>, import("../../../lib/route").Route<"@vitnode/core", {
+    method: "delete";
+    description: string;
+    path: "/{id}";
+    request: {
+        params: import("zod").ZodObject<{
+            id: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+    };
+    responses: {
+        200: {
+            description: string;
+        };
+        401: {
+            description: string;
+        };
+        404: {
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        error: 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=files.module.d.ts.map

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

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

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

@@ -0,0 +1 @@
+import{buildModule}from"../../../lib/module.js";import{CONFIG_PLUGIN}from"../../../../config.js";import{deleteUserFileRoute}from"./routes/delete.route.js";import{downloadUserFileRoute}from"./routes/download.route.js";import{listUserFilesRoute}from"./routes/list.route.js";export const userFilesModule=buildModule({pluginId:CONFIG_PLUGIN.pluginId,name:"files",routes:[listUserFilesRoute,downloadUserFileRoute,deleteUserFileRoute]});

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

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

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

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

package/dist/src/api/modules/users/files/routes/delete.route.js

@@ -0,0 +1 @@
+import{z}from"@hono/zod-openapi";import{HTTPException}from"hono/http-exception";import{buildRoute}from"../../../../lib/route.js";import{CONFIG_PLUGIN}from"../../../../../config.js";export const deleteUserFileRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,route:{method:"delete",description:"Delete one of the current user's files.",path:"/{id}",request:{params:z.object({id:z.string().openapi({example:"1"})})},responses:{200:{description:"File deleted"},401:{description:"Not signed in"},404:{content:{"application/json":{schema:z.object({error:z.string()})}},description:"File not found"}}},handler:async c=>{const user=c.get("user");if(!user){throw new HTTPException(401,{message:"Unauthorized"})}const{id}=c.req.valid("param");const fileId=Number(id);if(!Number.isInteger(fileId)){return c.json({error:"File not found"},404)}await c.get("storage").deleteFile(fileId,user.id);return c.body(null,200)}});

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

@@ -0,0 +1,37 @@
+import { z } from "@hono/zod-openapi";
+export declare const downloadUserFileRoute: import("../../../../../api/lib/route").Route<"@vitnode/core", {
+    method: "get";
+    description: string;
+    path: "/{id}/download";
+    request: {
+        params: z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$strip>;
+    };
+    responses: {
+        200: {
+            content: {
+                "application/octet-stream": {
+                    schema: z.ZodString;
+                };
+            };
+            description: string;
+        };
+        401: {
+            description: string;
+        };
+        404: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        error: z.ZodString;
+                    }, z.core.$strip>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>;
+//# sourceMappingURL=download.route.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"download.route.d.ts","sourceRoot":"","sources":["../../../../../../../src/api/modules/users/files/routes/download.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AAQtC,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8EhC,CAAC"}

package/dist/src/api/modules/users/files/routes/download.route.js

@@ -0,0 +1 @@
+import{z}from"@hono/zod-openapi";import{and,eq}from"drizzle-orm";import{HTTPException}from"hono/http-exception";import{buildRoute}from"../../../../lib/route.js";import{CONFIG_PLUGIN}from"../../../../../config.js";import{core_files}from"../../../../../database/files.js";export const downloadUserFileRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,route:{method:"get",description:"Download one of the current user's files as an attachment with its original name.",path:"/{id}/download",request:{params:z.object({id:z.string().openapi({example:"1"})})},responses:{200:{content:{"application/octet-stream":{schema:z.string().openapi({format:"binary",type:"string"})}},description:"File contents"},401:{description:"Not signed in"},404:{content:{"application/json":{schema:z.object({error:z.string()})}},description:"File not found"}}},handler:async c=>{const user=c.get("user");if(!user){throw new HTTPException(401,{message:"Unauthorized"})}const{id}=c.req.valid("param");const fileId=Number(id);if(!Number.isInteger(fileId)){return c.json({error:"File not found"},404)}const[file]=await c.get("db").select({name:core_files.name,key:core_files.key,mimeType:core_files.mimeType}).from(core_files).where(and(eq(core_files.id,fileId),eq(core_files.userId,user.id))).limit(1);if(!file||!c.get("core").storage?.adapter){return c.json({error:"File not found"},404)}const upstream=await fetch(c.get("storage").getUrl(file.key));if(!upstream.ok||!upstream.body){return c.json({error:"File not found"},404)}c.header("Content-Type",file.mimeType??"application/octet-stream");c.header("Content-Disposition",`attachment; filename*=UTF-8''${encodeURIComponent(file.name)}`);const length=upstream.headers.get("content-length");if(length){c.header("Content-Length",length)}return c.body(upstream.body,200)}});

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

@@ -0,0 +1,62 @@
+import z from "zod";
+export declare const listUserFilesRoute: import("../../../../../api/lib/route").Route<"@vitnode/core", {
+    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<{
+                name: "name";
+                createdAt: "createdAt";
+                size: "size";
+            }>>;
+            search: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    };
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        edges: z.ZodArray<z.ZodObject<{
+                            id: z.ZodNumber;
+                            name: z.ZodString;
+                            folder: z.ZodString;
+                            mimeType: z.ZodNullable<z.ZodString>;
+                            size: z.ZodNumber;
+                            metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                            createdAt: z.ZodDate;
+                            dimensions: z.ZodNullable<z.ZodObject<{
+                                width: z.ZodNumber;
+                                height: z.ZodNumber;
+                            }, z.core.$strip>>;
+                            url: z.ZodNullable<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;
+        };
+        401: {
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>;
+//# sourceMappingURL=list.route.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"list.route.d.ts","sourceRoot":"","sources":["../../../../../../../src/api/modules/users/files/routes/list.route.ts"],"names":[],"mappings":"AAEA,OAAO,CAAC,MAAM,KAAK,CAAC;AAYpB,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+F7B,CAAC"}

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

@@ -0,0 +1 @@
+import{eq}from"drizzle-orm";import{HTTPException}from"hono/http-exception";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_files}from"../../../../../database/files.js";import{parseImageDimensions}from"../../../../../lib/api/upload.js";export const listUserFilesRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,route:{method:"get",description:"List files uploaded by the current user.",path:"/",request:{query:zodPaginationQuery.extend({order:z.enum(["asc","desc"]).optional(),orderBy:z.enum(["name","size","createdAt"]).optional(),search:z.string().optional()})},responses:{200:{content:{"application/json":{schema:z.object({edges:z.array(z.object({id:z.number(),name:z.string(),folder:z.string(),mimeType:z.string().nullable(),size:z.number(),metadata:z.record(z.string(),z.unknown()),createdAt:z.date(),dimensions:z.object({width:z.number(),height:z.number()}).nullable(),url:z.string().nullable()})),pageInfo:zodPaginationPageInfo})}},description:"List of the current user's files"},401:{description:"Not signed in"}}},handler:async c=>{const user=c.get("user");if(!user){throw new HTTPException(401,{message:"Unauthorized"})}const query=c.req.valid("query");const hasAdapter=!!c.get("core").storage?.adapter;const storage=c.get("storage");const data=await withPagination({params:{query},c,primaryCursor:core_files.id,search:[core_files.name],where:eq(core_files.userId,user.id),query:async({limit,where,orderBy})=>await c.get("db").select({id:core_files.id,name:core_files.name,key:core_files.key,folder:core_files.folder,mimeType:core_files.mimeType,size:core_files.size,metadata:core_files.metadata,createdAt:core_files.createdAt}).from(core_files).where(where).orderBy(orderBy).limit(limit),table:core_files,orderBy:{column:query.orderBy?core_files[query.orderBy]:core_files.createdAt,order:query.order??"desc"}});return c.json({...data,edges:data.edges.map(({key,...file})=>({...file,url:hasAdapter?storage.getUrl(key):null,dimensions:parseImageDimensions(file.metadata)}))})}});