Update system UDFs to account for _cron_next_run table (#36386)

We migrated the backend tables but didn't update the system UDFs or dashboard UI that reads from them.

GitOrigin-RevId: cb1287e72823d9e2e8d667088d2c88f7c208fcfe

Author: sshader

npm-packages/dashboard-common/src/features/schedules/components/crons/CronJobsContent.tsx

@@ -13,8 +13,8 @@ import Link from "next/link";
 import { useRouter } from "next/router";
 import React, { useEffect, useRef, useState } from "react";
 import {
-  CronJob,
   CronJobLog,
+  CronJobWithRuns,
 } from "system-udfs/convex/_system/frontend/common";
 import { FileModal } from "@common/features/schedules/components/crons/FileModal";
 import { CronsTable } from "@common/features/schedules/components/crons/CronsTable";
@@ -92,15 +92,15 @@ function Details({
   cronJob,
   cronJobRuns,
 }: {
-  cronJob: CronJob;
+  cronJob: CronJobWithRuns;
   cronJobRuns: CronJobLog[];
 }) {
   const router = useRouter();
   const back = () => {
     delete router.query.id;
     void router.push({ query: router.query });
   };
-  const currentlyRunning = cronJob.state.type === "inProgress";
+  const currentlyRunning = cronJob.nextRun?.state.type === "inProgress";
 
   return (
     <div className="flex h-full w-full max-w-6xl flex-col gap-4">
@@ -193,13 +193,19 @@ function CronJobLogListItem({ cronJobLog }: { cronJobLog: CronJobLog }) {
 /**
  * The next scheduled execution, or the currently running execution.
  */
-export function TopCronJobLogListItem({ cronJob }: { cronJob: CronJob }) {
+export function TopCronJobLogListItem({
+  cronJob,
+}: {
+  cronJob: CronJobWithRuns;
+}) {
   const url = useFunctionUrl(cronJob.cronSpec.udfPath);
 
-  const timestamp = formatDateTime(
-    new Date(Number(cronJob.nextTs / BigInt(1000000))),
-  );
-  const currentlyRunning = cronJob.state.type === "inProgress";
+  const { nextRun } = cronJob;
+  const nextTs = nextRun?.nextTs;
+  const timestamp = nextTs
+    ? formatDateTime(new Date(Number(nextTs / BigInt(1000000))))
+    : null;
+  const currentlyRunning = nextRun?.state.type === "inProgress";
 
   // Make a quickly-updating timer to make function execution feel fast.
   // To avoid a React render every frame (often fine but can gum things up),
@@ -210,7 +216,7 @@ export function TopCronJobLogListItem({ cronJob }: { cronJob: CronJob }) {
       let handle = 0;
       const update = () => {
         if (estRuntimeRef.current) {
-          const start = new Date(Number(cronJob.nextTs) / 1000000);
+          const start = new Date(Number(nextTs) / 1000000);
           const s = msFormat(Date.now() - +start);
           estRuntimeRef.current.textContent = s;
           requestAnimationFrame(update);
@@ -219,7 +225,7 @@ export function TopCronJobLogListItem({ cronJob }: { cronJob: CronJob }) {
       handle = requestAnimationFrame(update);
       return () => cancelAnimationFrame(handle);
     }
-  }, [currentlyRunning, cronJob.nextTs]);
+  }, [currentlyRunning, nextTs]);
 
   const textColor = currentlyRunning
     ? "text-content-primary"
@@ -228,7 +234,9 @@ export function TopCronJobLogListItem({ cronJob }: { cronJob: CronJob }) {
     <div className="flex items-start gap-4 font-mono text-xs">
       <div className="flex flex-col gap-2">
         <div className="flex h-6 items-center gap-4">
-          <div className={`${textColor} whitespace-nowrap`}>{timestamp}</div>
+          <div className={`${textColor} whitespace-nowrap`}>
+            {timestamp ?? "unknown"}
+          </div>
           <div
             className={`${textColor} w-14 whitespace-nowrap text-right text-content-secondary`}
           >

npm-packages/dashboard-common/src/features/schedules/components/crons/CronsTable.tsx

@@ -8,7 +8,7 @@ import { ChevronRightIcon, ExternalLinkIcon } from "@radix-ui/react-icons";
 import {
   CronSchedule,
   CronJobLog,
-  CronJobWithLastRun,
+  CronJobWithRuns,
 } from "system-udfs/convex/_system/frontend/common";
 import { useWasmCron } from "@common/features/schedules/lib/useWasmCron";
 import {
@@ -26,6 +26,7 @@ import { Button } from "@common/elements/Button";
 import { DetailPanel } from "@common/elements/DetailPanel";
 import { ReadonlyCode } from "@common/elements/ReadonlyCode";
 import { Sheet } from "@common/elements/Sheet";
+import { Doc } from "system-udfs/convex/_generated/dataModel";
 
 const COLUMN_STYLES = [
   { fontWeight: "500", flex: "2 0 80px", fontSize: "0.875rem" },
@@ -46,7 +47,10 @@ function Name({ value }: CellProps<CronDatum, string>) {
 
 function Schedule({
   value: { schedule },
-}: CellProps<CronDatum, { schedule: CronSchedule; nextDate: Date }>) {
+}: CellProps<
+  CronDatum,
+  { schedule: CronSchedule; nextDate: Date | undefined }
+>) {
   const literal = scheduleLiteral(schedule);
 
   let formattedSchedule = "";
@@ -129,17 +133,17 @@ function PrevNextTs({
 }: CellProps<
   CronDatum,
   {
-    nextDate: Date;
+    nextDate: Date | undefined;
     prevDate: Date;
     prevRun: CronJobLog | undefined;
-    state: CronJobWithLastRun["state"];
+    nextRun: Doc<"_cron_next_run"> | undefined;
   }
 >) {
-  const isRunning = value.state.type === "inProgress";
+  const isRunning = value.nextRun?.state.type === "inProgress";
   return (
     <div className="flex flex-col truncate">
       <PrevTs date={value.prevDate} isRunning={isRunning} run={value.prevRun} />
-      <NextTs value={value.nextDate} />
+      {value.nextDate && <NextTs value={value.nextDate} />}
     </div>
   );
 }
@@ -202,18 +206,20 @@ function Args({ value }: CellProps<CronDatum, JSONValue[]>) {
   );
 }
 
-function cronDatum(cronJob: CronJobWithLastRun) {
-  const { name, cronSpec, nextTs, prevTs, lastRun, state } = cronJob;
-  const nextDate = new Date(Number(nextTs / BigInt("1000000")));
-  const prevDate = prevTs && new Date(Number(prevTs / BigInt("1000000")));
+function cronDatum(cronJob: CronJobWithRuns) {
+  const { name, cronSpec, lastRun, nextRun } = cronJob;
+  const nextDate = nextRun
+    ? new Date(Number(nextRun.nextTs / BigInt("1000000")))
+    : undefined;
+  const prevDate = lastRun && new Date(Number(lastRun.ts / BigInt("1000000")));
   return {
     name,
     schedule: { schedule: cronSpec.cronSchedule, nextDate },
     prevNextTs: {
       prevDate,
       nextDate,
       prevRun: lastRun,
-      state,
+      state: nextRun?.state,
     },
     udfPath: cronSpec.udfPath,
     udfArgs:
@@ -225,7 +231,7 @@ function cronDatum(cronJob: CronJobWithLastRun) {
 }
 type CronDatum = ReturnType<typeof cronDatum>;
 
-export function CronsTable({ cronJobs }: { cronJobs: CronJobWithLastRun[] }) {
+export function CronsTable({ cronJobs }: { cronJobs: CronJobWithRuns[] }) {
   const columns = useMemo(
     () =>
       [

npm-packages/dashboard-common/src/features/schedules/lib/CronsProvider.tsx

@@ -4,7 +4,7 @@ import udfs from "@common/udfs";
 import {
   CronSpec,
   Module,
-  CronJobWithLastRun,
+  CronJobWithRuns,
   CronJobLog,
 } from "system-udfs/convex/_system/frontend/common";
 import { useInMemoryDocumentCache } from "@common/features/schedules/lib/useInMemoryDocumentCache";
@@ -15,7 +15,7 @@ import { DeploymentInfoContext } from "@common/lib/deploymentContext";
 
 type CronJobsContextType = {
   cronsModule: Module | undefined;
-  cronJobs: CronJobWithLastRun[] | undefined;
+  cronJobs: CronJobWithRuns[] | undefined;
   loading: boolean;
   cronJobRuns: CronJobLog[] | undefined;
 };
@@ -34,7 +34,7 @@ export function CronJobsProviderWithCronHistory({
   // Get functions
   const modules = useListModules();
   // Get cron jobs
-  const cronJobs: CronJobWithLastRun[] | undefined = useQuery(
+  const cronJobs: CronJobWithRuns[] | undefined = useQuery(
     udfs.listCronJobs.default,
     { componentId: useNents().selectedNent?.id || null },
   );
@@ -48,7 +48,7 @@ export function CronJobsProviderWithCronHistory({
 
   // This might be a new typed (source mapped cron jobs) in the future.
   const [orderedCronJobs, cronsModule]: [
-    CronJobWithLastRun[] | undefined,
+    CronJobWithRuns[] | undefined,
     Module | undefined,
   ] = useMemo(() => {
     if (!cronJobs || !modules || !cronJobRuns) return [undefined, undefined];
@@ -74,7 +74,7 @@ export function CronJobsProviderWithCronHistory({
     }
     if (!cronSpecs) return [undefined, cronsModuleInner];
 
-    const cronJobsMap = new Map<string, CronJobWithLastRun>();
+    const cronJobsMap = new Map<string, CronJobWithRuns>();
     for (const cronJob of cronJobs) {
       cronJobsMap.set(cronJob.name, cronJob);
     }

npm-packages/dashboard/src/generatedApi.ts

@@ -1632,7 +1632,7 @@ export interface components {
             warningThresholdCents?: number | null;
         };
         GetTokenInfoResponse: {
-            isDisabled: boolean;
+            isTeamDisabled: boolean;
             /** Format: int64 */
             tokensQuota: number;
             /** Format: int64 */

npm-packages/system-udfs/convex/_system/frontend/common.ts

@@ -96,9 +96,10 @@ export type CronJob = Doc<"_cron_jobs">;
 export type CronSpec = Doc<"_cron_jobs">["cronSpec"];
 export type CronSchedule = Doc<"_cron_jobs">["cronSpec"]["cronSchedule"];
 export type CronJobLog = Doc<"_cron_job_logs">;
-export type CronJobWithLastRun = Doc<"_cron_jobs"> & {
+export type CronJobWithRuns = Doc<"_cron_jobs"> & {
   // only undefined while feature-flagged (but still might be null)
   lastRun: CronJobLog | null | undefined;
+  nextRun: Doc<"_cron_next_run"> | null | undefined;
 };
 
 export type Modules = Map<string, Module>;

npm-packages/system-udfs/convex/_system/frontend/listCronJobs.ts

@@ -1,24 +1,29 @@
-import { CronJob, CronJobWithLastRun } from "./common";
+import { CronJob, CronJobWithRuns } from "./common";
 import { queryPrivateSystem } from "../secretSystemTables";
 import { v } from "convex/values";
 export default queryPrivateSystem({
   args: { componentId: v.optional(v.union(v.string(), v.null())) },
-  handler: async ({ db }): Promise<CronJobWithLastRun[]> => {
+  handler: async ({ db }): Promise<CronJobWithRuns[]> => {
     const jobs: CronJob[] = await db.query("_cron_jobs").collect();
-    const jobsWithLastRun: CronJobWithLastRun[] = [];
+    const jobsWithRuns: CronJobWithRuns[] = [];
 
     for (const job of jobs) {
       const lastRun = await db
         .query("_cron_job_logs")
         .withIndex("by_name_and_ts", (q) => q.eq("name", job.name))
         .order("desc")
         .first();
-      jobsWithLastRun.push({
+      const nextRun = await db
+        .query("_cron_next_run")
+        .withIndex("by_cron_job_id", (q) => q.eq("cronJobId", job._id))
+        .first();
+      jobsWithRuns.push({
         ...job,
-        lastRun: lastRun || null,
+        lastRun: lastRun,
+        nextRun: nextRun,
       });
     }
 
-    return jobsWithLastRun;
+    return jobsWithRuns;
   },
 });

npm-packages/system-udfs/convex/schema.ts

@@ -241,6 +241,11 @@ const backendStateTable = defineTable({
   state: deploymentState,
 });
 
+export const cronJobState = v.union(
+  v.object({ type: v.literal("pending") }),
+  v.object({ type: v.literal("inProgress") }),
+);
+
 export default defineSchema({
   _tables: defineTable({
     name: v.string(),
@@ -319,15 +324,15 @@ export default defineSchema({
   _cron_jobs: defineTable({
     name: v.string(),
     cronSpec: analyzedCronSpec,
-    state: v.union(
-      v.object({ type: v.literal("pending") }),
-      v.object({ type: v.literal("inProgress") }),
-    ),
-    nextTs: v.int64(),
+  }).index("by_name", ["name"]),
+  _cron_next_run: defineTable({
+    cronJobId: v.id("_cron_jobs"),
+    state: cronJobState,
     prevTs: v.union(v.int64(), v.null()),
+    nextTs: v.int64(),
   })
-    .index("by_next_ts", ["nextTs"])
-    .index("by_name", ["name"]),
+    .index("by_cron_job_id", ["cronJobId"])
+    .index("by_next_ts", ["nextTs"]),
   _cron_job_logs: defineTable({
     name: v.string(),
     ts: v.int64(),