@vitnode/core 1.2.0-canary.78 → 2.0.0-canary.2

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

@@ -8,8 +8,8 @@ export declare const debugAdminModule: import("../../../lib/module").BuildModule
             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";
+                asc: "asc";
             }>>;
             orderBy: import("zod").ZodOptional<import("zod").ZodEnum<{
                 type: "type";
@@ -49,8 +49,8 @@ export declare const debugAdminModule: import("../../../lib/module").BuildModule
                             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>;
+                            startCursor: import("zod").ZodNullable<import("zod").ZodString>;
+                            endCursor: import("zod").ZodNullable<import("zod").ZodString>;
                         }, import("zod/v4/core").$strip>;
                     }, import("zod/v4/core").$strip>;
                 };
@@ -69,6 +69,13 @@ export declare const debugAdminModule: import("../../../lib/module").BuildModule
             content: {
                 "application/json": {
                     schema: import("zod").ZodObject<{
+                        ai: import("zod").ZodObject<{
+                            active: import("zod").ZodBoolean;
+                            models: import("zod").ZodArray<import("zod").ZodObject<{
+                                id: import("zod").ZodString;
+                                name: import("zod").ZodString;
+                            }, import("zod/v4/core").$strip>>;
+                        }, import("zod/v4/core").$strip>;
                         captcha: import("zod").ZodObject<{
                             active: import("zod").ZodBoolean;
                             type: import("zod").ZodNullable<import("zod").ZodEnum<{
@@ -76,6 +83,10 @@ export declare const debugAdminModule: import("../../../lib/module").BuildModule
                                 recaptcha_v3: "recaptcha_v3";
                             }>>;
                         }, import("zod/v4/core").$strip>;
+                        contentPreview: import("zod").ZodObject<{
+                            active: import("zod").ZodBoolean;
+                            contentTypes: import("zod").ZodNumber;
+                        }, import("zod/v4/core").$strip>;
                         cron: import("zod").ZodObject<{
                             active: import("zod").ZodBoolean;
                             jobs: import("zod").ZodNumber;
@@ -133,9 +144,9 @@ export declare const debugAdminModule: import("../../../lib/module").BuildModule
                             pluginId: import("zod").ZodString;
                             queue: import("zod").ZodString;
                             status: import("zod").ZodEnum<{
+                                completed: "completed";
                                 pending: "pending";
                                 processing: "processing";
-                                completed: "completed";
                                 failed: "failed";
                             }>;
                             attempts: import("zod").ZodNumber;
@@ -161,16 +172,29 @@ export declare const debugAdminModule: import("../../../lib/module").BuildModule
                 "application/json": {
                     schema: import("zod").ZodObject<{
                         collections: import("zod").ZodArray<import("zod").ZodObject<{
+                            documents: import("zod").ZodNumber;
+                            hasIndexer: import("zod").ZodBoolean;
                             indexed: import("zod").ZodNumber;
                             itemType: import("zod").ZodString;
+                            languages: import("zod").ZodArray<import("zod").ZodObject<{
+                                documents: import("zod").ZodNumber;
+                                languageCode: import("zod").ZodString;
+                                lastIndexedAt: import("zod").ZodNullable<import("zod").ZodDate>;
+                            }, import("zod/v4/core").$strip>>;
                             lastIndexedAt: import("zod").ZodNullable<import("zod").ZodDate>;
                             pluginId: import("zod").ZodString;
-                            total: import("zod").ZodNumber;
+                            total: import("zod").ZodNullable<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>;
+                        syncErrors: import("zod").ZodArray<import("zod").ZodObject<{
+                            content: import("zod").ZodString;
+                            createdAt: import("zod").ZodDate;
+                            id: import("zod").ZodNumber;
+                            pluginId: import("zod").ZodString;
+                        }, import("zod/v4/core").$strip>>;
                         total: import("zod").ZodNumber;
                     }, import("zod/v4/core").$strip>;
                 };
@@ -207,6 +231,101 @@ export declare const debugAdminModule: import("../../../lib/module").BuildModule
             };
             description: string;
         };
+        404: {
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>, import("../../../lib/route").Route<"@vitnode/core", {
+    method: "post";
+    description: string;
+    path: "/search/clear";
+    request: {
+        body: {
+            required: true;
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        itemType: import("zod").ZodString;
+                    }, import("zod/v4/core").$strip>;
+                };
+            };
+        };
+    };
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        cleared: import("zod").ZodBoolean;
+                    }, import("zod/v4/core").$strip>;
+                };
+            };
+            description: string;
+        };
+        409: {
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>, import("../../../lib/route").Route<"@vitnode/core", {
+    method: "get";
+    description: string;
+    path: "/content/status";
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        contentTypes: import("zod").ZodArray<import("zod").ZodObject<{
+                            contentTypeId: import("zod").ZodString;
+                            features: import("zod").ZodObject<{
+                                editorial: import("zod").ZodBoolean;
+                                localization: import("zod").ZodBoolean;
+                                publicApi: import("zod").ZodBoolean;
+                                publication: import("zod").ZodBoolean;
+                                scheduling: import("zod").ZodBoolean;
+                                search: import("zod").ZodBoolean;
+                            }, import("zod/v4/core").$strip>;
+                            pluginId: import("zod").ZodString;
+                            search: import("zod").ZodNullable<import("zod").ZodObject<{
+                                canonicalHealthy: import("zod").ZodBoolean;
+                                canonicalIndexedTotal: import("zod").ZodNumber;
+                                contentTypeId: import("zod").ZodString;
+                                expectedTotal: import("zod").ZodNumber;
+                                healthy: import("zod").ZodBoolean;
+                                locales: import("zod").ZodArray<import("zod").ZodObject<{
+                                    canonicalIndexed: import("zod").ZodNumber;
+                                    canonicalHealthy: import("zod").ZodBoolean;
+                                    expected: import("zod").ZodNumber;
+                                    locale: import("zod").ZodString;
+                                    providerHealthy: import("zod").ZodNullable<import("zod").ZodBoolean>;
+                                    providerIndexed: import("zod").ZodNullable<import("zod").ZodNumber>;
+                                }, import("zod/v4/core").$strip>>;
+                                provider: import("zod").ZodObject<{
+                                    error: import("zod").ZodOptional<import("zod").ZodString>;
+                                    healthy: import("zod").ZodNullable<import("zod").ZodBoolean>;
+                                    indexedTotal: import("zod").ZodNullable<import("zod").ZodNumber>;
+                                    name: import("zod").ZodString;
+                                    verified: import("zod").ZodBoolean;
+                                }, import("zod/v4/core").$strip>;
+                            }, import("zod/v4/core").$strip>>;
+                            schedules: import("zod").ZodNullable<import("zod").ZodObject<{
+                                failedEffects: import("zod").ZodNumber;
+                                pending: import("zod").ZodNumber;
+                                withErrors: import("zod").ZodNumber;
+                            }, import("zod/v4/core").$strip>>;
+                        }, import("zod/v4/core").$strip>>;
+                        effectsHealthy: import("zod").ZodBoolean;
+                        healthy: import("zod").ZodBoolean;
+                        searchHealthy: import("zod").ZodBoolean;
+                    }, import("zod/v4/core").$strip>;
+                };
+            };
+            description: string;
+        };
     };
 } & {
     path: string;
@@ -245,6 +364,38 @@ export declare const debugAdminModule: import("../../../lib/module").BuildModule
     };
 } & {
     path: string;
+}>, import("../../../lib/route").Route<"@vitnode/core", {
+    method: "post";
+    description: string;
+    path: "/test-ai";
+    request: {
+        body: {
+            required: true;
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        model: import("zod").ZodOptional<import("zod").ZodString>;
+                        prompt: import("zod").ZodString;
+                    }, import("zod/v4/core").$strip>;
+                };
+            };
+        };
+    };
+    responses: {
+        200: {
+            content: {
+                "application/x-ndjson": {
+                    schema: import("zod").ZodString;
+                };
+            };
+            description: string;
+        };
+        400: {
+            description: string;
+        };
+    };
+} & {
+    path: string;
 }>, import("../../../lib/route").Route<"@vitnode/core", {
     method: "post";
     description: string;

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":"AAUA,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oLAY3B,CAAC"}
+{"version":3,"file":"debug.admin.module.d.ts","sourceRoot":"","sources":["../../../../../../src/api/modules/admin/debug/debug.admin.module.ts"],"names":[],"mappings":"AAaA,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oLAe3B,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{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]});
+import{CONFIG_PLUGIN}from"../../../../config.js";import{buildModule}from"../../../lib/module.js";import{clearSearchDebugAdminRoute}from"./routes/clear-search.route.js";import{contentStatusDebugAdminRoute}from"./routes/content-status.route.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{testAiDebugAdminRoute}from"./routes/test-ai.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,clearSearchDebugAdminRoute,contentStatusDebugAdminRoute,sendTestEmailDebugAdminRoute,testAiDebugAdminRoute,testStorageUploadDebugAdminRoute]});

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"clear-search.route.d.ts","sourceRoot":"","sources":["../../../../../../../src/api/modules/admin/debug/routes/clear-search.route.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,oBAAoB;;iBAE/B,CAAC;AAqBH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2DrC,CAAC"}

package/dist/src/api/modules/admin/debug/routes/clear-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 zodClearSearchSchema=z.object({itemType:z.string().min(1)});export const clearSearchDebugAdminRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,adminStaffPermission:{module:"system",permission:"can_view"},route:{method:"post",description:"Permanently remove the currently indexed documents of one collection that has no registered rebuild indexer.",path:"/search/clear",request:{body:{required:true,content:{"application/json":{schema:zodClearSearchSchema}}}},responses:{200:{content:{"application/json":{schema:z.object({cleared:z.boolean()})}},description:"Collection cleared"},409:{description:"The collection has a registered rebuild indexer"}}},handler:async c=>{const{itemType}=c.req.valid("json");if(c.get("core").searchIndexers.some(i=>i.itemType===itemType)){throw new HTTPException(409,{message:`"${itemType}" has a registered rebuild indexer. Rebuild it instead of deleting its documents.`})}await c.get("search").clear(itemType);const message=`[Search] Removed the indexed documents of unmanaged collection "${itemType}".`;try{await c.get("log").warn(message)}catch{console.warn(`[VitNode] Failed to persist search cleanup audit: ${message}`)}return c.json({cleared:true})}});

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

@@ -0,0 +1,62 @@
+import { z } from "zod";
+export declare const contentStatusDebugAdminRoute: import("../../../../../api/lib/route").Route<"@vitnode/core", {
+    method: "get";
+    description: string;
+    path: "/content/status";
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        contentTypes: z.ZodArray<z.ZodObject<{
+                            contentTypeId: z.ZodString;
+                            features: z.ZodObject<{
+                                editorial: z.ZodBoolean;
+                                localization: z.ZodBoolean;
+                                publicApi: z.ZodBoolean;
+                                publication: z.ZodBoolean;
+                                scheduling: z.ZodBoolean;
+                                search: z.ZodBoolean;
+                            }, z.core.$strip>;
+                            pluginId: z.ZodString;
+                            search: z.ZodNullable<z.ZodObject<{
+                                canonicalHealthy: z.ZodBoolean;
+                                canonicalIndexedTotal: z.ZodNumber;
+                                contentTypeId: z.ZodString;
+                                expectedTotal: z.ZodNumber;
+                                healthy: z.ZodBoolean;
+                                locales: z.ZodArray<z.ZodObject<{
+                                    canonicalIndexed: z.ZodNumber;
+                                    canonicalHealthy: z.ZodBoolean;
+                                    expected: z.ZodNumber;
+                                    locale: z.ZodString;
+                                    providerHealthy: z.ZodNullable<z.ZodBoolean>;
+                                    providerIndexed: z.ZodNullable<z.ZodNumber>;
+                                }, z.core.$strip>>;
+                                provider: z.ZodObject<{
+                                    error: z.ZodOptional<z.ZodString>;
+                                    healthy: z.ZodNullable<z.ZodBoolean>;
+                                    indexedTotal: z.ZodNullable<z.ZodNumber>;
+                                    name: z.ZodString;
+                                    verified: z.ZodBoolean;
+                                }, z.core.$strip>;
+                            }, z.core.$strip>>;
+                            schedules: z.ZodNullable<z.ZodObject<{
+                                failedEffects: z.ZodNumber;
+                                pending: z.ZodNumber;
+                                withErrors: z.ZodNumber;
+                            }, z.core.$strip>>;
+                        }, z.core.$strip>>;
+                        effectsHealthy: z.ZodBoolean;
+                        healthy: z.ZodBoolean;
+                        searchHealthy: z.ZodBoolean;
+                    }, z.core.$strip>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>;
+//# sourceMappingURL=content-status.route.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"content-status.route.d.ts","sourceRoot":"","sources":["../../../../../../../src/api/modules/admin/debug/routes/content-status.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAoFxB,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2BvC,CAAC"}

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

@@ -0,0 +1 @@
+import{z}from"zod";import{buildRoute}from"../../../../lib/route.js";import{CONFIG_PLUGIN}from"../../../../../config.js";import{contentEngineDiagnostics}from"../../../../../content/server/diagnostics.js";const localeDriftSchema=z.object({canonicalIndexed:z.number(),canonicalHealthy:z.boolean(),expected:z.number(),locale:z.string(),providerHealthy:z.boolean().nullable(),providerIndexed:z.number().nullable()});const contentTypeSchema=z.object({contentTypeId:z.string(),features:z.object({editorial:z.boolean(),localization:z.boolean(),publicApi:z.boolean(),publication:z.boolean(),scheduling:z.boolean(),search:z.boolean()}),pluginId:z.string(),search:z.object({canonicalHealthy:z.boolean(),canonicalIndexedTotal:z.number(),contentTypeId:z.string(),expectedTotal:z.number(),healthy:z.boolean(),locales:z.array(localeDriftSchema),provider:z.object({error:z.string().optional(),healthy:z.boolean().nullable(),indexedTotal:z.number().nullable(),name:z.string(),verified:z.boolean()})}).nullable(),schedules:z.object({failedEffects:z.number(),pending:z.number(),withErrors:z.number()}).nullable()});export const contentStatusDebugAdminRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,adminStaffPermission:{module:"system",permission:"can_view"},route:{method:"get",description:"Report every registered content type, its search index drift per locale, and its outstanding scheduled-effect failures.",path:"/content/status",responses:{200:{content:{"application/json":{schema:z.object({contentTypes:z.array(contentTypeSchema),effectsHealthy:z.boolean(),healthy:z.boolean(),searchHealthy:z.boolean()})}},description:"Content Engine status"}}},handler:async c=>c.json(await contentEngineDiagnostics(c))});

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

@@ -8,6 +8,13 @@ export declare const integrationsDebugAdminRoute: import("../../../../lib/route"
             content: {
                 "application/json": {
                     schema: z.ZodObject<{
+                        ai: z.ZodObject<{
+                            active: z.ZodBoolean;
+                            models: z.ZodArray<z.ZodObject<{
+                                id: z.ZodString;
+                                name: z.ZodString;
+                            }, z.core.$strip>>;
+                        }, z.core.$strip>;
                         captcha: z.ZodObject<{
                             active: z.ZodBoolean;
                             type: z.ZodNullable<z.ZodEnum<{
@@ -15,6 +22,10 @@ export declare const integrationsDebugAdminRoute: import("../../../../lib/route"
                                 recaptcha_v3: "recaptcha_v3";
                             }>>;
                         }, z.core.$strip>;
+                        contentPreview: z.ZodObject<{
+                            active: z.ZodBoolean;
+                            contentTypes: z.ZodNumber;
+                        }, z.core.$strip>;
                         cron: z.ZodObject<{
                             active: z.ZodBoolean;
                             jobs: z.ZodNumber;

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;AAYxB,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgKtC,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6LtC,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_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)}});
+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 (AI, WebSocket, Redis, Email, Captcha, Cron) are active on the server.",path:"/integrations",responses:{200:{content:{"application/json":{schema:z.object({ai:z.object({active:z.boolean(),models:z.array(z.object({id:z.string(),name:z.string()}))}),captcha:z.object({active:z.boolean(),type:z.enum(["cloudflare_turnstile","recaptcha_v3"]).nullable()}),contentPreview:z.object({active:z.boolean(),contentTypes:z.number()}),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 previewContentTypes=core.contentTypes.filter(entry=>entry.definition.editorial.preview.enabled).length;const queueStatus=getQueueStatus({cronActive,cronStale,hasTaskHandlers:core.queue.length>0});return c.json({ai:{active:(core.ai?.models.length??0)>0,models:c.get("ai").models().map(({id,name})=>({id,name}))},captcha:{active:!!(captcha?.secretKey&&captcha.siteKey),type:captcha?.type??null},contentPreview:{active:previewContentTypes>0,contentTypes:previewContentTypes},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

@@ -9,8 +9,8 @@ export declare const logsDebugAdminRoute: import("../../../../lib/route").Route<
             first: z.ZodOptional<z.ZodString>;
             last: z.ZodOptional<z.ZodString>;
             order: z.ZodOptional<z.ZodEnum<{
-                asc: "asc";
                 desc: "desc";
+                asc: "asc";
             }>>;
             orderBy: z.ZodOptional<z.ZodEnum<{
                 type: "type";
@@ -50,8 +50,8 @@ export declare const logsDebugAdminRoute: import("../../../../lib/route").Route<
                             count: z.ZodNumber;
                             hasNextPage: z.ZodBoolean;
                             hasPreviousPage: z.ZodBoolean;
-                            startCursor: z.ZodNullable<z.ZodNumber>;
-                            endCursor: z.ZodNullable<z.ZodNumber>;
+                            startCursor: z.ZodNullable<z.ZodString>;
+                            endCursor: z.ZodNullable<z.ZodString>;
                         }, z.core.$strip>;
                     }, z.core.$strip>;
                 };

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

@@ -1 +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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyF9B,CAAC"}
+{"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

@@ -1 +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({limit,where,orderBy})=>await c.get("db").select({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)}});
+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

@@ -20,9 +20,9 @@ export declare const queueDebugAdminRoute: import("../../../../../api/lib/route"
                             pluginId: z.ZodString;
                             queue: z.ZodString;
                             status: z.ZodEnum<{
+                                completed: "completed";
                                 pending: "pending";
                                 processing: "processing";
-                                completed: "completed";
                                 failed: "failed";
                             }>;
                             attempts: z.ZodNumber;

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

@@ -29,6 +29,9 @@ export declare const rebuildSearchDebugAdminRoute: import("../../../../../api/li
             };
             description: string;
         };
+        404: {
+            description: string;
+        };
     };
 } & {
     path: string;

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

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

@@ -1 +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})}});
+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

@@ -9,16 +9,29 @@ export declare const searchStatusDebugAdminRoute: import("../../../../../api/lib
                 "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.ZodNumber;
+                            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>;
                 };

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

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

@@ -1 +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)})}});
+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/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"})}});