@vitnode/core 0.0.1-canary.0

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

@@ -0,0 +1 @@
+import{z}from"@hono/zod-openapi";import{and,eq}from"drizzle-orm";import{buildRoute}from"../../../../lib/route.js";import{CONFIG_PLUGIN}from"../../../../../config.js";import{core_languages_words}from"../../../../../database/languages.js";import{core_roles}from"../../../../../database/roles.js";const roleAdminSchema=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()});export const showRoleAdminRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,route:{method:"get",description:"Get a single role by id (Admin only)",path:"/{id}",request:{params:z.object({id:z.string().openapi({example:"1"})})},responses:{200:{content:{"application/json":{schema:roleAdminSchema}},description:"Role found"},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 roleId=Number(id);if(!Number.isInteger(roleId)){return c.json({error:"Role not found"},404)}const[role]=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}).from(core_roles).where(eq(core_roles.id,roleId)).limit(1);if(!role){return c.json({error:"Role not found"},404)}const names=await c.get("db").select({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"),eq(core_languages_words.itemId,roleId)));return c.json({...role,name:names.map(word=>({name:word.value,languageCode:word.languageCode}))},200)}});

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

@@ -0,0 +1,66 @@
+import { z } from "@hono/zod-openapi";
+export declare const zodUpdateRoleAdminSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        languageCode: z.ZodString;
+        value: z.ZodString;
+    }, z.core.$strip>>>;
+    color: z.ZodOptional<z.ZodString>;
+    allowUploadFiles: z.ZodOptional<z.ZodBoolean>;
+    totalMaxStorage: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    maxStorageForSubmit: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, z.core.$strip>;
+export declare const updateRoleAdminRoute: import("../../../../../api/lib/route").Route<"@vitnode/core", {
+    method: "patch";
+    description: string;
+    path: "/{id}";
+    request: {
+        params: z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$strip>;
+        body: {
+            required: true;
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        name: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                            languageCode: z.ZodString;
+                            value: z.ZodString;
+                        }, z.core.$strip>>>;
+                        color: z.ZodOptional<z.ZodString>;
+                        allowUploadFiles: z.ZodOptional<z.ZodBoolean>;
+                        totalMaxStorage: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                        maxStorageForSubmit: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                    }, z.core.$strip>;
+                };
+            };
+        };
+    };
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        id: z.ZodNumber;
+                    }, 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.route.d.ts.map

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

@@ -0,0 +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;AAYtC,eAAO,MAAM,wBAAwB;;;;;;;;;iBAWjC,CAAC;AAEL,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsG/B,CAAC"}

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

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

@@ -0,0 +1,54 @@
+import { z } from "zod";
+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";
+        warning: "warning";
+    }>>;
+    userId: z.ZodNumber;
+}, z.core.$strip>;
+export declare const sendNotificationRoute: import("../../../../api/lib/route").Route<"@vitnode/core", {
+    method: "post";
+    description: string;
+    path: "/notifications/send";
+    request: {
+        body: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        description: z.ZodOptional<z.ZodString>;
+                        title: z.ZodString;
+                        type: z.ZodOptional<z.ZodEnum<{
+                            info: "info";
+                            error: "error";
+                            success: "success";
+                            warning: "warning";
+                        }>>;
+                        userId: z.ZodNumber;
+                    }, z.core.$strip>;
+                };
+            };
+        };
+    };
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        success: z.ZodBoolean;
+                    }, z.core.$strip>;
+                };
+            };
+            description: string;
+        };
+        403: {
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>;
+//# sourceMappingURL=notifications.route.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"notifications.route.d.ts","sourceRoot":"","sources":["../../../../../../src/api/modules/admin/routes/notifications.route.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,yBAAyB;;;;;;;;;;iBAKpC,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4ChC,CAAC"}

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

@@ -0,0 +1 @@
+import{HTTPException}from"hono/http-exception";import{z}from"zod";import{buildRoute}from"../../../lib/route.js";import{CONFIG_PLUGIN}from"../../../../config.js";import{notificationsChannel}from"../../../../ws/notifications.js";export const zodSendNotificationSchema=z.object({description:z.string().optional(),title:z.string().min(1,"Title is required"),type:z.enum(["error","info","success","warning"]).optional(),userId:z.number()});export const sendNotificationRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,route:{method:"post",description:"Send a notification to a user",path:"/notifications/send",request:{body:{content:{"application/json":{schema:zodSendNotificationSchema}}}},responses:{200:{content:{"application/json":{schema:z.object({success:z.boolean()})}},description:"Notification sent"},403:{description:"Access Denied"}}},handler:c=>{const admin=c.get("admin")?.user;if(!admin)throw new HTTPException(403);const{userId,title,description,type}=c.req.valid("json");c.get("realtime").sendToUser(userId,notificationsChannel,{description,title,type});return c.json({success:true})}});

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

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

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

@@ -0,0 +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;AAMxB,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2D5B,CAAC"}

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

@@ -0,0 +1 @@
+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,36 @@
+import type { Context } from "hono";
+interface RawStaffEdge {
+    createdAt: Date;
+    id: number;
+    protected: boolean;
+    roleId: null | number;
+    unrestricted: boolean;
+    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,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,OAAO,CAAC;IACnB,MAAM,EAAE,IAAI,GAAG,MAAM,CAAC;IACtB,YAAY,EAAE,OAAO,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.unrestricted,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<{
+        desc: "desc";
+        asc: "asc";
+    }>>;
+    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.ZodString>;
+        endCursor: z.ZodNullable<z.ZodString>;
+    }, 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<{
+                desc: "desc";
+                asc: "asc";
+            }>>;
+            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").ZodString>;
+                            endCursor: import("zod").ZodNullable<import("zod").ZodString>;
+                        }, 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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgEpC,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({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

@@ -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;AAiBtC,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2FhC,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{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

@@ -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;AAqBtC,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqFhC,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{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

@@ -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<{
+                desc: "desc";
+                asc: "asc";
+            }>>;
+            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").ZodString>;
+                            endCursor: import("zod").ZodNullable<import("zod").ZodString>;
+                        }, import("zod/v4/core").$strip>;
+                    }, import("zod/v4/core").$strip>;
+                };
+            };
+            description: string;
+        };
+        403: {
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>;
+//# sourceMappingURL=moderators.route.d.ts.map