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

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

@@ -0,0 +1,83 @@
+import { z } from "@hono/zod-openapi";
+export declare const zodUpdateUserAdminSchema: z.ZodObject<{
+    email: z.ZodOptional<z.ZodEmail>;
+    name: z.ZodOptional<z.ZodString>;
+    nameCode: z.ZodOptional<z.ZodString>;
+    roleId: z.ZodOptional<z.ZodNumber>;
+    secondaryRoleIds: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+}, z.core.$strip>;
+export declare const updateUserAdminRoute: 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<{
+                        email: z.ZodOptional<z.ZodEmail>;
+                        name: z.ZodOptional<z.ZodString>;
+                        nameCode: z.ZodOptional<z.ZodString>;
+                        roleId: z.ZodOptional<z.ZodNumber>;
+                        secondaryRoleIds: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+                    }, z.core.$strip>;
+                };
+            };
+        };
+    };
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        id: z.ZodNumber;
+                        name: z.ZodString;
+                        email: z.ZodEmail;
+                        nameCode: z.ZodString;
+                    }, z.core.$strip>;
+                };
+            };
+            description: string;
+        };
+        400: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        error: z.ZodString;
+                    }, z.core.$strip>;
+                };
+            };
+            description: string;
+        };
+        403: {
+            description: string;
+        };
+        404: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        error: z.ZodString;
+                    }, z.core.$strip>;
+                };
+            };
+            description: string;
+        };
+        409: {
+            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/users/routes/update.route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update.route.d.ts","sourceRoot":"","sources":["../../../../../../../src/api/modules/admin/users/routes/update.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AAetC,eAAO,MAAM,wBAAwB;;;;;;iBA0BjC,CAAC;AAEL,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqN/B,CAAC"}

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

@@ -0,0 +1 @@
+import{z}from"@hono/zod-openapi";import{and,eq,inArray,ne}from"drizzle-orm";import{buildRoute}from"../../../../lib/route.js";import{CONFIG_PLUGIN}from"../../../../../config.js";import{core_roles}from"../../../../../database/roles.js";import{core_users,core_users_secondary_roles}from"../../../../../database/users.js";import{assertCanAssignPrimaryRole,assertCanEditAdminTarget}from"../lib/assert-edit-user-permission.js";const nameRegex=/^(?!.* {2})[\p{L}\p{N}._@ -]*$/u;export const zodUpdateUserAdminSchema=z.object({email:z.email().toLowerCase().openapi({example:"test@test.com"}),name:z.string().min(3).refine(val=>nameRegex.test(val),{message:"Invalid name"}).openapi({example:"test"}),nameCode:z.string().min(3).max(255).regex(/^[a-zA-Z0-9-]+$/,{message:"Invalid name code"}).openapi({example:"test"}),roleId:z.number().int().positive().openapi({example:1}),secondaryRoleIds:z.array(z.number().int().positive()).openapi({example:[2,3]})}).partial().refine(body=>Object.values(body).some(value=>value!==undefined),{message:"At least one field is required"});export const updateUserAdminRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,adminStaffPermission:{module:"users",permission:"can_edit"},route:{method:"patch",description:"Update a user's name or email by id (Admin only)",path:"/{id}",request:{params:z.object({id:z.string().openapi({example:"1"})}),body:{required:true,content:{"application/json":{schema:zodUpdateUserAdminSchema}}}},responses:{200:{content:{"application/json":{schema:z.object({id:z.number(),name:z.string(),email:z.email(),nameCode:z.string()})}},description:"User updated"},400:{content:{"application/json":{schema:z.object({error:z.string()})}},description:"Invalid role"},403:{description:"Access Denied"},404:{content:{"application/json":{schema:z.object({error:z.string()})}},description:"User not found"},409:{content:{"application/json":{schema:z.object({error:z.string()})}},description:"Email or name already exists"}}},handler:async c=>{const{id}=c.req.valid("param");const body=c.req.valid("json");const db=c.get("db");const userId=Number(id);if(!Number.isInteger(userId)){return c.json({error:"User not found"},404)}const[user]=await db.select({id:core_users.id,roleId:core_users.roleId}).from(core_users).where(eq(core_users.id,userId)).limit(1);if(!user){return c.json({error:"User not found"},404)}await assertCanEditAdminTarget(c,userId);const values={};if(body.email!==undefined){const[existing]=await db.select({id:core_users.id}).from(core_users).where(and(eq(core_users.email,body.email),ne(core_users.id,user.id))).limit(1);if(existing){return c.json({error:"Email already exists"},409)}values.email=body.email}if(body.name!==undefined){const[existing]=await db.select({id:core_users.id}).from(core_users).where(and(eq(core_users.name,body.name),ne(core_users.id,user.id))).limit(1);if(existing){return c.json({error:"Name already exists"},409)}values.name=body.name}if(body.nameCode!==undefined){const[existing]=await db.select({id:core_users.id}).from(core_users).where(and(eq(core_users.nameCode,body.nameCode),ne(core_users.id,user.id))).limit(1);if(existing){return c.json({error:"Name code already exists"},409)}values.nameCode=body.nameCode}const effectivePrimaryId=body.roleId??user.roleId;const secondaryRoleIds=body.secondaryRoleIds!==undefined?[...new Set(body.secondaryRoleIds)].filter(id=>id!==effectivePrimaryId):undefined;const roleIdsToValidate=[...body.roleId!==undefined?[body.roleId]:[],...secondaryRoleIds??[]];if(roleIdsToValidate.length>0){const existingRoles=await db.select({id:core_roles.id,guest:core_roles.guest}).from(core_roles).where(inArray(core_roles.id,roleIdsToValidate));const assignableRoleIds=new Set(existingRoles.filter(role=>!role.guest).map(role=>role.id));if(roleIdsToValidate.some(id=>!assignableRoleIds.has(id))){return c.json({error:"Invalid role"},400)}}if(body.roleId!==undefined){await assertCanAssignPrimaryRole(c,body.roleId);values.roleId=body.roleId}if(secondaryRoleIds!==undefined){await db.delete(core_users_secondary_roles).where(eq(core_users_secondary_roles.userId,user.id));if(secondaryRoleIds.length>0){await db.insert(core_users_secondary_roles).values(secondaryRoleIds.map(roleId=>({userId:user.id,roleId})))}}if(Object.keys(values).length>0){const[updated]=await db.update(core_users).set(values).where(eq(core_users.id,user.id)).returning({id:core_users.id,name:core_users.name,email:core_users.email,nameCode:core_users.nameCode});return c.json(updated,200)}const[current]=await db.select({id:core_users.id,name:core_users.name,email:core_users.email,nameCode:core_users.nameCode}).from(core_users).where(eq(core_users.id,user.id)).limit(1);return c.json(current,200)}});

package/dist/src/api/modules/admin/users/routes/verify-email.route.d.ts

@@ -2,10 +2,10 @@ import { z } from "@hono/zod-openapi";
 export declare const verifyEmailUserAdminRoute: import("../../../../../api/lib/route").Route<"@vitnode/core", {
     method: "post";
     description: string;
-    path: "/{nameCode}/verify-email";
+    path: "/{id}/verify-email";
     request: {
         params: z.ZodObject<{
-            nameCode: z.ZodString;
+            id: z.ZodString;
         }, z.core.$strip>;
     };
     responses: {

package/dist/src/api/modules/admin/users/routes/verify-email.route.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"verify-email.route.d.ts","sourceRoot":"","sources":["../../../../../../../src/api/modules/admin/users/routes/verify-email.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AAOtC,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2DpC,CAAC"}
+{"version":3,"file":"verify-email.route.d.ts","sourceRoot":"","sources":["../../../../../../../src/api/modules/admin/users/routes/verify-email.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AAStC,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0EpC,CAAC"}

package/dist/src/api/modules/admin/users/routes/verify-email.route.js

@@ -1 +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_users}from"../../../../../database/users.js";export const verifyEmailUserAdminRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,route:{method:"post",description:"Verify a user's email by name SEO (Admin only)",path:"/{nameCode}/verify-email",request:{params:z.object({nameCode:z.string().openapi({example:"test"})})},responses:{200:{content:{"application/json":{schema:z.object({name:z.string(),emailVerified:z.boolean()})}},description:"Email verified"},403:{description:"Access Denied"},404:{content:{"application/json":{schema:z.object({error:z.string()})}},description:"User not found"}}},handler:async c=>{const{nameCode}=c.req.valid("param");const[updated]=await c.get("db").update(core_users).set({emailVerified:true}).where(eq(core_users.nameCode,nameCode)).returning({name:core_users.name,emailVerified:core_users.emailVerified});if(!updated){return c.json({error:"User not found"},404)}return c.json({name:updated.name,emailVerified:updated.emailVerified},200)}});
+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_users}from"../../../../../database/users.js";import{assertCanEditAdminTarget}from"../lib/assert-edit-user-permission.js";export const verifyEmailUserAdminRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,adminStaffPermission:{module:"users",permission:"can_edit"},route:{method:"post",description:"Verify a user's email by id (Admin only)",path:"/{id}/verify-email",request:{params:z.object({id:z.string().openapi({example:"1"})})},responses:{200:{content:{"application/json":{schema:z.object({name:z.string(),emailVerified:z.boolean()})}},description:"Email verified"},403:{description:"Access Denied"},404:{content:{"application/json":{schema:z.object({error:z.string()})}},description:"User not found"}}},handler:async c=>{const{id}=c.req.valid("param");const userId=Number(id);if(!Number.isInteger(userId)){return c.json({error:"User not found"},404)}const db=c.get("db");const[user]=await db.select({id:core_users.id}).from(core_users).where(eq(core_users.id,userId)).limit(1);if(!user){return c.json({error:"User not found"},404)}await assertCanEditAdminTarget(c,userId);const[updated]=await db.update(core_users).set({emailVerified:true}).where(eq(core_users.id,user.id)).returning({name:core_users.name,emailVerified:core_users.emailVerified});return c.json({name:updated.name,emailVerified:updated.emailVerified},200)}});

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

@@ -34,6 +34,22 @@ export declare const usersAdminModule: import("../../../../api/lib/module").Buil
                             avatarColor: import("zod").ZodString;
                             emailVerified: import("zod").ZodBoolean;
                             roleId: import("zod").ZodNumber;
+                            role: import("zod").ZodObject<{
+                                id: import("zod").ZodNumber;
+                                color: import("zod").ZodNullable<import("zod").ZodString>;
+                                name: import("zod").ZodArray<import("zod").ZodObject<{
+                                    name: import("zod").ZodString;
+                                    languageCode: import("zod").ZodString;
+                                }, import("zod/v4/core").$strip>>;
+                            }, import("zod/v4/core").$strip>;
+                            secondaryRoles: import("zod").ZodArray<import("zod").ZodObject<{
+                                id: import("zod").ZodNumber;
+                                color: import("zod").ZodNullable<import("zod").ZodString>;
+                                name: import("zod").ZodArray<import("zod").ZodObject<{
+                                    name: import("zod").ZodString;
+                                    languageCode: import("zod").ZodString;
+                                }, import("zod/v4/core").$strip>>;
+                            }, import("zod/v4/core").$strip>>;
                             birthday: import("zod").ZodNullable<import("zod").ZodDate>;
                             language: import("zod").ZodString;
                         }, import("zod/v4/core").$strip>>;
@@ -96,10 +112,10 @@ export declare const usersAdminModule: import("../../../../api/lib/module").Buil
 }>, import("../../../lib/route").Route<"@vitnode/core", {
     method: "get";
     description: string;
-    path: "/{nameCode}";
+    path: "/{id}";
     request: {
         params: import("zod").ZodObject<{
-            nameCode: import("zod").ZodString;
+            id: import("zod").ZodString;
         }, import("zod/v4/core").$strip>;
     };
     responses: {
@@ -116,8 +132,88 @@ export declare const usersAdminModule: import("../../../../api/lib/module").Buil
                         avatarColor: import("zod").ZodString;
                         emailVerified: import("zod").ZodBoolean;
                         roleId: import("zod").ZodNumber;
+                        role: import("zod").ZodObject<{
+                            id: import("zod").ZodNumber;
+                            color: import("zod").ZodNullable<import("zod").ZodString>;
+                            name: import("zod").ZodArray<import("zod").ZodObject<{
+                                name: import("zod").ZodString;
+                                languageCode: import("zod").ZodString;
+                            }, import("zod/v4/core").$strip>>;
+                        }, import("zod/v4/core").$strip>;
+                        secondaryRoles: import("zod").ZodArray<import("zod").ZodObject<{
+                            id: import("zod").ZodNumber;
+                            color: import("zod").ZodNullable<import("zod").ZodString>;
+                            name: import("zod").ZodArray<import("zod").ZodObject<{
+                                name: import("zod").ZodString;
+                                languageCode: import("zod").ZodString;
+                            }, import("zod/v4/core").$strip>>;
+                        }, import("zod/v4/core").$strip>>;
                         birthday: import("zod").ZodNullable<import("zod").ZodDate>;
                         language: import("zod").ZodString;
+                        isAdmin: import("zod").ZodBoolean;
+                    }, import("zod/v4/core").$strip>;
+                };
+            };
+            description: string;
+        };
+        403: {
+            description: string;
+        };
+        404: {
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        error: import("zod").ZodString;
+                    }, import("zod/v4/core").$strip>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>, import("../../../lib/route").Route<"@vitnode/core", {
+    method: "patch";
+    description: string;
+    path: "/{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<{
+                        email: import("zod").ZodOptional<import("zod").ZodEmail>;
+                        name: import("zod").ZodOptional<import("zod").ZodString>;
+                        nameCode: import("zod").ZodOptional<import("zod").ZodString>;
+                        roleId: import("zod").ZodOptional<import("zod").ZodNumber>;
+                        secondaryRoleIds: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodNumber>>;
+                    }, import("zod/v4/core").$strip>;
+                };
+            };
+        };
+    };
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        id: import("zod").ZodNumber;
+                        name: import("zod").ZodString;
+                        email: import("zod").ZodEmail;
+                        nameCode: import("zod").ZodString;
+                    }, import("zod/v4/core").$strip>;
+                };
+            };
+            description: string;
+        };
+        400: {
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        error: import("zod").ZodString;
                     }, import("zod/v4/core").$strip>;
                 };
             };
@@ -136,16 +232,26 @@ export declare const usersAdminModule: import("../../../../api/lib/module").Buil
             };
             description: string;
         };
+        409: {
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        error: import("zod").ZodString;
+                    }, import("zod/v4/core").$strip>;
+                };
+            };
+            description: string;
+        };
     };
 } & {
     path: string;
 }>, import("../../../lib/route").Route<"@vitnode/core", {
     method: "post";
     description: string;
-    path: "/{nameCode}/verify-email";
+    path: "/{id}/verify-email";
     request: {
         params: import("zod").ZodObject<{
-            nameCode: import("zod").ZodString;
+            id: import("zod").ZodString;
         }, import("zod/v4/core").$strip>;
     };
     responses: {

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

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

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

@@ -1 +1 @@
-import{buildModule}from"../../../lib/module.js";import{CONFIG_PLUGIN}from"../../../../config.js";import{createUserAdminRoute}from"./routes/create.route.js";import{listUsersAdminRoute}from"./routes/list.route.js";import{showUserAdminRoute}from"./routes/show.route.js";import{verifyEmailUserAdminRoute}from"./routes/verify-email.route.js";export const usersAdminModule=buildModule({pluginId:CONFIG_PLUGIN.pluginId,name:"users",routes:[listUsersAdminRoute,createUserAdminRoute,showUserAdminRoute,verifyEmailUserAdminRoute]});
+import{buildModule}from"../../../lib/module.js";import{CONFIG_PLUGIN}from"../../../../config.js";import{createUserAdminRoute}from"./routes/create.route.js";import{listUsersAdminRoute}from"./routes/list.route.js";import{showUserAdminRoute}from"./routes/show.route.js";import{updateUserAdminRoute}from"./routes/update.route.js";import{verifyEmailUserAdminRoute}from"./routes/verify-email.route.js";export const usersAdminModule=buildModule({pluginId:CONFIG_PLUGIN.pluginId,name:"users",routes:[listUsersAdminRoute,createUserAdminRoute,showUserAdminRoute,updateUserAdminRoute,verifyEmailUserAdminRoute]});

package/dist/src/api/modules/queue/cron/process-queue.cron.d.ts

@@ -0,0 +1,2 @@
+export declare const processQueueCron: import("../../../../api/lib/cron").BuildCronReturn;
+//# sourceMappingURL=process-queue.cron.d.ts.map

package/dist/src/api/modules/queue/cron/process-queue.cron.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"process-queue.cron.d.ts","sourceRoot":"","sources":["../../../../../../src/api/modules/queue/cron/process-queue.cron.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,gBAAgB,0CAO3B,CAAC"}

package/dist/src/api/modules/queue/cron/process-queue.cron.js

@@ -0,0 +1 @@
+import{buildCron}from"../../../lib/cron.js";import{processQueueTasks}from"../helpers/process-queue-tasks.js";export const processQueueCron=buildCron({name:"process-queue",description:"Process pending database queue tasks",schedule:"* * * * *",handler:async c=>{await processQueueTasks(c)}});

package/dist/src/api/modules/queue/helpers/process-queue-tasks.d.ts

@@ -0,0 +1,4 @@
+import type { Context } from "hono";
+import type { EnvVitNode } from "../../../../api/middlewares/global.middleware";
+export declare const processQueueTasks: (c: Context<EnvVitNode>) => Promise<void>;
+//# sourceMappingURL=process-queue-tasks.d.ts.map

package/dist/src/api/modules/queue/helpers/process-queue-tasks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"process-queue-tasks.d.ts","sourceRoot":"","sources":["../../../../../../src/api/modules/queue/helpers/process-queue-tasks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAIpC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAC;AAgBtE,eAAO,MAAM,iBAAiB,GAC5B,GAAG,OAAO,CAAC,UAAU,CAAC,KACrB,OAAO,CAAC,IAAI,CAmGd,CAAC"}

package/dist/src/api/modules/queue/helpers/process-queue-tasks.js

@@ -0,0 +1 @@
+import{and,asc,desc,eq,inArray,lt,lte,sql}from"drizzle-orm";import{core_queue}from"../../../../database/queue.js";import{resolveQueueTaskOutcome}from"../../../../lib/api/resolve-queue-task-outcome.js";const QUEUE_BATCH_SIZE=25;const QUEUE_LOCK_KEY="queue:process";const QUEUE_LOCK_TTL_SECONDS=55;const QUEUE_RETENTION_DAYS=7;export const processQueueTasks=async c=>{const gotLock=await c.get("cache").acquireLock(QUEUE_LOCK_KEY,QUEUE_LOCK_TTL_SECONDS);if(!gotLock)return;try{const db=c.get("db");const now=new Date;const claimed=await db.transaction(async tx=>{const rows=await tx.select({id:core_queue.id}).from(core_queue).where(and(eq(core_queue.status,"pending"),lte(core_queue.availableAt,now))).orderBy(desc(core_queue.priority),asc(core_queue.id)).limit(QUEUE_BATCH_SIZE).for("update",{skipLocked:true});if(rows.length===0)return[];return tx.update(core_queue).set({status:"processing",reservedAt:now,attempts:sql`${core_queue.attempts} + 1`}).where(inArray(core_queue.id,rows.map(row=>row.id))).returning()});if(claimed.length>0){const handlerMap=new Map(c.get("core").queue.map(task=>[`${task.pluginId}:${task.name}`,task]));for(const task of claimed){const key=`${task.pluginId}:${task.name}`;const registered=handlerMap.get(key);let error=null;if(!registered){error=`No handler registered for queue task "${key}"`;await c.get("log").warn(error)}else{try{await registered.handler(c,task.payload)}catch(err){error=err instanceof Error?err.message:String(err);await c.get("log").error(`Queue task "${key}" failed: ${error}`)}}const outcome=resolveQueueTaskOutcome({attempts:task.attempts,maxAttempts:task.maxAttempts,error});await db.update(core_queue).set({status:outcome.status,lastError:outcome.lastError,availableAt:outcome.availableAt??task.availableAt,completedAt:outcome.completedAt??null,reservedAt:null}).where(eq(core_queue.id,task.id))}}const cutoff=new Date(now.getTime()-QUEUE_RETENTION_DAYS*24*60*60*1e3);await db.delete(core_queue).where(and(inArray(core_queue.status,["completed","failed"]),lt(core_queue.completedAt,cutoff)))}finally{await c.get("cache").releaseLock(QUEUE_LOCK_KEY)}};

package/dist/src/api/modules/queue/queue.module.d.ts

@@ -0,0 +1,2 @@
+export declare const queueModule: import("../../../api/lib/module").BuildModuleReturn<"@vitnode/core", "queue", [], import("../../../api/lib/module").BaseBuildModuleReturn<"@vitnode/core", string, import("../../lib/route").Route<"@vitnode/core", import("@hono/zod-openapi").RouteConfig>[]>[]>;
+//# sourceMappingURL=queue.module.d.ts.map

package/dist/src/api/modules/queue/queue.module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue.module.d.ts","sourceRoot":"","sources":["../../../../../src/api/modules/queue/queue.module.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,WAAW,sPAMtB,CAAC"}

package/dist/src/api/modules/queue/queue.module.js

@@ -0,0 +1 @@
+import{buildModule}from"../../lib/module.js";import{CONFIG_PLUGIN}from"../../../config.js";import{processQueueCron}from"./cron/process-queue.cron.js";import{sendEmailQueueTask}from"./tasks/send-email.task.js";export const queueModule=buildModule({pluginId:CONFIG_PLUGIN.pluginId,name:"queue",routes:[],cronJobs:[processQueueCron],queueTasks:[sendEmailQueueTask]});

package/dist/src/api/modules/queue/tasks/send-email.task.d.ts

@@ -0,0 +1,10 @@
+import { z } from "zod";
+export declare const sendEmailPayloadSchema: z.ZodObject<{
+    to: z.ZodString;
+    subject: z.ZodString;
+    html: z.ZodString;
+    text: z.ZodString;
+    replyTo: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const sendEmailQueueTask: import("../../../../api/lib/queue").BuildQueueTaskReturn;
+//# sourceMappingURL=send-email.task.d.ts.map

package/dist/src/api/modules/queue/tasks/send-email.task.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"send-email.task.d.ts","sourceRoot":"","sources":["../../../../../../src/api/modules/queue/tasks/send-email.task.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,sBAAsB;;;;;;iBAMjC,CAAC;AAEH,eAAO,MAAM,kBAAkB,gDAQ7B,CAAC"}

package/dist/src/api/modules/queue/tasks/send-email.task.js

@@ -0,0 +1 @@
+import{z}from"zod";import{buildQueueTask}from"../../../lib/queue.js";import{EmailModel}from"../../../models/email.js";export const sendEmailPayloadSchema=z.object({to:z.string(),subject:z.string(),html:z.string(),text:z.string(),replyTo:z.string().optional()});export const sendEmailQueueTask=buildQueueTask({name:"send-email",description:"Deliver a rendered email through the configured provider.",handler:async(c,payload)=>{const email=sendEmailPayloadSchema.parse(payload);await new EmailModel(c).deliver(email)}});

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

@@ -0,0 +1,26 @@
+import { z } from "zod";
+export declare const permissionsRoute: import("../../../../api/lib/route").Route<"@vitnode/core", {
+    method: "get";
+    description: string;
+    path: "/permissions";
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        root: z.ZodBoolean;
+                        permissions: z.ZodArray<z.ZodObject<{
+                            plugin: z.ZodString;
+                            module: z.ZodString;
+                            permission: z.ZodString;
+                        }, z.core.$strip>>;
+                    }, z.core.$strip>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>;
+//# sourceMappingURL=permissions.route.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"permissions.route.d.ts","sourceRoot":"","sources":["../../../../../../src/api/modules/users/routes/permissions.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;EAwC3B,CAAC"}

package/dist/src/api/modules/users/routes/permissions.route.js

@@ -0,0 +1 @@
+import{z}from"zod";import{resolveStaffPermissions}from"../../../lib/check-staff-permission.js";import{buildRoute}from"../../../lib/route.js";import{CONFIG_PLUGIN}from"../../../../config.js";export const permissionsRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,route:{method:"get",description:"Get the current user's effective moderator permissions (public site)",path:"/permissions",responses:{200:{content:{"application/json":{schema:z.object({root:z.boolean(),permissions:z.array(z.object({plugin:z.string(),module:z.string(),permission:z.string()}))})}},description:"Effective moderator permissions"}}},handler:async c=>{const user=c.get("user");if(!user){return c.json({root:false,permissions:[]},200)}const permissions=await resolveStaffPermissions(c,{type:"moderator",user});return c.json(permissions,200)}});

package/dist/src/api/modules/users/routes/reset-passowrd.route.js

@@ -1 +1 @@
-import{eq}from"drizzle-orm";import{createTranslator}from"use-intl";import{z}from"zod";import{buildRoute}from"../../../lib/route.js";import{ForgotPasswordTokenModel}from"../../../models/password.js";import{CONFIG_PLUGIN}from"../../../../config.js";import{core_users,core_users_forgot_password}from"../../../../database/users.js";import ResetPasswordEmailTemplate from"../../../../emails/reset-password.js";import{CONFIG}from"../../../../lib/config.js";export const resetPasswordRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,route:{method:"post",description:"Request a password reset",path:"/reset-password",withCaptcha:true,request:{body:{required:true,content:{"application/json":{schema:z.object({email:z.email().toLowerCase().openapi({example:"test@test.com"})})}}}},responses:{201:{description:"Email sent"}}},handler:async c=>{const RESPONSE_TEXT=c.text("Email sent",201);const{email}=c.req.valid("json");const[findUser]=await c.get("db").select({email:core_users.email,id:core_users.id,language:core_users.language}).from(core_users).where(eq(core_users.email,email)).limit(1);if(!findUser){return RESPONSE_TEXT}const hashToken=new ForgotPasswordTokenModel().generateResetToken();const[findLastRecord]=await c.get("db").select().from(core_users_forgot_password).where(eq(core_users_forgot_password.userId,findUser.id)).limit(1);if(findLastRecord?.createdAt>new Date(Date.now()-1e3*60*5)){return RESPONSE_TEXT}const EXPIRES_AT=new Date(Date.now()+1e3*60*30);if(findLastRecord){await c.get("db").update(core_users_forgot_password).set({createdAt:new Date,expiresAt:EXPIRES_AT,token:hashToken,ipAddress:c.get("ipAddress")}).where(eq(core_users_forgot_password.id,findLastRecord.id))}else{await c.get("db").insert(core_users_forgot_password).values({token:hashToken,ipAddress:c.get("ipAddress"),userId:findUser.id,expiresAt:EXPIRES_AT})}const resetUrlNative=new URL(`login/reset-password?token=${hashToken}&userId=${findUser.id}`,CONFIG.web.href);await c.get("email").send({user:{id:findUser.id,email:findUser.email,language:findUser.language},content:props=>ResetPasswordEmailTemplate({...props,resetUrl:resetUrlNative.href,expiryDate:EXPIRES_AT,userIpAddress:c.get("ipAddress")}),subject:({i18n})=>{const t=createTranslator(i18n);return t("core.auth.reset_password.email.subject")}});return RESPONSE_TEXT}});
+import{eq}from"drizzle-orm";import{createTranslator}from"next-intl";import{z}from"zod";import{buildRoute}from"../../../lib/route.js";import{ForgotPasswordTokenModel}from"../../../models/password.js";import{CONFIG_PLUGIN}from"../../../../config.js";import{core_users,core_users_forgot_password}from"../../../../database/users.js";import ResetPasswordEmailTemplate from"../../../../emails/reset-password.js";import{CONFIG}from"../../../../lib/config.js";export const resetPasswordRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,route:{method:"post",description:"Request a password reset",path:"/reset-password",withCaptcha:true,request:{body:{required:true,content:{"application/json":{schema:z.object({email:z.email().toLowerCase().openapi({example:"test@test.com"})})}}}},responses:{201:{description:"Email sent"}}},handler:async c=>{const RESPONSE_TEXT=c.text("Email sent",201);const{email}=c.req.valid("json");const[findUser]=await c.get("db").select({email:core_users.email,id:core_users.id,language:core_users.language}).from(core_users).where(eq(core_users.email,email)).limit(1);if(!findUser){return RESPONSE_TEXT}const hashToken=new ForgotPasswordTokenModel().generateResetToken();const[findLastRecord]=await c.get("db").select().from(core_users_forgot_password).where(eq(core_users_forgot_password.userId,findUser.id)).limit(1);if(findLastRecord?.createdAt>new Date(Date.now()-1e3*60*5)){return RESPONSE_TEXT}const EXPIRES_AT=new Date(Date.now()+1e3*60*30);if(findLastRecord){await c.get("db").update(core_users_forgot_password).set({createdAt:new Date,expiresAt:EXPIRES_AT,token:hashToken,ipAddress:c.get("ipAddress")}).where(eq(core_users_forgot_password.id,findLastRecord.id))}else{await c.get("db").insert(core_users_forgot_password).values({token:hashToken,ipAddress:c.get("ipAddress"),userId:findUser.id,expiresAt:EXPIRES_AT})}const resetUrlNative=new URL(`login/reset-password?token=${hashToken}&userId=${findUser.id}`,CONFIG.web.href);await c.get("email").send({user:{id:findUser.id,email:findUser.email,language:findUser.language},content:props=>ResetPasswordEmailTemplate({...props,resetUrl:resetUrlNative.href,expiryDate:EXPIRES_AT,userIpAddress:c.get("ipAddress")}),subject:({i18n})=>{const t=createTranslator(i18n);return t("core.auth.reset_password.email.subject")}});return RESPONSE_TEXT}});

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

@@ -20,6 +20,7 @@ export declare const sessionRoute: import("../../../../api/lib/route").Route<"@v
                             roleId: z.ZodNumber;
                             birthday: z.ZodNullable<z.ZodDate>;
                             isAdmin: z.ZodBoolean;
+                            isModerator: z.ZodBoolean;
                         }, z.core.$strip>>;
                     }, z.core.$strip>;
                 };

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

@@ -1 +1 @@
-{"version":3,"file":"session.route.d.ts","sourceRoot":"","sources":["../../../../../../src/api/modules/users/routes/session.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8CvB,CAAC"}
+{"version":3,"file":"session.route.d.ts","sourceRoot":"","sources":["../../../../../../src/api/modules/users/routes/session.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgDvB,CAAC"}

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

@@ -1 +1 @@
-import{z}from"zod";import{buildRoute}from"../../../lib/route.js";import{SessionAdminModel}from"../../../models/session-admin.js";import{CONFIG_PLUGIN}from"../../../../config.js";export const sessionRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,route:{method:"get",description:"Verify session",path:"/session",responses:{200:{content:{"application/json":{schema:z.object({user:z.object({id:z.number(),email:z.string(),name:z.string(),nameCode:z.string(),createdAt:z.date(),newsletter:z.boolean(),avatarColor:z.string(),emailVerified:z.boolean(),roleId:z.number(),birthday:z.date().nullable(),isAdmin:z.boolean()}).nullable()})}},description:"User"}}},handler:async c=>{const user=c.get("user");const admin=new SessionAdminModel(c);return c.json({user:user?{...user,isAdmin:await admin.checkIfUserIsAdmin(user.id)}:null})}});
+import{z}from"zod";import{buildRoute}from"../../../lib/route.js";import{SessionAdminModel}from"../../../models/session-admin.js";import{CONFIG_PLUGIN}from"../../../../config.js";export const sessionRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,route:{method:"get",description:"Verify session",path:"/session",responses:{200:{content:{"application/json":{schema:z.object({user:z.object({id:z.number(),email:z.string(),name:z.string(),nameCode:z.string(),createdAt:z.date(),newsletter:z.boolean(),avatarColor:z.string(),emailVerified:z.boolean(),roleId:z.number(),birthday:z.date().nullable(),isAdmin:z.boolean(),isModerator:z.boolean()}).nullable()})}},description:"User"}}},handler:async c=>{const user=c.get("user");const admin=new SessionAdminModel(c);return c.json({user:user?{...user,isAdmin:await admin.checkIfUserIsAdmin(user.id),isModerator:false}:null})}});

package/dist/src/api/modules/users/users.module.d.ts

@@ -19,6 +19,7 @@ export declare const usersModule: import("../../../api/lib/module").BuildModuleR
                             roleId: import("zod").ZodNumber;
                             birthday: import("zod").ZodNullable<import("zod").ZodDate>;
                             isAdmin: import("zod").ZodBoolean;
+                            isModerator: import("zod").ZodBoolean;
                         }, import("zod/v4/core").$strip>>;
                     }, import("zod/v4/core").$strip>;
                 };
@@ -204,6 +205,29 @@ export declare const usersModule: import("../../../api/lib/module").BuildModuleR
     };
 } & {
     path: string;
+}>, import("../../lib/route").Route<"@vitnode/core", {
+    method: "get";
+    description: string;
+    path: "/permissions";
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        root: import("zod").ZodBoolean;
+                        permissions: import("zod").ZodArray<import("zod").ZodObject<{
+                            plugin: import("zod").ZodString;
+                            module: import("zod").ZodString;
+                            permission: import("zod").ZodString;
+                        }, import("zod/v4/core").$strip>>;
+                    }, import("zod/v4/core").$strip>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    path: string;
 }>], import("../../../api/lib/module").BuildModuleReturn<"@vitnode/core", "sso", [import("../../lib/route").Route<"@vitnode/core", {
     method: "get";
     description: string;

package/dist/src/api/modules/users/users.module.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"users.module.d.ts","sourceRoot":"","sources":["../../../../../src/api/modules/users/users.module.ts"],"names":[],"mappings":"AAYA,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iLAatB,CAAC"}
+{"version":3,"file":"users.module.d.ts","sourceRoot":"","sources":["../../../../../src/api/modules/users/users.module.ts"],"names":[],"mappings":"AAaA,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iLActB,CAAC"}

package/dist/src/api/modules/users/users.module.js

@@ -1 +1 @@
-import{buildModule}from"../../lib/module.js";import{CONFIG_PLUGIN}from"../../../config.js";import{changePasswordRoute}from"./routes/change-password.route.js";import{resetPasswordRoute}from"./routes/reset-passowrd.route.js";import{sessionRoute}from"./routes/session.route.js";import{signInRoute}from"./routes/sign-in.route.js";import{signOutRoute}from"./routes/sign-out.route.js";import{signUpRoute}from"./routes/sign-up.route.js";import{testRoute}from"./routes/test.route.js";import{ssoUserModule}from"./sso/sso.module.js";export const usersModule=buildModule({pluginId:CONFIG_PLUGIN.pluginId,name:"users",routes:[sessionRoute,signInRoute,signOutRoute,signUpRoute,testRoute,resetPasswordRoute,changePasswordRoute],modules:[ssoUserModule]});
+import{buildModule}from"../../lib/module.js";import{CONFIG_PLUGIN}from"../../../config.js";import{changePasswordRoute}from"./routes/change-password.route.js";import{permissionsRoute}from"./routes/permissions.route.js";import{resetPasswordRoute}from"./routes/reset-passowrd.route.js";import{sessionRoute}from"./routes/session.route.js";import{signInRoute}from"./routes/sign-in.route.js";import{signOutRoute}from"./routes/sign-out.route.js";import{signUpRoute}from"./routes/sign-up.route.js";import{testRoute}from"./routes/test.route.js";import{ssoUserModule}from"./sso/sso.module.js";export const usersModule=buildModule({pluginId:CONFIG_PLUGIN.pluginId,name:"users",routes:[sessionRoute,signInRoute,signOutRoute,signUpRoute,testRoute,resetPasswordRoute,changePasswordRoute,permissionsRoute],modules:[ssoUserModule]});

package/dist/src/api/plugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../../../src/api/plugin.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,qBAAqB,6CAGhC,CAAC"}
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../../../src/api/plugin.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,qBAAqB,6CA4ChC,CAAC"}

package/dist/src/api/plugin.js

@@ -1 +1 @@
-import{CONFIG_PLUGIN}from"../config.js";import{buildApiPlugin}from"./lib/plugin.js";import{adminModule}from"./modules/admin/admin.module.js";import{cronModule}from"./modules/cron/cron.module.js";import{middlewareModule}from"./modules/middleware/middleware.module.js";import{usersModule}from"./modules/users/users.module.js";export const newBuildPluginApiCore=buildApiPlugin({pluginId:CONFIG_PLUGIN.pluginId,modules:[middlewareModule,usersModule,adminModule,cronModule]});
+import{CONFIG_PLUGIN}from"../config.js";import{buildApiPlugin}from"./lib/plugin.js";import{adminModule}from"./modules/admin/admin.module.js";import{cronModule}from"./modules/cron/cron.module.js";import{middlewareModule}from"./modules/middleware/middleware.module.js";import{queueModule}from"./modules/queue/queue.module.js";import{usersModule}from"./modules/users/users.module.js";export const newBuildPluginApiCore=buildApiPlugin({pluginId:CONFIG_PLUGIN.pluginId,modules:[middlewareModule,usersModule,adminModule,cronModule,queueModule],permissionStaff:{moderator:{users:["can_edit"]},admin:{users:["can_view",{permission:"can_create",dependsOn:["can_view"]},{permission:"can_edit",dependsOn:["can_view"]},{permission:"can_edit_admin",dependsOn:["can_view"]}],roles:["can_manage"],debug:["can_view",{permission:"can_clear_cache",dependsOn:["can_view"]}],system:["can_view",{permission:"can_send_test_email",dependsOn:["can_view"]}],queue:["can_view"],staff_moderators:["can_view",{permission:"can_create",dependsOn:["can_view"]},{permission:"can_edit",dependsOn:["can_view"]},{permission:"can_delete",dependsOn:["can_view"]}],staff_admins:["can_view",{permission:"can_create",dependsOn:["can_view"]},{permission:"can_edit",dependsOn:["can_view"]},{permission:"can_delete",dependsOn:["can_view"]}]}}});

package/dist/src/components/confirm-action/confirm-action-alert-dialog.d.ts

@@ -7,7 +7,7 @@ declare const ContentConfirmAction: React.ComponentType<{
     textSubmit?: string;
 }>;
 export declare const ConfirmActionAlertDialog: ({ children, title, description, textSubmit, onSubmit, ...props }: Omit<React.ComponentProps<typeof AlertDialog>, "children"> & React.ComponentProps<typeof ContentConfirmAction> & {
-    children: React.ReactNode;
+    children: React.ReactElement;
     description?: React.ReactNode;
     title?: React.ReactNode;
 }) => React.JSX.Element;

package/dist/src/components/confirm-action/confirm-action-alert-dialog.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"confirm-action-alert-dialog.d.ts","sourceRoot":"","sources":["../../../../src/components/confirm-action/confirm-action-alert-dialog.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B,OAAO,EACL,WAAW,EAOZ,MAAM,oBAAoB,CAAC;AAE5B,QAAA,MAAM,oBAAoB;;;;;EAIzB,CAAC;AAEF,eAAO,MAAM,wBAAwB,GAAI,kEAOtC,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC,OAAO,WAAW,CAAC,EAAE,UAAU,CAAC,GAC3D,KAAK,CAAC,cAAc,CAAC,OAAO,oBAAoB,CAAC,GAAG;IAClD,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;IAC1B,WAAW,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IAC9B,KAAK,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;CACzB,sBAqBF,CAAC"}
+{"version":3,"file":"confirm-action-alert-dialog.d.ts","sourceRoot":"","sources":["../../../../src/components/confirm-action/confirm-action-alert-dialog.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B,OAAO,EACL,WAAW,EAOZ,MAAM,oBAAoB,CAAC;AAE5B,QAAA,MAAM,oBAAoB;;;;;EAIzB,CAAC;AAEF,eAAO,MAAM,wBAAwB,GAAI,kEAOtC,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC,OAAO,WAAW,CAAC,EAAE,UAAU,CAAC,GAC3D,KAAK,CAAC,cAAc,CAAC,OAAO,oBAAoB,CAAC,GAAG;IAClD,QAAQ,EAAE,KAAK,CAAC,YAAY,CAAC;IAC7B,WAAW,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IAC9B,KAAK,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;CACzB,sBAqBF,CAAC"}

package/dist/src/components/confirm-action/confirm-action-alert-dialog.js

@@ -1 +1 @@
-"use client";import{jsx as _jsx,jsxs as _jsxs}from"react/jsx-runtime";import{useTranslations}from"next-intl";import dynamic from"next/dynamic";import React from"react";import{AlertDialog,AlertDialogContent,AlertDialogDescription,AlertDialogFooterSkeleton,AlertDialogHeader,AlertDialogTitle,AlertDialogTrigger}from"../ui/alert-dialog.js";const ContentConfirmAction=dynamic(async()=>import("./content.js").then(module=>({default:module.ContentConfirmAction})));export const ConfirmActionAlertDialog=({children,title,description,textSubmit,onSubmit,...props})=>{const t=useTranslations("core.global.confirm_action");return _jsxs(AlertDialog,{...props,children:[_jsx(AlertDialogTrigger,{asChild:true,children:children}),_jsxs(AlertDialogContent,{children:[_jsxs(AlertDialogHeader,{children:[_jsx(AlertDialogTitle,{children:title??t("title")}),_jsx(AlertDialogDescription,{children:description??t("desc")})]}),_jsx(React.Suspense,{fallback:_jsx(AlertDialogFooterSkeleton,{}),children:_jsx(ContentConfirmAction,{onSubmit:onSubmit,textSubmit:textSubmit})})]})]})};
+"use client";import{jsx as _jsx,jsxs as _jsxs}from"react/jsx-runtime";import{useTranslations}from"next-intl";import dynamic from"next/dynamic";import React from"react";import{AlertDialog,AlertDialogContent,AlertDialogDescription,AlertDialogFooterSkeleton,AlertDialogHeader,AlertDialogTitle,AlertDialogTrigger}from"../ui/alert-dialog.js";const ContentConfirmAction=dynamic(async()=>import("./content.js").then(module=>({default:module.ContentConfirmAction})));export const ConfirmActionAlertDialog=({children,title,description,textSubmit,onSubmit,...props})=>{const t=useTranslations("core.global.confirm_action");return _jsxs(AlertDialog,{...props,children:[_jsx(AlertDialogTrigger,{render:children}),_jsxs(AlertDialogContent,{children:[_jsxs(AlertDialogHeader,{children:[_jsx(AlertDialogTitle,{children:title??t("title")}),_jsx(AlertDialogDescription,{children:description??t("desc")})]}),_jsx(React.Suspense,{fallback:_jsx(AlertDialogFooterSkeleton,{}),children:_jsx(ContentConfirmAction,{onSubmit:onSubmit,textSubmit:textSubmit})})]})]})};

package/dist/src/components/form/auto-form.js

@@ -1 +1 @@
-"use client";import{jsx as _jsx,jsxs as _jsxs}from"react/jsx-runtime";import{zodResolver}from"@hookform/resolvers/zod";import{useTranslations}from"next-intl";import{useForm}from"react-hook-form";import z from"zod";import{useCaptcha}from"../../hooks/use-captcha.js";import{getDefaults,getNestedParam,getZodInputParams}from"../../lib/helpers/auto-form.js";import{Button}from"../ui/button.js";import{DialogClose,DialogFooter,useDialog}from"../ui/dialog.js";import{Field}from"../ui/field.js";import{Form,FormField}from"../ui/form.js";export function AutoForm({formSchema,mode,onSubmit:onSubmitProp,captcha,fields,submitButtonProps,children,...props}){const{isReady,getToken:getTokenCaptcha,onReset:onResetCaptcha}=useCaptcha(captcha);const{setIsDirty}=useDialog();const t=useTranslations("core.global");const jsonSchema=z.toJSONSchema(formSchema);const inputParams=getZodInputParams(jsonSchema);const form=useForm({resolver:zodResolver(formSchema),defaultValues:getDefaults(jsonSchema),mode});const onSubmit=async values=>{const parsedValues=formSchema.safeParse(values);if(parsedValues.success){await onSubmitProp?.(parsedValues.data,form,{captchaToken:captcha?await getTokenCaptcha():""});if(captcha){onResetCaptcha()}}};const submitButton=_jsx(Button,{disabled:!form.formState.isValid||form.formState.isSubmitting||captcha&&!isReady,isLoading:form.formState.isSubmitting,...submitButtonProps,"aria-label":submitButtonProps?.["aria-label"]??t("submit"),type:"submit",children:submitButtonProps?.children??t("submit")});return _jsxs(Form,{form:form,onSubmit:onSubmit,...props,children:[fields.map(item=>{const params=getNestedParam(inputParams,item.id);if(!params)return null;if(!item.component&&(item.label||item.description)){return _jsxs("div",{children:[item.label&&_jsx("span",{className:"text-xl leading-none font-semibold tracking-tight",children:item.label}),item.description&&_jsx("div",{className:"text-muted-foreground text-sm",children:item.description})]},item.id)}if(!item.component)return null;return _jsx(FormField,{name:item.id,render:({field,fieldState})=>{return _jsx(Field,{"data-invalid":fieldState.invalid,orientation:"responsive",children:item.component({field,description:typeof params.description==="string"?params.description:"",itemParams:"itemParams"in params?params.itemParams:undefined,otherProps:{isOptional:!params.required,enum:Array.isArray(params.enum)?params.enum:undefined,maxLength:typeof params.maxLength==="number"?params.maxLength:undefined,maxItems:typeof params.maxItems==="number"?params.maxItems:undefined,minLength:typeof params.minLength==="number"?params.minLength:undefined,["aria-invalid"]:fieldState.invalid,minItems:typeof params.minItems==="number"?params.minItems:undefined,pattern:typeof params.pattern==="string"?params.pattern:undefined,type:typeof params.type==="string"?params.type:undefined}})})}},item.id)}),children,captcha&&_jsx("div",{id:"vitnode_captcha"}),setIsDirty?_jsxs(DialogFooter,{children:[_jsx(DialogClose,{asChild:true,children:_jsx(Button,{variant:"ghost",children:t("cancel")})}),submitButton]}):submitButton]})}
+"use client";import{jsx as _jsx,jsxs as _jsxs}from"react/jsx-runtime";import{zodResolver}from"@hookform/resolvers/zod";import{useTranslations}from"next-intl";import{useForm}from"react-hook-form";import z from"zod";import{useCaptcha}from"../../hooks/use-captcha.js";import{getDefaults,getNestedParam,getZodInputParams}from"../../lib/helpers/auto-form.js";import{Button}from"../ui/button.js";import{DialogClose,DialogFooter,useDialog}from"../ui/dialog.js";import{Field}from"../ui/field.js";import{Form,FormField}from"../ui/form.js";export function AutoForm({formSchema,mode,onSubmit:onSubmitProp,captcha,fields,submitButtonProps,children,...props}){const{isReady,getToken:getTokenCaptcha,onReset:onResetCaptcha}=useCaptcha(captcha);const{setIsDirty}=useDialog();const t=useTranslations("core.global");const jsonSchema=z.toJSONSchema(formSchema);const inputParams=getZodInputParams(jsonSchema);const form=useForm({resolver:zodResolver(formSchema),defaultValues:getDefaults(jsonSchema),mode});const onSubmit=async values=>{const parsedValues=formSchema.safeParse(values);if(parsedValues.success){await onSubmitProp?.(parsedValues.data,form,{captchaToken:captcha?await getTokenCaptcha():""});if(captcha){onResetCaptcha()}}};const submitButton=_jsx(Button,{disabled:!form.formState.isValid||form.formState.isSubmitting||captcha&&!isReady,isLoading:form.formState.isSubmitting,...submitButtonProps,"aria-label":submitButtonProps?.["aria-label"]??t("submit"),type:"submit",children:submitButtonProps?.children??t("submit")});return _jsxs(Form,{form:form,onSubmit:onSubmit,...props,children:[fields.map(item=>{const params=getNestedParam(inputParams,item.id);if(!params)return null;if(!item.component&&(item.label||item.description)){return _jsxs("div",{children:[item.label&&_jsx("span",{className:"text-xl leading-none font-semibold tracking-tight",children:item.label}),item.description&&_jsx("div",{className:"text-muted-foreground text-sm",children:item.description})]},item.id)}if(!item.component)return null;return _jsx(FormField,{name:item.id,render:({field,fieldState})=>{return _jsx(Field,{"data-invalid":fieldState.invalid,orientation:"responsive",children:item.component({field,description:typeof params.description==="string"?params.description:"",itemParams:"itemParams"in params?params.itemParams:undefined,otherProps:{isOptional:!params.required,enum:Array.isArray(params.enum)?params.enum:undefined,maxLength:typeof params.maxLength==="number"?params.maxLength:undefined,maxItems:typeof params.maxItems==="number"?params.maxItems:undefined,minLength:typeof params.minLength==="number"?params.minLength:undefined,["aria-invalid"]:fieldState.invalid,minItems:typeof params.minItems==="number"?params.minItems:undefined,pattern:typeof params.pattern==="string"?params.pattern:undefined,type:typeof params.type==="string"?params.type:undefined}})})}},item.id)}),children,captcha&&_jsx("div",{id:"vitnode_captcha"}),setIsDirty?_jsxs(DialogFooter,{children:[_jsx(DialogClose,{render:_jsx(Button,{variant:"ghost",children:t("cancel")})}),submitButton]}):submitButton]})}

package/dist/src/components/form/fields/array.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"array.d.ts","sourceRoot":"","sources":["../../../../../src/components/form/fields/array.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,MAAM,OAAO,CAAC;AAK1B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAClE,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,cAAc,CAAC;AAc/D,MAAM,WAAW,kBAAkB;IACjC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,CAAC,KAAK,EAAE,0BAA0B,KAAK,KAAK,CAAC,SAAS,CAAC;IAClE,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,MAAM,WAAW,kBAAmB,SAAQ,0BAA0B;IACpE,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,kBAAkB,EAAE,CAAC;IAC7B,UAAU,CAAC,EAAE,WAAW,CAAC;IACzB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED,eAAO,MAAM,aAAa,GAAI,4LAY3B,kBAAkB,sBA0JpB,CAAC"}
+{"version":3,"file":"array.d.ts","sourceRoot":"","sources":["../../../../../src/components/form/fields/array.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,MAAM,OAAO,CAAC;AAK1B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAClE,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,cAAc,CAAC;AAc/D,MAAM,WAAW,kBAAkB;IACjC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,CAAC,KAAK,EAAE,0BAA0B,KAAK,KAAK,CAAC,SAAS,CAAC;IAClE,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,MAAM,WAAW,kBAAmB,SAAQ,0BAA0B;IACpE,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,kBAAkB,EAAE,CAAC;IAC7B,UAAU,CAAC,EAAE,WAAW,CAAC;IACzB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED,eAAO,MAAM,aAAa,GAAI,4LAY3B,kBAAkB,sBAyJpB,CAAC"}

package/dist/src/components/form/fields/checkbox.js

@@ -1 +1 @@
-import{jsx as _jsx,jsxs as _jsxs}from"react/jsx-runtime";import{cn}from"../../../lib/utils.js";import{Checkbox}from"../../ui/checkbox.js";import{FormControl,FormMessage}from"../../ui/form.js";import{AutoFormDesc}from"../common/desc.js";import{AutoFormLabel}from"../common/label.js";export const AutoFormCheckbox=({label,labelRight,description,otherProps:{isOptional},field,className,itemParams,...props})=>{return _jsxs("div",{className:cn("flex flex-row items-start space-y-0 space-x-3 rounded-md border p-4",className),children:[_jsx(FormControl,{children:_jsx(Checkbox,{checked:field.value??false,onCheckedChange:e=>{field.onChange(e);props.onCheckedChange?.(e)},...field,...props})}),!!(label??description)&&_jsxs("div",{className:"space-y-1 leading-none",children:[label&&_jsx(AutoFormLabel,{isOptional:isOptional,labelRight:labelRight,children:label}),description&&_jsx(AutoFormDesc,{children:description}),_jsx(FormMessage,{})]})]})};
+import{jsx as _jsx,jsxs as _jsxs}from"react/jsx-runtime";import{cn}from"../../../lib/utils.js";import{Checkbox}from"../../ui/checkbox.js";import{FormControl,FormMessage}from"../../ui/form.js";import{AutoFormDesc}from"../common/desc.js";import{AutoFormLabel}from"../common/label.js";export const AutoFormCheckbox=({label,labelRight,description,otherProps:{isOptional},field,className,itemParams,...props})=>{return _jsxs("div",{className:cn("flex flex-row items-start space-y-0 space-x-3 rounded-md border p-4",className),children:[_jsx(FormControl,{children:_jsx(Checkbox,{checked:field.value??false,onCheckedChange:(checked,eventDetails)=>{field.onChange(checked);props.onCheckedChange?.(checked,eventDetails)},...field,...props})}),!!(label??description)&&_jsxs("div",{className:"space-y-1 leading-none",children:[label&&_jsx(AutoFormLabel,{isOptional:isOptional,labelRight:labelRight,children:label}),description&&_jsx(AutoFormDesc,{children:description}),_jsx(FormMessage,{})]})]})};

package/dist/src/components/form/fields/select.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"select.d.ts","sourceRoot":"","sources":["../../../../../src/components/form/fields/select.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAK/B,OAAO,EACL,MAAM,EAKP,MAAM,wBAAwB,CAAC;AAEhC,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,cAAc,CAAC;AAK/D,eAAO,MAAM,cAAc,GAAI,oIAW5B,0BAA0B,GAC3B,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC,OAAO,MAAM,CAAC,EAAE,OAAO,CAAC,GAAG;IACnD,MAAM,CAAC,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAC5C,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,sBAwDF,CAAC"}
+{"version":3,"file":"select.d.ts","sourceRoot":"","sources":["../../../../../src/components/form/fields/select.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAK/B,OAAO,EACL,MAAM,EAKP,MAAM,wBAAwB,CAAC;AAEhC,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,cAAc,CAAC;AAK/D,eAAO,MAAM,cAAc,GAAI,oIAW5B,0BAA0B,GAC3B,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC,OAAO,MAAM,CAAC,EAAE,OAAO,CAAC,GAAG;IACnD,MAAM,CAAC,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAC5C,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,sBA+CF,CAAC"}

package/dist/src/components/form/fields/select.js

@@ -1 +1 @@
-import{jsx as _jsx,jsxs as _jsxs,Fragment as _Fragment}from"react/jsx-runtime";import{useTranslations}from"next-intl";import{FormControl,FormMessage}from"../../ui/form.js";import{Select,SelectContent,SelectItem,SelectTrigger,SelectValue}from"../../ui/select.js";import{AutoFormDesc}from"../common/desc.js";import{AutoFormLabel}from"../common/label.js";export const AutoFormSelect=({label,field,itemParams,description,otherProps:{enum:enumValues=[],isOptional},placeholder,labelRight,labels=[],...props})=>{const t=useTranslations("core.global");const values=enumValues.map(value=>{const label=labels.find(l=>l.value===value)?.label;return{value,label:label??value}});const currentPlaceholder=(values??labels).find(l=>l.value===field.value)?.label??t("select_option");return _jsxs(_Fragment,{children:[label&&_jsx(AutoFormLabel,{isOptional:isOptional,labelRight:labelRight,children:label}),_jsx(FormControl,{children:_jsxs(Select,{defaultValue:field.value,disabled:props.disabled,onValueChange:e=>{field.onChange(e);props?.onValueChange?.(e)},...props,children:[_jsx(SelectTrigger,{...props,children:_jsx(SelectValue,{onBlur:field.onBlur,placeholder:placeholder??currentPlaceholder,children:currentPlaceholder})}),_jsx(SelectContent,{children:values.map(({value,label})=>_jsx(SelectItem,{value:value,children:label},value))})]})}),description&&_jsx(AutoFormDesc,{children:description}),_jsx(FormMessage,{})]})};
+import{jsx as _jsx,jsxs as _jsxs,Fragment as _Fragment}from"react/jsx-runtime";import{useTranslations}from"next-intl";import{FormControl,FormMessage}from"../../ui/form.js";import{Select,SelectContent,SelectItem,SelectTrigger,SelectValue}from"../../ui/select.js";import{AutoFormDesc}from"../common/desc.js";import{AutoFormLabel}from"../common/label.js";export const AutoFormSelect=({label,field,itemParams,description,otherProps:{enum:enumValues=[],isOptional},placeholder,labelRight,labels=[],...props})=>{const t=useTranslations("core.global");const values=enumValues.map(value=>{const label=labels.find(l=>l.value===value)?.label;return{value,label:label??value}});return _jsxs(_Fragment,{children:[label&&_jsx(AutoFormLabel,{isOptional:isOptional,labelRight:labelRight,children:label}),_jsx(FormControl,{children:_jsxs(Select,{defaultValue:field.value,items:values,...props,onValueChange:(value,eventDetails)=>{field.onChange(value);props.onValueChange?.(value,eventDetails)},children:[_jsx(SelectTrigger,{onBlur:field.onBlur,children:_jsx(SelectValue,{placeholder:placeholder??t("select_option")})}),_jsx(SelectContent,{children:values.map(({value,label})=>_jsx(SelectItem,{value:value,children:label},value))})]})}),description&&_jsx(AutoFormDesc,{children:description}),_jsx(FormMessage,{})]})};

package/dist/src/components/form/fields/switch.js

@@ -1 +1 @@
-import{jsx as _jsx,jsxs as _jsxs}from"react/jsx-runtime";import{FormControl}from"../../ui/form.js";import{Switch}from"../../ui/switch.js";import{cn}from"../../../lib/utils.js";import{AutoFormDesc}from"../common/desc.js";import{AutoFormLabel}from"../common/label.js";export const AutoFormSwitch=({label,field,itemParams,labelRight,otherProps:{isOptional},className,description,...props})=>{return _jsxs("div",{className:cn("flex flex-row items-center justify-between rounded-lg border p-4",className),children:[(label??description)&&_jsxs("div",{className:"space-y-0.5",children:[label&&_jsx(AutoFormLabel,{className:"text-base",isOptional:isOptional,labelRight:labelRight,children:label}),description&&_jsx(AutoFormDesc,{children:description})]}),_jsx(FormControl,{children:_jsx(Switch,{checked:field.value??false,onCheckedChange:e=>{field.onChange(e);props?.onCheckedChange?.(e)},...props})})]})};
+import{jsx as _jsx,jsxs as _jsxs}from"react/jsx-runtime";import{FormControl}from"../../ui/form.js";import{Switch}from"../../ui/switch.js";import{cn}from"../../../lib/utils.js";import{AutoFormDesc}from"../common/desc.js";import{AutoFormLabel}from"../common/label.js";export const AutoFormSwitch=({label,field,itemParams,labelRight,otherProps:{isOptional},className,description,...props})=>{return _jsxs("div",{className:cn("flex flex-row items-center justify-between rounded-lg border p-4",className),children:[(label??description)&&_jsxs("div",{className:"space-y-0.5",children:[label&&_jsx(AutoFormLabel,{className:"text-base",isOptional:isOptional,labelRight:labelRight,children:label}),description&&_jsx(AutoFormDesc,{children:description})]}),_jsx(FormControl,{children:_jsx(Switch,{checked:field.value??false,onCheckedChange:(checked,eventDetails)=>{field.onChange(checked);props?.onCheckedChange?.(checked,eventDetails)},...props})})]})};

package/dist/src/components/staff-permission/provider.d.ts

@@ -0,0 +1,13 @@
+import React from "react";
+import type { PermissionsStaffArgs, StaffPermissionSet } from "../../api/lib/permission-staff";
+export declare const AdminStaffPermissionProvider: ({ value, children, }: {
+    children: React.ReactNode;
+    value: StaffPermissionSet;
+}) => React.JSX.Element;
+export declare const useAdminStaffPermissions: () => StaffPermissionSet;
+export declare const useAdminStaffPermission: (args: PermissionsStaffArgs) => boolean;
+export declare const AdminStaffPermissionGate: ({ plugin, module, permission, children, fallback, }: PermissionsStaffArgs & {
+    children: React.ReactNode;
+    fallback?: React.ReactNode;
+}) => React.JSX.Element;
+//# sourceMappingURL=provider.d.ts.map