@vitnode/core 1.2.0-canary.23 → 1.2.0-canary.25

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

@@ -0,0 +1,222 @@
+import { z } from 'zod';
+export declare const logsDebugAdminRoute: {
+    handler: (c: import("hono").Context<import("../../../../middlewares/global.middleware").EnvVitNode, "/logs", {
+        in: {
+            query: {
+                orderBy?: "createdAt" | "type" | "pluginId" | undefined;
+                cursor?: string | undefined;
+                order?: "asc" | "desc" | undefined;
+                first?: string | undefined;
+                last?: string | undefined;
+            };
+        };
+        out: {
+            query: {
+                orderBy?: "createdAt" | "type" | "pluginId" | undefined;
+                cursor?: string | undefined;
+                order?: "asc" | "desc" | undefined;
+                first?: string | undefined;
+                last?: string | undefined;
+            };
+        };
+    }>) => Promise<Response & import("hono").TypedResponse<{
+        edges: {
+            id: number;
+            pluginId: string;
+            type: "warn" | "error" | "debug";
+            content: string;
+            createdAt: string;
+            ipAddress: string;
+            method: string;
+            path: string;
+            userAgent: string | null;
+            statusCode: number;
+            user: {
+                id: number;
+                name: string;
+                nameCode: string;
+            } | null;
+        }[];
+        pageInfo: {
+            count: number;
+            endCursor: null | number;
+            hasNextPage: boolean;
+            hasPreviousPage: boolean;
+            startCursor: null | number;
+            totalCount: number;
+        };
+    }, 200, "json">>;
+    pluginId: "@vitnode/core";
+    route: {
+        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<["asc", "desc"]>>;
+                orderBy: z.ZodOptional<z.ZodEnum<["type", "createdAt", "pluginId"]>>;
+            }, "strip", z.ZodTypeAny, {
+                orderBy?: "createdAt" | "type" | "pluginId" | undefined;
+                cursor?: string | undefined;
+                order?: "asc" | "desc" | undefined;
+                first?: string | undefined;
+                last?: string | undefined;
+            }, {
+                orderBy?: "createdAt" | "type" | "pluginId" | undefined;
+                cursor?: string | undefined;
+                order?: "asc" | "desc" | undefined;
+                first?: string | undefined;
+                last?: string | undefined;
+            }>;
+        };
+        responses: {
+            200: {
+                content: {
+                    'application/json': {
+                        schema: z.ZodObject<{
+                            edges: z.ZodArray<z.ZodObject<{
+                                id: z.ZodNumber;
+                                pluginId: z.ZodString;
+                                type: z.ZodEnum<["warn", "error", "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;
+                                }, "strip", z.ZodTypeAny, {
+                                    id: number;
+                                    name: string;
+                                    nameCode: string;
+                                }, {
+                                    id: number;
+                                    name: string;
+                                    nameCode: string;
+                                }>>;
+                            }, "strip", z.ZodTypeAny, {
+                                ipAddress: string;
+                                user: {
+                                    id: number;
+                                    name: string;
+                                    nameCode: string;
+                                } | null;
+                                id: number;
+                                createdAt: Date;
+                                userAgent: string | null;
+                                type: "warn" | "error" | "debug";
+                                path: string;
+                                pluginId: string;
+                                content: string;
+                                method: string;
+                                statusCode: number;
+                            }, {
+                                ipAddress: string;
+                                user: {
+                                    id: number;
+                                    name: string;
+                                    nameCode: string;
+                                } | null;
+                                id: number;
+                                createdAt: Date;
+                                userAgent: string | null;
+                                type: "warn" | "error" | "debug";
+                                path: string;
+                                pluginId: string;
+                                content: string;
+                                method: string;
+                                statusCode: number;
+                            }>, "many">;
+                            pageInfo: z.ZodObject<{
+                                totalCount: z.ZodNumber;
+                                count: z.ZodNumber;
+                                hasNextPage: z.ZodBoolean;
+                                hasPreviousPage: z.ZodBoolean;
+                                startCursor: z.ZodNullable<z.ZodNumber>;
+                                endCursor: z.ZodNullable<z.ZodNumber>;
+                            }, "strip", z.ZodTypeAny, {
+                                count: number;
+                                totalCount: number;
+                                hasNextPage: boolean;
+                                hasPreviousPage: boolean;
+                                startCursor: number | null;
+                                endCursor: number | null;
+                            }, {
+                                count: number;
+                                totalCount: number;
+                                hasNextPage: boolean;
+                                hasPreviousPage: boolean;
+                                startCursor: number | null;
+                                endCursor: number | null;
+                            }>;
+                        }, "strip", z.ZodTypeAny, {
+                            edges: {
+                                ipAddress: string;
+                                user: {
+                                    id: number;
+                                    name: string;
+                                    nameCode: string;
+                                } | null;
+                                id: number;
+                                createdAt: Date;
+                                userAgent: string | null;
+                                type: "warn" | "error" | "debug";
+                                path: string;
+                                pluginId: string;
+                                content: string;
+                                method: string;
+                                statusCode: number;
+                            }[];
+                            pageInfo: {
+                                count: number;
+                                totalCount: number;
+                                hasNextPage: boolean;
+                                hasPreviousPage: boolean;
+                                startCursor: number | null;
+                                endCursor: number | null;
+                            };
+                        }, {
+                            edges: {
+                                ipAddress: string;
+                                user: {
+                                    id: number;
+                                    name: string;
+                                    nameCode: string;
+                                } | null;
+                                id: number;
+                                createdAt: Date;
+                                userAgent: string | null;
+                                type: "warn" | "error" | "debug";
+                                path: string;
+                                pluginId: string;
+                                content: string;
+                                method: string;
+                                statusCode: number;
+                            }[];
+                            pageInfo: {
+                                count: number;
+                                totalCount: number;
+                                hasNextPage: boolean;
+                                hasPreviousPage: boolean;
+                                startCursor: number | null;
+                                endCursor: number | null;
+                            };
+                        }>;
+                    };
+                };
+                description: string;
+            };
+        };
+    } & {
+        getRoutingPath: () => "/logs";
+    };
+};
+//# 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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwF9B,CAAC"}

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

@@ -0,0 +1,90 @@
+import { eq } from "drizzle-orm";
+import { z } from "zod";
+import { CONFIG_PLUGIN } from "../../../../../config.js";
+import { core_logs, coreLogsType } 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({
+    ...CONFIG_PLUGIN,
+    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(coreLogsType.enumValues),
+                                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);
+    }
+});

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

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 export declare const sessionAdminRoute: {
-    handler: (c: import("hono").Context<import("../../../middlewares/global/global").EnvVitNode, "/session", {}>) => Response & import("hono").TypedResponse<{
+    handler: (c: import("hono").Context<import("../../../middlewares/global.middleware").EnvVitNode, "/session", {}>) => Response & import("hono").TypedResponse<{
         user: {
             avatarColor: string;
             birthday: string | null;
@@ -19,10 +19,6 @@ export declare const sessionAdminRoute: {
     route: {
         method: "get";
         description: string;
-        pluginConfig: {
-            id: string;
-            name: string;
-        };
         path: "/session";
         responses: {
             200: {

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

@@ -1 +1 @@
-{"version":3,"file":"session.route.d.ts","sourceRoot":"","sources":["../../../../../../src/api/modules/admin/routes/session.route.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+C5B,CAAC"}
+{"version":3,"file":"session.route.d.ts","sourceRoot":"","sources":["../../../../../../src/api/modules/admin/routes/session.route.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2C5B,CAAC"}

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

@@ -7,10 +7,6 @@ export const sessionAdminRoute = buildRoute({
     route: {
         method: 'get',
         description: 'Verify admin session',
-        pluginConfig: {
-            id: 'core',
-            name: 'Core'
-        },
         path: '/session',
         responses: {
             200: {

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

@@ -1,6 +1,6 @@
 import { z } from '@hono/zod-openapi';
 export declare const listUsersAdminRoute: {
-    handler: (c: import("hono").Context<import("../../../../middlewares/global/global").EnvVitNode, "/list", {
+    handler: (c: import("hono").Context<import("../../../../middlewares/global.middleware").EnvVitNode, "/list", {
         in: {
             query: {
                 orderBy?: "name" | "createdAt" | undefined;

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

@@ -1,6 +1,6 @@
 import { z } from '@hono/zod-openapi';
 export declare const usersAdminRoute: {
-    handler: (c: import("hono").Context<import("../../../../middlewares/global/global").EnvVitNode, "/list", {
+    handler: (c: import("hono").Context<import("../../../../middlewares/global.middleware").EnvVitNode, "/list", {
         in: {
             query: {
                 orderBy?: "id" | "name" | "createdAt" | "email" | undefined;

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

@@ -1,5 +1,5 @@
 export declare const usersAdminModule: import("../../../../api/lib/module").BuildModuleReturn<"@vitnode/core", "users", [{
-    handler: (c: import("hono").Context<import("../../../middlewares/global/global").EnvVitNode, "/list", {
+    handler: (c: import("hono").Context<import("../../../middlewares/global.middleware").EnvVitNode, "/list", {
         in: {
             query: {
                 orderBy?: "name" | "createdAt" | undefined;

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

@@ -1,5 +1,5 @@
 export declare const middlewareModule: import("../../../api/lib/module").BuildModuleReturn<"@vitnode/core", "middleware", [{
-    handler: (c: import("hono").Context<import("../../middlewares/global/global").EnvVitNode, "/", {}>) => Response & import("hono").TypedResponse<{
+    handler: (c: import("hono").Context<import("../../middlewares/global.middleware").EnvVitNode, "/", {}>) => Response & import("hono").TypedResponse<{
         isEmail: boolean;
         sso: {
             id: string;

package/dist/src/api/modules/middleware/route.d.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 export declare const routeMiddleware: {
-    handler: (c: import("hono").Context<import("../../middlewares/global/global").EnvVitNode, "/", {}>) => Response & import("hono").TypedResponse<{
+    handler: (c: import("hono").Context<import("../../middlewares/global.middleware").EnvVitNode, "/", {}>) => Response & import("hono").TypedResponse<{
         isEmail: boolean;
         sso: {
             id: string;

package/dist/src/api/modules/middleware/route.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../../../../src/api/modules/middleware/route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6B1B,CAAC"}
+{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../../../../src/api/modules/middleware/route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4B1B,CAAC"}

package/dist/src/api/modules/middleware/route.js

@@ -1,6 +1,5 @@
 import { z } from "zod";
 import { buildRoute } from "../../lib/route.js";
-import { EmailModel } from "../../models/email.js";
 import { CONFIG_PLUGIN } from "../../../config.js";
 export const routeMiddleware = buildRoute({
     ...CONFIG_PLUGIN,
@@ -26,10 +25,9 @@ export const routeMiddleware = buildRoute({
         }
     },
     handler: (c)=>{
-        const sso = c.get('core').authorization.ssoPlugins;
-        const email = new EmailModel(c);
+        const sso = c.get('core').authorization.ssoProviders;
         return c.json({
-            isEmail: email.isAvailable(),
+            isEmail: !!c.get('core').emailAdapter,
             sso: sso.map((s)=>({
                     id: s.id,
                     name: s.name

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

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 export declare const sessionRoute: {
-    handler: (c: import("hono").Context<import("../../../middlewares/global/global").EnvVitNode, "/session", {}>) => Promise<Response & import("hono").TypedResponse<{
+    handler: (c: import("hono").Context<import("../../../middlewares/global.middleware").EnvVitNode, "/session", {}>) => Promise<Response & import("hono").TypedResponse<{
         user: {
             isAdmin: boolean;
             avatarColor: string;

package/dist/src/api/modules/users/routes/sign-in.route.d.ts

@@ -13,7 +13,7 @@ export declare const zodSignInSchema: z.ZodObject<{
     isAdmin?: boolean | undefined;
 }>;
 export declare const signInRoute: {
-    handler: (c: import("hono").Context<import("../../../middlewares/global/global").EnvVitNode, "/sign_in", {
+    handler: (c: import("hono").Context<import("../../../middlewares/global.middleware").EnvVitNode, "/sign_in", {
         in: {
             json: {
                 email: string;

package/dist/src/api/modules/users/routes/sign-out.route.d.ts

@@ -1,6 +1,6 @@
 import { z } from '@hono/zod-openapi';
 export declare const signOutRoute: {
-    handler: (c: import("hono").Context<import("../../../middlewares/global/global").EnvVitNode, "/sign_out", {
+    handler: (c: import("hono").Context<import("../../../middlewares/global.middleware").EnvVitNode, "/sign_out", {
         in: {
             json: {
                 isAdmin?: boolean | undefined;

package/dist/src/api/modules/users/routes/sign-up.route.d.ts

@@ -16,7 +16,7 @@ export declare const zodSignUpSchema: z.ZodObject<{
     newsletter?: boolean | undefined;
 }>;
 export declare const signUpRoute: {
-    handler: (c: import("hono").Context<import("../../../middlewares/global/global").EnvVitNode, "/sign_up", {
+    handler: (c: import("hono").Context<import("../../../middlewares/global.middleware").EnvVitNode, "/sign_up", {
         in: {
             json: {
                 name: string;

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

@@ -1,9 +1,9 @@
 import { z } from 'zod';
 export declare const testRoute: {
-    handler: (c: import("hono").Context<import("../../../middlewares/global/global").EnvVitNode, "/test", {}>) => Response & import("hono").TypedResponse<"test", 200 | 201, "text">;
+    handler: (c: import("hono").Context<import("../../../middlewares/global.middleware").EnvVitNode, "/test", {}>) => Response & import("hono").TypedResponse<"test", 200 | 201, "text">;
     pluginId: "@vitnode/core";
     route: {
-        method: "get";
+        method: "post";
         description: string;
         path: "/test";
         responses: {

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

@@ -1 +1 @@
-{"version":3,"file":"test.route.d.ts","sourceRoot":"","sources":["../../../../../../src/api/modules/users/routes/test.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4BpB,CAAC"}
+{"version":3,"file":"test.route.d.ts","sourceRoot":"","sources":["../../../../../../src/api/modules/users/routes/test.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsCpB,CAAC"}

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

@@ -1,10 +1,11 @@
 import { z } from "zod";
 import { buildRoute } from "../../../lib/route.js";
 import { CONFIG_PLUGIN } from "../../../../config.js";
+// import { EmailModel } from '../../../models/email';
 export const testRoute = buildRoute({
     ...CONFIG_PLUGIN,
     route: {
-        method: 'get',
+        method: 'post',
         description: 'Test route',
         path: '/test',
         responses: {
@@ -27,6 +28,13 @@ export const testRoute = buildRoute({
         }
     },
     handler: (c)=>{
+        // new EmailModel(c).send({
+        //   html: '<p>Test email</p>',
+        //   to: 'ithereplay@gmail.com',
+        //   subject: 'Test Email',
+        // });
+        // throw new Error('Test error');
+        c.get('log').warn('This is a test warn log');
         return c.text('test');
     }
 });

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

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 export declare const callbackRoute: {
-    handler: (c: import("hono").Context<import("../../../../middlewares/global/global").EnvVitNode, "/:providerId/callback", {
+    handler: (c: import("hono").Context<import("../../../../middlewares/global.middleware").EnvVitNode, "/:providerId/callback", {
         in: {
             param: {
                 providerId: string;

package/dist/src/api/modules/users/sso/routes/create-url.route.d.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 export declare const createUrlRoute: {
-    handler: (c: import("hono").Context<import("../../../../middlewares/global/global").EnvVitNode, "/:providerId", {
+    handler: (c: import("hono").Context<import("../../../../middlewares/global.middleware").EnvVitNode, "/:providerId", {
         in: {
             param: {
                 providerId: string;

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

@@ -1,5 +1,5 @@
 export declare const ssoUserModule: import("../../../../api/lib/module").BuildModuleReturn<"@vitnode/core", "sso", [{
-    handler: (c: import("hono").Context<import("../../../middlewares/global/global").EnvVitNode, "/:providerId/callback", {
+    handler: (c: import("hono").Context<import("../../../middlewares/global.middleware").EnvVitNode, "/:providerId/callback", {
         in: {
             param: {
                 providerId: string;
@@ -74,7 +74,7 @@ export declare const ssoUserModule: import("../../../../api/lib/module").BuildMo
         getRoutingPath: () => "/:providerId/callback";
     };
 }, {
-    handler: (c: import("hono").Context<import("../../../middlewares/global/global").EnvVitNode, "/:providerId", {
+    handler: (c: import("hono").Context<import("../../../middlewares/global.middleware").EnvVitNode, "/:providerId", {
         in: {
             param: {
                 providerId: string;

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

@@ -1,5 +1,5 @@
 export declare const usersModule: import("../../../api/lib/module").BuildModuleReturn<"@vitnode/core", "users", [{
-    handler: (c: import("hono").Context<import("../../middlewares/global/global").EnvVitNode, "/session", {}>) => Promise<Response & import("hono").TypedResponse<{
+    handler: (c: import("hono").Context<import("../../middlewares/global.middleware").EnvVitNode, "/session", {}>) => Promise<Response & import("hono").TypedResponse<{
         user: {
             isAdmin: boolean;
             avatarColor: string;
@@ -99,7 +99,7 @@ export declare const usersModule: import("../../../api/lib/module").BuildModuleR
         getRoutingPath: () => "/session";
     };
 }, {
-    handler: (c: import("hono").Context<import("../../middlewares/global/global").EnvVitNode, "/sign_in", {
+    handler: (c: import("hono").Context<import("../../middlewares/global.middleware").EnvVitNode, "/sign_in", {
         in: {
             json: {
                 email: string;
@@ -171,7 +171,7 @@ export declare const usersModule: import("../../../api/lib/module").BuildModuleR
         getRoutingPath: () => "/sign_in";
     };
 }, {
-    handler: (c: import("hono").Context<import("../../middlewares/global/global").EnvVitNode, "/sign_out", {
+    handler: (c: import("hono").Context<import("../../middlewares/global.middleware").EnvVitNode, "/sign_out", {
         in: {
             json: {
                 isAdmin?: boolean | undefined;
@@ -215,7 +215,7 @@ export declare const usersModule: import("../../../api/lib/module").BuildModuleR
         getRoutingPath: () => "/sign_out";
     };
 }, {
-    handler: (c: import("hono").Context<import("../../middlewares/global/global").EnvVitNode, "/sign_up", {
+    handler: (c: import("hono").Context<import("../../middlewares/global.middleware").EnvVitNode, "/sign_up", {
         in: {
             json: {
                 name: string;
@@ -293,10 +293,10 @@ export declare const usersModule: import("../../../api/lib/module").BuildModuleR
         getRoutingPath: () => "/sign_up";
     };
 }, {
-    handler: (c: import("hono").Context<import("../../middlewares/global/global").EnvVitNode, "/test", {}>) => Response & import("hono").TypedResponse<"test", 200 | 201, "text">;
+    handler: (c: import("hono").Context<import("../../middlewares/global.middleware").EnvVitNode, "/test", {}>) => Response & import("hono").TypedResponse<"test", 200 | 201, "text">;
     pluginId: "@vitnode/core";
     route: {
-        method: "get";
+        method: "post";
         description: string;
         path: "/test";
         responses: {
@@ -321,7 +321,7 @@ export declare const usersModule: import("../../../api/lib/module").BuildModuleR
         getRoutingPath: () => "/test";
     };
 }], import("../../../api/lib/module").BuildModuleReturn<"@vitnode/core", "sso", [{
-    handler: (c: import("hono").Context<import("../../middlewares/global/global").EnvVitNode, "/:providerId/callback", {
+    handler: (c: import("hono").Context<import("../../middlewares/global.middleware").EnvVitNode, "/:providerId/callback", {
         in: {
             param: {
                 providerId: string;
@@ -396,7 +396,7 @@ export declare const usersModule: import("../../../api/lib/module").BuildModuleR
         getRoutingPath: () => "/:providerId/callback";
     };
 }, {
-    handler: (c: import("hono").Context<import("../../middlewares/global/global").EnvVitNode, "/:providerId", {
+    handler: (c: import("hono").Context<import("../../middlewares/global.middleware").EnvVitNode, "/:providerId", {
         in: {
             param: {
                 providerId: string;

package/dist/src/app_admin/core/debug/page.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+declare const SystemLogsView: React.LazyExoticComponent<({ searchParams, }: {
+    searchParams: Promise<Record<string, string | string[] | undefined>>;
+}) => Promise<import("react/jsx-runtime").JSX.Element>>;
+export declare const generateMetadata: () => Promise<{
+    title: string;
+    description: string;
+}>;
+export default function Page(props: React.ComponentProps<typeof SystemLogsView>): Promise<import("react/jsx-runtime").JSX.Element>;
+export {};
+//# sourceMappingURL=page.d.ts.map

package/dist/src/app_admin/core/debug/page.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"page.d.ts","sourceRoot":"","sources":["../../../../../src/app_admin/core/debug/page.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,OAAO,CAAC;AAO1B,QAAA,MAAM,cAAc;;uDAMnB,CAAC;AAEF,eAAO,MAAM,gBAAgB;;;EAO5B,CAAC;AAEF,wBAA8B,IAAI,CAChC,KAAK,EAAE,KAAK,CAAC,cAAc,CAAC,OAAO,cAAc,CAAC,oDAkBnD"}