@vitnode/core 1.2.0-canary.52 → 1.2.0-canary.54

package/dist/src/api/modules/admin/advanced/cron/routes/get.route.d.ts

@@ -0,0 +1,98 @@
+import z from "zod";
+export declare const getCronsRoute: {
+    handler: (c: import("hono").Context<import("../../../../../middlewares/global.middleware").EnvVitNode, "/", {
+        in: {
+            query: {
+                cursor?: string | undefined;
+                first?: string | undefined;
+                last?: string | undefined;
+                order?: "asc" | "desc" | undefined;
+                orderBy?: "createdAt" | "lastRun" | "nextRun" | undefined;
+            };
+        };
+        out: {
+            query: {
+                cursor?: string | undefined;
+                first?: string | undefined;
+                last?: string | undefined;
+                order?: "asc" | "desc" | undefined;
+                orderBy?: "createdAt" | "lastRun" | "nextRun" | undefined;
+            };
+        };
+    }>) => Promise<Response & import("hono").TypedResponse<{
+        edges: {
+            id: number;
+            name: string;
+            description: string | null;
+            lastRun: string | null;
+            createdAt: string;
+            pluginId: string;
+            module: string;
+            nextRun: string | null;
+            schedule: string;
+        }[];
+        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: "/";
+        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: "asc";
+                    desc: "desc";
+                }>>;
+                orderBy: z.ZodOptional<z.ZodEnum<{
+                    createdAt: "createdAt";
+                    lastRun: "lastRun";
+                    nextRun: "nextRun";
+                }>>;
+            }, z.core.$strip>;
+        };
+        responses: {
+            200: {
+                content: {
+                    "application/json": {
+                        schema: z.ZodObject<{
+                            edges: z.ZodArray<z.ZodObject<{
+                                id: z.ZodNumber;
+                                createdAt: z.ZodDate;
+                                name: z.ZodString;
+                                description: z.ZodNullable<z.ZodString>;
+                                pluginId: z.ZodString;
+                                module: z.ZodString;
+                                lastRun: z.ZodNullable<z.ZodDate>;
+                                nextRun: z.ZodNullable<z.ZodDate>;
+                                schedule: z.ZodString;
+                            }, z.core.$strip>>;
+                            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>;
+                            }, z.core.$strip>;
+                        }, z.core.$strip>;
+                    };
+                };
+                description: string;
+            };
+        };
+    } & {
+        getRoutingPath: () => "/";
+    };
+};
+//# sourceMappingURL=get.route.d.ts.map

package/dist/src/api/modules/admin/advanced/cron/routes/get.route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get.route.d.ts","sourceRoot":"","sources":["../../../../../../../../src/api/modules/admin/advanced/cron/routes/get.route.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAUpB,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+DxB,CAAC"}

package/dist/src/api/modules/admin/advanced/cron/routes/get.route.js

@@ -0,0 +1,66 @@
+import z from "zod";
+import { buildRoute } from "../../../../../lib/route.js";
+import { withPagination, zodPaginationPageInfo, zodPaginationQuery } from "../../../../../lib/with-pagination.js";
+import { CONFIG_PLUGIN } from "../../../../../../config.js";
+import { core_cron } from "../../../../../../database/cron.js";
+export const getCronsRoute = buildRoute({
+    pluginId: CONFIG_PLUGIN.pluginId,
+    route: {
+        method: "get",
+        description: "Get Admin Cron Logs",
+        path: "/",
+        request: {
+            query: zodPaginationQuery.extend({
+                order: z.enum([
+                    "asc",
+                    "desc"
+                ]).optional(),
+                orderBy: z.enum([
+                    "createdAt",
+                    "lastRun",
+                    "nextRun"
+                ]).optional()
+            })
+        },
+        responses: {
+            200: {
+                content: {
+                    "application/json": {
+                        schema: z.object({
+                            edges: z.array(z.object({
+                                id: z.number(),
+                                createdAt: z.date(),
+                                name: z.string(),
+                                description: z.string().nullable(),
+                                pluginId: z.string(),
+                                module: z.string(),
+                                lastRun: z.date().nullable(),
+                                nextRun: z.date().nullable(),
+                                schedule: z.string()
+                            })),
+                            pageInfo: zodPaginationPageInfo
+                        })
+                    }
+                },
+                description: "List of cron jobs"
+            }
+        }
+    },
+    handler: async (c)=>{
+        const query = c.req.valid("query");
+        const data = await withPagination({
+            params: {
+                query
+            },
+            c,
+            primaryCursor: core_cron.id,
+            query: async ({ limit, where, orderBy })=>await c.get("db").select().from(core_cron).where(where).orderBy(orderBy).limit(limit),
+            table: core_cron,
+            orderBy: {
+                column: query.orderBy ? core_cron[query.orderBy] : core_cron.lastRun,
+                order: query.order ?? "desc"
+            }
+        });
+        return c.json(data);
+    }
+});

package/dist/src/api/modules/admin/advanced/cron/routes/run.route.d.ts

@@ -0,0 +1,70 @@
+import { z } from "zod";
+export declare const runCronRoute: {
+    handler: (c: import("hono").Context<import("../../../../../middlewares/global.middleware").EnvVitNode, "/:id", {
+        in: {
+            param: {
+                id: string;
+            };
+        };
+        out: {
+            param: {
+                id: string;
+            };
+        };
+    }>) => Promise<(Response & import("hono").TypedResponse<{
+        error: string;
+    }, 404, "json">) | (Response & import("hono").TypedResponse<{
+        message: string;
+    }, 201, "json">) | (Response & import("hono").TypedResponse<{
+        error: string;
+    }, 500, "json">)>;
+    pluginId: "@vitnode/core";
+    route: {
+        method: "post";
+        description: string;
+        path: "/{id}";
+        request: {
+            params: z.ZodObject<{
+                id: z.ZodString;
+            }, z.core.$strip>;
+        };
+        responses: {
+            201: {
+                content: {
+                    "application/json": {
+                        schema: z.ZodObject<{
+                            message: z.ZodOptional<z.ZodString>;
+                            error: z.ZodOptional<z.ZodString>;
+                        }, z.core.$strip>;
+                    };
+                };
+                description: string;
+            };
+            404: {
+                content: {
+                    "application/json": {
+                        schema: z.ZodObject<{
+                            message: z.ZodOptional<z.ZodString>;
+                            error: z.ZodOptional<z.ZodString>;
+                        }, z.core.$strip>;
+                    };
+                };
+                description: string;
+            };
+            500: {
+                content: {
+                    "application/json": {
+                        schema: z.ZodObject<{
+                            message: z.ZodOptional<z.ZodString>;
+                            error: z.ZodOptional<z.ZodString>;
+                        }, z.core.$strip>;
+                    };
+                };
+                description: string;
+            };
+        };
+    } & {
+        getRoutingPath: () => "/:id";
+    };
+};
+//# sourceMappingURL=run.route.d.ts.map

package/dist/src/api/modules/admin/advanced/cron/routes/run.route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run.route.d.ts","sourceRoot":"","sources":["../../../../../../../../src/api/modules/admin/advanced/cron/routes/run.route.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwGvB,CAAC"}

package/dist/src/api/modules/admin/advanced/cron/routes/run.route.js

@@ -0,0 +1,95 @@
+import { eq } from "drizzle-orm";
+import { z } from "zod";
+import { buildRoute } from "../../../../../lib/route.js";
+import { CONFIG_PLUGIN } from "../../../../../../config.js";
+import { core_cron } from "../../../../../../database/cron.js";
+import { getNextCronRunDate } from "../../../../../../lib/api/get-next-cron-run-date.js";
+export const runCronRoute = buildRoute({
+    pluginId: CONFIG_PLUGIN.pluginId,
+    route: {
+        method: "post",
+        description: "Run a specific cron job",
+        path: "/{id}",
+        request: {
+            params: z.object({
+                id: z.string()
+            })
+        },
+        responses: {
+            201: {
+                content: {
+                    "application/json": {
+                        schema: z.object({
+                            message: z.string().optional(),
+                            error: z.string().optional()
+                        })
+                    }
+                },
+                description: "Cron job executed successfully"
+            },
+            404: {
+                content: {
+                    "application/json": {
+                        schema: z.object({
+                            message: z.string().optional(),
+                            error: z.string().optional()
+                        })
+                    }
+                },
+                description: "Cron job not found"
+            },
+            500: {
+                content: {
+                    "application/json": {
+                        schema: z.object({
+                            message: z.string().optional(),
+                            error: z.string().optional()
+                        })
+                    }
+                },
+                description: "Internal server error"
+            }
+        }
+    },
+    handler: async (c)=>{
+        const db = c.get("db");
+        const cronJobs = c.get("core").cron;
+        const param = c.req.valid("param");
+        try {
+            const cronFromDb = await db.select().from(core_cron).where(eq(core_cron.id, +param.id)).limit(1);
+            if (cronFromDb.length === 0) {
+                return c.json({
+                    error: "Cron job not found"
+                }, 404);
+            }
+            const dbCron = cronFromDb[0];
+            const job = cronJobs.find((j)=>j.name === dbCron.name && j.pluginId === dbCron.pluginId && j.module === dbCron.module);
+            if (!job) {
+                return c.json({
+                    error: "Cron job configuration not found"
+                }, 404);
+            }
+            const now = new Date();
+            try {
+                await job.handler(c);
+                await db.update(core_cron).set({
+                    lastRun: now,
+                    nextRun: getNextCronRunDate(job.schedule, now)
+                }).where(eq(core_cron.id, dbCron.id));
+                return c.json({
+                    message: "Cron job executed successfully"
+                }, 201);
+            } catch (error) {
+                await c.get("log").error(`Error executing cron job: ${error}`);
+                return c.json({
+                    error: "Failed to execute cron job"
+                }, 500);
+            }
+        } catch (error) {
+            await c.get("log").error(`Error running cron job: ${error}`);
+            return c.json({
+                error: "Internal server error"
+            }, 500);
+        }
+    }
+});

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

@@ -69,7 +69,7 @@ export declare const debugAdminModule: import("../../../lib/module").BuildModule
         responses: {
             200: {
                 content: {
-                    'application/json': {
+                    "application/json": {
                         schema: import("zod").ZodObject<{
                             edges: import("zod").ZodArray<import("zod").ZodObject<{
                                 id: import("zod").ZodNumber;

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

@@ -2,8 +2,8 @@ import { CONFIG_PLUGIN } from "../../../../config.js";
 import { buildModule } from "../../../lib/module.js";
 import { logsDebugAdminRoute } from "./routes/logs.route.js";
 export const debugAdminModule = buildModule({
-    ...CONFIG_PLUGIN,
-    name: 'debug',
+    pluginId: CONFIG_PLUGIN.pluginId,
+    name: "debug",
     routes: [
         logsDebugAdminRoute
     ]

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

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import { z } from "zod";
 export declare const logsDebugAdminRoute: {
     handler: (c: import("hono").Context<import("../../../../middlewares/global.middleware").EnvVitNode, "/logs", {
         in: {
@@ -70,7 +70,7 @@ export declare const logsDebugAdminRoute: {
         responses: {
             200: {
                 content: {
-                    'application/json': {
+                    "application/json": {
                         schema: z.ZodObject<{
                             edges: z.ZodArray<z.ZodObject<{
                                 id: z.ZodNumber;

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

@@ -6,36 +6,36 @@ 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,
+    pluginId: CONFIG_PLUGIN.pluginId,
     route: {
-        method: 'get',
-        description: 'Get Admin Debug Logs',
-        path: '/logs',
+        method: "get",
+        description: "Get Admin Debug Logs",
+        path: "/logs",
         request: {
             query: zodPaginationQuery.extend({
                 order: z.enum([
-                    'asc',
-                    'desc'
+                    "asc",
+                    "desc"
                 ]).optional(),
                 orderBy: z.enum([
-                    'type',
-                    'createdAt',
-                    'pluginId'
+                    "type",
+                    "createdAt",
+                    "pluginId"
                 ]).optional()
             })
         },
         responses: {
             200: {
                 content: {
-                    'application/json': {
+                    "application/json": {
                         schema: z.object({
                             edges: z.array(z.object({
                                 id: z.number(),
                                 pluginId: z.string(),
                                 type: z.enum([
-                                    'warn',
-                                    'error',
-                                    'debug'
+                                    "warn",
+                                    "error",
+                                    "debug"
                                 ]),
                                 content: z.string(),
                                 createdAt: z.date(),
@@ -54,18 +54,18 @@ export const logsDebugAdminRoute = buildRoute({
                         })
                     }
                 },
-                description: 'List of users'
+                description: "List of users"
             }
         }
     },
     handler: async (c)=>{
-        const query = c.req.valid('query');
+        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({
+            query: async ({ limit, where, orderBy })=>await c.get("db").select({
                     id: core_logs.id,
                     pluginId: core_logs.pluginId,
                     type: core_logs.type,
@@ -85,7 +85,7 @@ export const logsDebugAdminRoute = buildRoute({
             table: core_logs,
             orderBy: {
                 column: query.orderBy ? core_logs[query.orderBy] : core_logs.createdAt,
-                order: query.order ?? 'desc'
+                order: query.order ?? "desc"
             },
             c
         });

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

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import { z } from "zod";
 export declare const sessionAdminRoute: {
     handler: (c: import("hono").Context<import("../../../middlewares/global.middleware").EnvVitNode, "/session", {}>) => Response & import("hono").TypedResponse<{
         user: {
@@ -23,7 +23,7 @@ export declare const sessionAdminRoute: {
         responses: {
             200: {
                 content: {
-                    'application/json': {
+                    "application/json": {
                         schema: z.ZodObject<{
                             user: z.ZodObject<{
                                 id: z.ZodNumber;

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

@@ -3,15 +3,15 @@ import { z } from "zod";
 import { buildRoute } from "../../../lib/route.js";
 import { CONFIG_PLUGIN } from "../../../../config.js";
 export const sessionAdminRoute = buildRoute({
-    ...CONFIG_PLUGIN,
+    pluginId: CONFIG_PLUGIN.pluginId,
     route: {
-        method: 'get',
-        description: 'Verify admin session',
-        path: '/session',
+        method: "get",
+        description: "Verify admin session",
+        path: "/session",
         responses: {
             200: {
                 content: {
-                    'application/json': {
+                    "application/json": {
                         schema: z.object({
                             user: z.object({
                                 id: z.number(),
@@ -29,15 +29,15 @@ export const sessionAdminRoute = buildRoute({
                         })
                     }
                 },
-                description: 'User'
+                description: "User"
             },
             403: {
-                description: 'Access Denied'
+                description: "Access Denied"
             }
         }
     },
     handler: (c)=>{
-        const user = c.get('admin')?.user;
+        const user = c.get("admin")?.user;
         if (!user) throw new HTTPException(403);
         return c.json({
             user,

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

@@ -1,4 +1,4 @@
-import { z } from '@hono/zod-openapi';
+import { z } from "@hono/zod-openapi";
 export declare const listUsersAdminRoute: {
     handler: (c: import("hono").Context<import("../../../../middlewares/global.middleware").EnvVitNode, "/list", {
         in: {
@@ -65,7 +65,7 @@ export declare const listUsersAdminRoute: {
         responses: {
             200: {
                 content: {
-                    'application/json': {
+                    "application/json": {
                         schema: z.ZodObject<{
                             edges: z.ZodArray<z.ZodObject<{
                                 id: z.ZodNumber;

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

@@ -4,27 +4,27 @@ import { withPagination, zodPaginationPageInfo, zodPaginationQuery } from "../..
 import { CONFIG_PLUGIN } from "../../../../../config.js";
 import { core_users } from "../../../../../database/users.js";
 export const listUsersAdminRoute = buildRoute({
-    ...CONFIG_PLUGIN,
+    pluginId: CONFIG_PLUGIN.pluginId,
     route: {
-        method: 'get',
-        description: 'Get list of all users',
-        path: '/list',
+        method: "get",
+        description: "Get list of all users",
+        path: "/list",
         request: {
             query: zodPaginationQuery.extend({
                 order: z.enum([
-                    'asc',
-                    'desc'
+                    "asc",
+                    "desc"
                 ]).optional(),
                 orderBy: z.enum([
-                    'name',
-                    'createdAt'
+                    "name",
+                    "createdAt"
                 ]).optional()
             })
         },
         responses: {
             200: {
                 content: {
-                    'application/json': {
+                    "application/json": {
                         schema: z.object({
                             edges: z.array(z.object({
                                 id: z.number(),
@@ -43,18 +43,18 @@ export const listUsersAdminRoute = buildRoute({
                         })
                     }
                 },
-                description: 'List of users'
+                description: "List of users"
             }
         }
     },
     handler: async (c)=>{
-        const query = c.req.valid('query');
+        const query = c.req.valid("query");
         const data = await withPagination({
             params: {
                 query
             },
             primaryCursor: core_users.id,
-            query: async ({ limit, where, orderBy })=>await c.get('db').select({
+            query: async ({ limit, where, orderBy })=>await c.get("db").select({
                     id: core_users.id,
                     name: core_users.name,
                     email: core_users.email,
@@ -70,7 +70,7 @@ export const listUsersAdminRoute = buildRoute({
             table: core_users,
             orderBy: {
                 column: query.orderBy ? core_users[query.orderBy] : core_users.createdAt,
-                order: query.order ?? 'desc'
+                order: query.order ?? "desc"
             },
             c
         });

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

@@ -1,4 +1,4 @@
-import { z } from '@hono/zod-openapi';
+import { z } from "@hono/zod-openapi";
 export declare const usersAdminRoute: {
     handler: (c: import("hono").Context<import("../../../../middlewares/global.middleware").EnvVitNode, "/list", {
         in: {
@@ -7,7 +7,7 @@ export declare const usersAdminRoute: {
                 first?: string | undefined;
                 last?: string | undefined;
                 order?: "asc" | "desc" | undefined;
-                orderBy?: "email" | "id" | "name" | "createdAt" | undefined;
+                orderBy?: "id" | "email" | "name" | "createdAt" | undefined;
             };
         };
         out: {
@@ -16,7 +16,7 @@ export declare const usersAdminRoute: {
                 first?: string | undefined;
                 last?: string | undefined;
                 order?: "asc" | "desc" | undefined;
-                orderBy?: "email" | "id" | "name" | "createdAt" | undefined;
+                orderBy?: "id" | "email" | "name" | "createdAt" | undefined;
             };
         };
     }>) => Promise<Response & import("hono").TypedResponse<{
@@ -57,8 +57,8 @@ export declare const usersAdminRoute: {
                     desc: "desc";
                 }>>;
                 orderBy: z.ZodOptional<z.ZodEnum<{
-                    email: "email";
                     id: "id";
+                    email: "email";
                     name: "name";
                     createdAt: "createdAt";
                 }>>;
@@ -67,7 +67,7 @@ export declare const usersAdminRoute: {
         responses: {
             200: {
                 content: {
-                    'application/json': {
+                    "application/json": {
                         schema: z.ZodObject<{
                             edges: z.ZodArray<z.ZodObject<{
                                 id: z.ZodNumber;