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

package/dist/src/database/cron.js

@@ -0,0 +1,22 @@
+import { pgTable } from "drizzle-orm/pg-core";
+export const core_cron = pgTable("core_cron", (t)=>({
+        id: t.serial().primaryKey(),
+        name: t.varchar({
+            length: 255
+        }).notNull(),
+        description: t.varchar({
+            length: 255
+        }),
+        lastRun: t.timestamp(),
+        createdAt: t.timestamp().notNull().defaultNow(),
+        pluginId: t.varchar({
+            length: 100
+        }).notNull(),
+        module: t.varchar({
+            length: 100
+        }).notNull(),
+        nextRun: t.timestamp(),
+        schedule: t.varchar({
+            length: 100
+        }).notNull()
+    })).enableRLS();

package/dist/src/database/users.d.ts

@@ -420,8 +420,8 @@ export declare const core_users_confirm_emails: Omit<import("drizzle-orm/pg-core
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
-        expires: import("drizzle-orm/pg-core").PgColumn<{
-            name: "expires";
+        expiresAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "expiresAt";
             tableName: "core_users_confirm_emails";
             dataType: "date";
             columnType: "PgTimestamp";

package/dist/src/database/users.js

@@ -104,7 +104,7 @@ export const core_users_confirm_emails = pgTable("core_users_confirm_emails", (t
             length: 100
         }).notNull().unique(),
         createdAt: t.timestamp().notNull().defaultNow(),
-        expires: t.timestamp().notNull(),
+        expiresAt: t.timestamp().notNull(),
         ipAddress: t.varchar({
             length: 40
         }).notNull()

package/dist/src/lib/api/get-next-cron-run-date.d.ts

@@ -0,0 +1,2 @@
+export declare const getNextCronRunDate: (schedule: string, lastRun: Date | null) => Date | null;
+//# sourceMappingURL=get-next-cron-run-date.d.ts.map

package/dist/src/lib/api/get-next-cron-run-date.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-next-cron-run-date.d.ts","sourceRoot":"","sources":["../../../../src/lib/api/get-next-cron-run-date.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,kBAAkB,GAC7B,UAAU,MAAM,EAChB,SAAS,IAAI,GAAG,IAAI,KACnB,IAAI,GAAG,IAgBT,CAAC"}

package/dist/src/lib/api/get-next-cron-run-date.js

@@ -0,0 +1,14 @@
+import cronParser from "cron-parser";
+export const getNextCronRunDate = (schedule, lastRun)=>{
+    try {
+        const options = {
+            currentDate: lastRun || new Date(0)
+        };
+        const interval = cronParser.parse(schedule, options);
+        return interval.next().toDate();
+    } catch (err) {
+        // biome-ignore lint/suspicious/noConsole: needed for cron job monitoring
+        console.error(`\x1b[34m[VitNode]\x1b[0m \x1b[38;5;208mError parsing schedule for nextRun\x1b[0m: ${schedule}`, err);
+        return null;
+    }
+};

package/dist/src/lib/api/get-next-cron-run-date.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=get-next-cron-run-date.test.d.ts.map

package/dist/src/lib/api/get-next-cron-run-date.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-next-cron-run-date.test.d.ts","sourceRoot":"","sources":["../../../../src/lib/api/get-next-cron-run-date.test.ts"],"names":[],"mappings":""}

package/dist/src/lib/api/get-next-cron-run-date.test.js

@@ -0,0 +1,55 @@
+import { describe, expect, it, vi } from "vitest";
+import { getNextCronRunDate } from "./get-next-cron-run-date.js";
+describe("getNextCronRunDate", ()=>{
+    it("should return the next run date for a valid cron schedule with lastRun null", ()=>{
+        const schedule = "0 0 * * *"; // Daily at midnight
+        const lastRun = null;
+        const result = getNextCronRunDate(schedule, lastRun);
+        expect(result).toBeInstanceOf(Date);
+        if (result) {
+            expect(result.getHours()).toBe(0);
+            expect(result.getMinutes()).toBe(0);
+        }
+    });
+    it("should return the next run date for a valid cron schedule with lastRun provided", ()=>{
+        const schedule = "0 0 * * *"; // Daily at midnight
+        const lastRun = new Date("2023-01-01T12:00:00Z");
+        const result = getNextCronRunDate(schedule, lastRun);
+        expect(result).toBeInstanceOf(Date);
+        if (result) {
+            expect(result.getHours()).toBe(0);
+            expect(result.getMinutes()).toBe(0);
+            expect(result.getTime()).toBeGreaterThan(lastRun.getTime());
+        }
+    });
+    it("should return null for an invalid cron schedule", ()=>{
+        const schedule = "invalid cron";
+        const lastRun = null;
+        const consoleSpy = vi.spyOn(console, "error").mockImplementation(()=>{});
+        const result = getNextCronRunDate(schedule, lastRun);
+        expect(result).toBeNull();
+        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("[VitNode]"), expect.any(Error));
+        consoleSpy.mockRestore();
+    });
+    it("should handle cron schedules with specific times", ()=>{
+        const schedule = "30 14 * * 1"; // Every Monday at 14:30
+        const lastRun = new Date("2023-01-01T10:00:00Z"); // Sunday
+        const result = getNextCronRunDate(schedule, lastRun);
+        expect(result).toBeInstanceOf(Date);
+        if (result) {
+            expect(result.getDay()).toBe(1); // Monday
+            expect(result.getHours()).toBe(14);
+            expect(result.getMinutes()).toBe(30);
+        }
+    });
+    it("should return null when cron parsing throws an error", ()=>{
+        // This test assumes cron-parser can throw for certain invalid inputs
+        const schedule = "99 99 99 99 99"; // Invalid cron with out-of-range values
+        const lastRun = null;
+        const consoleSpy = vi.spyOn(console, "error").mockImplementation(()=>{});
+        const result = getNextCronRunDate(schedule, lastRun);
+        expect(result).toBeNull();
+        expect(consoleSpy).toHaveBeenCalled();
+        consoleSpy.mockRestore();
+    });
+});

package/dist/src/lib/api/should-cron-job-run.d.ts

@@ -0,0 +1,2 @@
+export declare const shouldCronJobRun: (schedule: string, lastRun: Date | null) => boolean;
+//# sourceMappingURL=should-cron-job-run.d.ts.map

package/dist/src/lib/api/should-cron-job-run.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"should-cron-job-run.d.ts","sourceRoot":"","sources":["../../../../src/lib/api/should-cron-job-run.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,gBAAgB,GAC3B,UAAU,MAAM,EAChB,SAAS,IAAI,GAAG,IAAI,KACnB,OAmBF,CAAC"}

package/dist/src/lib/api/should-cron-job-run.js

@@ -0,0 +1,16 @@
+import cronParser from "cron-parser";
+export const shouldCronJobRun = (schedule, lastRun)=>{
+    try {
+        const now = new Date();
+        const options = {
+            currentDate: lastRun || new Date(0)
+        };
+        const interval = cronParser.parse(schedule, options);
+        const nextScheduledRun = interval.next().toDate();
+        return nextScheduledRun <= now;
+    } catch (err) {
+        // biome-ignore lint/suspicious/noConsole: needed for cron job monitoring
+        console.error(`\x1b[34m[VitNode]\x1b[0m \x1b[38;5;208mError parsing schedule\x1b[0m: ${schedule}`, err);
+        return false;
+    }
+};

package/dist/src/lib/api/should-cron-job-run.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=should-cron-job-run.test.d.ts.map

package/dist/src/lib/api/should-cron-job-run.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"should-cron-job-run.test.d.ts","sourceRoot":"","sources":["../../../../src/lib/api/should-cron-job-run.test.ts"],"names":[],"mappings":""}

package/dist/src/lib/api/should-cron-job-run.test.js

@@ -0,0 +1,213 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { shouldCronJobRun } from "./should-cron-job-run.js";
+describe("shouldCronJobRun", ()=>{
+    beforeEach(()=>{
+        // Reset any mocked console methods
+        vi.clearAllMocks();
+    });
+    describe("valid cron schedules", ()=>{
+        it("should return true when job has never run (lastRun is null)", ()=>{
+            const schedule = "0 * * * *"; // Every hour
+            const lastRun = null;
+            const result = shouldCronJobRun(schedule, lastRun);
+            expect(result).toBe(true);
+        });
+        it("should return true when enough time has passed since last run", ()=>{
+            const schedule = "0 * * * *"; // Every hour
+            const lastRun = new Date("2024-01-01T10:00:00Z");
+            // Mock current time to be 2 hours later
+            vi.useFakeTimers();
+            vi.setSystemTime(new Date("2024-01-01T12:00:00Z"));
+            const result = shouldCronJobRun(schedule, lastRun);
+            expect(result).toBe(true);
+            vi.useRealTimers();
+        });
+        it("should return false when not enough time has passed since last run", ()=>{
+            const schedule = "0 * * * *"; // Every hour
+            const lastRun = new Date("2024-01-01T11:30:00Z");
+            // Mock current time to be 15 minutes later (not enough for hourly job)
+            vi.useFakeTimers();
+            vi.setSystemTime(new Date("2024-01-01T11:45:00Z"));
+            const result = shouldCronJobRun(schedule, lastRun);
+            expect(result).toBe(false);
+            vi.useRealTimers();
+        });
+        it("should handle daily job correctly", ()=>{
+            const schedule = "0 9 * * *"; // Every day at 9 AM
+            const lastRun = new Date("2024-01-01T09:00:00Z");
+            // Mock current time to be next day at 10 AM
+            vi.useFakeTimers();
+            vi.setSystemTime(new Date("2024-01-02T10:00:00Z"));
+            const result = shouldCronJobRun(schedule, lastRun);
+            expect(result).toBe(true);
+            vi.useRealTimers();
+        });
+        it("should handle weekly job correctly", ()=>{
+            const schedule = "0 9 * * 1"; // Every Monday at 9 AM
+            const lastRun = new Date("2024-01-01T09:00:00Z"); // Monday
+            // Mock current time to be next Monday
+            vi.useFakeTimers();
+            vi.setSystemTime(new Date("2024-01-08T10:00:00Z")); // Next Monday
+            const result = shouldCronJobRun(schedule, lastRun);
+            expect(result).toBe(true);
+            vi.useRealTimers();
+        });
+        it("should handle monthly job correctly", ()=>{
+            const schedule = "0 9 1 * *"; // First day of every month at 9 AM
+            const lastRun = new Date("2024-01-01T09:00:00Z");
+            // Mock current time to be next month
+            vi.useFakeTimers();
+            vi.setSystemTime(new Date("2024-02-01T10:00:00Z"));
+            const result = shouldCronJobRun(schedule, lastRun);
+            expect(result).toBe(true);
+            vi.useRealTimers();
+        });
+        it("should handle every minute job correctly", ()=>{
+            const schedule = "* * * * *"; // Every minute
+            const lastRun = new Date("2024-01-01T10:00:00Z");
+            // Mock current time to be 1 minute later
+            vi.useFakeTimers();
+            vi.setSystemTime(new Date("2024-01-01T10:01:00Z"));
+            const result = shouldCronJobRun(schedule, lastRun);
+            expect(result).toBe(true);
+            vi.useRealTimers();
+        });
+        it("should handle every 5 minutes job correctly", ()=>{
+            const schedule = "*/5 * * * *"; // Every 5 minutes
+            const lastRun = new Date("2024-01-01T10:00:00Z");
+            // Mock current time to be 3 minutes later (not enough)
+            vi.useFakeTimers();
+            vi.setSystemTime(new Date("2024-01-01T10:03:00Z"));
+            const result = shouldCronJobRun(schedule, lastRun);
+            expect(result).toBe(false);
+            // Mock current time to be 5 minutes later (enough)
+            vi.setSystemTime(new Date("2024-01-01T10:05:00Z"));
+            const result2 = shouldCronJobRun(schedule, lastRun);
+            expect(result2).toBe(true);
+            vi.useRealTimers();
+        });
+        it("should handle complex cron expressions", ()=>{
+            const schedule = "0 9-17 * * 1-5"; // 9 AM to 5 PM on weekdays
+            const lastRun = new Date("2024-01-01T09:00:00Z"); // Monday 9 AM
+            // Mock current time to be same day at 10 AM
+            vi.useFakeTimers();
+            vi.setSystemTime(new Date("2024-01-01T10:00:00Z"));
+            const result = shouldCronJobRun(schedule, lastRun);
+            expect(result).toBe(true);
+            vi.useRealTimers();
+        });
+    });
+    describe("invalid cron schedules", ()=>{
+        it("should return false and log error for invalid cron schedule", ()=>{
+            const consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(()=>{});
+            const schedule = "invalid cron"; // Invalid schedule
+            const lastRun = null;
+            const result = shouldCronJobRun(schedule, lastRun);
+            expect(result).toBe(false);
+            expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining("[VitNode]") && expect.stringContaining("Error parsing schedule") && expect.stringContaining("invalid cron"), expect.any(Error));
+            consoleErrorSpy.mockRestore();
+        });
+        it("should return false for malformed cron expression", ()=>{
+            const consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(()=>{});
+            const schedule = "60 * * * *"; // Invalid minute (should be 0-59)
+            const lastRun = null;
+            const result = shouldCronJobRun(schedule, lastRun);
+            expect(result).toBe(false);
+            expect(consoleErrorSpy).toHaveBeenCalled();
+            consoleErrorSpy.mockRestore();
+        });
+        it("should return true for empty cron schedule (parsed as valid)", ()=>{
+            // Note: cron-parser actually parses empty string as a valid cron expression
+            const schedule = ""; // Empty schedule
+            const lastRun = null;
+            const result = shouldCronJobRun(schedule, lastRun);
+            expect(result).toBe(true);
+        });
+    });
+    describe("edge cases", ()=>{
+        it("should handle lastRun being exactly at the next scheduled time", ()=>{
+            const schedule = "0 * * * *"; // Every hour
+            const lastRun = new Date("2024-01-01T10:00:00Z");
+            // Mock current time to be exactly at the next scheduled time
+            vi.useFakeTimers();
+            vi.setSystemTime(new Date("2024-01-01T11:00:00Z"));
+            const result = shouldCronJobRun(schedule, lastRun);
+            expect(result).toBe(true);
+            vi.useRealTimers();
+        });
+        it("should handle lastRun being in the future (clock skew)", ()=>{
+            const schedule = "0 * * * *"; // Every hour
+            const lastRun = new Date("2024-01-01T12:00:00Z"); // Future time
+            // Mock current time to be earlier
+            vi.useFakeTimers();
+            vi.setSystemTime(new Date("2024-01-01T11:00:00Z"));
+            const result = shouldCronJobRun(schedule, lastRun);
+            expect(result).toBe(false);
+            vi.useRealTimers();
+        });
+        it("should handle lastRun being epoch (new Date(0))", ()=>{
+            const schedule = "0 * * * *"; // Every hour
+            const lastRun = new Date(0); // Epoch time
+            // Mock current time to be much later
+            vi.useFakeTimers();
+            vi.setSystemTime(new Date("2024-01-01T10:00:00Z"));
+            const result = shouldCronJobRun(schedule, lastRun);
+            expect(result).toBe(true);
+            vi.useRealTimers();
+        });
+        it("should handle yearly cron job", ()=>{
+            const schedule = "0 0 1 1 *"; // January 1st at midnight
+            const lastRun = new Date("2023-01-01T00:00:00Z");
+            // Mock current time to be next year
+            vi.useFakeTimers();
+            vi.setSystemTime(new Date("2024-01-01T01:00:00Z"));
+            const result = shouldCronJobRun(schedule, lastRun);
+            expect(result).toBe(true);
+            vi.useRealTimers();
+        });
+        it("should handle specific day of month with month", ()=>{
+            const schedule = "0 12 15 6 *"; // June 15th at noon
+            const lastRun = new Date("2023-06-15T12:00:00Z");
+            // Mock current time to be next year same date
+            vi.useFakeTimers();
+            vi.setSystemTime(new Date("2024-06-15T13:00:00Z"));
+            const result = shouldCronJobRun(schedule, lastRun);
+            expect(result).toBe(true);
+            vi.useRealTimers();
+        });
+    });
+    describe("timezone handling", ()=>{
+        it("should work with different timezone dates", ()=>{
+            const schedule = "0 9 * * *"; // Every day at 9 AM
+            const lastRun = new Date("2024-01-01T09:00:00+05:00"); // 9 AM in +5 timezone
+            // Mock current time to be next day in UTC
+            vi.useFakeTimers();
+            vi.setSystemTime(new Date("2024-01-02T04:00:00Z")); // 9 AM in +5 timezone
+            const result = shouldCronJobRun(schedule, lastRun);
+            expect(result).toBe(true);
+            vi.useRealTimers();
+        });
+    });
+    describe("performance and boundary conditions", ()=>{
+        it("should handle very old lastRun dates", ()=>{
+            const schedule = "0 * * * *"; // Every hour
+            const lastRun = new Date("1970-01-01T00:00:00Z"); // Very old date
+            // Current time
+            vi.useFakeTimers();
+            vi.setSystemTime(new Date("2024-01-01T10:00:00Z"));
+            const result = shouldCronJobRun(schedule, lastRun);
+            expect(result).toBe(true);
+            vi.useRealTimers();
+        });
+        it("should handle leap year considerations", ()=>{
+            const schedule = "0 0 29 2 *"; // February 29th (leap day)
+            const lastRun = new Date("2020-02-29T00:00:00Z"); // Last leap year
+            // Mock current time to be next leap year
+            vi.useFakeTimers();
+            vi.setSystemTime(new Date("2024-02-29T01:00:00Z"));
+            const result = shouldCronJobRun(schedule, lastRun);
+            expect(result).toBe(true);
+            vi.useRealTimers();
+        });
+    });
+});

package/dist/src/lib/config.d.ts

@@ -1,4 +1,5 @@
 export declare const CONFIG: {
+    cronJobSecret: string;
     api: URL;
     web: URL;
     node_development: boolean;

package/dist/src/lib/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/lib/config.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,MAAM;;;;CAGlB,CAAC"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/lib/config.ts"],"names":[],"mappings":"AAYA,eAAO,MAAM,MAAM;;;;;CAIlB,CAAC"}

package/dist/src/lib/config.js

@@ -1,12 +1,14 @@
 const ENVS = {
-    api_url: process.env.NEXT_PUBLIC_API_URL,
-    web_url: process.env.NEXT_PUBLIC_WEB_URL
+    apiUrl: process.env.NEXT_PUBLIC_API_URL,
+    webUrl: process.env.NEXT_PUBLIC_WEB_URL,
+    cronConfig: process.env.CRON_SECRET || "default-cron-secret-change-in-production"
 };
 const urls = {
-    api: new URL(ENVS.api_url ?? "http://localhost:3000"),
-    web: new URL(ENVS.web_url ?? "http://localhost:3000")
+    api: new URL(ENVS.apiUrl ?? "http://localhost:3000"),
+    web: new URL(ENVS.webUrl ?? "http://localhost:3000")
 };
 export const CONFIG = {
     node_development: process.env.NODE_ENV === "development",
-    ...urls
+    ...urls,
+    cronJobSecret: ENVS.cronConfig
 };

package/dist/src/lib/ctrl-or-command-character.d.ts

@@ -0,0 +1,2 @@
+export declare const CtrlOrCommandCharacter: () => string;
+//# sourceMappingURL=ctrl-or-command-character.d.ts.map

package/dist/src/lib/ctrl-or-command-character.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ctrl-or-command-character.d.ts","sourceRoot":"","sources":["../../../src/lib/ctrl-or-command-character.tsx"],"names":[],"mappings":"AAEA,eAAO,MAAM,sBAAsB,cAUlC,CAAC"}

package/dist/src/lib/ctrl-or-command-character.js

@@ -0,0 +1,9 @@
+import React from "react";
+export const CtrlOrCommandCharacter = ()=>{
+    const [key, setKey] = React.useState("⌘");
+    React.useEffect(()=>{
+        const isWindows = window.navigator.userAgent.includes("Windows");
+        if (isWindows) setKey("Ctrl");
+    }, []);
+    return key;
+};

package/dist/src/lib/navigation.d.ts

@@ -15,7 +15,7 @@ declare const Link: import("react").ForwardRefExoticComponent<Omit<{
     scroll?: boolean | undefined;
     shallow?: boolean | undefined;
     passHref?: boolean | undefined;
-    prefetch?: boolean | null | undefined;
+    prefetch?: boolean | "auto" | null | "unstable_forceStale" | undefined;
     legacyBehavior?: boolean | undefined;
     onMouseEnter?: React.MouseEventHandler<HTMLAnchorElement> | undefined;
     onTouchStart?: React.TouchEventHandler<HTMLAnchorElement> | undefined;

package/dist/src/lib/navigation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"navigation.d.ts","sourceRoot":"","sources":["../../../src/lib/navigation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAKxD,QAAA,MACE,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+DAEJ,WAAW,gBACX,SAAS;;;;;cAmBgkyB,CAAC;;;;;;cAAuxC,CAAC;;;;;;cAAwxC,CAAC;;;;;GAlB3n3B,WAAW;;;;;;;YACS,CAAC;AAEvB,QAAA,MAAM,QAAQ,GACZ,MACI,MAAM,GACN;IACE,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,WAAW,CAAC;CACrB,EACL,OAAO,YAAY,kBAKpB,CAAC;AAEF,OAAO,EAAE,WAAW,EAAE,IAAI,EAAE,QAAQ,EAAE,WAAW,EAAE,SAAS,EAAE,CAAC"}
+{"version":3,"file":"navigation.d.ts","sourceRoot":"","sources":["../../../src/lib/navigation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAKxD,QAAA,MACE,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+DAEJ,WAAW,gBACX,SAAS;;;;;cAmBimyB,CAAC;;;;;;cAAuxC,CAAC;;;;;;cAAwxC,CAAC;;;;;GAlB5p3B,WAAW;;;;;;;YACS,CAAC;AAEvB,QAAA,MAAM,QAAQ,GACZ,MACI,MAAM,GACN;IACE,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,WAAW,CAAC;CACrB,EACL,OAAO,YAAY,kBAKpB,CAAC;AAEF,OAAO,EAAE,WAAW,EAAE,IAAI,EAAE,QAAQ,EAAE,WAAW,EAAE,SAAS,EAAE,CAAC"}

package/dist/src/views/admin/layouts/admin-layout.js

@@ -5,7 +5,7 @@ import { ThemeSwitcher } from "../../../components/switchers/themes/theme-switch
 import { SidebarInset, SidebarProvider, SidebarTrigger } from "../../../components/ui/sidebar.js";
 import { getSessionAdminApi } from "../../../lib/api/get-session-admin-api.js";
 import { I18nProvider } from "../../../components/i18n-provider.js";
-import { LanguageSwitcher } from "../../../components/switchers/langs/language-swietcher.js";
+import { LanguageSwitcher } from "../../../components/switchers/langs/language-switcher.js";
 import { SidebarAdmin } from "./sidebar/sidebar.js";
 import { UserBarAdmin } from "./user-bar/user-bar.js";
 export const AdminLayout = async ({ children, vitNodeConfig })=>{

package/dist/src/views/admin/layouts/sidebar/nav/item.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"item.d.ts","sourceRoot":"","sources":["../../../../../../../src/views/admin/layouts/sidebar/nav/item.tsx"],"names":[],"mappings":"AAqBA,UAAU,iBAAiB;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IACvB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,eAAO,MAAM,YAAY,GAAI,+CAM1B,iBAAiB,GAAG;IACrB,KAAK,CAAC,EAAE,IAAI,CAAC,iBAAiB,EAAE,MAAM,CAAC,EAAE,CAAC;CAC3C,4CAqHA,CAAC"}
+{"version":3,"file":"item.d.ts","sourceRoot":"","sources":["../../../../../../../src/views/admin/layouts/sidebar/nav/item.tsx"],"names":[],"mappings":"AAqBA,UAAU,iBAAiB;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IACvB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,eAAO,MAAM,YAAY,GAAI,+CAM1B,iBAAiB,GAAG;IACrB,KAAK,CAAC,EAAE,IAAI,CAAC,iBAAiB,EAAE,MAAM,CAAC,EAAE,CAAC;CAC3C,4CAsGA,CAAC"}

package/dist/src/views/admin/layouts/sidebar/nav/item.js

@@ -35,7 +35,6 @@ export const ItemNavAdmin = ({ href, title, icon, items = [], isOpenInNewTab })=
                 isActive: isActive,
                 tooltip: title,
                 children: /*#__PURE__*/ _jsx(Link, {
-                    className: cn("relative", isActive && "before:bg-primary before:absolute before:bottom-1 before:left-0 before:top-1 before:h-auto before:w-1 before:rounded-r-sm"),
                     href: href,
                     onClick: ()=>{
                         if (isMobile) {
@@ -58,7 +57,6 @@ export const ItemNavAdmin = ({ href, title, icon, items = [], isOpenInNewTab })=
                 /*#__PURE__*/ _jsx(CollapsibleTrigger, {
                     asChild: true,
                     children: /*#__PURE__*/ _jsxs(SidebarMenuButton, {
-                        className: cn("relative", (isActive || hasActiveChild) && "before:bg-primary before:absolute before:bottom-1 before:left-0 before:top-1 before:h-auto before:w-1 before:rounded-r-sm"),
                         isActive: isActive || hasActiveChild,
                         tooltip: title,
                         children: [
@@ -79,7 +77,6 @@ export const ItemNavAdmin = ({ href, title, icon, items = [], isOpenInNewTab })=
                                     asChild: true,
                                     isActive: isChildActive,
                                     children: /*#__PURE__*/ _jsx(Link, {
-                                        className: cn("relative", isChildActive && "before:bg-primary before:absolute before:bottom-1 before:left-0 before:top-1 before:h-auto before:w-1 before:rounded-r-sm"),
                                         href: item.href,
                                         onClick: ()=>{
                                             if (isMobile) {

package/dist/src/views/admin/layouts/sidebar/nav/nav.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"nav.d.ts","sourceRoot":"","sources":["../../../../../../../src/views/admin/layouts/sidebar/nav/nav.tsx"],"names":[],"mappings":"AASA,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAEtC,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,KAAK,CAAC,cAAc,CAAC,OAAO,YAAY,CAAC,EAAE,CAAC;IACnD,KAAK,EAAE,MAAM,CAAC;CACf;AAED,eAAO,MAAM,eAAe,GAAU,gBAEnC;IACD,SAAS,EAAE,cAAc,EAAE,CAAC;CAC7B,uDA0CA,CAAC"}
+{"version":3,"file":"nav.d.ts","sourceRoot":"","sources":["../../../../../../../src/views/admin/layouts/sidebar/nav/nav.tsx"],"names":[],"mappings":"AASA,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAEtC,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,KAAK,CAAC,cAAc,CAAC,OAAO,YAAY,CAAC,EAAE,CAAC;IACnD,KAAK,EAAE,MAAM,CAAC;CACf;AAED,eAAO,MAAM,eAAe,GAAU,gBAEnC;IACD,SAAS,EAAE,cAAc,EAAE,CAAC;CAC7B,uDAqDA,CAAC"}

package/dist/src/views/admin/layouts/sidebar/nav/nav.js

@@ -1,5 +1,5 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { LayoutDashboardIcon, UsersRoundIcon } from "lucide-react";
+import { LayoutDashboardIcon, UsersRoundIcon, WrenchIcon } from "lucide-react";
 import { getTranslations } from "next-intl/server";
 import { SidebarGroup, SidebarGroupLabel, SidebarMenu } from "../../../../../components/ui/sidebar.js";
 import { ItemNavAdmin } from "./item.js";
@@ -29,6 +29,17 @@ export const NavSidebarAdmin = async ({ pluginNav })=>{
                             href: "/admin/core/test"
                         }
                     ]
+                },
+                {
+                    href: "/admin/core/advanced",
+                    title: t("advanced.title"),
+                    icon: /*#__PURE__*/ _jsx(WrenchIcon, {}),
+                    items: [
+                        {
+                            title: t("advanced.cron"),
+                            href: "/admin/core/advanced/cron"
+                        }
+                    ]
                 }
             ]
         },

package/dist/src/views/admin/views/core/advanced/cron/cron-table-view.d.ts

@@ -0,0 +1,5 @@
+import { type SearchParamsDataTable } from "../../../../../../components/table/data-table";
+export declare const CronTableView: ({ searchParams, }: {
+    searchParams: Promise<SearchParamsDataTable>;
+}) => Promise<import("react/jsx-runtime").JSX.Element>;
+//# sourceMappingURL=cron-table-view.d.ts.map

package/dist/src/views/admin/views/core/advanced/cron/cron-table-view.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cron-table-view.d.ts","sourceRoot":"","sources":["../../../../../../../../src/views/admin/views/core/advanced/cron/cron-table-view.tsx"],"names":[],"mappings":"AAGA,OAAO,EAEL,KAAK,qBAAqB,EAC3B,MAAM,+BAA+B,CAAC;AAIvC,eAAO,MAAM,aAAa,GAAU,mBAEjC;IACD,YAAY,EAAE,OAAO,CAAC,qBAAqB,CAAC,CAAC;CAC9C,qDA8EA,CAAC"}

package/dist/src/views/admin/views/core/advanced/cron/cron-table-view.js

@@ -0,0 +1,97 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { getTranslations } from "next-intl/server";
+import { cronAdminModule } from "../../../../../../api/modules/admin/advanced/cron/cron.admin.module.js";
+import { DateFormat } from "../../../../../../components/date-format.js";
+import { DataTable } from "../../../../../../components/table/data-table.js";
+import { fetcher } from "../../../../../../lib/fetcher.js";
+import { RunActionCronTable } from "./run-action/run-action.js";
+export const CronTableView = async ({ searchParams })=>{
+    const query = await searchParams;
+    const res = await fetcher(cronAdminModule, {
+        path: "/",
+        method: "get",
+        module: "cron",
+        prefixPath: "/admin/advanced",
+        args: {
+            query
+        },
+        withPagination: true
+    });
+    const [data, t] = await Promise.all([
+        res.json(),
+        getTranslations("admin.advanced.cron")
+    ]);
+    return /*#__PURE__*/ _jsx(DataTable, {
+        columns: [
+            {
+                id: "name",
+                label: t("list.name"),
+                cell: ({ row })=>/*#__PURE__*/ _jsxs("div", {
+                        className: "flex flex-col max-w-sm",
+                        children: [
+                            /*#__PURE__*/ _jsx("span", {
+                                children: row.name
+                            }),
+                            /*#__PURE__*/ _jsx("p", {
+                                className: "text-sm text-muted-foreground",
+                                children: row.description
+                            })
+                        ]
+                    })
+            },
+            {
+                id: "pluginId",
+                label: t("list.pluginId")
+            },
+            {
+                id: "module",
+                label: t("list.module")
+            },
+            {
+                id: "schedule",
+                label: t("list.schedule")
+            },
+            {
+                id: "lastRun",
+                label: t("list.lastRun.title"),
+                cell: ({ row })=>row.lastRun ? /*#__PURE__*/ _jsx(DateFormat, {
+                        date: row.lastRun
+                    }) : /*#__PURE__*/ _jsx("span", {
+                        className: "italic text-muted-foreground",
+                        children: t("list.lastRun.never")
+                    })
+            },
+            {
+                id: "nextRun",
+                label: t("list.nextRun.title"),
+                cell: ({ row })=>row.nextRun ? /*#__PURE__*/ _jsx(DateFormat, {
+                        date: row.nextRun,
+                        showFullDate: true
+                    }) : /*#__PURE__*/ _jsx("span", {
+                        className: "italic text-muted-foreground",
+                        children: t("list.nextRun.never")
+                    })
+            },
+            {
+                id: "actions",
+                label: "",
+                cell: ({ row })=>/*#__PURE__*/ _jsx(RunActionCronTable, {
+                        id: row.id
+                    })
+            }
+        ],
+        edges: data.edges,
+        order: {
+            columns: [
+                "lastRun",
+                "createdAt",
+                "nextRun"
+            ],
+            defaultOrder: {
+                column: "lastRun",
+                order: "desc"
+            }
+        },
+        pageInfo: data.pageInfo
+    });
+};

package/dist/src/views/admin/views/core/advanced/cron/run-action/mutation-api.d.ts

@@ -0,0 +1,4 @@
+export declare const mutationApi: (id: number) => Promise<{
+    error: string;
+} | undefined>;
+//# sourceMappingURL=mutation-api.d.ts.map

package/dist/src/views/admin/views/core/advanced/cron/run-action/mutation-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mutation-api.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/views/admin/views/core/advanced/cron/run-action/mutation-api.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,WAAW,GAAU,IAAI,MAAM;;cAkB3C,CAAC"}