@vitnode/core 1.2.0-canary.78 → 2.0.0-canary.2

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

@@ -8,13 +8,13 @@ export declare const filesAdminModule: import("../../../../api/lib/module").Buil
             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";
+                asc: "asc";
             }>>;
             orderBy: import("zod").ZodOptional<import("zod").ZodEnum<{
-                name: "name";
                 createdAt: "createdAt";
                 size: "size";
+                name: "name";
             }>>;
             search: import("zod").ZodOptional<import("zod").ZodString>;
         }, import("zod/v4/core").$strip>;
@@ -56,8 +56,8 @@ export declare const filesAdminModule: import("../../../../api/lib/module").Buil
                             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>;
+                            startCursor: import("zod").ZodNullable<import("zod").ZodString>;
+                            endCursor: import("zod").ZodNullable<import("zod").ZodString>;
                         }, import("zod/v4/core").$strip>;
                     }, import("zod/v4/core").$strip>;
                 };
@@ -106,6 +106,12 @@ export declare const filesAdminModule: import("../../../../api/lib/module").Buil
         params: import("zod").ZodObject<{
             id: import("zod").ZodString;
         }, import("zod/v4/core").$strip>;
+        query: import("zod").ZodObject<{
+            force: import("zod").ZodOptional<import("zod").ZodEnum<{
+                true: "true";
+                false: "false";
+            }>>;
+        }, import("zod/v4/core").$strip>;
     };
     responses: {
         200: {
@@ -121,6 +127,19 @@ export declare const filesAdminModule: import("../../../../api/lib/module").Buil
             };
             description: string;
         };
+        409: {
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        code: import("zod").ZodString;
+                        content: import("zod").ZodBoolean;
+                        id: import("zod").ZodNumber;
+                        revisions: import("zod").ZodNumber;
+                    }, import("zod/v4/core").$strip>;
+                };
+            };
+            description: string;
+        };
     };
 } & {
     path: string;

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

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

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

@@ -7,6 +7,12 @@ export declare const deleteFileAdminRoute: import("../../../../../api/lib/route"
         params: z.ZodObject<{
             id: z.ZodString;
         }, z.core.$strip>;
+        query: z.ZodObject<{
+            force: z.ZodOptional<z.ZodEnum<{
+                true: "true";
+                false: "false";
+            }>>;
+        }, z.core.$strip>;
     };
     responses: {
         200: {
@@ -22,6 +28,19 @@ export declare const deleteFileAdminRoute: import("../../../../../api/lib/route"
             };
             description: string;
         };
+        409: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        code: z.ZodString;
+                        content: z.ZodBoolean;
+                        id: z.ZodNumber;
+                        revisions: z.ZodNumber;
+                    }, z.core.$strip>;
+                };
+            };
+            description: string;
+        };
     };
 } & {
     path: string;

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

@@ -1 +1 @@
-{"version":3,"file":"delete.route.d.ts","sourceRoot":"","sources":["../../../../../../../src/api/modules/admin/files/routes/delete.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AAKtC,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;EAqC/B,CAAC"}
+{"version":3,"file":"delete.route.d.ts","sourceRoot":"","sources":["../../../../../../../src/api/modules/admin/files/routes/delete.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AAKtC,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgE/B,CAAC"}

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

@@ -1 +1 @@
-import{z}from"@hono/zod-openapi";import{buildRoute}from"../../../../lib/route.js";import{CONFIG_PLUGIN}from"../../../../../config.js";export const deleteFileAdminRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,adminStaffPermission:{module:"files",permission:"can_delete"},route:{method:"delete",description:"Delete an uploaded file and its record (Admin only).",path:"/{id}",request:{params:z.object({id:z.string().openapi({example:"1"})})},responses:{200:{description:"File deleted"},404:{content:{"application/json":{schema:z.object({error:z.string()})}},description:"File not found"}}},handler:async c=>{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);return c.body(null,200)}});
+import{z}from"@hono/zod-openapi";import{buildRoute}from"../../../../lib/route.js";import{CONFIG_PLUGIN}from"../../../../../config.js";export const deleteFileAdminRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,adminStaffPermission:{module:"files",permission:"can_delete"},route:{method:"delete",description:"Delete an uploaded file and its record (Admin only).",path:"/{id}",request:{params:z.object({id:z.string().openapi({example:"1"})}),query:z.object({force:z.enum(["true","false"]).optional()})},responses:{200:{description:"File deleted"},404:{content:{"application/json":{schema:z.object({error:z.string()})}},description:"File not found"},409:{content:{"application/json":{schema:z.object({code:z.string(),content:z.boolean(),id:z.number(),revisions:z.number()})}},description:"Still referenced by content or by a retained revision, so the file was kept"}}},handler:async c=>{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,{force:c.req.query("force")==="true"});return c.body(null,200)}});

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

@@ -9,13 +9,13 @@ export declare const listFilesAdminRoute: import("../../../../../api/lib/route")
             first: z.ZodOptional<z.ZodString>;
             last: z.ZodOptional<z.ZodString>;
             order: z.ZodOptional<z.ZodEnum<{
-                asc: "asc";
                 desc: "desc";
+                asc: "asc";
             }>>;
             orderBy: z.ZodOptional<z.ZodEnum<{
-                name: "name";
                 createdAt: "createdAt";
                 size: "size";
+                name: "name";
             }>>;
             search: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>;
@@ -57,8 +57,8 @@ export declare const listFilesAdminRoute: import("../../../../../api/lib/route")
                             count: z.ZodNumber;
                             hasNextPage: z.ZodBoolean;
                             hasPreviousPage: z.ZodBoolean;
-                            startCursor: z.ZodNullable<z.ZodNumber>;
-                            endCursor: z.ZodNullable<z.ZodNumber>;
+                            startCursor: z.ZodNullable<z.ZodString>;
+                            endCursor: z.ZodNullable<z.ZodString>;
                         }, z.core.$strip>;
                     }, z.core.$strip>;
                 };

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

@@ -1 +1 @@
-{"version":3,"file":"list.route.d.ts","sourceRoot":"","sources":["../../../../../../../src/api/modules/admin/files/routes/list.route.ts"],"names":[],"mappings":"AACA,OAAO,CAAC,MAAM,KAAK,CAAC;AAepB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuJ9B,CAAC"}
+{"version":3,"file":"list.route.d.ts","sourceRoot":"","sources":["../../../../../../../src/api/modules/admin/files/routes/list.route.ts"],"names":[],"mappings":"AACA,OAAO,CAAC,MAAM,KAAK,CAAC;AAepB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwJ9B,CAAC"}

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

@@ -1 +1 @@
-import{eq}from"drizzle-orm";import z from"zod";import{resolveRoleNames}from"../../../../lib/resolve-role-names.js";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{core_roles}from"../../../../../database/roles.js";import{core_users}from"../../../../../database/users.js";import{parseImageDimensions}from"../../../../../lib/api/upload.js";export const listFilesAdminRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,adminStaffPermission:{module:"files",permission:"can_view"},route:{method:"get",description:"List uploaded files stored in core_files (Admin only).",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(),user:z.object({id:z.number(),name:z.string(),nameCode:z.string(),role:z.object({id:z.number(),color:z.string().nullable(),name:z.array(z.object({name:z.string(),languageCode:z.string()}))})}).nullable(),url:z.string().nullable()})),pageInfo:zodPaginationPageInfo})}},description:"List of uploaded files"}}},handler:async c=>{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],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,userId:core_files.userId,userName:core_users.name,userNameCode:core_users.nameCode,userRoleId:core_users.roleId,userRoleColor:core_roles.color}).from(core_files).leftJoin(core_users,eq(core_users.id,core_files.userId)).leftJoin(core_roles,eq(core_roles.id,core_users.roleId)).where(where).orderBy(orderBy).limit(limit),table:core_files,orderBy:{column:query.orderBy?core_files[query.orderBy]:core_files.createdAt,order:query.order??"desc"}});const roleNames=await resolveRoleNames(c,data.edges.map(edge=>edge.userRoleId).filter(id=>id!=null));return c.json({...data,edges:data.edges.map(({key,userId,userName,userNameCode,userRoleId,userRoleColor,...file})=>({...file,url:hasAdapter?storage.getUrl(key):null,dimensions:parseImageDimensions(file.metadata),user:userId!=null&&userName!=null?{id:userId,name:userName,nameCode:userNameCode??"",role:{id:userRoleId??0,color:userRoleColor??null,name:userRoleId!=null?roleNames.get(userRoleId)??[]:[]}}:null}))})}});
+import{eq}from"drizzle-orm";import z from"zod";import{resolveRoleNames}from"../../../../lib/resolve-role-names.js";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{core_roles}from"../../../../../database/roles.js";import{core_users}from"../../../../../database/users.js";import{parseImageDimensions}from"../../../../../lib/api/upload.js";export const listFilesAdminRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,adminStaffPermission:{module:"files",permission:"can_view"},route:{method:"get",description:"List uploaded files stored in core_files (Admin only).",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(),user:z.object({id:z.number(),name:z.string(),nameCode:z.string(),role:z.object({id:z.number(),color:z.string().nullable(),name:z.array(z.object({name:z.string(),languageCode:z.string()}))})}).nullable(),url:z.string().nullable()})),pageInfo:zodPaginationPageInfo})}},description:"List of uploaded files"}}},handler:async c=>{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],query:async({cursorSelection,limit,where,orderBy})=>await c.get("db").select({...cursorSelection,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,userId:core_files.userId,userName:core_users.name,userNameCode:core_users.nameCode,userRoleId:core_users.roleId,userRoleColor:core_roles.color}).from(core_files).leftJoin(core_users,eq(core_users.id,core_files.userId)).leftJoin(core_roles,eq(core_roles.id,core_users.roleId)).where(where).orderBy(orderBy).limit(limit),table:core_files,orderBy:{column:query.orderBy?core_files[query.orderBy]:core_files.createdAt,order:query.order??"desc"}});const roleNames=await resolveRoleNames(c,data.edges.map(edge=>edge.userRoleId).filter(id=>id!=null));return c.json({...data,edges:data.edges.map(({key,userId,userName,userNameCode,userRoleId,userRoleColor,...file})=>({...file,url:hasAdapter?storage.getUrl(key):null,dimensions:parseImageDimensions(file.metadata),user:userId!=null&&userName!=null?{id:userId,name:userName,nameCode:userNameCode??"",role:{id:userRoleId??0,color:userRoleColor??null,name:userRoleId!=null?roleNames.get(userRoleId)??[]:[]}}:null}))})}});

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

@@ -8,8 +8,8 @@ export declare const rolesAdminModule: import("../../../../api/lib/module").Buil
             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";
+                asc: "asc";
             }>>;
             orderBy: import("zod").ZodOptional<import("zod").ZodEnum<{
                 id: "id";
@@ -48,8 +48,8 @@ export declare const rolesAdminModule: import("../../../../api/lib/module").Buil
                             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>;
+                            startCursor: import("zod").ZodNullable<import("zod").ZodString>;
+                            endCursor: import("zod").ZodNullable<import("zod").ZodString>;
                         }, import("zod/v4/core").$strip>;
                     }, import("zod/v4/core").$strip>;
                 };

package/dist/src/api/modules/admin/roles/routes/delete.route.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"delete.route.d.ts","sourceRoot":"","sources":["../../../../../../../src/api/modules/admin/roles/routes/delete.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AAYtC,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqK/B,CAAC"}
+{"version":3,"file":"delete.route.d.ts","sourceRoot":"","sources":["../../../../../../../src/api/modules/admin/roles/routes/delete.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AAatC,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyK/B,CAAC"}

package/dist/src/api/modules/admin/roles/routes/delete.route.js

@@ -1 +1 @@
-import{z}from"@hono/zod-openapi";import{and,count,eq,inArray}from"drizzle-orm";import{buildRoute}from"../../../../lib/route.js";import{assertCanAssignPrimaryRole}from"../../users/lib/assert-edit-user-permission.js";import{CONFIG_PLUGIN}from"../../../../../config.js";import{core_languages_words}from"../../../../../database/languages.js";import{core_roles}from"../../../../../database/roles.js";import{core_users,core_users_secondary_roles}from"../../../../../database/users.js";import{assertCanManageAdminRole}from"../lib/assert-manage-admin-role.js";export const deleteRoleAdminRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,adminStaffPermission:{module:"roles",permission:"can_delete"},route:{method:"delete",description:"Delete a role by id (Admin only)",path:"/{id}",request:{params:z.object({id:z.string().openapi({example:"1"})}),query:z.object({moveToRoleId:z.string().optional()})},responses:{200:{description:"Role deleted"},400:{content:{"application/json":{schema:z.object({error:z.string()})}},description:"Role still has members or an invalid target was given"},403:{content:{"application/json":{schema:z.object({error:z.string()})}},description:"Role cannot be deleted"},404:{content:{"application/json":{schema:z.object({error:z.string()})}},description:"Role not found"}}},handler:async c=>{const{id}=c.req.valid("param");const{moveToRoleId}=c.req.valid("query");const db=c.get("db");const roleId=Number(id);if(!Number.isInteger(roleId)){return c.json({error:"Role not found"},404)}const[role]=await db.select({id:core_roles.id,protected:core_roles.protected,default:core_roles.default,root:core_roles.root,guest:core_roles.guest}).from(core_roles).where(eq(core_roles.id,roleId)).limit(1);if(!role){return c.json({error:"Role not found"},404)}if(role.protected||role.default||role.root||role.guest){return c.json({error:"This role cannot be deleted"},403)}await assertCanManageAdminRole(c,{roleId,permission:"can_delete_admin"});const[{total:usersCount}]=await db.select({total:count()}).from(core_users).where(eq(core_users.roleId,roleId));let targetRoleId=null;if(usersCount>0){if(moveToRoleId===undefined){return c.json({error:"Role has assigned users"},400)}targetRoleId=Number(moveToRoleId);if(!Number.isInteger(targetRoleId)||targetRoleId===roleId){return c.json({error:"Invalid target role"},400)}const[target]=await db.select({id:core_roles.id,guest:core_roles.guest}).from(core_roles).where(eq(core_roles.id,targetRoleId)).limit(1);if(!target||target.guest){return c.json({error:"Invalid target role"},400)}await assertCanAssignPrimaryRole(c,targetRoleId)}await db.transaction(async tx=>{if(targetRoleId!=null){const members=await tx.select({id:core_users.id}).from(core_users).where(eq(core_users.roleId,roleId));const memberIds=members.map(member=>member.id);await tx.update(core_users).set({roleId:targetRoleId}).where(eq(core_users.roleId,roleId));if(memberIds.length>0){await tx.delete(core_users_secondary_roles).where(and(eq(core_users_secondary_roles.roleId,targetRoleId),inArray(core_users_secondary_roles.userId,memberIds)))}}await tx.delete(core_languages_words).where(and(eq(core_languages_words.pluginCode,"core"),eq(core_languages_words.tableName,"core_roles"),eq(core_languages_words.variable,"name"),eq(core_languages_words.itemId,roleId)));await tx.delete(core_roles).where(eq(core_roles.id,roleId))});await c.get("events").emit("role.deleted",{roleId});return c.body(null,200)}});
+import{z}from"@hono/zod-openapi";import{and,count,eq,inArray}from"drizzle-orm";import{buildRoute}from"../../../../lib/route.js";import{invalidateAllStaffPermissions}from"../../../../lib/staff-permission-cache.js";import{assertCanAssignPrimaryRole}from"../../users/lib/assert-edit-user-permission.js";import{CONFIG_PLUGIN}from"../../../../../config.js";import{core_languages_words}from"../../../../../database/languages.js";import{core_roles}from"../../../../../database/roles.js";import{core_users,core_users_secondary_roles}from"../../../../../database/users.js";import{assertCanManageAdminRole}from"../lib/assert-manage-admin-role.js";export const deleteRoleAdminRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,adminStaffPermission:{module:"roles",permission:"can_delete"},route:{method:"delete",description:"Delete a role by id (Admin only)",path:"/{id}",request:{params:z.object({id:z.string().openapi({example:"1"})}),query:z.object({moveToRoleId:z.string().optional()})},responses:{200:{description:"Role deleted"},400:{content:{"application/json":{schema:z.object({error:z.string()})}},description:"Role still has members or an invalid target was given"},403:{content:{"application/json":{schema:z.object({error:z.string()})}},description:"Role cannot be deleted"},404:{content:{"application/json":{schema:z.object({error:z.string()})}},description:"Role not found"}}},handler:async c=>{const{id}=c.req.valid("param");const{moveToRoleId}=c.req.valid("query");const db=c.get("db");const roleId=Number(id);if(!Number.isInteger(roleId)){return c.json({error:"Role not found"},404)}const[role]=await db.select({id:core_roles.id,protected:core_roles.protected,default:core_roles.default,root:core_roles.root,guest:core_roles.guest}).from(core_roles).where(eq(core_roles.id,roleId)).limit(1);if(!role){return c.json({error:"Role not found"},404)}if(role.protected||role.default||role.root||role.guest){return c.json({error:"This role cannot be deleted"},403)}await assertCanManageAdminRole(c,{roleId,permission:"can_delete_admin"});const[{total:usersCount}]=await db.select({total:count()}).from(core_users).where(eq(core_users.roleId,roleId));let targetRoleId=null;if(usersCount>0){if(moveToRoleId===undefined){return c.json({error:"Role has assigned users"},400)}targetRoleId=Number(moveToRoleId);if(!Number.isInteger(targetRoleId)||targetRoleId===roleId){return c.json({error:"Invalid target role"},400)}const[target]=await db.select({id:core_roles.id,guest:core_roles.guest}).from(core_roles).where(eq(core_roles.id,targetRoleId)).limit(1);if(!target||target.guest){return c.json({error:"Invalid target role"},400)}await assertCanAssignPrimaryRole(c,targetRoleId)}await db.transaction(async tx=>{if(targetRoleId!=null){const members=await tx.select({id:core_users.id}).from(core_users).where(eq(core_users.roleId,roleId));const memberIds=members.map(member=>member.id);await tx.update(core_users).set({roleId:targetRoleId}).where(eq(core_users.roleId,roleId));if(memberIds.length>0){await tx.delete(core_users_secondary_roles).where(and(eq(core_users_secondary_roles.roleId,targetRoleId),inArray(core_users_secondary_roles.userId,memberIds)))}}await tx.delete(core_languages_words).where(and(eq(core_languages_words.pluginCode,"core"),eq(core_languages_words.tableName,"core_roles"),eq(core_languages_words.variable,"name"),eq(core_languages_words.itemId,roleId)));await tx.delete(core_roles).where(eq(core_roles.id,roleId))});await invalidateAllStaffPermissions(c);await c.get("events").emit("role.deleted",{roleId});return c.body(null,200)}});

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

@@ -9,8 +9,8 @@ export declare const listRolesAdminRoute: import("../../../../../api/lib/route")
             first: z.ZodOptional<z.ZodString>;
             last: z.ZodOptional<z.ZodString>;
             order: z.ZodOptional<z.ZodEnum<{
-                asc: "asc";
                 desc: "desc";
+                asc: "asc";
             }>>;
             orderBy: z.ZodOptional<z.ZodEnum<{
                 id: "id";
@@ -49,8 +49,8 @@ export declare const listRolesAdminRoute: import("../../../../../api/lib/route")
                             count: z.ZodNumber;
                             hasNextPage: z.ZodBoolean;
                             hasPreviousPage: z.ZodBoolean;
-                            startCursor: z.ZodNullable<z.ZodNumber>;
-                            endCursor: z.ZodNullable<z.ZodNumber>;
+                            startCursor: z.ZodNullable<z.ZodString>;
+                            endCursor: z.ZodNullable<z.ZodString>;
                         }, z.core.$strip>;
                     }, z.core.$strip>;
                 };

package/dist/src/api/modules/admin/roles/routes/list.route.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"list.route.d.ts","sourceRoot":"","sources":["../../../../../../../src/api/modules/admin/roles/routes/list.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AA+CtC,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0I9B,CAAC"}
+{"version":3,"file":"list.route.d.ts","sourceRoot":"","sources":["../../../../../../../src/api/modules/admin/roles/routes/list.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AA+CtC,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2I9B,CAAC"}

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

@@ -1 +1 @@
-import{z}from"@hono/zod-openapi";import{and,count,eq,ilike,inArray}from"drizzle-orm";import{buildRoute}from"../../../../lib/route.js";import{withPagination,zodPaginationPageInfo,zodPaginationQuery}from"../../../../lib/with-pagination.js";import{CONFIG_PLUGIN}from"../../../../../config.js";import{core_admin_permissions}from"../../../../../database/admins.js";import{core_languages_words}from"../../../../../database/languages.js";import{core_roles}from"../../../../../database/roles.js";import{core_users}from"../../../../../database/users.js";const rolesAdminListSchema=z.object({edges:z.array(z.object({id:z.number(),name:z.array(z.object({name:z.string(),languageCode:z.string()})),color:z.string().nullable(),protected:z.boolean(),default:z.boolean(),root:z.boolean(),guest:z.boolean(),allowUploadFiles:z.boolean(),totalMaxStorage:z.number().nullable(),maxStorageForSubmit:z.number().nullable(),createdAt:z.date(),updatedAt:z.date(),usersCount:z.number(),grantsAdmin:z.boolean()})),pageInfo:zodPaginationPageInfo});export const listRolesAdminRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,route:{method:"get",description:"Get list of all roles (Admin only)",path:"/list",request:{query:zodPaginationQuery.extend({order:z.enum(["asc","desc"]).optional(),orderBy:z.enum(["id","createdAt","updatedAt"]).optional(),search:z.string().optional()})},responses:{200:{content:{"application/json":{schema:rolesAdminListSchema}},description:"List of roles"},403:{description:"Access Denied"}}},handler:async c=>{const query=c.req.valid("query");const search=query.search?.trim();const data=await withPagination({params:{query},where:search?inArray(core_roles.id,c.get("db").select({id:core_languages_words.itemId}).from(core_languages_words).where(and(eq(core_languages_words.tableName,"core_roles"),eq(core_languages_words.variable,"name"),eq(core_languages_words.pluginCode,"core"),ilike(core_languages_words.value,`%${search}%`)))):undefined,primaryCursor:core_roles.id,query:async({limit,where,orderBy})=>await c.get("db").select({id:core_roles.id,color:core_roles.color,protected:core_roles.protected,default:core_roles.default,root:core_roles.root,guest:core_roles.guest,allowUploadFiles:core_roles.allowUploadFiles,totalMaxStorage:core_roles.totalMaxStorage,maxStorageForSubmit:core_roles.maxStorageForSubmit,createdAt:core_roles.createdAt,updatedAt:core_roles.updatedAt}).from(core_roles).where(where).orderBy(orderBy).limit(limit),table:core_roles,orderBy:{column:query.orderBy?core_roles[query.orderBy]:core_roles.updatedAt,order:query.order??"desc"},c});const roleIds=data.edges.map(role=>role.id);const names=roleIds.length?await c.get("db").select({itemId:core_languages_words.itemId,languageCode:core_languages_words.languageCode,value:core_languages_words.value}).from(core_languages_words).where(and(eq(core_languages_words.tableName,"core_roles"),eq(core_languages_words.variable,"name"),eq(core_languages_words.pluginCode,"core"),inArray(core_languages_words.itemId,roleIds))):[];const userCounts=roleIds.length?await c.get("db").select({roleId:core_users.roleId,total:count()}).from(core_users).where(inArray(core_users.roleId,roleIds)).groupBy(core_users.roleId):[];const adminRoles=roleIds.length?await c.get("db").selectDistinct({roleId:core_admin_permissions.roleId}).from(core_admin_permissions).where(inArray(core_admin_permissions.roleId,roleIds)):[];const adminRoleIds=new Set(adminRoles.map(row=>row.roleId));return c.json({pageInfo:data.pageInfo,edges:data.edges.map(role=>({...role,name:names.filter(word=>word.itemId===role.id).map(word=>({name:word.value,languageCode:word.languageCode})),usersCount:userCounts.find(item=>item.roleId===role.id)?.total??0,grantsAdmin:adminRoleIds.has(role.id)}))})}});
+import{z}from"@hono/zod-openapi";import{and,count,eq,ilike,inArray}from"drizzle-orm";import{buildRoute}from"../../../../lib/route.js";import{withPagination,zodPaginationPageInfo,zodPaginationQuery}from"../../../../lib/with-pagination.js";import{CONFIG_PLUGIN}from"../../../../../config.js";import{core_admin_permissions}from"../../../../../database/admins.js";import{core_languages_words}from"../../../../../database/languages.js";import{core_roles}from"../../../../../database/roles.js";import{core_users}from"../../../../../database/users.js";const rolesAdminListSchema=z.object({edges:z.array(z.object({id:z.number(),name:z.array(z.object({name:z.string(),languageCode:z.string()})),color:z.string().nullable(),protected:z.boolean(),default:z.boolean(),root:z.boolean(),guest:z.boolean(),allowUploadFiles:z.boolean(),totalMaxStorage:z.number().nullable(),maxStorageForSubmit:z.number().nullable(),createdAt:z.date(),updatedAt:z.date(),usersCount:z.number(),grantsAdmin:z.boolean()})),pageInfo:zodPaginationPageInfo});export const listRolesAdminRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,route:{method:"get",description:"Get list of all roles (Admin only)",path:"/list",request:{query:zodPaginationQuery.extend({order:z.enum(["asc","desc"]).optional(),orderBy:z.enum(["id","createdAt","updatedAt"]).optional(),search:z.string().optional()})},responses:{200:{content:{"application/json":{schema:rolesAdminListSchema}},description:"List of roles"},403:{description:"Access Denied"}}},handler:async c=>{const query=c.req.valid("query");const search=query.search?.trim();const data=await withPagination({params:{query},where:search?inArray(core_roles.id,c.get("db").select({id:core_languages_words.itemId}).from(core_languages_words).where(and(eq(core_languages_words.tableName,"core_roles"),eq(core_languages_words.variable,"name"),eq(core_languages_words.pluginCode,"core"),ilike(core_languages_words.value,`%${search}%`)))):undefined,primaryCursor:core_roles.id,query:async({cursorSelection,limit,where,orderBy})=>await c.get("db").select({...cursorSelection,id:core_roles.id,color:core_roles.color,protected:core_roles.protected,default:core_roles.default,root:core_roles.root,guest:core_roles.guest,allowUploadFiles:core_roles.allowUploadFiles,totalMaxStorage:core_roles.totalMaxStorage,maxStorageForSubmit:core_roles.maxStorageForSubmit,createdAt:core_roles.createdAt,updatedAt:core_roles.updatedAt}).from(core_roles).where(where).orderBy(orderBy).limit(limit),table:core_roles,orderBy:{column:query.orderBy?core_roles[query.orderBy]:core_roles.updatedAt,order:query.order??"desc"},c});const roleIds=data.edges.map(role=>role.id);const names=roleIds.length?await c.get("db").select({itemId:core_languages_words.itemId,languageCode:core_languages_words.languageCode,value:core_languages_words.value}).from(core_languages_words).where(and(eq(core_languages_words.tableName,"core_roles"),eq(core_languages_words.variable,"name"),eq(core_languages_words.pluginCode,"core"),inArray(core_languages_words.itemId,roleIds))):[];const userCounts=roleIds.length?await c.get("db").select({roleId:core_users.roleId,total:count()}).from(core_users).where(inArray(core_users.roleId,roleIds)).groupBy(core_users.roleId):[];const adminRoles=roleIds.length?await c.get("db").selectDistinct({roleId:core_admin_permissions.roleId}).from(core_admin_permissions).where(inArray(core_admin_permissions.roleId,roleIds)):[];const adminRoleIds=new Set(adminRoles.map(row=>row.roleId));return c.json({pageInfo:data.pageInfo,edges:data.edges.map(role=>({...role,name:names.filter(word=>word.itemId===role.id).map(word=>({name:word.value,languageCode:word.languageCode})),usersCount:userCounts.find(item=>item.roleId===role.id)?.total??0,grantsAdmin:adminRoleIds.has(role.id)}))})}});

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

@@ -1 +1 @@
-{"version":3,"file":"update.route.d.ts","sourceRoot":"","sources":["../../../../../../../src/api/modules/admin/roles/routes/update.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AAWtC,eAAO,MAAM,wBAAwB;;;;;;;;;iBAWjC,CAAC;AAEL,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkG/B,CAAC"}
+{"version":3,"file":"update.route.d.ts","sourceRoot":"","sources":["../../../../../../../src/api/modules/admin/roles/routes/update.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AAYtC,eAAO,MAAM,wBAAwB;;;;;;;;;iBAWjC,CAAC;AAEL,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsG/B,CAAC"}

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

@@ -1 +1 @@
-import{z}from"@hono/zod-openapi";import{eq}from"drizzle-orm";import{buildRoute}from"../../../../lib/route.js";import{saveLanguageWords}from"../../../../lib/save-language-words.js";import{CONFIG_PLUGIN}from"../../../../../config.js";import{core_roles}from"../../../../../database/roles.js";import{assertCanManageAdminRole}from"../lib/assert-manage-admin-role.js";import{zodRoleNameSchema,zodRoleStorageSchema}from"./create.route.js";export const zodUpdateRoleAdminSchema=z.object({name:zodRoleNameSchema,color:z.string().max(50),allowUploadFiles:z.boolean(),totalMaxStorage:zodRoleStorageSchema,maxStorageForSubmit:zodRoleStorageSchema}).partial().refine(body=>Object.values(body).some(value=>value!==undefined),{message:"At least one field is required"});export const updateRoleAdminRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,adminStaffPermission:{module:"roles",permission:"can_edit"},route:{method:"patch",description:"Update a role by id (Admin only)",path:"/{id}",request:{params:z.object({id:z.string().openapi({example:"1"})}),body:{required:true,content:{"application/json":{schema:zodUpdateRoleAdminSchema}}}},responses:{200:{content:{"application/json":{schema:z.object({id:z.number()})}},description:"Role updated"},403:{description:"Access Denied"},404:{content:{"application/json":{schema:z.object({error:z.string()})}},description:"Role not found"}}},handler:async c=>{const{id}=c.req.valid("param");const body=c.req.valid("json");const db=c.get("db");const roleId=Number(id);if(!Number.isInteger(roleId)){return c.json({error:"Role not found"},404)}const[role]=await db.select({id:core_roles.id}).from(core_roles).where(eq(core_roles.id,roleId)).limit(1);if(!role){return c.json({error:"Role not found"},404)}await assertCanManageAdminRole(c,{roleId,permission:"can_edit_admin"});const values={updatedAt:new Date};if(body.color!==undefined){values.color=body.color.trim()?body.color:null}if(body.allowUploadFiles!==undefined){values.allowUploadFiles=body.allowUploadFiles}if(body.totalMaxStorage!==undefined){values.totalMaxStorage=body.totalMaxStorage}if(body.maxStorageForSubmit!==undefined){values.maxStorageForSubmit=body.maxStorageForSubmit}await db.update(core_roles).set(values).where(eq(core_roles.id,roleId));if(body.name!==undefined){await saveLanguageWords(c,{pluginCode:"core",tableName:"core_roles",variable:"name",itemId:roleId,values:body.name})}await c.get("events").emit("role.updated",{roleId});return c.json({id:roleId},200)}});
+import{z}from"@hono/zod-openapi";import{eq}from"drizzle-orm";import{buildRoute}from"../../../../lib/route.js";import{saveLanguageWords}from"../../../../lib/save-language-words.js";import{invalidateAllStaffPermissions}from"../../../../lib/staff-permission-cache.js";import{CONFIG_PLUGIN}from"../../../../../config.js";import{core_roles}from"../../../../../database/roles.js";import{assertCanManageAdminRole}from"../lib/assert-manage-admin-role.js";import{zodRoleNameSchema,zodRoleStorageSchema}from"./create.route.js";export const zodUpdateRoleAdminSchema=z.object({name:zodRoleNameSchema,color:z.string().max(50),allowUploadFiles:z.boolean(),totalMaxStorage:zodRoleStorageSchema,maxStorageForSubmit:zodRoleStorageSchema}).partial().refine(body=>Object.values(body).some(value=>value!==undefined),{message:"At least one field is required"});export const updateRoleAdminRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,adminStaffPermission:{module:"roles",permission:"can_edit"},route:{method:"patch",description:"Update a role by id (Admin only)",path:"/{id}",request:{params:z.object({id:z.string().openapi({example:"1"})}),body:{required:true,content:{"application/json":{schema:zodUpdateRoleAdminSchema}}}},responses:{200:{content:{"application/json":{schema:z.object({id:z.number()})}},description:"Role updated"},403:{description:"Access Denied"},404:{content:{"application/json":{schema:z.object({error:z.string()})}},description:"Role not found"}}},handler:async c=>{const{id}=c.req.valid("param");const body=c.req.valid("json");const db=c.get("db");const roleId=Number(id);if(!Number.isInteger(roleId)){return c.json({error:"Role not found"},404)}const[role]=await db.select({id:core_roles.id}).from(core_roles).where(eq(core_roles.id,roleId)).limit(1);if(!role){return c.json({error:"Role not found"},404)}await assertCanManageAdminRole(c,{roleId,permission:"can_edit_admin"});const values={updatedAt:new Date};if(body.color!==undefined){values.color=body.color.trim()?body.color:null}if(body.allowUploadFiles!==undefined){values.allowUploadFiles=body.allowUploadFiles}if(body.totalMaxStorage!==undefined){values.totalMaxStorage=body.totalMaxStorage}if(body.maxStorageForSubmit!==undefined){values.maxStorageForSubmit=body.maxStorageForSubmit}await db.update(core_roles).set(values).where(eq(core_roles.id,roleId));if(body.name!==undefined){await saveLanguageWords(c,{pluginCode:"core",tableName:"core_roles",variable:"name",itemId:roleId,values:body.name})}await invalidateAllStaffPermissions(c);await c.get("events").emit("role.updated",{roleId});return c.json({id:roleId},200)}});

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

@@ -3,9 +3,9 @@ export declare const zodSendNotificationSchema: z.ZodObject<{
     description: z.ZodOptional<z.ZodString>;
     title: z.ZodString;
     type: z.ZodOptional<z.ZodEnum<{
+        info: "info";
         error: "error";
         success: "success";
-        info: "info";
         warning: "warning";
     }>>;
     userId: z.ZodNumber;
@@ -22,9 +22,9 @@ export declare const sendNotificationRoute: import("../../../../api/lib/route").
                         description: z.ZodOptional<z.ZodString>;
                         title: z.ZodString;
                         type: z.ZodOptional<z.ZodEnum<{
+                            info: "info";
                             error: "error";
                             success: "success";
-                            info: "info";
                             warning: "warning";
                         }>>;
                         userId: z.ZodNumber;

package/dist/src/api/modules/admin/staff/lib/schema.d.ts

@@ -4,8 +4,8 @@ export declare const staffListAdminQuery: z.ZodObject<{
     first: z.ZodOptional<z.ZodString>;
     last: z.ZodOptional<z.ZodString>;
     order: z.ZodOptional<z.ZodEnum<{
-        asc: "asc";
         desc: "desc";
+        asc: "asc";
     }>>;
     orderBy: z.ZodOptional<z.ZodEnum<{
         id: "id";
@@ -87,8 +87,8 @@ export declare const staffListAdminSchema: z.ZodObject<{
         count: z.ZodNumber;
         hasNextPage: z.ZodBoolean;
         hasPreviousPage: z.ZodBoolean;
-        startCursor: z.ZodNullable<z.ZodNumber>;
-        endCursor: z.ZodNullable<z.ZodNumber>;
+        startCursor: z.ZodNullable<z.ZodString>;
+        endCursor: z.ZodNullable<z.ZodString>;
     }, z.core.$strip>;
 }, z.core.$strip>;
 export declare const permissionsStaffArgsSchema: z.ZodObject<{

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

@@ -8,8 +8,8 @@ export declare const listAdminsStaffAdminRoute: import("../../../../../api/lib/r
             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";
+                asc: "asc";
             }>>;
             orderBy: import("zod").ZodOptional<import("zod").ZodEnum<{
                 id: "id";
@@ -58,8 +58,8 @@ export declare const listAdminsStaffAdminRoute: import("../../../../../api/lib/r
                             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>;
+                            startCursor: import("zod").ZodNullable<import("zod").ZodString>;
+                            endCursor: import("zod").ZodNullable<import("zod").ZodString>;
                         }, import("zod/v4/core").$strip>;
                     }, import("zod/v4/core").$strip>;
                 };

package/dist/src/api/modules/admin/staff/routes/admins.route.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"admins.route.d.ts","sourceRoot":"","sources":["../../../../../../../src/api/modules/admin/staff/routes/admins.route.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+DpC,CAAC"}
+{"version":3,"file":"admins.route.d.ts","sourceRoot":"","sources":["../../../../../../../src/api/modules/admin/staff/routes/admins.route.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgEpC,CAAC"}

package/dist/src/api/modules/admin/staff/routes/admins.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_admin_permissions}from"../../../../../database/admins.js";import{resolveStaffEdges}from"../lib/resolve-staff-edges.js";import{staffListAdminQuery,staffListAdminSchema}from"../lib/schema.js";export const listAdminsStaffAdminRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,adminStaffPermission:{module:"staff_admins",permission:"can_view"},route:{method:"get",description:"Get list of administrators staff (Admin only)",path:"/admins",request:{query:staffListAdminQuery},responses:{200:{content:{"application/json":{schema:staffListAdminSchema}},description:"List of administrators staff"},403:{description:"Access Denied"}}},handler:async c=>{const query=c.req.valid("query");const data=await withPagination({params:{query},primaryCursor:core_admin_permissions.id,query:async({limit,where,orderBy})=>await c.get("db").select({id:core_admin_permissions.id,roleId:core_admin_permissions.roleId,userId:core_admin_permissions.userId,createdAt:core_admin_permissions.createdAt,updatedAt:core_admin_permissions.updatedAt,unrestricted:core_admin_permissions.unrestricted,protected:core_admin_permissions.protected}).from(core_admin_permissions).where(where).orderBy(orderBy).limit(limit),table:core_admin_permissions,orderBy:{column:query.orderBy?core_admin_permissions[query.orderBy]:core_admin_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_admin_permissions}from"../../../../../database/admins.js";import{resolveStaffEdges}from"../lib/resolve-staff-edges.js";import{staffListAdminQuery,staffListAdminSchema}from"../lib/schema.js";export const listAdminsStaffAdminRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,adminStaffPermission:{module:"staff_admins",permission:"can_view"},route:{method:"get",description:"Get list of administrators staff (Admin only)",path:"/admins",request:{query:staffListAdminQuery},responses:{200:{content:{"application/json":{schema:staffListAdminSchema}},description:"List of administrators staff"},403:{description:"Access Denied"}}},handler:async c=>{const query=c.req.valid("query");const data=await withPagination({params:{query},primaryCursor:core_admin_permissions.id,query:async({cursorSelection,limit,where,orderBy})=>await c.get("db").select({...cursorSelection,id:core_admin_permissions.id,roleId:core_admin_permissions.roleId,userId:core_admin_permissions.userId,createdAt:core_admin_permissions.createdAt,updatedAt:core_admin_permissions.updatedAt,unrestricted:core_admin_permissions.unrestricted,protected:core_admin_permissions.protected}).from(core_admin_permissions).where(where).orderBy(orderBy).limit(limit),table:core_admin_permissions,orderBy:{column:query.orderBy?core_admin_permissions[query.orderBy]:core_admin_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/create.route.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create.route.d.ts","sourceRoot":"","sources":["../../../../../../../src/api/modules/admin/staff/routes/create.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AAgBtC,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyFhC,CAAC"}
+{"version":3,"file":"create.route.d.ts","sourceRoot":"","sources":["../../../../../../../src/api/modules/admin/staff/routes/create.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AAiBtC,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2FhC,CAAC"}

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}).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{invalidateStaffEntry}from"../../../../lib/staff-permission-cache.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});await invalidateStaffEntry(c,{roleId,userId});return c.json({id:created.id},201)}});

package/dist/src/api/modules/admin/staff/routes/delete.route.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"delete.route.d.ts","sourceRoot":"","sources":["../../../../../../../src/api/modules/admin/staff/routes/delete.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AAoBtC,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmFhC,CAAC"}
+{"version":3,"file":"delete.route.d.ts","sourceRoot":"","sources":["../../../../../../../src/api/modules/admin/staff/routes/delete.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AAqBtC,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqFhC,CAAC"}

package/dist/src/api/modules/admin/staff/routes/delete.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{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 deleteStaffAdminRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,route:{method:"delete",description:"Remove a staff entry (Admin only)",path:"/entry/{type}/{id}",request:{params:z.object({type:staffTypeSchema,id:z.string().openapi({example:"1"})})},responses:{200:{description:"Staff entry removed"},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_delete"});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 remove your own staff permissions."})}await c.get("db").delete(table).where(eq(table.id,entryId));return c.body(null,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{invalidateStaffEntry}from"../../../../lib/staff-permission-cache.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 deleteStaffAdminRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,route:{method:"delete",description:"Remove a staff entry (Admin only)",path:"/entry/{type}/{id}",request:{params:z.object({type:staffTypeSchema,id:z.string().openapi({example:"1"})})},responses:{200:{description:"Staff entry removed"},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_delete"});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 remove your own staff permissions."})}await c.get("db").delete(table).where(eq(table.id,entryId));await invalidateStaffEntry(c,entry);return c.body(null,200)}});

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

@@ -8,8 +8,8 @@ export declare const listModeratorsStaffAdminRoute: import("../../../../../api/l
             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";
+                asc: "asc";
             }>>;
             orderBy: import("zod").ZodOptional<import("zod").ZodEnum<{
                 id: "id";
@@ -58,8 +58,8 @@ export declare const listModeratorsStaffAdminRoute: import("../../../../../api/l
                             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>;
+                            startCursor: import("zod").ZodNullable<import("zod").ZodString>;
+                            endCursor: import("zod").ZodNullable<import("zod").ZodString>;
                         }, import("zod/v4/core").$strip>;
                     }, import("zod/v4/core").$strip>;
                 };

package/dist/src/api/modules/admin/staff/routes/moderators.route.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"moderators.route.d.ts","sourceRoot":"","sources":["../../../../../../../src/api/modules/admin/staff/routes/moderators.route.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+DxC,CAAC"}
+{"version":3,"file":"moderators.route.d.ts","sourceRoot":"","sources":["../../../../../../../src/api/modules/admin/staff/routes/moderators.route.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgExC,CAAC"}

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,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)})}});
+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({cursorSelection,limit,where,orderBy})=>await c.get("db").select({...cursorSelection,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/update-permissions.route.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"update-permissions.route.d.ts","sourceRoot":"","sources":["../../../../../../../src/api/modules/admin/staff/routes/update-permissions.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AA2BtC,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2K3C,CAAC"}
+{"version":3,"file":"update-permissions.route.d.ts","sourceRoot":"","sources":["../../../../../../../src/api/modules/admin/staff/routes/update-permissions.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AA4BtC,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6K3C,CAAC"}

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({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{invalidateStaffEntry}from"../../../../lib/staff-permission-cache.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)}await invalidateStaffEntry(c,entry);return c.json({unrestricted,permissions:sanitized},200)}});

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

@@ -8,8 +8,8 @@ export declare const staffAdminModule: import("../../../../api/lib/module").Buil
             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";
+                asc: "asc";
             }>>;
             orderBy: import("zod").ZodOptional<import("zod").ZodEnum<{
                 id: "id";
@@ -58,8 +58,8 @@ export declare const staffAdminModule: import("../../../../api/lib/module").Buil
                             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>;
+                            startCursor: import("zod").ZodNullable<import("zod").ZodString>;
+                            endCursor: import("zod").ZodNullable<import("zod").ZodString>;
                         }, import("zod/v4/core").$strip>;
                     }, import("zod/v4/core").$strip>;
                 };
@@ -82,8 +82,8 @@ export declare const staffAdminModule: import("../../../../api/lib/module").Buil
             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";
+                asc: "asc";
             }>>;
             orderBy: import("zod").ZodOptional<import("zod").ZodEnum<{
                 id: "id";
@@ -132,8 +132,8 @@ export declare const staffAdminModule: import("../../../../api/lib/module").Buil
                             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>;
+                            startCursor: import("zod").ZodNullable<import("zod").ZodString>;
+                            endCursor: import("zod").ZodNullable<import("zod").ZodString>;
                         }, import("zod/v4/core").$strip>;
                     }, import("zod/v4/core").$strip>;
                 };

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

@@ -9,12 +9,12 @@ export declare const listUsersAdminRoute: import("../../../../../api/lib/route")
             first: z.ZodOptional<z.ZodString>;
             last: z.ZodOptional<z.ZodString>;
             order: z.ZodOptional<z.ZodEnum<{
-                asc: "asc";
                 desc: "desc";
+                asc: "asc";
             }>>;
             orderBy: z.ZodOptional<z.ZodEnum<{
-                name: "name";
                 createdAt: "createdAt";
+                name: "name";
             }>>;
             roleId: z.ZodOptional<z.ZodString>;
             search: z.ZodOptional<z.ZodString>;
@@ -59,8 +59,8 @@ export declare const listUsersAdminRoute: import("../../../../../api/lib/route")
                             count: z.ZodNumber;
                             hasNextPage: z.ZodBoolean;
                             hasPreviousPage: z.ZodBoolean;
-                            startCursor: z.ZodNullable<z.ZodNumber>;
-                            endCursor: z.ZodNullable<z.ZodNumber>;
+                            startCursor: z.ZodNullable<z.ZodString>;
+                            endCursor: z.ZodNullable<z.ZodString>;
                         }, z.core.$strip>;
                     }, z.core.$strip>;
                 };

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

@@ -1 +1 @@
-{"version":3,"file":"list.route.d.ts","sourceRoot":"","sources":["../../../../../../../src/api/modules/admin/users/routes/list.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AActC,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2J9B,CAAC"}
+{"version":3,"file":"list.route.d.ts","sourceRoot":"","sources":["../../../../../../../src/api/modules/admin/users/routes/list.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AActC,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4J9B,CAAC"}

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

@@ -1 +1 @@
-import{z}from"@hono/zod-openapi";import{eq,inArray}from"drizzle-orm";import{resolveRoleNames}from"../../../../lib/resolve-role-names.js";import{buildRoute}from"../../../../lib/route.js";import{withPagination,zodPaginationPageInfo,zodPaginationQuery}from"../../../../lib/with-pagination.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";export const listUsersAdminRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,adminStaffPermission:{module:"users",permission:"can_view"},route:{method:"get",description:"Get list of all users",path:"/list",request:{query:zodPaginationQuery.extend({order:z.enum(["asc","desc"]).optional(),orderBy:z.enum(["name","createdAt"]).optional(),roleId:z.string().optional(),search:z.string().optional()})},responses:{200:{content:{"application/json":{schema:z.object({edges:z.array(z.object({id:z.number(),name:z.string(),email:z.string(),nameCode:z.string(),createdAt:z.date(),newsletter:z.boolean(),avatarColor:z.string(),emailVerified:z.boolean(),roleId:z.number(),role:z.object({id:z.number(),color:z.string().nullable(),name:z.array(z.object({name:z.string(),languageCode:z.string()}))}),secondaryRoles:z.array(z.object({id:z.number(),color:z.string().nullable(),name:z.array(z.object({name:z.string(),languageCode:z.string()}))})),birthday:z.date().nullable(),language:z.string()})),pageInfo:zodPaginationPageInfo})}},description:"List of users"}}},handler:async c=>{const query=c.req.valid("query");const roleIds=(query.roleId?.split(",")??[]).filter(Boolean).map(id=>Number(id)).filter(id=>!Number.isNaN(id));const data=await withPagination({params:{query},search:[core_users.name,core_users.email],where:roleIds.length?inArray(core_users.roleId,roleIds):undefined,primaryCursor:core_users.id,query:async({limit,where,orderBy})=>await c.get("db").select({id:core_users.id,name:core_users.name,email:core_users.email,nameCode:core_users.nameCode,createdAt:core_users.createdAt,newsletter:core_users.newsletter,avatarColor:core_users.avatarColor,emailVerified:core_users.emailVerified,roleId:core_users.roleId,roleColor:core_roles.color,birthday:core_users.birthday,language:core_users.language}).from(core_users).leftJoin(core_roles,eq(core_roles.id,core_users.roleId)).where(where).orderBy(orderBy).limit(limit),table:core_users,orderBy:{column:query.orderBy?core_users[query.orderBy]:core_users.createdAt,order:query.order??"desc"},c});const userIds=data.edges.map(user=>user.id);const secondaryRoleRows=userIds.length?await c.get("db").select({userId:core_users_secondary_roles.userId,roleId:core_users_secondary_roles.roleId,roleColor:core_roles.color}).from(core_users_secondary_roles).innerJoin(core_roles,eq(core_roles.id,core_users_secondary_roles.roleId)).where(inArray(core_users_secondary_roles.userId,userIds)):[];const roleNames=await resolveRoleNames(c,[...data.edges.map(user=>user.roleId),...secondaryRoleRows.map(row=>row.roleId)]);return c.json({pageInfo:data.pageInfo,edges:data.edges.map(({roleColor,...user})=>({...user,role:{id:user.roleId,color:roleColor,name:roleNames.get(user.roleId)??[]},secondaryRoles:secondaryRoleRows.filter(row=>row.userId===user.id).map(row=>({id:row.roleId,color:row.roleColor,name:roleNames.get(row.roleId)??[]}))}))})}});
+import{z}from"@hono/zod-openapi";import{eq,inArray}from"drizzle-orm";import{resolveRoleNames}from"../../../../lib/resolve-role-names.js";import{buildRoute}from"../../../../lib/route.js";import{withPagination,zodPaginationPageInfo,zodPaginationQuery}from"../../../../lib/with-pagination.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";export const listUsersAdminRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,adminStaffPermission:{module:"users",permission:"can_view"},route:{method:"get",description:"Get list of all users",path:"/list",request:{query:zodPaginationQuery.extend({order:z.enum(["asc","desc"]).optional(),orderBy:z.enum(["name","createdAt"]).optional(),roleId:z.string().optional(),search:z.string().optional()})},responses:{200:{content:{"application/json":{schema:z.object({edges:z.array(z.object({id:z.number(),name:z.string(),email:z.string(),nameCode:z.string(),createdAt:z.date(),newsletter:z.boolean(),avatarColor:z.string(),emailVerified:z.boolean(),roleId:z.number(),role:z.object({id:z.number(),color:z.string().nullable(),name:z.array(z.object({name:z.string(),languageCode:z.string()}))}),secondaryRoles:z.array(z.object({id:z.number(),color:z.string().nullable(),name:z.array(z.object({name:z.string(),languageCode:z.string()}))})),birthday:z.date().nullable(),language:z.string()})),pageInfo:zodPaginationPageInfo})}},description:"List of users"}}},handler:async c=>{const query=c.req.valid("query");const roleIds=(query.roleId?.split(",")??[]).filter(Boolean).map(id=>Number(id)).filter(id=>!Number.isNaN(id));const data=await withPagination({params:{query},search:[core_users.name,core_users.email,core_users.nameCode],where:roleIds.length?inArray(core_users.roleId,roleIds):undefined,primaryCursor:core_users.id,query:async({cursorSelection,limit,where,orderBy})=>await c.get("db").select({...cursorSelection,id:core_users.id,name:core_users.name,email:core_users.email,nameCode:core_users.nameCode,createdAt:core_users.createdAt,newsletter:core_users.newsletter,avatarColor:core_users.avatarColor,emailVerified:core_users.emailVerified,roleId:core_users.roleId,roleColor:core_roles.color,birthday:core_users.birthday,language:core_users.language}).from(core_users).leftJoin(core_roles,eq(core_roles.id,core_users.roleId)).where(where).orderBy(orderBy).limit(limit),table:core_users,orderBy:{column:query.orderBy?core_users[query.orderBy]:core_users.createdAt,order:query.order??"desc"},c});const userIds=data.edges.map(user=>user.id);const secondaryRoleRows=userIds.length?await c.get("db").select({userId:core_users_secondary_roles.userId,roleId:core_users_secondary_roles.roleId,roleColor:core_roles.color}).from(core_users_secondary_roles).innerJoin(core_roles,eq(core_roles.id,core_users_secondary_roles.roleId)).where(inArray(core_users_secondary_roles.userId,userIds)):[];const roleNames=await resolveRoleNames(c,[...data.edges.map(user=>user.roleId),...secondaryRoleRows.map(row=>row.roleId)]);return c.json({pageInfo:data.pageInfo,edges:data.edges.map(({roleColor,...user})=>({...user,role:{id:user.roleId,color:roleColor,name:roleNames.get(user.roleId)??[]},secondaryRoles:secondaryRoleRows.filter(row=>row.userId===user.id).map(row=>({id:row.roleId,color:row.roleColor,name:roleNames.get(row.roleId)??[]}))}))})}});

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkO/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;AAgBtC,eAAO,MAAM,wBAAwB;;;;;;iBA0BjC,CAAC;AAEL,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgP/B,CAAC"}