@vitnode/core 0.0.1-canary.0

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

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

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

@@ -0,0 +1,72 @@
+import z from "zod";
+export declare const listFilesAdminRoute: import("../../../../../api/lib/route").Route<"@vitnode/core", {
+    method: "get";
+    description: string;
+    path: "/";
+    request: {
+        query: z.ZodObject<{
+            cursor: z.ZodOptional<z.ZodString>;
+            first: z.ZodOptional<z.ZodString>;
+            last: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodEnum<{
+                desc: "desc";
+                asc: "asc";
+            }>>;
+            orderBy: z.ZodOptional<z.ZodEnum<{
+                createdAt: "createdAt";
+                size: "size";
+                name: "name";
+            }>>;
+            search: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    };
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        edges: z.ZodArray<z.ZodObject<{
+                            id: z.ZodNumber;
+                            name: z.ZodString;
+                            folder: z.ZodString;
+                            mimeType: z.ZodNullable<z.ZodString>;
+                            size: z.ZodNumber;
+                            metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                            createdAt: z.ZodDate;
+                            dimensions: z.ZodNullable<z.ZodObject<{
+                                width: z.ZodNumber;
+                                height: z.ZodNumber;
+                            }, z.core.$strip>>;
+                            user: z.ZodNullable<z.ZodObject<{
+                                id: z.ZodNumber;
+                                name: z.ZodString;
+                                nameCode: 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>>;
+                            url: z.ZodNullable<z.ZodString>;
+                        }, z.core.$strip>>;
+                        pageInfo: z.ZodObject<{
+                            totalCount: z.ZodNumber;
+                            count: z.ZodNumber;
+                            hasNextPage: z.ZodBoolean;
+                            hasPreviousPage: z.ZodBoolean;
+                            startCursor: z.ZodNullable<z.ZodString>;
+                            endCursor: z.ZodNullable<z.ZodString>;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>;
+//# sourceMappingURL=list.route.d.ts.map

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

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

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

@@ -0,0 +1 @@
+import{eq}from"drizzle-orm";import z from"zod";import{resolveRoleNames}from"../../../../lib/resolve-role-names.js";import{buildRoute}from"../../../../lib/route.js";import{withPagination,zodPaginationPageInfo,zodPaginationQuery}from"../../../../lib/with-pagination.js";import{CONFIG_PLUGIN}from"../../../../../config.js";import{core_files}from"../../../../../database/files.js";import{core_roles}from"../../../../../database/roles.js";import{core_users}from"../../../../../database/users.js";import{parseImageDimensions}from"../../../../../lib/api/upload.js";export const listFilesAdminRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,adminStaffPermission:{module:"files",permission:"can_view"},route:{method:"get",description:"List uploaded files stored in core_files (Admin only).",path:"/",request:{query:zodPaginationQuery.extend({order:z.enum(["asc","desc"]).optional(),orderBy:z.enum(["name","size","createdAt"]).optional(),search:z.string().optional()})},responses:{200:{content:{"application/json":{schema:z.object({edges:z.array(z.object({id:z.number(),name:z.string(),folder:z.string(),mimeType:z.string().nullable(),size:z.number(),metadata:z.record(z.string(),z.unknown()),createdAt:z.date(),dimensions:z.object({width:z.number(),height:z.number()}).nullable(),user:z.object({id:z.number(),name:z.string(),nameCode:z.string(),role:z.object({id:z.number(),color:z.string().nullable(),name:z.array(z.object({name:z.string(),languageCode:z.string()}))})}).nullable(),url:z.string().nullable()})),pageInfo:zodPaginationPageInfo})}},description:"List of uploaded files"}}},handler:async c=>{const query=c.req.valid("query");const hasAdapter=!!c.get("core").storage?.adapter;const storage=c.get("storage");const data=await withPagination({params:{query},c,primaryCursor:core_files.id,search:[core_files.name],query:async({cursorSelection,limit,where,orderBy})=>await c.get("db").select({...cursorSelection,id:core_files.id,name:core_files.name,key:core_files.key,folder:core_files.folder,mimeType:core_files.mimeType,size:core_files.size,metadata:core_files.metadata,createdAt:core_files.createdAt,userId:core_files.userId,userName:core_users.name,userNameCode:core_users.nameCode,userRoleId:core_users.roleId,userRoleColor:core_roles.color}).from(core_files).leftJoin(core_users,eq(core_users.id,core_files.userId)).leftJoin(core_roles,eq(core_roles.id,core_users.roleId)).where(where).orderBy(orderBy).limit(limit),table:core_files,orderBy:{column:query.orderBy?core_files[query.orderBy]:core_files.createdAt,order:query.order??"desc"}});const roleNames=await resolveRoleNames(c,data.edges.map(edge=>edge.userRoleId).filter(id=>id!=null));return c.json({...data,edges:data.edges.map(({key,userId,userName,userNameCode,userRoleId,userRoleColor,...file})=>({...file,url:hasAdapter?storage.getUrl(key):null,dimensions:parseImageDimensions(file.metadata),user:userId!=null&&userName!=null?{id:userId,name:userName,nameCode:userNameCode??"",role:{id:userRoleId??0,color:userRoleColor??null,name:userRoleId!=null?roleNames.get(userRoleId)??[]:[]}}:null}))})}});

package/dist/src/api/modules/admin/roles/lib/assert-manage-admin-role.d.ts

@@ -0,0 +1,6 @@
+import type { Context } from "hono";
+export declare const assertCanManageAdminRole: (c: Context, { roleId, permission, }: {
+    permission: "can_delete_admin" | "can_edit_admin";
+    roleId: number;
+}) => Promise<void>;
+//# sourceMappingURL=assert-manage-admin-role.d.ts.map

package/dist/src/api/modules/admin/roles/lib/assert-manage-admin-role.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assert-manage-admin-role.d.ts","sourceRoot":"","sources":["../../../../../../../src/api/modules/admin/roles/lib/assert-manage-admin-role.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAiBpC,eAAO,MAAM,wBAAwB,GACnC,GAAG,OAAO,EACV,yBAGG;IACD,UAAU,EAAE,kBAAkB,GAAG,gBAAgB,CAAC;IAClD,MAAM,EAAE,MAAM,CAAC;CAChB,KACA,OAAO,CAAC,IAAI,CAgBd,CAAC"}

package/dist/src/api/modules/admin/roles/lib/assert-manage-admin-role.js

@@ -0,0 +1 @@
+import{eq}from"drizzle-orm";import{assertStaffPermission}from"../../../../lib/check-staff-permission.js";import{CONFIG_PLUGIN}from"../../../../../config.js";import{core_admin_permissions}from"../../../../../database/admins.js";export const assertCanManageAdminRole=async(c,{roleId,permission})=>{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 assertStaffPermission(c,{type:"admin",plugin:CONFIG_PLUGIN.pluginId,module:"roles",permission})};

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

@@ -0,0 +1,258 @@
+export declare const rolesAdminModule: import("../../../../api/lib/module").BuildModuleReturn<"@vitnode/core", "roles", [import("../../../lib/route").Route<"@vitnode/core", {
+    method: "get";
+    description: string;
+    path: "/list";
+    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";
+            }>>;
+            search: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>;
+    };
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        edges: import("zod").ZodArray<import("zod").ZodObject<{
+                            id: import("zod").ZodNumber;
+                            name: import("zod").ZodArray<import("zod").ZodObject<{
+                                name: import("zod").ZodString;
+                                languageCode: import("zod").ZodString;
+                            }, import("zod/v4/core").$strip>>;
+                            color: import("zod").ZodNullable<import("zod").ZodString>;
+                            protected: import("zod").ZodBoolean;
+                            default: import("zod").ZodBoolean;
+                            root: import("zod").ZodBoolean;
+                            guest: import("zod").ZodBoolean;
+                            allowUploadFiles: import("zod").ZodBoolean;
+                            totalMaxStorage: import("zod").ZodNullable<import("zod").ZodNumber>;
+                            maxStorageForSubmit: import("zod").ZodNullable<import("zod").ZodNumber>;
+                            createdAt: import("zod").ZodDate;
+                            updatedAt: import("zod").ZodDate;
+                            usersCount: import("zod").ZodNumber;
+                            grantsAdmin: import("zod").ZodBoolean;
+                        }, 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;
+}>, import("../../../lib/route").Route<"@vitnode/core", {
+    method: "get";
+    description: string;
+    path: "/{id}";
+    request: {
+        params: import("zod").ZodObject<{
+            id: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+    };
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        id: import("zod").ZodNumber;
+                        name: import("zod").ZodArray<import("zod").ZodObject<{
+                            name: import("zod").ZodString;
+                            languageCode: import("zod").ZodString;
+                        }, import("zod/v4/core").$strip>>;
+                        color: import("zod").ZodNullable<import("zod").ZodString>;
+                        protected: import("zod").ZodBoolean;
+                        default: import("zod").ZodBoolean;
+                        root: import("zod").ZodBoolean;
+                        guest: import("zod").ZodBoolean;
+                        allowUploadFiles: import("zod").ZodBoolean;
+                        totalMaxStorage: import("zod").ZodNullable<import("zod").ZodNumber>;
+                        maxStorageForSubmit: import("zod").ZodNullable<import("zod").ZodNumber>;
+                        createdAt: import("zod").ZodDate;
+                        updatedAt: import("zod").ZodDate;
+                    }, 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: "/create";
+    request: {
+        body: {
+            required: true;
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        name: import("zod").ZodArray<import("zod").ZodObject<{
+                            languageCode: import("zod").ZodString;
+                            value: import("zod").ZodString;
+                        }, import("zod/v4/core").$strip>>;
+                        color: import("zod").ZodOptional<import("zod").ZodString>;
+                        allowUploadFiles: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                        totalMaxStorage: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodNumber>>;
+                        maxStorageForSubmit: 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;
+        };
+    };
+} & {
+    path: string;
+}>, import("../../../lib/route").Route<"@vitnode/core", {
+    method: "patch";
+    description: string;
+    path: "/{id}";
+    request: {
+        params: import("zod").ZodObject<{
+            id: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+        body: {
+            required: true;
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        name: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                            languageCode: import("zod").ZodString;
+                            value: import("zod").ZodString;
+                        }, import("zod/v4/core").$strip>>>;
+                        color: import("zod").ZodOptional<import("zod").ZodString>;
+                        allowUploadFiles: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                        totalMaxStorage: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodNumber>>;
+                        maxStorageForSubmit: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodNumber>>;
+                    }, import("zod/v4/core").$strip>;
+                };
+            };
+        };
+    };
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        id: import("zod").ZodNumber;
+                    }, 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: "delete";
+    description: string;
+    path: "/{id}";
+    request: {
+        params: import("zod").ZodObject<{
+            id: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+        query: import("zod").ZodObject<{
+            moveToRoleId: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>;
+    };
+    responses: {
+        200: {
+            description: string;
+        };
+        400: {
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        error: import("zod").ZodString;
+                    }, import("zod/v4/core").$strip>;
+                };
+            };
+            description: string;
+        };
+        403: {
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        error: import("zod").ZodString;
+                    }, import("zod/v4/core").$strip>;
+                };
+            };
+            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=roles.admin.module.d.ts.map

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

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

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

@@ -0,0 +1 @@
+import{buildModule}from"../../../lib/module.js";import{CONFIG_PLUGIN}from"../../../../config.js";import{createRoleAdminRoute}from"./routes/create.route.js";import{deleteRoleAdminRoute}from"./routes/delete.route.js";import{listRolesAdminRoute}from"./routes/list.route.js";import{showRoleAdminRoute}from"./routes/show.route.js";import{updateRoleAdminRoute}from"./routes/update.route.js";export const rolesAdminModule=buildModule({pluginId:CONFIG_PLUGIN.pluginId,name:"roles",routes:[listRolesAdminRoute,showRoleAdminRoute,createRoleAdminRoute,updateRoleAdminRoute,deleteRoleAdminRoute]});

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

@@ -0,0 +1,58 @@
+import { z } from "@hono/zod-openapi";
+export declare const zodRoleNameSchema: z.ZodArray<z.ZodObject<{
+    languageCode: z.ZodString;
+    value: z.ZodString;
+}, z.core.$strip>>;
+export declare const zodRoleStorageSchema: z.ZodNullable<z.ZodNumber>;
+export declare const zodCreateRoleAdminSchema: z.ZodObject<{
+    name: 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 createRoleAdminRoute: import("../../../../../api/lib/route").Route<"@vitnode/core", {
+    method: "post";
+    description: string;
+    path: "/create";
+    request: {
+        body: {
+            required: true;
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        name: 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: {
+        201: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        id: z.ZodNumber;
+                    }, z.core.$strip>;
+                };
+            };
+            description: string;
+        };
+        403: {
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>;
+//# sourceMappingURL=create.route.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"create.route.d.ts","sourceRoot":"","sources":["../../../../../../../src/api/modules/admin/roles/routes/create.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AAStC,eAAO,MAAM,iBAAiB;;;kBAOrB,CAAC;AAGV,eAAO,MAAM,oBAAoB,4BAAqC,CAAC;AAEvE,eAAO,MAAM,wBAAwB;;;;;;;;;iBAMnC,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgE/B,CAAC"}

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

@@ -0,0 +1 @@
+import{z}from"@hono/zod-openapi";import{buildRoute}from"../../../../lib/route.js";import{saveLanguageWords}from"../../../../lib/save-language-words.js";import{CONFIG_PLUGIN}from"../../../../../config.js";import{core_roles}from"../../../../../database/roles.js";export const zodRoleNameSchema=z.array(z.object({languageCode:z.string(),value:z.string().min(1).max(255)})).min(1);export const zodRoleStorageSchema=z.number().int().min(0).nullable();export const zodCreateRoleAdminSchema=z.object({name:zodRoleNameSchema,color:z.string().max(50).optional(),allowUploadFiles:z.boolean().optional(),totalMaxStorage:zodRoleStorageSchema.optional(),maxStorageForSubmit:zodRoleStorageSchema.optional()});export const createRoleAdminRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,adminStaffPermission:{module:"roles",permission:"can_create"},route:{method:"post",description:"Create a new role (Admin only)",path:"/create",request:{body:{required:true,content:{"application/json":{schema:zodCreateRoleAdminSchema}}}},responses:{201:{content:{"application/json":{schema:z.object({id:z.number()})}},description:"Role created"},403:{description:"Access Denied"}}},handler:async c=>{const{name,color,allowUploadFiles,totalMaxStorage,maxStorageForSubmit}=c.req.valid("json");const[role]=await c.get("db").insert(core_roles).values({color:color?.trim()?color:null,allowUploadFiles:allowUploadFiles??false,totalMaxStorage:totalMaxStorage??null,maxStorageForSubmit:maxStorageForSubmit??null,updatedAt:new Date}).returning({id:core_roles.id});await saveLanguageWords(c,{pluginCode:"core",tableName:"core_roles",variable:"name",itemId:role.id,values:name});await c.get("events").emit("role.created",{roleId:role.id});return c.json({id:role.id},201)}});

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

@@ -0,0 +1,52 @@
+import { z } from "@hono/zod-openapi";
+export declare const deleteRoleAdminRoute: import("../../../../../api/lib/route").Route<"@vitnode/core", {
+    method: "delete";
+    description: string;
+    path: "/{id}";
+    request: {
+        params: z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$strip>;
+        query: z.ZodObject<{
+            moveToRoleId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    };
+    responses: {
+        200: {
+            description: string;
+        };
+        400: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        error: z.ZodString;
+                    }, z.core.$strip>;
+                };
+            };
+            description: string;
+        };
+        403: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        error: z.ZodString;
+                    }, z.core.$strip>;
+                };
+            };
+            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/roles/routes/delete.route.d.ts.map

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

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

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

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

@@ -0,0 +1,67 @@
+import { z } from "@hono/zod-openapi";
+export declare const listRolesAdminRoute: import("../../../../../api/lib/route").Route<"@vitnode/core", {
+    method: "get";
+    description: string;
+    path: "/list";
+    request: {
+        query: 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";
+            }>>;
+            search: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    };
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        edges: z.ZodArray<z.ZodObject<{
+                            id: z.ZodNumber;
+                            name: z.ZodArray<z.ZodObject<{
+                                name: z.ZodString;
+                                languageCode: z.ZodString;
+                            }, z.core.$strip>>;
+                            color: z.ZodNullable<z.ZodString>;
+                            protected: z.ZodBoolean;
+                            default: z.ZodBoolean;
+                            root: z.ZodBoolean;
+                            guest: z.ZodBoolean;
+                            allowUploadFiles: z.ZodBoolean;
+                            totalMaxStorage: z.ZodNullable<z.ZodNumber>;
+                            maxStorageForSubmit: z.ZodNullable<z.ZodNumber>;
+                            createdAt: z.ZodDate;
+                            updatedAt: z.ZodDate;
+                            usersCount: z.ZodNumber;
+                            grantsAdmin: z.ZodBoolean;
+                        }, 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>;
+                };
+            };
+            description: string;
+        };
+        403: {
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>;
+//# sourceMappingURL=list.route.d.ts.map

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

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

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

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

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

@@ -0,0 +1,53 @@
+import { z } from "@hono/zod-openapi";
+export declare const showRoleAdminRoute: import("../../../../../api/lib/route").Route<"@vitnode/core", {
+    method: "get";
+    description: string;
+    path: "/{id}";
+    request: {
+        params: z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$strip>;
+    };
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        id: z.ZodNumber;
+                        name: z.ZodArray<z.ZodObject<{
+                            name: z.ZodString;
+                            languageCode: z.ZodString;
+                        }, z.core.$strip>>;
+                        color: z.ZodNullable<z.ZodString>;
+                        protected: z.ZodBoolean;
+                        default: z.ZodBoolean;
+                        root: z.ZodBoolean;
+                        guest: z.ZodBoolean;
+                        allowUploadFiles: z.ZodBoolean;
+                        totalMaxStorage: z.ZodNullable<z.ZodNumber>;
+                        maxStorageForSubmit: z.ZodNullable<z.ZodNumber>;
+                        createdAt: z.ZodDate;
+                        updatedAt: z.ZodDate;
+                    }, 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.route.d.ts.map

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

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