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

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

@@ -1 +1 @@
-{"version":3,"file":"session.route.d.ts","sourceRoot":"","sources":["../../../../../../src/api/modules/admin/routes/session.route.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2C5B,CAAC"}
+{"version":3,"file":"session.route.d.ts","sourceRoot":"","sources":["../../../../../../src/api/modules/admin/routes/session.route.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2D5B,CAAC"}

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

@@ -1 +1 @@
-import{HTTPException}from"hono/http-exception";import{z}from"zod";import{buildRoute}from"../../../lib/route.js";import{CONFIG_PLUGIN}from"../../../../config.js";export const sessionAdminRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,route:{method:"get",description:"Verify admin session",path:"/session",responses:{200:{content:{"application/json":{schema:z.object({user:z.object({id:z.number(),email:z.string(),name:z.string(),nameCode:z.string(),createdAt:z.date(),newsletter:z.boolean(),avatarColor:z.string(),emailVerified:z.boolean(),roleId:z.number(),birthday:z.date().nullable()}),vitnode_version:z.string()})}},description:"User"},403:{description:"Access Denied"}}},handler:c=>{const user=c.get("admin")?.user;if(!user)throw new HTTPException(403);return c.json({user,vitnode_version:CONFIG_PLUGIN.version})}});
+import{HTTPException}from"hono/http-exception";import{z}from"zod";import{resolveStaffPermissions}from"../../../lib/check-staff-permission.js";import{buildRoute}from"../../../lib/route.js";import{CONFIG_PLUGIN}from"../../../../config.js";export const sessionAdminRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,route:{method:"get",description:"Verify admin session",path:"/session",responses:{200:{content:{"application/json":{schema:z.object({user:z.object({id:z.number(),email:z.string(),name:z.string(),nameCode:z.string(),createdAt:z.date(),newsletter:z.boolean(),avatarColor:z.string(),emailVerified:z.boolean(),roleId:z.number(),birthday:z.date().nullable()}),permissions:z.object({root:z.boolean(),permissions:z.array(z.object({plugin:z.string(),module:z.string(),permission:z.string()}))}),vitnode_version:z.string()})}},description:"User"},403:{description:"Access Denied"}}},handler:async c=>{const user=c.get("admin")?.user;if(!user)throw new HTTPException(403);const permissions=await resolveStaffPermissions(c,{type:"admin",user});return c.json({user,permissions,vitnode_version:CONFIG_PLUGIN.version})}});

package/dist/src/api/modules/admin/staff/lib/resolve-staff-edges.d.ts

@@ -0,0 +1,38 @@
+import type { Context } from "hono";
+interface RawStaffEdge {
+    createdAt: Date;
+    data?: null | {
+        unrestricted: boolean;
+    };
+    id: number;
+    protected: boolean;
+    roleId: null | number;
+    updatedAt: Date;
+    userId: null | number;
+}
+export declare const resolveStaffEdges: (c: Context, edges: RawStaffEdge[]) => Promise<{
+    id: number;
+    createdAt: Date;
+    updatedAt: Date;
+    unrestricted: boolean;
+    protected: boolean;
+    self: boolean;
+    role: {
+        id: number;
+        color: string | null;
+        name: import("../../../../../api/lib/resolve-role-names").ResolvedRoleName[];
+    } | null;
+    user: {
+        id: number;
+        name: string;
+        nameCode: string;
+        avatarColor: string;
+        role: {
+            id: number;
+            color: string | null;
+            name: import("../../../../../api/lib/resolve-role-names").ResolvedRoleName[];
+        };
+    } | null;
+}[]>;
+export {};
+//# sourceMappingURL=resolve-staff-edges.d.ts.map

package/dist/src/api/modules/admin/staff/lib/resolve-staff-edges.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-staff-edges.d.ts","sourceRoot":"","sources":["../../../../../../../src/api/modules/admin/staff/lib/resolve-staff-edges.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AASpC,UAAU,YAAY;IACpB,SAAS,EAAE,IAAI,CAAC;IAChB,IAAI,CAAC,EAAE,IAAI,GAAG;QAAE,YAAY,EAAE,OAAO,CAAA;KAAE,CAAC;IACxC,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,OAAO,CAAC;IACnB,MAAM,EAAE,IAAI,GAAG,MAAM,CAAC;IACtB,SAAS,EAAE,IAAI,CAAC;IAChB,MAAM,EAAE,IAAI,GAAG,MAAM,CAAC;CACvB;AAED,eAAO,MAAM,iBAAiB,GAAU,GAAG,OAAO,EAAE,OAAO,YAAY,EAAE;;;;;;;;;;;;;;;;;;;;;;;IAgFxE,CAAC"}

package/dist/src/api/modules/admin/staff/lib/resolve-staff-edges.js

@@ -0,0 +1 @@
+import{eq,inArray}from"drizzle-orm";import{getUserRoleIds}from"../../../../lib/check-staff-permission.js";import{resolveRoleNames}from"../../../../lib/resolve-role-names.js";import{core_roles}from"../../../../../database/roles.js";import{core_users}from"../../../../../database/users.js";export const resolveStaffEdges=async(c,edges)=>{const currentUser=c.get("admin")?.user;const currentUserRoleIds=currentUser?new Set(await getUserRoleIds(c,currentUser)):new Set;const entryRoleIds=edges.map(edge=>edge.roleId).filter(id=>id!=null);const userIds=edges.map(edge=>edge.userId).filter(id=>id!=null);const entryRoles=entryRoleIds.length?await c.get("db").select({id:core_roles.id,color:core_roles.color}).from(core_roles).where(inArray(core_roles.id,entryRoleIds)):[];const users=userIds.length?await c.get("db").select({id:core_users.id,name:core_users.name,nameCode:core_users.nameCode,avatarColor:core_users.avatarColor,roleId:core_users.roleId,roleColor:core_roles.color}).from(core_users).leftJoin(core_roles,eq(core_roles.id,core_users.roleId)).where(inArray(core_users.id,userIds)):[];const roleNames=await resolveRoleNames(c,[...entryRoleIds,...users.map(user=>user.roleId)]);return edges.map(edge=>{const entryRole=entryRoles.find(role=>role.id===edge.roleId);const user=users.find(item=>item.id===edge.userId);const self=currentUser!=null&&(edge.userId!=null&&edge.userId===currentUser.id||edge.roleId!=null&&currentUserRoleIds.has(edge.roleId));return{id:edge.id,createdAt:edge.createdAt,updatedAt:edge.updatedAt,unrestricted:edge.data?.unrestricted??false,protected:edge.protected,self,role:entryRole?{id:entryRole.id,color:entryRole.color,name:roleNames.get(entryRole.id)??[]}:null,user:user?{id:user.id,name:user.name,nameCode:user.nameCode,avatarColor:user.avatarColor,role:{id:user.roleId,color:user.roleColor,name:roleNames.get(user.roleId)??[]}}:null}})};

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

@@ -0,0 +1,107 @@
+import { z } from "@hono/zod-openapi";
+export declare const staffListAdminQuery: z.ZodObject<{
+    cursor: z.ZodOptional<z.ZodString>;
+    first: z.ZodOptional<z.ZodString>;
+    last: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodEnum<{
+        asc: "asc";
+        desc: "desc";
+    }>>;
+    orderBy: z.ZodOptional<z.ZodEnum<{
+        id: "id";
+        createdAt: "createdAt";
+        updatedAt: "updatedAt";
+    }>>;
+}, z.core.$strip>;
+export declare const staffRoleSchema: 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>;
+export declare const staffEntrySchema: z.ZodObject<{
+    id: z.ZodNumber;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+    unrestricted: z.ZodBoolean;
+    protected: z.ZodBoolean;
+    self: z.ZodBoolean;
+    role: z.ZodNullable<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>>;
+    user: z.ZodNullable<z.ZodObject<{
+        id: z.ZodNumber;
+        name: z.ZodString;
+        nameCode: z.ZodString;
+        avatarColor: z.ZodString;
+        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>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const staffListAdminSchema: z.ZodObject<{
+    edges: z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        createdAt: z.ZodDate;
+        updatedAt: z.ZodDate;
+        unrestricted: z.ZodBoolean;
+        protected: z.ZodBoolean;
+        self: z.ZodBoolean;
+        role: z.ZodNullable<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>>;
+        user: z.ZodNullable<z.ZodObject<{
+            id: z.ZodNumber;
+            name: z.ZodString;
+            nameCode: z.ZodString;
+            avatarColor: z.ZodString;
+            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>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    pageInfo: z.ZodObject<{
+        totalCount: z.ZodNumber;
+        count: z.ZodNumber;
+        hasNextPage: z.ZodBoolean;
+        hasPreviousPage: z.ZodBoolean;
+        startCursor: z.ZodNullable<z.ZodNumber>;
+        endCursor: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const permissionsStaffArgsSchema: z.ZodObject<{
+    plugin: z.ZodString;
+    module: z.ZodString;
+    permission: z.ZodString;
+}, z.core.$strip>;
+export declare const staffTypeSchema: z.ZodEnum<{
+    admin: "admin";
+    moderator: "moderator";
+}>;
+export declare const staffPermissionModuleByType: {
+    readonly admin: "staff_admins";
+    readonly moderator: "staff_moderators";
+};
+//# sourceMappingURL=schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../../../../src/api/modules/admin/staff/lib/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AAStC,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;iBAG9B,CAAC;AAIH,eAAO,MAAM,eAAe;;;;;;;iBAS1B,CAAC;AAGH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiB3B,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAG/B,CAAC;AAEH,eAAO,MAAM,0BAA0B;;;;iBAIrC,CAAC;AAEH,eAAO,MAAM,eAAe;;;EAAiC,CAAC;AAI9D,eAAO,MAAM,2BAA2B;;;CAG9B,CAAC"}

package/dist/src/api/modules/admin/staff/lib/schema.js

@@ -0,0 +1 @@
+import{z}from"@hono/zod-openapi";import{zodPaginationPageInfo,zodPaginationQuery}from"../../../../lib/with-pagination.js";export const staffListAdminQuery=zodPaginationQuery.extend({order:z.enum(["asc","desc"]).optional(),orderBy:z.enum(["id","createdAt","updatedAt"]).optional()});export const staffRoleSchema=z.object({id:z.number(),color:z.string().nullable(),name:z.array(z.object({name:z.string(),languageCode:z.string()}))});export const staffEntrySchema=z.object({id:z.number(),createdAt:z.date(),updatedAt:z.date(),unrestricted:z.boolean(),protected:z.boolean(),self:z.boolean(),role:staffRoleSchema.nullable(),user:z.object({id:z.number(),name:z.string(),nameCode:z.string(),avatarColor:z.string(),role:staffRoleSchema}).nullable()});export const staffListAdminSchema=z.object({edges:z.array(staffEntrySchema),pageInfo:zodPaginationPageInfo});export const permissionsStaffArgsSchema=z.object({plugin:z.string(),module:z.string(),permission:z.string()});export const staffTypeSchema=z.enum(["admin","moderator"]);export const staffPermissionModuleByType={admin:"staff_admins",moderator:"staff_moderators"};

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

@@ -0,0 +1,76 @@
+export declare const listAdminsStaffAdminRoute: import("../../../../../api/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;
+}>;
+//# sourceMappingURL=admins.route.d.ts.map

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

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

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

@@ -0,0 +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,data:core_admin_permissions.data,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

@@ -0,0 +1,52 @@
+import { z } from "@hono/zod-openapi";
+export declare const createStaffAdminRoute: import("../../../../../api/lib/route").Route<"@vitnode/core", {
+    method: "post";
+    description: string;
+    path: "/entry/{type}";
+    request: {
+        params: z.ZodObject<{
+            type: z.ZodEnum<{
+                admin: "admin";
+                moderator: "moderator";
+            }>;
+        }, z.core.$strip>;
+        body: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        roleId: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                        userId: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                    }, z.core.$strip>;
+                };
+            };
+        };
+    };
+    responses: {
+        201: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        id: z.ZodNumber;
+                    }, z.core.$strip>;
+                };
+            };
+            description: string;
+        };
+        403: {
+            description: string;
+        };
+        409: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        error: z.ZodString;
+                    }, z.core.$strip>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>;
+//# sourceMappingURL=create.route.d.ts.map

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

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

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

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

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

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

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

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

package/dist/src/api/modules/admin/staff/routes/delete.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{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)}});

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

@@ -0,0 +1,76 @@
+export declare const listModeratorsStaffAdminRoute: import("../../../../../api/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;
+}>;
+//# sourceMappingURL=moderators.route.d.ts.map

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

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

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

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

package/dist/src/api/modules/admin/staff/routes/permission-catalog.route.d.ts

@@ -0,0 +1,32 @@
+import { z } from "@hono/zod-openapi";
+export declare const permissionCatalogStaffAdminRoute: import("../../../../../api/lib/route").Route<"@vitnode/core", {
+    method: "get";
+    description: string;
+    path: "/permission-catalog";
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.ZodArray<z.ZodObject<{
+                        pluginId: z.ZodString;
+                        admin: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodObject<{
+                            permission: z.ZodString;
+                            dependsOn: z.ZodArray<z.ZodString>;
+                        }, z.core.$strip>>>;
+                        moderator: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodObject<{
+                            permission: z.ZodString;
+                            dependsOn: z.ZodArray<z.ZodString>;
+                        }, z.core.$strip>>>;
+                    }, z.core.$strip>>;
+                };
+            };
+            description: string;
+        };
+        403: {
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>;
+//# sourceMappingURL=permission-catalog.route.d.ts.map

package/dist/src/api/modules/admin/staff/routes/permission-catalog.route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"permission-catalog.route.d.ts","sourceRoot":"","sources":["../../../../../../../src/api/modules/admin/staff/routes/permission-catalog.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AAetC,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8B3C,CAAC"}

package/dist/src/api/modules/admin/staff/routes/permission-catalog.route.js

@@ -0,0 +1 @@
+import{z}from"@hono/zod-openapi";import{buildRoute}from"../../../../lib/route.js";import{CONFIG_PLUGIN}from"../../../../../config.js";const permissionStaffModulesSchema=z.record(z.string(),z.array(z.object({permission:z.string(),dependsOn:z.array(z.string())})));export const permissionCatalogStaffAdminRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,route:{method:"get",description:"Get the staff permission catalog declared by every plugin (Admin only)",path:"/permission-catalog",responses:{200:{content:{"application/json":{schema:z.array(z.object({pluginId:z.string(),admin:permissionStaffModulesSchema,moderator:permissionStaffModulesSchema}))}},description:"Staff permission catalog"},403:{description:"Access Denied"}}},handler:c=>{return c.json(c.get("core").permissionStaff,200)}});

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

@@ -0,0 +1,75 @@
+import { z } from "@hono/zod-openapi";
+export declare const showPermissionsStaffAdminRoute: import("../../../../../api/lib/route").Route<"@vitnode/core", {
+    method: "get";
+    description: string;
+    path: "/entry/{type}/{id}";
+    request: {
+        params: z.ZodObject<{
+            type: z.ZodEnum<{
+                admin: "admin";
+                moderator: "moderator";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strip>;
+    };
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        id: z.ZodNumber;
+                        createdAt: z.ZodDate;
+                        updatedAt: z.ZodDate;
+                        unrestricted: z.ZodBoolean;
+                        protected: z.ZodBoolean;
+                        self: z.ZodBoolean;
+                        role: z.ZodNullable<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>>;
+                        user: z.ZodNullable<z.ZodObject<{
+                            id: z.ZodNumber;
+                            name: z.ZodString;
+                            nameCode: z.ZodString;
+                            avatarColor: z.ZodString;
+                            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>;
+                        }, z.core.$strip>>;
+                        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=show-permissions.route.d.ts.map

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

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

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

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