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

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

@@ -0,0 +1,62 @@
+import { z } from "@hono/zod-openapi";
+export declare const updatePermissionsStaffAdminRoute: import("../../../../../api/lib/route").Route<"@vitnode/core", {
+    method: "patch";
+    description: string;
+    path: "/entry/{type}/{id}";
+    request: {
+        params: z.ZodObject<{
+            type: z.ZodEnum<{
+                admin: "admin";
+                moderator: "moderator";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strip>;
+        body: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        unrestricted: z.ZodBoolean;
+                        permissions: z.ZodArray<z.ZodObject<{
+                            plugin: z.ZodString;
+                            module: z.ZodString;
+                            permission: z.ZodString;
+                        }, z.core.$strip>>;
+                    }, z.core.$strip>;
+                };
+            };
+        };
+    };
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        unrestricted: z.ZodBoolean;
+                        permissions: z.ZodArray<z.ZodObject<{
+                            plugin: z.ZodString;
+                            module: z.ZodString;
+                            permission: z.ZodString;
+                        }, z.core.$strip>>;
+                    }, z.core.$strip>;
+                };
+            };
+            description: string;
+        };
+        403: {
+            description: string;
+        };
+        404: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        error: z.ZodString;
+                    }, z.core.$strip>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>;
+//# sourceMappingURL=update-permissions.route.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +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)}});

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

@@ -0,0 +1,392 @@
+export declare const staffAdminModule: import("../../../../api/lib/module").BuildModuleReturn<"@vitnode/core", "staff", [import("../../../lib/route").Route<"@vitnode/core", {
+    method: "get";
+    description: string;
+    path: "/moderators";
+    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<{
+                id: "id";
+                createdAt: "createdAt";
+                updatedAt: "updatedAt";
+            }>>;
+        }, 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;
+                            createdAt: import("zod").ZodDate;
+                            updatedAt: import("zod").ZodDate;
+                            unrestricted: import("zod").ZodBoolean;
+                            protected: import("zod").ZodBoolean;
+                            self: import("zod").ZodBoolean;
+                            role: import("zod").ZodNullable<import("zod").ZodObject<{
+                                id: import("zod").ZodNumber;
+                                color: import("zod").ZodNullable<import("zod").ZodString>;
+                                name: import("zod").ZodArray<import("zod").ZodObject<{
+                                    name: import("zod").ZodString;
+                                    languageCode: import("zod").ZodString;
+                                }, import("zod/v4/core").$strip>>;
+                            }, import("zod/v4/core").$strip>>;
+                            user: import("zod").ZodNullable<import("zod").ZodObject<{
+                                id: import("zod").ZodNumber;
+                                name: import("zod").ZodString;
+                                nameCode: import("zod").ZodString;
+                                avatarColor: import("zod").ZodString;
+                                role: import("zod").ZodObject<{
+                                    id: import("zod").ZodNumber;
+                                    color: import("zod").ZodNullable<import("zod").ZodString>;
+                                    name: import("zod").ZodArray<import("zod").ZodObject<{
+                                        name: import("zod").ZodString;
+                                        languageCode: import("zod").ZodString;
+                                    }, import("zod/v4/core").$strip>>;
+                                }, import("zod/v4/core").$strip>;
+                            }, 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;
+        };
+        403: {
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>, import("../../../lib/route").Route<"@vitnode/core", {
+    method: "get";
+    description: string;
+    path: "/admins";
+    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<{
+                id: "id";
+                createdAt: "createdAt";
+                updatedAt: "updatedAt";
+            }>>;
+        }, 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;
+                            createdAt: import("zod").ZodDate;
+                            updatedAt: import("zod").ZodDate;
+                            unrestricted: import("zod").ZodBoolean;
+                            protected: import("zod").ZodBoolean;
+                            self: import("zod").ZodBoolean;
+                            role: import("zod").ZodNullable<import("zod").ZodObject<{
+                                id: import("zod").ZodNumber;
+                                color: import("zod").ZodNullable<import("zod").ZodString>;
+                                name: import("zod").ZodArray<import("zod").ZodObject<{
+                                    name: import("zod").ZodString;
+                                    languageCode: import("zod").ZodString;
+                                }, import("zod/v4/core").$strip>>;
+                            }, import("zod/v4/core").$strip>>;
+                            user: import("zod").ZodNullable<import("zod").ZodObject<{
+                                id: import("zod").ZodNumber;
+                                name: import("zod").ZodString;
+                                nameCode: import("zod").ZodString;
+                                avatarColor: import("zod").ZodString;
+                                role: import("zod").ZodObject<{
+                                    id: import("zod").ZodNumber;
+                                    color: import("zod").ZodNullable<import("zod").ZodString>;
+                                    name: import("zod").ZodArray<import("zod").ZodObject<{
+                                        name: import("zod").ZodString;
+                                        languageCode: import("zod").ZodString;
+                                    }, import("zod/v4/core").$strip>>;
+                                }, import("zod/v4/core").$strip>;
+                            }, 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;
+        };
+        403: {
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>, import("../../../lib/route").Route<"@vitnode/core", {
+    method: "get";
+    description: string;
+    path: "/permission-catalog";
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodArray<import("zod").ZodObject<{
+                        pluginId: import("zod").ZodString;
+                        admin: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodArray<import("zod").ZodObject<{
+                            permission: import("zod").ZodString;
+                            dependsOn: import("zod").ZodArray<import("zod").ZodString>;
+                        }, import("zod/v4/core").$strip>>>;
+                        moderator: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodArray<import("zod").ZodObject<{
+                            permission: import("zod").ZodString;
+                            dependsOn: import("zod").ZodArray<import("zod").ZodString>;
+                        }, import("zod/v4/core").$strip>>>;
+                    }, import("zod/v4/core").$strip>>;
+                };
+            };
+            description: string;
+        };
+        403: {
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>, import("../../../lib/route").Route<"@vitnode/core", {
+    method: "get";
+    description: string;
+    path: "/entry/{type}/{id}";
+    request: {
+        params: import("zod").ZodObject<{
+            type: import("zod").ZodEnum<{
+                admin: "admin";
+                moderator: "moderator";
+            }>;
+            id: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+    };
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        id: import("zod").ZodNumber;
+                        createdAt: import("zod").ZodDate;
+                        updatedAt: import("zod").ZodDate;
+                        unrestricted: import("zod").ZodBoolean;
+                        protected: import("zod").ZodBoolean;
+                        self: import("zod").ZodBoolean;
+                        role: import("zod").ZodNullable<import("zod").ZodObject<{
+                            id: import("zod").ZodNumber;
+                            color: import("zod").ZodNullable<import("zod").ZodString>;
+                            name: import("zod").ZodArray<import("zod").ZodObject<{
+                                name: import("zod").ZodString;
+                                languageCode: import("zod").ZodString;
+                            }, import("zod/v4/core").$strip>>;
+                        }, import("zod/v4/core").$strip>>;
+                        user: import("zod").ZodNullable<import("zod").ZodObject<{
+                            id: import("zod").ZodNumber;
+                            name: import("zod").ZodString;
+                            nameCode: import("zod").ZodString;
+                            avatarColor: import("zod").ZodString;
+                            role: import("zod").ZodObject<{
+                                id: import("zod").ZodNumber;
+                                color: import("zod").ZodNullable<import("zod").ZodString>;
+                                name: import("zod").ZodArray<import("zod").ZodObject<{
+                                    name: import("zod").ZodString;
+                                    languageCode: import("zod").ZodString;
+                                }, import("zod/v4/core").$strip>>;
+                            }, import("zod/v4/core").$strip>;
+                        }, import("zod/v4/core").$strip>>;
+                        permissions: import("zod").ZodArray<import("zod").ZodObject<{
+                            plugin: import("zod").ZodString;
+                            module: import("zod").ZodString;
+                            permission: import("zod").ZodString;
+                        }, import("zod/v4/core").$strip>>;
+                    }, import("zod/v4/core").$strip>;
+                };
+            };
+            description: string;
+        };
+        403: {
+            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: "patch";
+    description: string;
+    path: "/entry/{type}/{id}";
+    request: {
+        params: import("zod").ZodObject<{
+            type: import("zod").ZodEnum<{
+                admin: "admin";
+                moderator: "moderator";
+            }>;
+            id: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+        body: {
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        unrestricted: import("zod").ZodBoolean;
+                        permissions: import("zod").ZodArray<import("zod").ZodObject<{
+                            plugin: import("zod").ZodString;
+                            module: import("zod").ZodString;
+                            permission: import("zod").ZodString;
+                        }, import("zod/v4/core").$strip>>;
+                    }, import("zod/v4/core").$strip>;
+                };
+            };
+        };
+    };
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        unrestricted: import("zod").ZodBoolean;
+                        permissions: import("zod").ZodArray<import("zod").ZodObject<{
+                            plugin: import("zod").ZodString;
+                            module: import("zod").ZodString;
+                            permission: import("zod").ZodString;
+                        }, import("zod/v4/core").$strip>>;
+                    }, import("zod/v4/core").$strip>;
+                };
+            };
+            description: string;
+        };
+        403: {
+            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: "post";
+    description: string;
+    path: "/entry/{type}";
+    request: {
+        params: import("zod").ZodObject<{
+            type: import("zod").ZodEnum<{
+                admin: "admin";
+                moderator: "moderator";
+            }>;
+        }, import("zod/v4/core").$strip>;
+        body: {
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        roleId: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodNumber>>;
+                        userId: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodNumber>>;
+                    }, import("zod/v4/core").$strip>;
+                };
+            };
+        };
+    };
+    responses: {
+        201: {
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        id: import("zod").ZodNumber;
+                    }, import("zod/v4/core").$strip>;
+                };
+            };
+            description: string;
+        };
+        403: {
+            description: string;
+        };
+        409: {
+            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: "/entry/{type}/{id}";
+    request: {
+        params: import("zod").ZodObject<{
+            type: import("zod").ZodEnum<{
+                admin: "admin";
+                moderator: "moderator";
+            }>;
+            id: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+    };
+    responses: {
+        200: {
+            description: string;
+        };
+        403: {
+            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=staff.admin.module.d.ts.map

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

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

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

@@ -0,0 +1 @@
+import{buildModule}from"../../../lib/module.js";import{CONFIG_PLUGIN}from"../../../../config.js";import{listAdminsStaffAdminRoute}from"./routes/admins.route.js";import{createStaffAdminRoute}from"./routes/create.route.js";import{deleteStaffAdminRoute}from"./routes/delete.route.js";import{listModeratorsStaffAdminRoute}from"./routes/moderators.route.js";import{permissionCatalogStaffAdminRoute}from"./routes/permission-catalog.route.js";import{showPermissionsStaffAdminRoute}from"./routes/show-permissions.route.js";import{updatePermissionsStaffAdminRoute}from"./routes/update-permissions.route.js";export const staffAdminModule=buildModule({pluginId:CONFIG_PLUGIN.pluginId,name:"staff",routes:[listModeratorsStaffAdminRoute,listAdminsStaffAdminRoute,permissionCatalogStaffAdminRoute,showPermissionsStaffAdminRoute,updatePermissionsStaffAdminRoute,createStaffAdminRoute,deleteStaffAdminRoute]});

package/dist/src/api/modules/admin/users/lib/assert-edit-user-permission.d.ts

@@ -0,0 +1,4 @@
+import type { Context } from "hono";
+export declare const assertCanEditAdminTarget: (c: Context, userId: number) => Promise<void>;
+export declare const assertCanAssignPrimaryRole: (c: Context, roleId: number) => Promise<void>;
+//# sourceMappingURL=assert-edit-user-permission.d.ts.map

package/dist/src/api/modules/admin/users/lib/assert-edit-user-permission.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assert-edit-user-permission.d.ts","sourceRoot":"","sources":["../../../../../../../src/api/modules/admin/users/lib/assert-edit-user-permission.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAkBpC,eAAO,MAAM,wBAAwB,GACnC,GAAG,OAAO,EACV,QAAQ,MAAM,KACb,OAAO,CAAC,IAAI,CAOd,CAAC;AASF,eAAO,MAAM,0BAA0B,GACrC,GAAG,OAAO,EACV,QAAQ,MAAM,KACb,OAAO,CAAC,IAAI,CAWd,CAAC"}

package/dist/src/api/modules/admin/users/lib/assert-edit-user-permission.js

@@ -0,0 +1 @@
+import{eq}from"drizzle-orm";import{assertStaffPermission}from"../../../../lib/check-staff-permission.js";import{SessionAdminModel}from"../../../../models/session-admin.js";import{CONFIG_PLUGIN}from"../../../../../config.js";import{core_admin_permissions}from"../../../../../database/admins.js";const assertCanEditAdmin=async c=>{await assertStaffPermission(c,{type:"admin",plugin:CONFIG_PLUGIN.pluginId,module:"users",permission:"can_edit_admin"})};export const assertCanEditAdminTarget=async(c,userId)=>{const isTargetAdmin=await new SessionAdminModel(c).checkIfUserIsAdmin(userId);if(!isTargetAdmin)return;await assertCanEditAdmin(c)};export const assertCanAssignPrimaryRole=async(c,roleId)=>{const[adminRole]=await c.get("db").select({id:core_admin_permissions.id}).from(core_admin_permissions).where(eq(core_admin_permissions.roleId,roleId)).limit(1);if(!adminRole)return;await assertCanEditAdmin(c)};

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

@@ -1 +1 @@
-{"version":3,"file":"create.route.d.ts","sourceRoot":"","sources":["../../../../../../../src/api/modules/admin/users/routes/create.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AAStC,eAAO,MAAM,wBAAwB;;;;iBAcnC,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmD/B,CAAC"}
+{"version":3,"file":"create.route.d.ts","sourceRoot":"","sources":["../../../../../../../src/api/modules/admin/users/routes/create.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AAStC,eAAO,MAAM,wBAAwB;;;;iBAcnC,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoD/B,CAAC"}

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

@@ -1 +1 @@
-import{z}from"@hono/zod-openapi";import{buildRoute}from"../../../../lib/route.js";import{PasswordModel}from"../../../../models/password.js";import{UserModel}from"../../../../models/user.js";import{CONFIG_PLUGIN}from"../../../../../config.js";const nameRegex=/^(?!.* {2})[\p{L}\p{N}._@ -]*$/u;export const zodCreateUserAdminSchema=z.object({email:z.email().toLowerCase().openapi({example:"test@test.com"}),name:z.string().openapi({example:"test"}).min(3).refine(val=>nameRegex.test(val),{message:"Invalid name"}),password:z.string().min(8).openapi({example:"Test123!"})});export const createUserAdminRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,route:{method:"post",description:"Create a new user (Admin only)",path:"/create",request:{body:{required:true,content:{"application/json":{schema:zodCreateUserAdminSchema}}}},responses:{201:{content:{"application/json":{schema:z.object({id:z.number(),name:z.string(),email:z.email()})}},description:"User created"},403:{description:"Access Denied"},409:{description:"Email or name already exists"}}},handler:async c=>{const{password,...input}=c.req.valid("json");const hashedPassword=await new PasswordModel().encryptPassword(password);const data=await new UserModel().signUp({...input,hashedPassword},c);return c.json({id:data.id,name:data.name,email:data.email},201)}});
+import{z}from"@hono/zod-openapi";import{buildRoute}from"../../../../lib/route.js";import{PasswordModel}from"../../../../models/password.js";import{UserModel}from"../../../../models/user.js";import{CONFIG_PLUGIN}from"../../../../../config.js";const nameRegex=/^(?!.* {2})[\p{L}\p{N}._@ -]*$/u;export const zodCreateUserAdminSchema=z.object({email:z.email().toLowerCase().openapi({example:"test@test.com"}),name:z.string().openapi({example:"test"}).min(3).refine(val=>nameRegex.test(val),{message:"Invalid name"}),password:z.string().min(8).openapi({example:"Test123!"})});export const createUserAdminRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,adminStaffPermission:{module:"users",permission:"can_create"},route:{method:"post",description:"Create a new user (Admin only)",path:"/create",request:{body:{required:true,content:{"application/json":{schema:zodCreateUserAdminSchema}}}},responses:{201:{content:{"application/json":{schema:z.object({id:z.number(),name:z.string(),email:z.email()})}},description:"User created"},403:{description:"Access Denied"},409:{description:"Email or name already exists"}}},handler:async c=>{const{password,...input}=c.req.valid("json");const hashedPassword=await new PasswordModel().encryptPassword(password);const data=await new UserModel().signUp({...input,hashedPassword},c);return c.json({id:data.id,name:data.name,email:data.email},201)}});

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

@@ -35,6 +35,22 @@ export declare const listUsersAdminRoute: import("../../../../../api/lib/route")
                             avatarColor: z.ZodString;
                             emailVerified: z.ZodBoolean;
                             roleId: z.ZodNumber;
+                            role: z.ZodObject<{
+                                id: z.ZodNumber;
+                                color: z.ZodNullable<z.ZodString>;
+                                name: z.ZodArray<z.ZodObject<{
+                                    name: z.ZodString;
+                                    languageCode: z.ZodString;
+                                }, z.core.$strip>>;
+                            }, z.core.$strip>;
+                            secondaryRoles: z.ZodArray<z.ZodObject<{
+                                id: z.ZodNumber;
+                                color: z.ZodNullable<z.ZodString>;
+                                name: z.ZodArray<z.ZodObject<{
+                                    name: z.ZodString;
+                                    languageCode: z.ZodString;
+                                }, z.core.$strip>>;
+                            }, z.core.$strip>>;
                             birthday: z.ZodNullable<z.ZodDate>;
                             language: z.ZodString;
                         }, 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;AAYtC,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuF9B,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2J9B,CAAC"}

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

@@ -1 +1 @@
-import{z}from"@hono/zod-openapi";import{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_users}from"../../../../../database/users.js";export const listUsersAdminRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,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(),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,birthday:core_users.birthday,language:core_users.language}).from(core_users).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});return c.json(data)}});
+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)??[]}))}))})}});

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

@@ -2,10 +2,10 @@ import { z } from "@hono/zod-openapi";
 export declare const showUserAdminRoute: import("../../../../../api/lib/route").Route<"@vitnode/core", {
     method: "get";
     description: string;
-    path: "/{nameCode}";
+    path: "/{id}";
     request: {
         params: z.ZodObject<{
-            nameCode: z.ZodString;
+            id: z.ZodString;
         }, z.core.$strip>;
     };
     responses: {
@@ -22,8 +22,25 @@ export declare const showUserAdminRoute: import("../../../../../api/lib/route").
                         avatarColor: z.ZodString;
                         emailVerified: z.ZodBoolean;
                         roleId: z.ZodNumber;
+                        role: z.ZodObject<{
+                            id: z.ZodNumber;
+                            color: z.ZodNullable<z.ZodString>;
+                            name: z.ZodArray<z.ZodObject<{
+                                name: z.ZodString;
+                                languageCode: z.ZodString;
+                            }, z.core.$strip>>;
+                        }, z.core.$strip>;
+                        secondaryRoles: z.ZodArray<z.ZodObject<{
+                            id: z.ZodNumber;
+                            color: z.ZodNullable<z.ZodString>;
+                            name: z.ZodArray<z.ZodObject<{
+                                name: z.ZodString;
+                                languageCode: z.ZodString;
+                            }, z.core.$strip>>;
+                        }, z.core.$strip>>;
                         birthday: z.ZodNullable<z.ZodDate>;
                         language: z.ZodString;
+                        isAdmin: z.ZodBoolean;
                     }, z.core.$strip>;
                 };
             };

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

@@ -1 +1 @@
-{"version":3,"file":"show.route.d.ts","sourceRoot":"","sources":["../../../../../../../src/api/modules/admin/users/routes/show.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AAMtC,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4D7B,CAAC"}
+{"version":3,"file":"show.route.d.ts","sourceRoot":"","sources":["../../../../../../../src/api/modules/admin/users/routes/show.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AAsBtC,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkH7B,CAAC"}

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

@@ -1 +1 @@
-import{z}from"@hono/zod-openapi";import{buildRoute}from"../../../../lib/route.js";import{UserModel}from"../../../../models/user.js";import{CONFIG_PLUGIN}from"../../../../../config.js";export const showUserAdminRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,route:{method:"get",description:"Get a single user by name SEO (Admin only)",path:"/{nameCode}",request:{params:z.object({nameCode:z.string().openapi({example:"test"})})},responses:{200:{content:{"application/json":{schema: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(),birthday:z.date().nullable(),language:z.string()})}},description:"User found"},403:{description:"Access Denied"},404:{content:{"application/json":{schema:z.object({error:z.string()})}},description:"User not found"}}},handler:async c=>{const{nameCode}=c.req.valid("param");const user=await new UserModel().getUserByNameCode({nameCode,c});if(!user){return c.json({error:"User not found"},404)}return c.json(user,200)}});
+import{z}from"@hono/zod-openapi";import{eq}from"drizzle-orm";import{resolveRoleNames}from"../../../../lib/resolve-role-names.js";import{buildRoute}from"../../../../lib/route.js";import{SessionAdminModel}from"../../../../models/session-admin.js";import{UserModel}from"../../../../models/user.js";import{CONFIG_PLUGIN}from"../../../../../config.js";import{core_roles}from"../../../../../database/roles.js";import{core_users_secondary_roles}from"../../../../../database/users.js";const roleSchema=z.object({id:z.number(),color:z.string().nullable(),name:z.array(z.object({name:z.string(),languageCode:z.string()}))});export const showUserAdminRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,adminStaffPermission:{module:"users",permission:"can_view"},route:{method:"get",description:"Get a single user by id (Admin only)",path:"/{id}",request:{params:z.object({id:z.string().openapi({example:"1"})})},responses:{200:{content:{"application/json":{schema: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:roleSchema,secondaryRoles:z.array(roleSchema),birthday:z.date().nullable(),language:z.string(),isAdmin:z.boolean()})}},description:"User found"},403:{description:"Access Denied"},404:{content:{"application/json":{schema:z.object({error:z.string()})}},description:"User not found"}}},handler:async c=>{const{id}=c.req.valid("param");const userId=Number(id);if(!Number.isInteger(userId)){return c.json({error:"User not found"},404)}const user=await new UserModel().getUserById({id:userId,c});if(!user){return c.json({error:"User not found"},404)}const db=c.get("db");const secondaryRoleRows=await db.select({id:core_roles.id,color:core_roles.color}).from(core_users_secondary_roles).innerJoin(core_roles,eq(core_roles.id,core_users_secondary_roles.roleId)).where(eq(core_users_secondary_roles.userId,user.id));const[primaryRole]=await db.select({id:core_roles.id,color:core_roles.color}).from(core_roles).where(eq(core_roles.id,user.roleId)).limit(1);const names=await resolveRoleNames(c,[user.roleId,...secondaryRoleRows.map(role=>role.id)]);const isAdmin=await new SessionAdminModel(c).checkIfUserIsAdmin(user.id);return c.json({...user,isAdmin,role:{id:user.roleId,color:primaryRole?.color??null,name:names.get(user.roleId)??[]},secondaryRoles:secondaryRoleRows.map(role=>({id:role.id,color:role.color,name:names.get(role.id)??[]}))},200)}});