@vitnode/core 0.0.1-canary.0

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

@@ -0,0 +1,65 @@
+import { z } from "zod";
+export declare const logsDebugAdminRoute: import("../../../../lib/route").Route<"@vitnode/core", {
+    method: "get";
+    description: string;
+    path: "/logs";
+    request: {
+        query: z.ZodObject<{
+            cursor: z.ZodOptional<z.ZodString>;
+            first: z.ZodOptional<z.ZodString>;
+            last: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodEnum<{
+                desc: "desc";
+                asc: "asc";
+            }>>;
+            orderBy: z.ZodOptional<z.ZodEnum<{
+                type: "type";
+                createdAt: "createdAt";
+                pluginId: "pluginId";
+            }>>;
+        }, z.core.$strip>;
+    };
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        edges: z.ZodArray<z.ZodObject<{
+                            id: z.ZodNumber;
+                            pluginId: z.ZodString;
+                            type: z.ZodEnum<{
+                                error: "error";
+                                warn: "warn";
+                                debug: "debug";
+                            }>;
+                            content: z.ZodString;
+                            createdAt: z.ZodDate;
+                            ipAddress: z.ZodString;
+                            method: z.ZodString;
+                            path: z.ZodString;
+                            userAgent: z.ZodNullable<z.ZodString>;
+                            statusCode: z.ZodNumber;
+                            user: z.ZodNullable<z.ZodObject<{
+                                id: z.ZodNumber;
+                                name: z.ZodString;
+                                nameCode: z.ZodString;
+                            }, z.core.$strip>>;
+                        }, z.core.$strip>>;
+                        pageInfo: z.ZodObject<{
+                            totalCount: z.ZodNumber;
+                            count: z.ZodNumber;
+                            hasNextPage: z.ZodBoolean;
+                            hasPreviousPage: z.ZodBoolean;
+                            startCursor: z.ZodNullable<z.ZodString>;
+                            endCursor: z.ZodNullable<z.ZodString>;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>;
+//# sourceMappingURL=logs.route.d.ts.map

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

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

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

@@ -0,0 +1 @@
+import{eq}from"drizzle-orm";import{z}from"zod";import{CONFIG_PLUGIN}from"../../../../../config.js";import{core_logs}from"../../../../../database/logs.js";import{core_users}from"../../../../../database/users.js";import{buildRoute}from"../../../../lib/route.js";import{withPagination,zodPaginationPageInfo,zodPaginationQuery}from"../../../../lib/with-pagination.js";export const logsDebugAdminRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,adminStaffPermission:{module:"debug",permission:"can_view"},route:{method:"get",description:"Get Admin Debug Logs",path:"/logs",request:{query:zodPaginationQuery.extend({order:z.enum(["asc","desc"]).optional(),orderBy:z.enum(["type","createdAt","pluginId"]).optional()})},responses:{200:{content:{"application/json":{schema:z.object({edges:z.array(z.object({id:z.number(),pluginId:z.string(),type:z.enum(["warn","error","debug"]),content:z.string(),createdAt:z.date(),ipAddress:z.string(),method:z.string(),path:z.string(),userAgent:z.string().nullable(),statusCode:z.number(),user:z.object({id:z.number(),name:z.string(),nameCode:z.string()}).nullable()})),pageInfo:zodPaginationPageInfo})}},description:"List of users"}}},handler:async c=>{const query=c.req.valid("query");const data=await withPagination({params:{query},primaryCursor:core_logs.id,query:async({cursorSelection,limit,where,orderBy})=>await c.get("db").select({...cursorSelection,id:core_logs.id,pluginId:core_logs.pluginId,type:core_logs.type,content:core_logs.content,createdAt:core_logs.createdAt,ipAddress:core_logs.ipAddress,method:core_logs.method,path:core_logs.path,userAgent:core_logs.userAgent,statusCode:core_logs.statusCode,user:{id:core_users.id,name:core_users.name,nameCode:core_users.nameCode}}).from(core_logs).leftJoin(core_users,eq(core_users.id,core_logs.userId)).where(where).orderBy(orderBy).limit(limit),table:core_logs,orderBy:{column:query.orderBy?core_logs[query.orderBy]:core_logs.createdAt,order:query.order??"desc"},c});return c.json(data)}});

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

@@ -0,0 +1,42 @@
+import z from "zod";
+export declare const queueDebugAdminRoute: import("../../../../../api/lib/route").Route<"@vitnode/core", {
+    method: "get";
+    description: string;
+    path: "/queue";
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        counts: z.ZodObject<{
+                            pending: z.ZodNumber;
+                            processing: z.ZodNumber;
+                            completed: z.ZodNumber;
+                            failed: z.ZodNumber;
+                        }, z.core.$strip>;
+                        active: z.ZodArray<z.ZodObject<{
+                            id: z.ZodNumber;
+                            name: z.ZodString;
+                            pluginId: z.ZodString;
+                            queue: z.ZodString;
+                            status: z.ZodEnum<{
+                                completed: "completed";
+                                pending: "pending";
+                                processing: "processing";
+                                failed: "failed";
+                            }>;
+                            attempts: z.ZodNumber;
+                            maxAttempts: z.ZodNumber;
+                            availableAt: z.ZodDate;
+                            createdAt: z.ZodDate;
+                        }, z.core.$strip>>;
+                    }, z.core.$strip>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>;
+//# sourceMappingURL=queue.route.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"queue.route.d.ts","sourceRoot":"","sources":["../../../../../../../src/api/modules/admin/debug/routes/queue.route.ts"],"names":[],"mappings":"AACA,OAAO,CAAC,MAAM,KAAK,CAAC;AAapB,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4E/B,CAAC"}

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

@@ -0,0 +1 @@
+import{asc,desc,inArray,sql}from"drizzle-orm";import z from"zod";import{buildRoute}from"../../../../lib/route.js";import{CONFIG_PLUGIN}from"../../../../../config.js";import{core_queue}from"../../../../../database/queue.js";const QUEUE_STATUSES=["pending","processing","completed","failed"];export const queueDebugAdminRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,adminStaffPermission:{module:"debug",permission:"can_view"},route:{method:"get",description:"Currently active (pending/processing) queue tasks and per-status counts.",path:"/queue",responses:{200:{content:{"application/json":{schema:z.object({counts:z.object({pending:z.number(),processing:z.number(),completed:z.number(),failed:z.number()}),active:z.array(z.object({id:z.number(),name:z.string(),pluginId:z.string(),queue:z.string(),status:z.enum(QUEUE_STATUSES),attempts:z.number(),maxAttempts:z.number(),availableAt:z.date(),createdAt:z.date()}))})}},description:"Queue status"}}},handler:async c=>{const db=c.get("db");const grouped=await db.select({status:core_queue.status,count:sql`count(*)::int`}).from(core_queue).groupBy(core_queue.status);const counts={pending:0,processing:0,completed:0,failed:0};for(const row of grouped){if(row.status in counts){counts[row.status]=row.count}}const active=await db.select({id:core_queue.id,name:core_queue.name,pluginId:core_queue.pluginId,queue:core_queue.queue,status:core_queue.status,attempts:core_queue.attempts,maxAttempts:core_queue.maxAttempts,availableAt:core_queue.availableAt,createdAt:core_queue.createdAt}).from(core_queue).where(inArray(core_queue.status,["pending","processing"])).orderBy(desc(core_queue.priority),asc(core_queue.availableAt)).limit(50);return c.json({counts,active},200)}});

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

@@ -0,0 +1,39 @@
+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;
+        };
+        404: {
+            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":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,sBAAsB;;iBAGjC,CAAC;AAEH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoDvC,CAAC"}

package/dist/src/api/modules/admin/debug/routes/rebuild-search.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";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"},404:{description:"No indexer is registered for that collection"}}},handler:async c=>{const{itemType}=c.req.valid("json")??{};if(itemType&&!c.get("core").searchIndexers.some(i=>i.itemType===itemType)){throw new HTTPException(404,{message:`No search indexer is registered for "${itemType}".`})}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,45 @@
+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<{
+                            documents: z.ZodNumber;
+                            hasIndexer: z.ZodBoolean;
+                            indexed: z.ZodNumber;
+                            itemType: z.ZodString;
+                            languages: z.ZodArray<z.ZodObject<{
+                                documents: z.ZodNumber;
+                                languageCode: z.ZodString;
+                                lastIndexedAt: z.ZodNullable<z.ZodDate>;
+                            }, z.core.$strip>>;
+                            lastIndexedAt: z.ZodNullable<z.ZodDate>;
+                            pluginId: z.ZodString;
+                            total: z.ZodNullable<z.ZodNumber>;
+                        }, z.core.$strip>>;
+                        engine: z.ZodString;
+                        hasCronAdapter: z.ZodBoolean;
+                        healthy: z.ZodBoolean;
+                        lastIndexedAt: z.ZodNullable<z.ZodDate>;
+                        syncErrors: z.ZodArray<z.ZodObject<{
+                            content: z.ZodString;
+                            createdAt: z.ZodDate;
+                            id: z.ZodNumber;
+                            pluginId: z.ZodString;
+                        }, z.core.$strip>>;
+                        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":"AAUA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAwDxB,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoKtC,CAAC"}

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

@@ -0,0 +1 @@
+import{and,count,countDistinct,desc,eq,like,max,ne}from"drizzle-orm";import{z}from"zod";import{buildRoute}from"../../../../lib/route.js";import{searchDocumentOwner}from"../../../../models/search.js";import{CONFIG_PLUGIN}from"../../../../../config.js";import{core_logs}from"../../../../../database/logs.js";import{core_search_index}from"../../../../../database/search.js";const CONTENT_SEARCH_LOG_PREFIX="[content-search]";const SYNC_ERROR_LIMIT=10;const collectionSchema=z.object({documents:z.number(),hasIndexer:z.boolean(),indexed:z.number(),itemType:z.string(),languages:z.array(z.object({documents:z.number(),languageCode:z.string(),lastIndexedAt:z.date().nullable()})),lastIndexedAt:z.date().nullable(),pluginId:z.string(),total:z.number().nullable()});const syncErrorSchema=z.object({content:z.string(),createdAt:z.date(),id:z.number(),pluginId:z.string()});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(),syncErrors:z.array(syncErrorSchema),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,documents:count(),indexed:countDistinct(core_search_index.itemId),lastIndexedAt:max(core_search_index.indexedAt),pluginId:max(core_search_index.pluginId)}).from(core_search_index).groupBy(core_search_index.itemType);const statsByType=new Map(indexedByType.map(row=>[row.itemType,row]));const byLanguage=await db.select({itemType:core_search_index.itemType,documents:count(),languageCode:core_search_index.languageCode,lastIndexedAt:max(core_search_index.indexedAt)}).from(core_search_index).where(ne(core_search_index.languageCode,"")).groupBy(core_search_index.itemType,core_search_index.languageCode).orderBy(desc(count()));const languagesByType=new Map;for(const row of byLanguage){const entries=languagesByType.get(row.itemType)??[];entries.push({documents:row.documents,languageCode:row.languageCode,lastIndexedAt:row.lastIndexedAt});languagesByType.set(row.itemType,entries)}const syncErrors=await db.select({id:core_logs.id,pluginId:core_logs.pluginId,content:core_logs.content,createdAt:core_logs.createdAt}).from(core_logs).where(and(eq(core_logs.type,"error"),like(core_logs.content,`${CONTENT_SEARCH_LOG_PREFIX}%`))).orderBy(desc(core_logs.id)).limit(SYNC_ERROR_LIMIT);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?await indexer.count?.(c)??indexed:null;return{hasIndexer:indexer!==undefined,itemType,pluginId:indexer?.pluginId??searchDocumentOwner(stats?.pluginId)??"unknown",documents:stats?.documents??0,indexed,languages:languagesByType.get(itemType)??[],total,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,syncErrors,total:collections.reduce((sum,row)=>sum+row.indexed,0)})}});

package/dist/src/api/modules/admin/debug/routes/send-test-email.route.d.ts

@@ -0,0 +1,43 @@
+import { z } from "zod";
+export declare const zodSendTestEmailSchema: z.ZodObject<{
+    content: z.ZodString;
+    subject: z.ZodString;
+    to: z.ZodEmail;
+}, z.core.$strip>;
+export declare const sendTestEmailDebugAdminRoute: import("../../../../../api/lib/route").Route<"@vitnode/core", {
+    method: "post";
+    description: string;
+    path: "/send-test-email";
+    request: {
+        body: {
+            required: true;
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        content: z.ZodString;
+                        subject: z.ZodString;
+                        to: z.ZodEmail;
+                    }, z.core.$strip>;
+                };
+            };
+        };
+    };
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        success: z.ZodBoolean;
+                    }, z.core.$strip>;
+                };
+            };
+            description: string;
+        };
+        400: {
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>;
+//# sourceMappingURL=send-test-email.route.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"send-test-email.route.d.ts","sourceRoot":"","sources":["../../../../../../../src/api/modules/admin/debug/routes/send-test-email.route.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,sBAAsB;;;;iBAIjC,CAAC;AAEH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoDvC,CAAC"}

package/dist/src/api/modules/admin/debug/routes/send-test-email.route.js

@@ -0,0 +1 @@
+import{HTTPException}from"hono/http-exception";import{z}from"zod";import{buildRoute}from"../../../../lib/route.js";import{CONFIG_PLUGIN}from"../../../../../config.js";import TestEmailTemplate from"../../../../../emails/test-email.js";export const zodSendTestEmailSchema=z.object({content:z.string().min(1).max(5e3),subject:z.string().min(1).max(200),to:z.email()});export const sendTestEmailDebugAdminRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,adminStaffPermission:{module:"system",permission:"can_send_test_email"},route:{method:"post",description:"Send a test email to verify that the email adapter is configured correctly.",path:"/send-test-email",request:{body:{required:true,content:{"application/json":{schema:zodSendTestEmailSchema}}}},responses:{200:{content:{"application/json":{schema:z.object({success:z.boolean()})}},description:"Test email sent"},400:{description:"Email adapter not configured"}}},handler:async c=>{if(!c.get("core").email?.adapter){throw new HTTPException(400,{message:"Email provider not configured"})}const{to,subject,content}=c.req.valid("json");await c.get("email").send({to,locale:"en",subject,content:props=>TestEmailTemplate({...props,content})});return c.json({success:true})}});

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

@@ -0,0 +1,39 @@
+import { z } from "zod";
+export declare const zodTestAiSchema: z.ZodObject<{
+    model: z.ZodOptional<z.ZodString>;
+    prompt: z.ZodString;
+}, z.core.$strip>;
+export declare const testAiDebugAdminRoute: import("../../../../../api/lib/route").Route<"@vitnode/core", {
+    method: "post";
+    description: string;
+    path: "/test-ai";
+    request: {
+        body: {
+            required: true;
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        model: z.ZodOptional<z.ZodString>;
+                        prompt: z.ZodString;
+                    }, z.core.$strip>;
+                };
+            };
+        };
+    };
+    responses: {
+        200: {
+            content: {
+                "application/x-ndjson": {
+                    schema: z.ZodString;
+                };
+            };
+            description: string;
+        };
+        400: {
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>;
+//# sourceMappingURL=test-ai.route.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"test-ai.route.d.ts","sourceRoot":"","sources":["../../../../../../../src/api/modules/admin/debug/routes/test-ai.route.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,eAAe;;;iBAI1B,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsFhC,CAAC"}

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

@@ -0,0 +1,2 @@
+import{streamText}from"ai";import{HTTPException}from"hono/http-exception";import{z}from"zod";import{buildRoute}from"../../../../lib/route.js";import{CONFIG_PLUGIN}from"../../../../../config.js";export const zodTestAiSchema=z.object({model:z.string().optional(),prompt:z.string().min(1).max(5e3)});export const testAiDebugAdminRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,adminStaffPermission:{module:"system",permission:"can_test_ai"},route:{method:"post",description:"Stream a completion from a configured AI model to verify the setup.",path:"/test-ai",request:{body:{required:true,content:{"application/json":{schema:zodTestAiSchema}}}},responses:{200:{content:{"application/x-ndjson":{schema:z.string()}},description:"Streamed NDJSON events"},400:{description:"No AI models configured"}}},handler:c=>{if(!c.get("core").ai?.models.length){throw new HTTPException(400,{message:"No AI models configured"})}const{model,prompt}=c.req.valid("json");const result=streamText({model:c.get("ai").model(model),prompt,onError:({error})=>{void c.get("log").error(`AI test stream failed: ${String(error)}`)}});const encoder=new TextEncoder;const body=new ReadableStream({async start(controller){const send=event=>{controller.enqueue(encoder.encode(`${JSON.stringify(event)}
+`))};try{for await(const part of result.stream){if(part.type==="text-delta"){send({t:part.text})}else if(part.type==="error"){send({e:part.error instanceof Error?part.error.message:String(part.error)})}}}catch(error){send({e:error instanceof Error?error.message:String(error)})}finally{controller.close()}}});return c.body(body,200,{"Content-Type":"application/x-ndjson; charset=utf-8"})}});

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,147 @@
+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<{
+                desc: "desc";
+                asc: "asc";
+            }>>;
+            orderBy: import("zod").ZodOptional<import("zod").ZodEnum<{
+                createdAt: "createdAt";
+                size: "size";
+                name: "name";
+            }>>;
+            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").ZodString>;
+                            endCursor: import("zod").ZodNullable<import("zod").ZodString>;
+                        }, 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>;
+        query: import("zod").ZodObject<{
+            force: import("zod").ZodOptional<import("zod").ZodEnum<{
+                true: "true";
+                false: "false";
+            }>>;
+        }, 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;
+        };
+        409: {
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        code: import("zod").ZodString;
+                        content: import("zod").ZodBoolean;
+                        id: import("zod").ZodNumber;
+                        revisions: import("zod").ZodNumber;
+                    }, 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,48 @@
+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>;
+        query: z.ZodObject<{
+            force: z.ZodOptional<z.ZodEnum<{
+                true: "true";
+                false: "false";
+            }>>;
+        }, z.core.$strip>;
+    };
+    responses: {
+        200: {
+            description: string;
+        };
+        404: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        error: z.ZodString;
+                    }, z.core.$strip>;
+                };
+            };
+            description: string;
+        };
+        409: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        code: z.ZodString;
+                        content: z.ZodBoolean;
+                        id: z.ZodNumber;
+                        revisions: z.ZodNumber;
+                    }, 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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgE/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"})}),query:z.object({force:z.enum(["true","false"]).optional()})},responses:{200:{description:"File deleted"},404:{content:{"application/json":{schema:z.object({error:z.string()})}},description:"File not found"},409:{content:{"application/json":{schema:z.object({code:z.string(),content:z.boolean(),id:z.number(),revisions:z.number()})}},description:"Still referenced by content or by a retained revision, so the file was kept"}}},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,{force:c.req.query("force")==="true"});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"}