@vitnode/core 0.0.1-canary.0

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

@@ -0,0 +1,286 @@
+export declare const usersAdminModule: import("../../../../api/lib/module").BuildModuleReturn<"@vitnode/core", "users", [import("../../../lib/route").Route<"@vitnode/core", {
+    method: "get";
+    description: string;
+    path: "/list";
+    request: {
+        query: import("zod").ZodObject<{
+            cursor: import("zod").ZodOptional<import("zod").ZodString>;
+            first: import("zod").ZodOptional<import("zod").ZodString>;
+            last: import("zod").ZodOptional<import("zod").ZodString>;
+            order: import("zod").ZodOptional<import("zod").ZodEnum<{
+                desc: "desc";
+                asc: "asc";
+            }>>;
+            orderBy: import("zod").ZodOptional<import("zod").ZodEnum<{
+                createdAt: "createdAt";
+                name: "name";
+            }>>;
+            roleId: import("zod").ZodOptional<import("zod").ZodString>;
+            search: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>;
+    };
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        edges: import("zod").ZodArray<import("zod").ZodObject<{
+                            id: import("zod").ZodNumber;
+                            name: import("zod").ZodString;
+                            email: import("zod").ZodString;
+                            nameCode: import("zod").ZodString;
+                            createdAt: import("zod").ZodDate;
+                            newsletter: import("zod").ZodBoolean;
+                            avatarColor: import("zod").ZodString;
+                            emailVerified: import("zod").ZodBoolean;
+                            roleId: import("zod").ZodNumber;
+                            role: import("zod").ZodObject<{
+                                id: import("zod").ZodNumber;
+                                color: import("zod").ZodNullable<import("zod").ZodString>;
+                                name: import("zod").ZodArray<import("zod").ZodObject<{
+                                    name: import("zod").ZodString;
+                                    languageCode: import("zod").ZodString;
+                                }, import("zod/v4/core").$strip>>;
+                            }, import("zod/v4/core").$strip>;
+                            secondaryRoles: import("zod").ZodArray<import("zod").ZodObject<{
+                                id: import("zod").ZodNumber;
+                                color: import("zod").ZodNullable<import("zod").ZodString>;
+                                name: import("zod").ZodArray<import("zod").ZodObject<{
+                                    name: import("zod").ZodString;
+                                    languageCode: import("zod").ZodString;
+                                }, import("zod/v4/core").$strip>>;
+                            }, import("zod/v4/core").$strip>>;
+                            birthday: import("zod").ZodNullable<import("zod").ZodDate>;
+                            language: import("zod").ZodString;
+                        }, import("zod/v4/core").$strip>>;
+                        pageInfo: import("zod").ZodObject<{
+                            totalCount: import("zod").ZodNumber;
+                            count: import("zod").ZodNumber;
+                            hasNextPage: import("zod").ZodBoolean;
+                            hasPreviousPage: import("zod").ZodBoolean;
+                            startCursor: import("zod").ZodNullable<import("zod").ZodString>;
+                            endCursor: import("zod").ZodNullable<import("zod").ZodString>;
+                        }, import("zod/v4/core").$strip>;
+                    }, import("zod/v4/core").$strip>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>, import("../../../lib/route").Route<"@vitnode/core", {
+    method: "post";
+    description: string;
+    path: "/create";
+    request: {
+        body: {
+            required: true;
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        email: import("zod").ZodEmail;
+                        name: import("zod").ZodString;
+                        password: import("zod").ZodString;
+                    }, import("zod/v4/core").$strip>;
+                };
+            };
+        };
+    };
+    responses: {
+        201: {
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        id: import("zod").ZodNumber;
+                        name: import("zod").ZodString;
+                        email: import("zod").ZodEmail;
+                    }, import("zod/v4/core").$strip>;
+                };
+            };
+            description: string;
+        };
+        403: {
+            description: string;
+        };
+        409: {
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>, import("../../../lib/route").Route<"@vitnode/core", {
+    method: "get";
+    description: string;
+    path: "/{id}";
+    request: {
+        params: import("zod").ZodObject<{
+            id: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+    };
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        id: import("zod").ZodNumber;
+                        name: import("zod").ZodString;
+                        email: import("zod").ZodString;
+                        nameCode: import("zod").ZodString;
+                        createdAt: import("zod").ZodDate;
+                        newsletter: import("zod").ZodBoolean;
+                        avatarColor: import("zod").ZodString;
+                        emailVerified: import("zod").ZodBoolean;
+                        roleId: import("zod").ZodNumber;
+                        role: import("zod").ZodObject<{
+                            id: import("zod").ZodNumber;
+                            color: import("zod").ZodNullable<import("zod").ZodString>;
+                            name: import("zod").ZodArray<import("zod").ZodObject<{
+                                name: import("zod").ZodString;
+                                languageCode: import("zod").ZodString;
+                            }, import("zod/v4/core").$strip>>;
+                        }, import("zod/v4/core").$strip>;
+                        secondaryRoles: import("zod").ZodArray<import("zod").ZodObject<{
+                            id: import("zod").ZodNumber;
+                            color: import("zod").ZodNullable<import("zod").ZodString>;
+                            name: import("zod").ZodArray<import("zod").ZodObject<{
+                                name: import("zod").ZodString;
+                                languageCode: import("zod").ZodString;
+                            }, import("zod/v4/core").$strip>>;
+                        }, import("zod/v4/core").$strip>>;
+                        birthday: import("zod").ZodNullable<import("zod").ZodDate>;
+                        language: import("zod").ZodString;
+                        isAdmin: import("zod").ZodBoolean;
+                    }, import("zod/v4/core").$strip>;
+                };
+            };
+            description: string;
+        };
+        403: {
+            description: string;
+        };
+        404: {
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        error: import("zod").ZodString;
+                    }, import("zod/v4/core").$strip>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>, import("../../../lib/route").Route<"@vitnode/core", {
+    method: "patch";
+    description: string;
+    path: "/{id}";
+    request: {
+        params: import("zod").ZodObject<{
+            id: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+        body: {
+            required: true;
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        email: import("zod").ZodOptional<import("zod").ZodEmail>;
+                        name: import("zod").ZodOptional<import("zod").ZodString>;
+                        nameCode: import("zod").ZodOptional<import("zod").ZodString>;
+                        roleId: import("zod").ZodOptional<import("zod").ZodNumber>;
+                        secondaryRoleIds: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodNumber>>;
+                    }, import("zod/v4/core").$strip>;
+                };
+            };
+        };
+    };
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        id: import("zod").ZodNumber;
+                        name: import("zod").ZodString;
+                        email: import("zod").ZodEmail;
+                        nameCode: import("zod").ZodString;
+                    }, import("zod/v4/core").$strip>;
+                };
+            };
+            description: string;
+        };
+        400: {
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        error: import("zod").ZodString;
+                    }, import("zod/v4/core").$strip>;
+                };
+            };
+            description: string;
+        };
+        403: {
+            description: string;
+        };
+        404: {
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        error: import("zod").ZodString;
+                    }, import("zod/v4/core").$strip>;
+                };
+            };
+            description: string;
+        };
+        409: {
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        error: import("zod").ZodString;
+                    }, import("zod/v4/core").$strip>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>, import("../../../lib/route").Route<"@vitnode/core", {
+    method: "post";
+    description: string;
+    path: "/{id}/verify-email";
+    request: {
+        params: import("zod").ZodObject<{
+            id: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+    };
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        name: import("zod").ZodString;
+                        emailVerified: import("zod").ZodBoolean;
+                    }, import("zod/v4/core").$strip>;
+                };
+            };
+            description: string;
+        };
+        403: {
+            description: string;
+        };
+        404: {
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        error: import("zod").ZodString;
+                    }, import("zod/v4/core").$strip>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>], import("../../../../api/lib/module").BaseBuildModuleReturn<"@vitnode/core", string, import("../../../lib/route").Route<"@vitnode/core", import("@hono/zod-openapi").RouteConfig>[]>[]>;
+//# sourceMappingURL=users.admin.module.d.ts.map

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

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

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

@@ -0,0 +1 @@
+import{buildModule}from"../../../lib/module.js";import{CONFIG_PLUGIN}from"../../../../config.js";import{createUserAdminRoute}from"./routes/create.route.js";import{listUsersAdminRoute}from"./routes/list.route.js";import{showUserAdminRoute}from"./routes/show.route.js";import{updateUserAdminRoute}from"./routes/update.route.js";import{verifyEmailUserAdminRoute}from"./routes/verify-email.route.js";export const usersAdminModule=buildModule({pluginId:CONFIG_PLUGIN.pluginId,name:"users",routes:[listUsersAdminRoute,createUserAdminRoute,showUserAdminRoute,updateUserAdminRoute,verifyEmailUserAdminRoute]});

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

@@ -0,0 +1,2 @@
+export declare const contentModule: import("../../../api/lib/module").BuildModuleReturn<"@vitnode/core", "content", [], import("../../../api/lib/module").BaseBuildModuleReturn<"@vitnode/core", string, import("../../lib/route").Route<"@vitnode/core", import("@hono/zod-openapi").RouteConfig>[]>[]>;
+//# sourceMappingURL=content.module.d.ts.map

package/dist/src/api/modules/content/content.module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"content.module.d.ts","sourceRoot":"","sources":["../../../../../src/api/modules/content/content.module.ts"],"names":[],"mappings":"AA0BA,eAAO,MAAM,aAAa,wPAMxB,CAAC"}

package/dist/src/api/modules/content/content.module.js

@@ -0,0 +1 @@
+import{buildModule}from"../../lib/module.js";import{CONFIG_PLUGIN}from"../../../config.js";import{contentEditorialCleanupCron}from"./cron/content-editorial-cleanup.cron.js";import{contentScheduleEffectsQueueTask}from"./tasks/content-schedule-effects.task.js";import{contentScheduleQueueTask}from"./tasks/content-schedule.task.js";export const contentModule=buildModule({pluginId:CONFIG_PLUGIN.pluginId,name:"content",routes:[],cronJobs:[contentEditorialCleanupCron],queueTasks:[contentScheduleQueueTask,contentScheduleEffectsQueueTask]});

package/dist/src/api/modules/content/cron/content-editorial-cleanup.cron.d.ts

@@ -0,0 +1,2 @@
+export declare const contentEditorialCleanupCron: import("../../../../api/lib/cron").BuildCronReturn;
+//# sourceMappingURL=content-editorial-cleanup.cron.d.ts.map

package/dist/src/api/modules/content/cron/content-editorial-cleanup.cron.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"content-editorial-cleanup.cron.d.ts","sourceRoot":"","sources":["../../../../../../src/api/modules/content/cron/content-editorial-cleanup.cron.ts"],"names":[],"mappings":"AAuBA,eAAO,MAAM,2BAA2B,0CAmCtC,CAAC"}

package/dist/src/api/modules/content/cron/content-editorial-cleanup.cron.js

@@ -0,0 +1 @@
+import{buildCron}from"../../../lib/cron.js";import{CONTENT_REVISION_MAX_RETENTION,CONTENT_SCHEDULE_RETENTION_DAYS}from"../../../../content/const.js";import{pruneContentRevisions}from"../../../../content/server/revisions-model.js";import{pruneContentSchedules}from"../../../../content/server/schedules-model.js";const DAY_MS=24*60*60*1e3;export const contentEditorialCleanupCron=buildCron({name:"content-editorial-cleanup",description:"Remove revisions and schedules for content types that are no longer registered, and settled schedules past their retention window.",schedule:"20 3 * * *",handler:async c=>{const known=c.get("core").contentTypes.filter(entry=>entry.definition.editorial.enabled).map(entry=>entry.definition.id);const schedules=await pruneContentSchedules({db:c.get("db"),knownContentTypeIds:known,olderThan:new Date(Date.now()-CONTENT_SCHEDULE_RETENTION_DAYS*DAY_MS)});const revisions=await pruneContentRevisions({db:c.get("db"),knownContentTypeIds:known});if(schedules.orphaned+revisions.orphaned===0)return;await c.get("log").debug(`[content-editorial-cleanup] removed ${revisions.orphaned} orphaned revisions and ${schedules.orphaned} orphaned schedules (${schedules.settled} settled schedules aged out; revision retention stays capped at ${CONTENT_REVISION_MAX_RETENTION} per record).`)}});

package/dist/src/api/modules/content/helpers/execute-content-schedule.d.ts

@@ -0,0 +1,10 @@
+import type { Context } from "hono";
+export interface ContentScheduleOutcome {
+    reason?: string;
+    status: "executed" | "skipped" | "unregistered";
+}
+export declare const executeContentSchedule: (c: Context, { generation, scheduleId }: {
+    generation: number;
+    scheduleId: number;
+}) => Promise<ContentScheduleOutcome>;
+//# sourceMappingURL=execute-content-schedule.d.ts.map

package/dist/src/api/modules/content/helpers/execute-content-schedule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"execute-content-schedule.d.ts","sourceRoot":"","sources":["../../../../../../src/api/modules/content/helpers/execute-content-schedule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAepC,MAAM,WAAW,sBAAsB;IACrC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,UAAU,GAAG,SAAS,GAAG,cAAc,CAAC;CACjD;AA4GD,eAAO,MAAM,sBAAsB,GACjC,GAAG,OAAO,EACV,4BAA4B;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,KACrE,OAAO,CAAC,sBAAsB,CAgHhC,CAAC"}

package/dist/src/api/modules/content/helpers/execute-content-schedule.js

@@ -0,0 +1 @@
+import{CONTENT_QUEUE_TASK_SCHEDULE_EFFECTS}from"../../../../content/const.js";import{CONTENT_SYSTEM_ACTOR}from"../../../../content/server/actor.js";import{findContentModel}from"../../../../content/server/model.js";import{claimContentSchedule,settleContentSchedule}from"../../../../content/server/schedules-model.js";class ContentScheduleSettlementError extends Error{constructor(scheduleId){super(`Schedule ${scheduleId} was no longer pending at settlement time. Rolling the transition back.`);this.name="ContentScheduleSettlementError"}}const slugOf=(definition,row)=>{if(!definition.publicApi.enabled)return null;const value=row?.[definition.publicApi.slugField];return typeof value==="string"?value:null};const effectsPayload=({claimed,definition,outcome,pluginId})=>{const row=outcome.row;return{changedFields:[...outcome.changedFields],contentTypeId:definition.id,itemId:claimed.itemId,operation:claimed.action,pluginId,previousSlug:outcome.previousSlug??slugOf(definition,row),revisionId:outcome.revisionId,row:JSON.parse(JSON.stringify(row)),scheduleId:claimed.id,scheduledBy:claimed.createdBy,version:outcome.version,wasPublic:claimed.action==="unpublish"}};export const executeContentSchedule=async(c,{generation,scheduleId})=>{const db=c.get("db");let result;try{result=await db.transaction(async tx=>{const claimed=await claimContentSchedule(tx,{generation,scheduleId});if(!claimed){return{kind:"skipped",reason:"not pending, superseded, or not yet due"}}const entry=findContentModel(c.get("core").contentModels,claimed.contentTypeId);const editorialService=entry?.model.editorialService;if(!entry||!editorialService){await settleContentSchedule(tx,claimed.id,{expectedStatus:"pending",lastError:`Content type "${claimed.contentTypeId}" is no longer registered with an editorial workflow.`,status:"cancelled"});return{contentTypeId:claimed.contentTypeId,kind:"unregistered"}}const{model,pluginId}=entry;const outcome=await editorialService(c,{pluginId})[claimed.action](claimed.itemId,{actor:CONTENT_SYSTEM_ACTOR,tx});if(!await settleContentSchedule(tx,claimed.id,{expectedStatus:"pending",lastError:null,status:"completed"})){throw new ContentScheduleSettlementError(claimed.id)}if(!outcome){return{kind:"skipped",reason:"record no longer exists"}}if(!outcome.changed){return{kind:"skipped",reason:"already in that state"}}const effects=effectsPayload({claimed,definition:model.definition,outcome,pluginId});await c.get("queue").dispatch({name:CONTENT_QUEUE_TASK_SCHEDULE_EFFECTS,payload:effects,pluginId:"@vitnode/core",tx});return{effects,kind:"executed"}})}catch(error){await settleContentSchedule(db,scheduleId,{expectedStatus:"pending",lastError:error instanceof Error?error.message:"Unknown error"});throw error}if(result.kind==="unregistered"){return{reason:result.contentTypeId,status:"unregistered"}}if(result.kind==="skipped"){return{reason:result.reason,status:"skipped"}}return{status:"executed"}};

package/dist/src/api/modules/content/tasks/content-schedule-effects.task.d.ts

@@ -0,0 +1,2 @@
+export declare const contentScheduleEffectsQueueTask: import("../../../../api/lib/queue").BuildQueueTaskReturn;
+//# sourceMappingURL=content-schedule-effects.task.d.ts.map

package/dist/src/api/modules/content/tasks/content-schedule-effects.task.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"content-schedule-effects.task.d.ts","sourceRoot":"","sources":["../../../../../../src/api/modules/content/tasks/content-schedule-effects.task.ts"],"names":[],"mappings":"AAoBA,eAAO,MAAM,+BAA+B,gDAiB1C,CAAC"}

package/dist/src/api/modules/content/tasks/content-schedule-effects.task.js

@@ -0,0 +1 @@
+import{buildQueueTask}from"../../../lib/queue.js";import{CONTENT_QUEUE_TASK_SCHEDULE_EFFECTS}from"../../../../content/const.js";import{contentScheduleEffectsPayloadSchema,runContentScheduleEffects}from"../../../../content/server/schedule-effects.js";export const contentScheduleEffectsQueueTask=buildQueueTask({name:CONTENT_QUEUE_TASK_SCHEDULE_EFFECTS,description:"Emit the event, sync search and expire the cache for a scheduled publish or unpublish that has already committed. Never republishes.",maxAttempts:5,handler:async(c,payload)=>{const input=contentScheduleEffectsPayloadSchema.parse(payload);const outcome=await runContentScheduleEffects(c,input);if(outcome.status==="unregistered"){await c.get("log").warn(`[content-schedule-effects] ${input.scheduleId}: ${input.contentTypeId} is no longer registered, so nothing was announced.`)}}});

package/dist/src/api/modules/content/tasks/content-schedule.task.d.ts

@@ -0,0 +1,7 @@
+import { z } from "zod";
+export declare const contentSchedulePayloadSchema: z.ZodObject<{
+    generation: z.ZodNumber;
+    scheduleId: z.ZodNumber;
+}, z.core.$strip>;
+export declare const contentScheduleQueueTask: import("../../../../api/lib/queue").BuildQueueTaskReturn;
+//# sourceMappingURL=content-schedule.task.d.ts.map

package/dist/src/api/modules/content/tasks/content-schedule.task.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"content-schedule.task.d.ts","sourceRoot":"","sources":["../../../../../../src/api/modules/content/tasks/content-schedule.task.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAgBxB,eAAO,MAAM,4BAA4B;;;iBAGvC,CAAC;AAEH,eAAO,MAAM,wBAAwB,gDAqBnC,CAAC"}

package/dist/src/api/modules/content/tasks/content-schedule.task.js

@@ -0,0 +1 @@
+import{z}from"zod";import{buildQueueTask}from"../../../lib/queue.js";import{CONTENT_QUEUE_TASK_SCHEDULE}from"../../../../content/const.js";import{executeContentSchedule}from"../helpers/execute-content-schedule.js";export const contentSchedulePayloadSchema=z.object({generation:z.number().int().positive(),scheduleId:z.number().int().positive()});export const contentScheduleQueueTask=buildQueueTask({name:CONTENT_QUEUE_TASK_SCHEDULE,description:"Publish or unpublish a content record at its scheduled time. A cancelled, rescheduled or already-executed schedule is a no-op.",handler:async(c,payload)=>{const{generation,scheduleId}=contentSchedulePayloadSchema.parse(payload);const outcome=await executeContentSchedule(c,{generation,scheduleId});if(outcome.status==="executed")return;const message=`[content-schedule] ${scheduleId}: ${outcome.status}${outcome.reason?` (${outcome.reason})`:""}`;await (outcome.status==="unregistered"?c.get("log").warn(message):c.get("log").debug(message))}});

package/dist/src/api/modules/cron/cron/clean.cron.d.ts

@@ -0,0 +1,2 @@
+export declare const cleanCron: import("../../../../api/lib/cron").BuildCronReturn;
+//# sourceMappingURL=clean.cron.d.ts.map

package/dist/src/api/modules/cron/cron/clean.cron.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clean.cron.d.ts","sourceRoot":"","sources":["../../../../../../src/api/modules/cron/cron/clean.cron.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,SAAS,0CA0BpB,CAAC"}

package/dist/src/api/modules/cron/cron/clean.cron.js

@@ -0,0 +1 @@
+import{lt}from"drizzle-orm";import{buildCron}from"../../../lib/cron.js";import{core_admin_sessions}from"../../../../database/admins.js";import{core_sessions}from"../../../../database/sessions.js";import{core_users_forgot_password}from"../../../../database/users.js";export const cleanCron=buildCron({name:"clean",description:"Clean up expired sessions and tokens",schedule:"0 * * * *",handler:async c=>{await c.get("db").transaction(async tx=>{await tx.delete(core_sessions).where(lt(core_sessions.expiresAt,new Date));await tx.delete(core_admin_sessions).where(lt(core_admin_sessions.expiresAt,new Date));await tx.delete(core_users_forgot_password).where(lt(core_users_forgot_password.expiresAt,new Date))})}});

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

@@ -0,0 +1,22 @@
+export declare const cronModule: import("../../../api/lib/module").BuildModuleReturn<"@vitnode/core", "cron", [import("../../lib/route").Route<"@vitnode/core", {
+    method: "post";
+    description: string;
+    path: "/";
+    middleware: ((c: import("hono").Context, next: import("hono").Next) => Promise<void>)[];
+    responses: {
+        200: {
+            content: {
+                "text/plain": {
+                    schema: import("zod").ZodString;
+                };
+            };
+            description: string;
+        };
+        403: {
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>], import("../../../api/lib/module").BaseBuildModuleReturn<"@vitnode/core", string, import("../../lib/route").Route<"@vitnode/core", import("@hono/zod-openapi").RouteConfig>[]>[]>;
+//# sourceMappingURL=cron.module.d.ts.map

package/dist/src/api/modules/cron/cron.module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cron.module.d.ts","sourceRoot":"","sources":["../../../../../src/api/modules/cron/cron.module.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;8KAKrB,CAAC"}

package/dist/src/api/modules/cron/cron.module.js

@@ -0,0 +1 @@
+import{buildModule}from"../../lib/module.js";import{CONFIG_PLUGIN}from"../../../config.js";import{cleanCron}from"./cron/clean.cron.js";import{runCronRoute}from"./routes/cron.route.js";export const cronModule=buildModule({pluginId:CONFIG_PLUGIN.pluginId,name:"cron",routes:[runCronRoute],cronJobs:[cleanCron]});

package/dist/src/api/modules/cron/helpers/process-cron-jobs.d.ts

@@ -0,0 +1,36 @@
+import type { drizzle } from "drizzle-orm/postgres-js";
+import type { CronJobConfig } from "../../../../api/lib/cron";
+interface CronJobFromDb {
+    createdAt: Date;
+    description: null | string;
+    id: number;
+    lastRun: Date | null;
+    module: string;
+    name: string;
+    nextRun: Date | null;
+    pluginId: string;
+    schedule: string;
+}
+export declare function cleanupOutdatedCronJobs(db: ReturnType<typeof drizzle>, cronFromDb: CronJobFromDb[], currentCronJobs: CronJobConfig[]): Promise<void>;
+export declare function processCronJobs(cronJobs: CronJobConfig[], cronFromDb: CronJobFromDb[]): {
+    newJobs: CronJobConfig[];
+    jobsToExecute: CronJobConfig[];
+    jobsToUpdate: {
+        changes: {
+            description?: boolean;
+            schedule?: boolean;
+        };
+        existingJob: CronJobFromDb;
+        job: CronJobConfig;
+    }[];
+};
+export declare function updateCronJobs(db: ReturnType<typeof drizzle>, jobsToUpdate: {
+    changes: {
+        description?: boolean;
+        schedule?: boolean;
+    };
+    existingJob: CronJobFromDb;
+    job: CronJobConfig;
+}[]): Promise<void>;
+export {};
+//# sourceMappingURL=process-cron-jobs.d.ts.map

package/dist/src/api/modules/cron/helpers/process-cron-jobs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"process-cron-jobs.d.ts","sourceRoot":"","sources":["../../../../../../src/api/modules/cron/helpers/process-cron-jobs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAC;AAIvD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAMpD,UAAU,aAAa;IACrB,SAAS,EAAE,IAAI,CAAC;IAChB,WAAW,EAAE,IAAI,GAAG,MAAM,CAAC;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,IAAI,GAAG,IAAI,CAAC;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,IAAI,GAAG,IAAI,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAiBD,wBAAsB,uBAAuB,CAC3C,EAAE,EAAE,UAAU,CAAC,OAAO,OAAO,CAAC,EAC9B,UAAU,EAAE,aAAa,EAAE,EAC3B,eAAe,EAAE,aAAa,EAAE,iBAoBjC;AAED,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,aAAa,EAAE,EACzB,UAAU,EAAE,aAAa,EAAE;;;;iBAKhB;YAAE,WAAW,CAAC,EAAE,OAAO,CAAC;YAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;SAAE;qBACzC,aAAa;aACrB,aAAa;;EAqCrB;AAED,wBAAsB,cAAc,CAClC,EAAE,EAAE,UAAU,CAAC,OAAO,OAAO,CAAC,EAC9B,YAAY,EAAE;IACZ,OAAO,EAAE;QAAE,WAAW,CAAC,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;IACvD,WAAW,EAAE,aAAa,CAAC;IAC3B,GAAG,EAAE,aAAa,CAAC;CACpB,EAAE,iBAyBJ"}

package/dist/src/api/modules/cron/helpers/process-cron-jobs.js

@@ -0,0 +1 @@
+import{eq,inArray}from"drizzle-orm";import{core_cron}from"../../../../database/cron.js";import{shouldCronJobRun}from"../../../../lib/api/should-cron-job-run.js";import{validateCronSchedule}from"../../../../lib/api/validate-cron-schedule.js";function getJobChanges(job,existingJob){const changes={};if(existingJob.description!==job.description){changes.description=true}if(existingJob.schedule!==job.schedule){changes.schedule=true}return changes}export async function cleanupOutdatedCronJobs(db,cronFromDb,currentCronJobs){if(cronFromDb.length===0)return;const currentCronIdentifiers=new Set(currentCronJobs.map(job=>`${job.pluginId}:${job.module}:${job.name}`));const cronJobsToDelete=cronFromDb.filter(dbCron=>!currentCronIdentifiers.has(`${dbCron.pluginId}:${dbCron.module}:${dbCron.name}`)).map(dbCron=>dbCron.id);if(cronJobsToDelete.length>0){await db.delete(core_cron).where(inArray(core_cron.id,cronJobsToDelete))}}export function processCronJobs(cronJobs,cronFromDb){const newJobs=[];const jobsToExecute=[];const jobsToUpdate=[];const cronFromDbMap=new Map(cronFromDb.map(dbJob=>[`${dbJob.pluginId}:${dbJob.module}:${dbJob.name}`,dbJob]));for(const job of cronJobs){if(!validateCronSchedule(job.schedule)){console.warn(`\x1b[34m[VitNode]\x1b[0m \x1b[33mInvalid cron schedule for job "${job.pluginId}:${job.module}:${job.name}"\x1b[0m: ${job.schedule}`);continue}const jobKey=`${job.pluginId}:${job.module}:${job.name}`;const existingJob=cronFromDbMap.get(jobKey);if(existingJob){const changes=getJobChanges(job,existingJob);if(Object.keys(changes).length>0){jobsToUpdate.push({job,existingJob,changes})}}else{newJobs.push(job)}if(shouldCronJobRun(job.schedule,existingJob?.lastRun??null)){jobsToExecute.push(job)}}return{newJobs,jobsToExecute,jobsToUpdate}}export async function updateCronJobs(db,jobsToUpdate){if(jobsToUpdate.length===0)return;const updatePromises=jobsToUpdate.map(({job,existingJob,changes})=>{const updateData={};if(changes.description){updateData.description=job.description??null}if(changes.schedule){updateData.schedule=job.schedule}return db.update(core_cron).set(updateData).where(eq(core_cron.id,existingJob.id))});await Promise.all(updatePromises)}

package/dist/src/api/modules/cron/helpers/register-cron-jobs.d.ts

@@ -0,0 +1,4 @@
+import type { drizzle } from "drizzle-orm/postgres-js";
+import type { CronJobConfig } from "../../../../api/lib/cron";
+export declare function registerCronJobs(db: ReturnType<typeof drizzle>, cronJobs: CronJobConfig[]): Promise<void>;
+//# sourceMappingURL=register-cron-jobs.d.ts.map

package/dist/src/api/modules/cron/helpers/register-cron-jobs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"register-cron-jobs.d.ts","sourceRoot":"","sources":["../../../../../../src/api/modules/cron/helpers/register-cron-jobs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAC;AAEvD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAUpD,wBAAsB,gBAAgB,CACpC,EAAE,EAAE,UAAU,CAAC,OAAO,OAAO,CAAC,EAC9B,QAAQ,EAAE,aAAa,EAAE,iBAsB1B"}

package/dist/src/api/modules/cron/helpers/register-cron-jobs.js

@@ -0,0 +1 @@
+import{core_cron}from"../../../../database/cron.js";import{cleanupOutdatedCronJobs,processCronJobs,updateCronJobs}from"./process-cron-jobs.js";export async function registerCronJobs(db,cronJobs){const cronFromDb=await db.select().from(core_cron);await cleanupOutdatedCronJobs(db,cronFromDb,cronJobs);const{newJobs,jobsToUpdate}=processCronJobs(cronJobs,cronFromDb);if(newJobs.length>0){await db.insert(core_cron).values(newJobs.map(job=>({name:job.name,description:job.description??null,lastRun:null,nextRun:null,pluginId:job.pluginId,module:job.module,schedule:job.schedule})))}await updateCronJobs(db,jobsToUpdate)}

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

@@ -0,0 +1,23 @@
+import { z } from "zod";
+export declare const runCronRoute: import("../../../../api/lib/route").Route<"@vitnode/core", {
+    method: "post";
+    description: string;
+    path: "/";
+    middleware: ((c: import("hono").Context, next: import("hono").Next) => Promise<void>)[];
+    responses: {
+        200: {
+            content: {
+                "text/plain": {
+                    schema: z.ZodString;
+                };
+            };
+            description: string;
+        };
+        403: {
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>;
+//# sourceMappingURL=cron.route.d.ts.map

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

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

package/dist/src/api/modules/cron/routes/cron.route.js

@@ -0,0 +1 @@
+import{eq}from"drizzle-orm";import{z}from"zod";import{buildRoute}from"../../../lib/route.js";import{cronAuthMiddleware}from"../../../middlewares/cron-auth.middleware.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";import{cleanupOutdatedCronJobs,processCronJobs,updateCronJobs}from"../helpers/process-cron-jobs.js";export const runCronRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,route:{method:"post",description:"Run cron job",path:"/",middleware:[cronAuthMiddleware()],responses:{200:{content:{"text/plain":{schema:z.string()}},description:"Cron started successfully"},403:{description:"Access Denied"}}},handler:async c=>{const db=c.get("db");const cronJobs=c.get("core").cron;try{const cronFromDb=await db.select().from(core_cron);await cleanupOutdatedCronJobs(db,cronFromDb,cronJobs);const now=new Date;let executedJobs=0;const{newJobs,jobsToExecute,jobsToUpdate}=processCronJobs(cronJobs,cronFromDb);if(newJobs.length>0){try{const newJobsValues=newJobs.map(job=>({name:job.name,description:job.description??null,lastRun:null,nextRun:null,pluginId:job.pluginId,module:job.module,schedule:job.schedule}));await db.insert(core_cron).values(newJobsValues)}catch(error){await c.get("log").error(`Error inserting new cron jobs: ${error}`)}}try{await updateCronJobs(db,jobsToUpdate)}catch(error){await c.get("log").error(`Error updating cron jobs: ${error}`)}if(jobsToExecute.length>0){const cronFromDbMap=new Map(cronFromDb.map(dbJob=>[`${dbJob.pluginId}:${dbJob.module}:${dbJob.name}`,dbJob]));const executionPromises=jobsToExecute.map(async job=>{try{await job.handler(c);const jobKey=`${job.pluginId}:${job.module}:${job.name}`;const dbJob=cronFromDbMap.get(jobKey);if(dbJob){await db.update(core_cron).set({lastRun:now,nextRun:getNextCronRunDate(job.schedule,now)}).where(eq(core_cron.id,dbJob.id))}return{success:true,jobName:job.name}}catch(error){await c.get("log").error(`Error executing cron job "${job.pluginId}:${job.module}:${job.name}": ${error}`);return{success:false,jobName:job.name,error}}});const results=await Promise.allSettled(executionPromises);executedJobs=results.filter(result=>result.status==="fulfilled"&&result.value.success).length}return c.text(`Cron jobs processed. Executed ${executedJobs} jobs.`,200)}catch(error){await c.get("log").error(`Error processing cron jobs: ${error}`);return c.text("Error processing cron jobs",500)}}});

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

@@ -0,0 +1,31 @@
+export declare const middlewareModule: import("../../../api/lib/module").BuildModuleReturn<"@vitnode/core", "middleware", [import("../../lib/route").Route<"@vitnode/core", {
+    path: "/";
+    method: "get";
+    description: string;
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        sso: import("zod").ZodArray<import("zod").ZodObject<{
+                            id: import("zod").ZodString;
+                            name: import("zod").ZodString;
+                        }, import("zod/v4/core").$strip>>;
+                        isEmail: import("zod").ZodBoolean;
+                        captcha: import("zod").ZodOptional<import("zod").ZodObject<{
+                            siteKey: import("zod").ZodString;
+                            type: import("zod").ZodEnum<{
+                                cloudflare_turnstile: "cloudflare_turnstile";
+                                recaptcha_v3: "recaptcha_v3";
+                            }>;
+                        }, import("zod/v4/core").$strip>>;
+                    }, import("zod/v4/core").$strip>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>], import("../../../api/lib/module").BaseBuildModuleReturn<"@vitnode/core", string, import("../../lib/route").Route<"@vitnode/core", import("@hono/zod-openapi").RouteConfig>[]>[]>;
+//# sourceMappingURL=middleware.module.d.ts.map

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

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

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

@@ -0,0 +1 @@
+import{buildModule}from"../../lib/module.js";import{CONFIG_PLUGIN}from"../../../config.js";import{routeMiddleware}from"./route.js";export const middlewareModule=buildModule({pluginId:CONFIG_PLUGIN.pluginId,name:"middleware",routes:[routeMiddleware]});

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

@@ -0,0 +1,46 @@
+import { z } from "zod";
+export declare const routeMiddlewareSchema: z.ZodObject<{
+    sso: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strip>>;
+    isEmail: z.ZodBoolean;
+    captcha: z.ZodOptional<z.ZodObject<{
+        siteKey: z.ZodString;
+        type: z.ZodEnum<{
+            cloudflare_turnstile: "cloudflare_turnstile";
+            recaptcha_v3: "recaptcha_v3";
+        }>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const routeMiddleware: import("../../../api/lib/route").Route<"@vitnode/core", {
+    path: "/";
+    method: "get";
+    description: string;
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        sso: z.ZodArray<z.ZodObject<{
+                            id: z.ZodString;
+                            name: z.ZodString;
+                        }, z.core.$strip>>;
+                        isEmail: z.ZodBoolean;
+                        captcha: z.ZodOptional<z.ZodObject<{
+                            siteKey: z.ZodString;
+                            type: z.ZodEnum<{
+                                cloudflare_turnstile: "cloudflare_turnstile";
+                                recaptcha_v3: "recaptcha_v3";
+                            }>;
+                        }, z.core.$strip>>;
+                    }, z.core.$strip>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>;
+//# sourceMappingURL=route.d.ts.map

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

@@ -0,0 +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;AAKxB,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;iBAShC,CAAC;AAEH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkC1B,CAAC"}

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

@@ -0,0 +1 @@
+import{z}from"zod";import{buildRoute}from"../../lib/route.js";import{CONFIG_PLUGIN}from"../../../config.js";export const routeMiddlewareSchema=z.object({sso:z.array(z.object({id:z.string(),name:z.string()})),isEmail:z.boolean(),captcha:z.object({siteKey:z.string(),type:z.enum(["cloudflare_turnstile","recaptcha_v3"])}).optional()});export const routeMiddleware=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,route:{path:"/",method:"get",description:"Middleware route with user authentication",responses:{200:{content:{"application/json":{schema:routeMiddlewareSchema}},description:"Middleware route"}}},handler:c=>{const sso=c.get("core").authorization.ssoAdapters;return c.json({isEmail:!!c.get("core").email?.adapter,sso:sso.map(s=>({id:s.id,name:s.name})),captcha:c.get("core").captcha?{siteKey:c.get("core").captcha?.siteKey??"",type:c.get("core").captcha?.type??"cloudflare_turnstile"}:undefined},200)}});

package/dist/src/api/modules/queue/cron/process-queue.cron.d.ts

@@ -0,0 +1,2 @@
+export declare const processQueueCron: import("../../../../api/lib/cron").BuildCronReturn;
+//# sourceMappingURL=process-queue.cron.d.ts.map

package/dist/src/api/modules/queue/cron/process-queue.cron.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"process-queue.cron.d.ts","sourceRoot":"","sources":["../../../../../../src/api/modules/queue/cron/process-queue.cron.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,gBAAgB,0CAO3B,CAAC"}