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

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

@@ -13,8 +13,8 @@ export declare const debugAdminModule: import("../../../lib/module").BuildModule
             }>>;
             orderBy: import("zod").ZodOptional<import("zod").ZodEnum<{
                 type: "type";
-                pluginId: "pluginId";
                 createdAt: "createdAt";
+                pluginId: "pluginId";
             }>>;
         }, import("zod/v4/core").$strip>;
     };
@@ -79,13 +79,16 @@ export declare const debugAdminModule: import("../../../lib/module").BuildModule
                         cron: import("zod").ZodObject<{
                             active: import("zod").ZodBoolean;
                             jobs: import("zod").ZodNumber;
+                            lastRun: import("zod").ZodNullable<import("zod").ZodString>;
                             secure: import("zod").ZodBoolean;
+                            stale: import("zod").ZodBoolean;
                         }, import("zod/v4/core").$strip>;
                         email: import("zod").ZodObject<{
                             active: import("zod").ZodBoolean;
                         }, import("zod/v4/core").$strip>;
                         queue: import("zod").ZodObject<{
                             active: import("zod").ZodBoolean;
+                            cronStale: import("zod").ZodBoolean;
                             pending: import("zod").ZodNumber;
                             processing: import("zod").ZodNumber;
                             tasks: import("zod").ZodNumber;
@@ -94,6 +97,9 @@ export declare const debugAdminModule: import("../../../lib/module").BuildModule
                             active: import("zod").ZodBoolean;
                             configuredButDown: import("zod").ZodBoolean;
                         }, import("zod/v4/core").$strip>;
+                        storage: import("zod").ZodObject<{
+                            active: import("zod").ZodBoolean;
+                        }, import("zod/v4/core").$strip>;
                         websocket: import("zod").ZodObject<{
                             active: import("zod").ZodBoolean;
                             crossInstance: import("zod").ZodBoolean;
@@ -145,6 +151,65 @@ export declare const debugAdminModule: import("../../../lib/module").BuildModule
     };
 } & {
     path: string;
+}>, import("../../../lib/route").Route<"@vitnode/core", {
+    method: "get";
+    description: string;
+    path: "/search/status";
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        collections: import("zod").ZodArray<import("zod").ZodObject<{
+                            indexed: import("zod").ZodNumber;
+                            itemType: import("zod").ZodString;
+                            lastIndexedAt: import("zod").ZodNullable<import("zod").ZodDate>;
+                            pluginId: import("zod").ZodString;
+                            total: import("zod").ZodNumber;
+                        }, import("zod/v4/core").$strip>>;
+                        engine: import("zod").ZodString;
+                        hasCronAdapter: import("zod").ZodBoolean;
+                        healthy: import("zod").ZodBoolean;
+                        lastIndexedAt: import("zod").ZodNullable<import("zod").ZodDate>;
+                        total: import("zod").ZodNumber;
+                    }, import("zod/v4/core").$strip>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>, import("../../../lib/route").Route<"@vitnode/core", {
+    method: "post";
+    description: string;
+    path: "/search/rebuild";
+    request: {
+        body: {
+            required: false;
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        itemType: import("zod").ZodOptional<import("zod").ZodString>;
+                    }, import("zod/v4/core").$strip>;
+                };
+            };
+        };
+    };
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        queued: import("zod").ZodBoolean;
+                    }, import("zod/v4/core").$strip>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    path: string;
 }>, import("../../../lib/route").Route<"@vitnode/core", {
     method: "post";
     description: string;
@@ -180,5 +245,39 @@ export declare const debugAdminModule: import("../../../lib/module").BuildModule
     };
 } & {
     path: string;
+}>, import("../../../lib/route").Route<"@vitnode/core", {
+    method: "post";
+    description: string;
+    path: "/test-storage-upload";
+    request: {
+        body: {
+            required: true;
+            content: {
+                "multipart/form-data": {
+                    schema: import("zod").ZodObject<{
+                        file: import("zod").ZodCustom<File, File>;
+                    }, import("zod/v4/core").$strip>;
+                };
+            };
+        };
+    };
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        key: import("zod").ZodString;
+                        url: import("zod").ZodString;
+                    }, import("zod/v4/core").$strip>;
+                };
+            };
+            description: string;
+        };
+        400: {
+            description: string;
+        };
+    };
+} & {
+    path: string;
 }>], import("../../../lib/module").BaseBuildModuleReturn<"@vitnode/core", string, import("../../../lib/route").Route<"@vitnode/core", import("@hono/zod-openapi").RouteConfig>[]>[]>;
 //# sourceMappingURL=debug.admin.module.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"debug.admin.module.d.ts","sourceRoot":"","sources":["../../../../../../src/api/modules/admin/debug/debug.admin.module.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oLAS3B,CAAC"}
+{"version":3,"file":"debug.admin.module.d.ts","sourceRoot":"","sources":["../../../../../../src/api/modules/admin/debug/debug.admin.module.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oLAY3B,CAAC"}

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

@@ -1 +1 @@
-import{CONFIG_PLUGIN}from"../../../../config.js";import{buildModule}from"../../../lib/module.js";import{integrationsDebugAdminRoute}from"./routes/integrations.route.js";import{logsDebugAdminRoute}from"./routes/logs.route.js";import{queueDebugAdminRoute}from"./routes/queue.route.js";import{sendTestEmailDebugAdminRoute}from"./routes/send-test-email.route.js";export const debugAdminModule=buildModule({pluginId:CONFIG_PLUGIN.pluginId,name:"debug",routes:[logsDebugAdminRoute,integrationsDebugAdminRoute,queueDebugAdminRoute,sendTestEmailDebugAdminRoute]});
+import{CONFIG_PLUGIN}from"../../../../config.js";import{buildModule}from"../../../lib/module.js";import{integrationsDebugAdminRoute}from"./routes/integrations.route.js";import{logsDebugAdminRoute}from"./routes/logs.route.js";import{queueDebugAdminRoute}from"./routes/queue.route.js";import{rebuildSearchDebugAdminRoute}from"./routes/rebuild-search.route.js";import{searchStatusDebugAdminRoute}from"./routes/search-status.route.js";import{sendTestEmailDebugAdminRoute}from"./routes/send-test-email.route.js";import{testStorageUploadDebugAdminRoute}from"./routes/test-storage-upload.route.js";export const debugAdminModule=buildModule({pluginId:CONFIG_PLUGIN.pluginId,name:"debug",routes:[logsDebugAdminRoute,integrationsDebugAdminRoute,queueDebugAdminRoute,searchStatusDebugAdminRoute,rebuildSearchDebugAdminRoute,sendTestEmailDebugAdminRoute,testStorageUploadDebugAdminRoute]});

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

@@ -18,13 +18,16 @@ export declare const integrationsDebugAdminRoute: import("../../../../lib/route"
                         cron: z.ZodObject<{
                             active: z.ZodBoolean;
                             jobs: z.ZodNumber;
+                            lastRun: z.ZodNullable<z.ZodString>;
                             secure: z.ZodBoolean;
+                            stale: z.ZodBoolean;
                         }, z.core.$strip>;
                         email: z.ZodObject<{
                             active: z.ZodBoolean;
                         }, z.core.$strip>;
                         queue: z.ZodObject<{
                             active: z.ZodBoolean;
+                            cronStale: z.ZodBoolean;
                             pending: z.ZodNumber;
                             processing: z.ZodNumber;
                             tasks: z.ZodNumber;
@@ -33,6 +36,9 @@ export declare const integrationsDebugAdminRoute: import("../../../../lib/route"
                             active: z.ZodBoolean;
                             configuredButDown: z.ZodBoolean;
                         }, z.core.$strip>;
+                        storage: z.ZodObject<{
+                            active: z.ZodBoolean;
+                        }, z.core.$strip>;
                         websocket: z.ZodObject<{
                             active: z.ZodBoolean;
                             crossInstance: z.ZodBoolean;

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

@@ -1 +1 @@
-{"version":3,"file":"integrations.route.d.ts","sourceRoot":"","sources":["../../../../../../../src/api/modules/admin/debug/routes/integrations.route.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AASxB,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgHtC,CAAC"}
+{"version":3,"file":"integrations.route.d.ts","sourceRoot":"","sources":["../../../../../../../src/api/modules/admin/debug/routes/integrations.route.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAYxB,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgKtC,CAAC"}

package/dist/src/api/modules/admin/debug/routes/integrations.route.js

@@ -1 +1 @@
-import{inArray,sql}from"drizzle-orm";import{z}from"zod";import{CONFIG_PLUGIN}from"../../../../../config.js";import{core_queue}from"../../../../../database/queue.js";import{INSECURE_DEFAULT_CRON_SECRET}from"../../../../../lib/config.js";import{isRealtimePubSubEnabled,isWebSocketEnabled}from"../../../../../ws/registry.js";import{buildRoute}from"../../../../lib/route.js";export const integrationsDebugAdminRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,adminStaffPermission:{module:"system",permission:"can_view"},route:{method:"get",description:"Report whether the core integrations (WebSocket, Redis, Email, Captcha, Cron) are active on the server.",path:"/integrations",responses:{200:{content:{"application/json":{schema:z.object({captcha:z.object({active:z.boolean(),type:z.enum(["cloudflare_turnstile","recaptcha_v3"]).nullable()}),cron:z.object({active:z.boolean(),jobs:z.number(),secure:z.boolean()}),email:z.object({active:z.boolean()}),queue:z.object({active:z.boolean(),pending:z.number(),processing:z.number(),tasks:z.number()}),redis:z.object({active:z.boolean(),configuredButDown:z.boolean()}),websocket:z.object({active:z.boolean(),crossInstance:z.boolean()})})}},description:"Integration statuses"}}},handler:async c=>{const core=c.get("core");const captcha=core.captcha;const redis=await c.get("cache").status();const queueGrouped=await c.get("db").select({status:core_queue.status,count:sql`count(*)::int`}).from(core_queue).where(inArray(core_queue.status,["pending","processing"])).groupBy(core_queue.status);const queuePending=queueGrouped.find(row=>row.status==="pending")?.count??0;const queueProcessing=queueGrouped.find(row=>row.status==="processing")?.count??0;return c.json({captcha:{active:!!(captcha?.secretKey&&captcha.siteKey),type:captcha?.type??null},cron:{active:core.hasCronAdapter,jobs:core.cron.length,secure:!!core.cronSecret&&core.cronSecret!==INSECURE_DEFAULT_CRON_SECRET},email:{active:!!core.email?.adapter},queue:{active:core.queue.length>0,pending:queuePending,processing:queueProcessing,tasks:core.queue.length},redis:{active:redis.configured&&redis.connected,configuredButDown:redis.configured&&!redis.connected},websocket:{active:isWebSocketEnabled(),crossInstance:isRealtimePubSubEnabled()}},200)}});
+import{inArray,sql}from"drizzle-orm";import{z}from"zod";import{CONFIG_PLUGIN}from"../../../../../config.js";import{core_cron}from"../../../../../database/cron.js";import{core_queue}from"../../../../../database/queue.js";import{getQueueStatus}from"../../../../../lib/api/get-queue-status.js";import{isCronStale}from"../../../../../lib/api/is-cron-stale.js";import{INSECURE_DEFAULT_CRON_SECRET}from"../../../../../lib/config.js";import{isRealtimePubSubEnabled,isWebSocketEnabled}from"../../../../../ws/registry.js";import{buildRoute}from"../../../../lib/route.js";export const integrationsDebugAdminRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,adminStaffPermission:{module:"system",permission:"can_view"},route:{method:"get",description:"Report whether the core integrations (WebSocket, Redis, Email, Captcha, Cron) are active on the server.",path:"/integrations",responses:{200:{content:{"application/json":{schema:z.object({captcha:z.object({active:z.boolean(),type:z.enum(["cloudflare_turnstile","recaptcha_v3"]).nullable()}),cron:z.object({active:z.boolean(),jobs:z.number(),lastRun:z.string().nullable(),secure:z.boolean(),stale:z.boolean()}),email:z.object({active:z.boolean()}),queue:z.object({active:z.boolean(),cronStale:z.boolean(),pending:z.number(),processing:z.number(),tasks:z.number()}),redis:z.object({active:z.boolean(),configuredButDown:z.boolean()}),storage:z.object({active:z.boolean()}),websocket:z.object({active:z.boolean(),crossInstance:z.boolean()})})}},description:"Integration statuses"}}},handler:async c=>{const core=c.get("core");const captcha=core.captcha;const redis=await c.get("cache").status();const queueGrouped=await c.get("db").select({status:core_queue.status,count:sql`count(*)::int`}).from(core_queue).where(inArray(core_queue.status,["pending","processing"])).groupBy(core_queue.status);const queuePending=queueGrouped.find(row=>row.status==="pending")?.count??0;const queueProcessing=queueGrouped.find(row=>row.status==="processing")?.count??0;const[cronActivity]=await c.get("db").select({lastRun:sql`max(${core_cron.lastRun})`,lastActivity:sql`max(coalesce(${core_cron.lastRun}, ${core_cron.createdAt}))`}).from(core_cron);const cronLastRun=cronActivity?.lastRun?new Date(cronActivity.lastRun):null;const cronStale=isCronStale(cronActivity?.lastActivity?new Date(cronActivity.lastActivity):null);const cronActive=core.hasCronAdapter;const queueStatus=getQueueStatus({cronActive,cronStale,hasTaskHandlers:core.queue.length>0});return c.json({captcha:{active:!!(captcha?.secretKey&&captcha.siteKey),type:captcha?.type??null},cron:{active:cronActive,jobs:core.cron.length,lastRun:cronLastRun?cronLastRun.toISOString():null,secure:!!core.cronSecret&&core.cronSecret!==INSECURE_DEFAULT_CRON_SECRET,stale:cronStale},email:{active:!!core.email?.adapter},queue:{active:queueStatus.active,cronStale:queueStatus.cronStale,pending:queuePending,processing:queueProcessing,tasks:core.queue.length},redis:{active:redis.configured&&redis.connected,configuredButDown:redis.configured&&!redis.connected},storage:{active:!!core.storage?.adapter},websocket:{active:isWebSocketEnabled(),crossInstance:isRealtimePubSubEnabled()}},200)}});

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

@@ -14,8 +14,8 @@ export declare const logsDebugAdminRoute: import("../../../../lib/route").Route<
             }>>;
             orderBy: z.ZodOptional<z.ZodEnum<{
                 type: "type";
-                pluginId: "pluginId";
                 createdAt: "createdAt";
+                pluginId: "pluginId";
             }>>;
         }, z.core.$strip>;
     };

package/dist/src/api/modules/admin/debug/routes/rebuild-search.route.d.ts

@@ -0,0 +1,36 @@
+import { z } from "zod";
+export declare const zodRebuildSearchSchema: z.ZodObject<{
+    itemType: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const rebuildSearchDebugAdminRoute: import("../../../../../api/lib/route").Route<"@vitnode/core", {
+    method: "post";
+    description: string;
+    path: "/search/rebuild";
+    request: {
+        body: {
+            required: false;
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        itemType: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>;
+                };
+            };
+        };
+    };
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        queued: z.ZodBoolean;
+                    }, z.core.$strip>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>;
+//# sourceMappingURL=rebuild-search.route.d.ts.map

package/dist/src/api/modules/admin/debug/routes/rebuild-search.route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rebuild-search.route.d.ts","sourceRoot":"","sources":["../../../../../../../src/api/modules/admin/debug/routes/rebuild-search.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,sBAAsB;;iBAGjC,CAAC;AAEH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuCvC,CAAC"}

package/dist/src/api/modules/admin/debug/routes/rebuild-search.route.js

@@ -0,0 +1 @@
+import{z}from"zod";import{buildRoute}from"../../../../lib/route.js";import{CONFIG_PLUGIN}from"../../../../../config.js";export const zodRebuildSearchSchema=z.object({itemType:z.string().optional()});export const rebuildSearchDebugAdminRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,adminStaffPermission:{module:"system",permission:"can_view"},route:{method:"post",description:"Queue a rebuild of the content search index, optionally scoped to one collection.",path:"/search/rebuild",request:{body:{required:false,content:{"application/json":{schema:zodRebuildSearchSchema}}}},responses:{200:{content:{"application/json":{schema:z.object({queued:z.boolean()})}},description:"Rebuild queued"}}},handler:async c=>{const{itemType}=c.req.valid("json")??{};await c.get("queue").dispatch({name:"rebuild-search-index",payload:itemType?{itemType}:{}});return c.json({queued:true})}});

package/dist/src/api/modules/admin/debug/routes/search-status.route.d.ts

@@ -0,0 +1,32 @@
+import { z } from "zod";
+export declare const searchStatusDebugAdminRoute: import("../../../../../api/lib/route").Route<"@vitnode/core", {
+    method: "get";
+    description: string;
+    path: "/search/status";
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        collections: z.ZodArray<z.ZodObject<{
+                            indexed: z.ZodNumber;
+                            itemType: z.ZodString;
+                            lastIndexedAt: z.ZodNullable<z.ZodDate>;
+                            pluginId: z.ZodString;
+                            total: z.ZodNumber;
+                        }, z.core.$strip>>;
+                        engine: z.ZodString;
+                        hasCronAdapter: z.ZodBoolean;
+                        healthy: z.ZodBoolean;
+                        lastIndexedAt: z.ZodNullable<z.ZodDate>;
+                        total: z.ZodNumber;
+                    }, z.core.$strip>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>;
+//# sourceMappingURL=search-status.route.d.ts.map

package/dist/src/api/modules/admin/debug/routes/search-status.route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search-status.route.d.ts","sourceRoot":"","sources":["../../../../../../../src/api/modules/admin/debug/routes/search-status.route.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAcxB,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuFtC,CAAC"}

package/dist/src/api/modules/admin/debug/routes/search-status.route.js

@@ -0,0 +1 @@
+import{countDistinct,max}from"drizzle-orm";import{z}from"zod";import{buildRoute}from"../../../../lib/route.js";import{CONFIG_PLUGIN}from"../../../../../config.js";import{core_search_index}from"../../../../../database/search.js";const collectionSchema=z.object({indexed:z.number(),itemType:z.string(),lastIndexedAt:z.date().nullable(),pluginId:z.string(),total:z.number()});export const searchStatusDebugAdminRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,adminStaffPermission:{module:"system",permission:"can_view"},route:{method:"get",description:"Report the active search engine, its health, and per-collection index coverage.",path:"/search/status",responses:{200:{content:{"application/json":{schema:z.object({collections:z.array(collectionSchema),engine:z.string(),hasCronAdapter:z.boolean(),healthy:z.boolean(),lastIndexedAt:z.date().nullable(),total:z.number()})}},description:"Search engine status"}}},handler:async c=>{const db=c.get("db");const search=c.get("search");const core=c.get("core");const indexedByType=await db.select({itemType:core_search_index.itemType,indexed:countDistinct(core_search_index.itemId),lastIndexedAt:max(core_search_index.indexedAt)}).from(core_search_index).groupBy(core_search_index.itemType);const statsByType=new Map(indexedByType.map(row=>[row.itemType,row]));const itemTypes=[...new Set([...core.searchIndexers.map(indexer=>indexer.itemType),...indexedByType.map(row=>row.itemType)])];const collections=await Promise.all(itemTypes.map(async itemType=>{const indexer=core.searchIndexers.find(i=>i.itemType===itemType);const stats=statsByType.get(itemType);const indexed=stats?.indexed??0;const total=indexer?.count?await indexer.count(c):indexed;return{itemType,pluginId:indexer?.pluginId??"core",indexed,total:Math.max(total,indexed),lastIndexedAt:stats?.lastIndexedAt??null}}));const lastIndexedAt=collections.reduce((latest,row)=>{if(!row.lastIndexedAt)return latest;return!latest||row.lastIndexedAt>latest?row.lastIndexedAt:latest},null);return c.json({collections,engine:search.name(),hasCronAdapter:core.hasCronAdapter,healthy:await search.ping(),lastIndexedAt,total:collections.reduce((sum,row)=>sum+row.indexed,0)})}});

package/dist/src/api/modules/admin/debug/routes/test-storage-upload.route.d.ts

@@ -0,0 +1,37 @@
+import { z } from "zod";
+export declare const testStorageUploadDebugAdminRoute: import("../../../../../api/lib/route").Route<"@vitnode/core", {
+    method: "post";
+    description: string;
+    path: "/test-storage-upload";
+    request: {
+        body: {
+            required: true;
+            content: {
+                "multipart/form-data": {
+                    schema: z.ZodObject<{
+                        file: z.ZodCustom<File, File>;
+                    }, z.core.$strip>;
+                };
+            };
+        };
+    };
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        key: z.ZodString;
+                        url: z.ZodString;
+                    }, z.core.$strip>;
+                };
+            };
+            description: string;
+        };
+        400: {
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>;
+//# sourceMappingURL=test-storage-upload.route.d.ts.map

package/dist/src/api/modules/admin/debug/routes/test-storage-upload.route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-storage-upload.route.d.ts","sourceRoot":"","sources":["../../../../../../../src/api/modules/admin/debug/routes/test-storage-upload.route.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAexB,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsD3C,CAAC"}

package/dist/src/api/modules/admin/debug/routes/test-storage-upload.route.js

@@ -0,0 +1 @@
+import{HTTPException}from"hono/http-exception";import{z}from"zod";import{buildRoute}from"../../../../lib/route.js";import{CONFIG_PLUGIN}from"../../../../../config.js";const ADMIN_TEST_MAX_BYTES=10*1024*1024;const ADMIN_TEST_MIME_TYPES=["image/avif","image/gif","image/jpeg","image/png","image/webp"];export const testStorageUploadDebugAdminRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,adminStaffPermission:{module:"system",permission:"can_test_storage"},route:{method:"post",description:"Upload a test image to verify the storage adapter end-to-end from the admin panel.",path:"/test-storage-upload",request:{body:{required:true,content:{"multipart/form-data":{schema:z.object({file:z.instanceof(File).openapi({format:"binary",type:"string"})})}}}},responses:{200:{content:{"application/json":{schema:z.object({key:z.string(),url:z.string()})}},description:"Image uploaded"},400:{description:"Storage adapter not configured or invalid file"}}},handler:async c=>{if(!c.get("core").storage?.adapter){throw new HTTPException(400,{message:"Storage adapter not configured"})}const{file}=c.req.valid("form");const{key,url}=await c.get("storage").upload({file,folder:"admin-storage-test",maxBytes:ADMIN_TEST_MAX_BYTES,allowedMimeTypes:ADMIN_TEST_MIME_TYPES});return c.json({key,url},200)}});

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

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

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

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

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

@@ -0,0 +1 @@
+import{buildModule}from"../../../lib/module.js";import{CONFIG_PLUGIN}from"../../../../config.js";import{deleteFileAdminRoute}from"./routes/delete.route.js";import{downloadFileAdminRoute}from"./routes/download.route.js";import{listFilesAdminRoute}from"./routes/list.route.js";export const filesAdminModule=buildModule({pluginId:CONFIG_PLUGIN.pluginId,name:"files",routes:[listFilesAdminRoute,downloadFileAdminRoute,deleteFileAdminRoute]});

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

@@ -0,0 +1,29 @@
+import { z } from "@hono/zod-openapi";
+export declare const deleteFileAdminRoute: import("../../../../../api/lib/route").Route<"@vitnode/core", {
+    method: "delete";
+    description: string;
+    path: "/{id}";
+    request: {
+        params: z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$strip>;
+    };
+    responses: {
+        200: {
+            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/files/routes/delete.route.d.ts.map

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

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

@@ -0,0 +1 @@
+import{z}from"@hono/zod-openapi";import{buildRoute}from"../../../../lib/route.js";import{CONFIG_PLUGIN}from"../../../../../config.js";export const deleteFileAdminRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,adminStaffPermission:{module:"files",permission:"can_delete"},route:{method:"delete",description:"Delete an uploaded file and its record (Admin only).",path:"/{id}",request:{params:z.object({id:z.string().openapi({example:"1"})})},responses:{200:{description:"File deleted"},404:{content:{"application/json":{schema:z.object({error:z.string()})}},description:"File not found"}}},handler:async c=>{const{id}=c.req.valid("param");const fileId=Number(id);if(!Number.isInteger(fileId)){return c.json({error:"File not found"},404)}await c.get("storage").deleteFile(fileId);return c.body(null,200)}});

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

@@ -0,0 +1,34 @@
+import { z } from "@hono/zod-openapi";
+export declare const downloadFileAdminRoute: import("../../../../../api/lib/route").Route<"@vitnode/core", {
+    method: "get";
+    description: string;
+    path: "/{id}/download";
+    request: {
+        params: z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$strip>;
+    };
+    responses: {
+        200: {
+            content: {
+                "application/octet-stream": {
+                    schema: z.ZodString;
+                };
+            };
+            description: string;
+        };
+        404: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        error: z.ZodString;
+                    }, z.core.$strip>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>;
+//# sourceMappingURL=download.route.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"download.route.d.ts","sourceRoot":"","sources":["../../../../../../../src/api/modules/admin/files/routes/download.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AAOtC,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0EjC,CAAC"}

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

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