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

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<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
+            orderBy: z.ZodOptional<z.ZodEnum<{
+                name: "name";
+                createdAt: "createdAt";
+                size: "size";
+            }>>;
+            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.ZodNumber>;
+                            endCursor: z.ZodNullable<z.ZodNumber>;
+                        }, 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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuJ9B,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({limit,where,orderBy})=>await c.get("db").select({id:core_files.id,name:core_files.name,key:core_files.key,folder:core_files.folder,mimeType:core_files.mimeType,size:core_files.size,metadata:core_files.metadata,createdAt:core_files.createdAt,userId:core_files.userId,userName:core_users.name,userNameCode:core_users.nameCode,userRoleId:core_users.roleId,userRoleColor:core_roles.color}).from(core_files).leftJoin(core_users,eq(core_users.id,core_files.userId)).leftJoin(core_roles,eq(core_roles.id,core_users.roleId)).where(where).orderBy(orderBy).limit(limit),table:core_files,orderBy:{column:query.orderBy?core_files[query.orderBy]:core_files.createdAt,order:query.order??"desc"}});const roleNames=await resolveRoleNames(c,data.edges.map(edge=>edge.userRoleId).filter(id=>id!=null));return c.json({...data,edges:data.edges.map(({key,userId,userName,userNameCode,userRoleId,userRoleColor,...file})=>({...file,url:hasAdapter?storage.getUrl(key):null,dimensions:parseImageDimensions(file.metadata),user:userId!=null&&userName!=null?{id:userId,name:userName,nameCode:userNameCode??"",role:{id:userRoleId??0,color:userRoleColor??null,name:userRoleId!=null?roleNames.get(userRoleId)??[]:[]}}:null}))})}});

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

@@ -35,9 +35,13 @@ export declare const rolesAdminModule: import("../../../../api/lib/module").Buil
                             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;
@@ -82,6 +86,9 @@ export declare const rolesAdminModule: import("../../../../api/lib/module").Buil
                         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>;
@@ -105,5 +112,147 @@ export declare const rolesAdminModule: import("../../../../api/lib/module").Buil
     };
 } & {
     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

@@ -1 +1 @@
-{"version":3,"file":"roles.admin.module.d.ts","sourceRoot":"","sources":["../../../../../../src/api/modules/admin/roles/roles.admin.module.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iLAI3B,CAAC"}
+{"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

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

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

@@ -36,9 +36,13 @@ export declare const listRolesAdminRoute: import("../../../../../api/lib/route")
                             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;

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

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

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

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

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

@@ -23,6 +23,9 @@ export declare const showRoleAdminRoute: import("../../../../../api/lib/route").
                         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>;

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

@@ -1 +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;AA2BtC,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwF7B,CAAC"}
+{"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"}

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

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

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

@@ -1,12 +1,10 @@
 import type { Context } from "hono";
 interface RawStaffEdge {
     createdAt: Date;
-    data?: null | {
-        unrestricted: boolean;
-    };
     id: number;
     protected: boolean;
     roleId: null | number;
+    unrestricted: boolean;
     updatedAt: Date;
     userId: null | number;
 }

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

@@ -1 +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"}
+{"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

@@ -1 +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}})};
+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/routes/admins.route.js

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

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

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