support zero, improve tests, add server-change

Author: carderne

apps/webapp/app/presenters/v3/ViewSchedulePresenter.server.ts

@@ -13,6 +13,7 @@ type ViewScheduleOptions = {
   projectId: string;
   friendlyId: string;
   environmentId: string;
+  includeRunHistory?: boolean;
 };
 
 export class ViewSchedulePresenter {
@@ -22,7 +23,13 @@ export class ViewSchedulePresenter {
     this.#prismaClient = prismaClient;
   }
 
-  public async call({ userId, projectId, friendlyId, environmentId }: ViewScheduleOptions) {
+  public async call({
+    userId,
+    projectId,
+    friendlyId,
+    environmentId,
+    includeRunHistory = true,
+  }: ViewScheduleOptions) {
     const schedule = await this.#prismaClient.taskSchedule.findFirst({
       select: {
         id: true,
@@ -79,17 +86,14 @@ export class ViewSchedulePresenter {
       ? nextScheduledTimestamps(schedule.generatorExpression, schedule.timezone, new Date(), 5)
       : [];
 
-    const clickhouse = await clickhouseFactory.getClickhouseForOrganization(
-      schedule.project.organizationId,
-      "standard"
-    );
-    const runPresenter = new NextRunListPresenter(this.#prismaClient, clickhouse);
-    const { runs } = await runPresenter.call(schedule.project.organizationId, environmentId, {
-      projectId: schedule.project.id,
-      scheduleId: schedule.id,
-      pageSize: 5,
-      period: "31d",
-    });
+    const runs = includeRunHistory
+      ? await this.#getRunHistory({
+          organizationId: schedule.project.organizationId,
+          environmentId,
+          projectId: schedule.project.id,
+          scheduleId: schedule.id,
+        })
+      : [];
 
     return {
       schedule: {
@@ -110,6 +114,32 @@ export class ViewSchedulePresenter {
     };
   }
 
+  async #getRunHistory({
+    organizationId,
+    environmentId,
+    projectId,
+    scheduleId,
+  }: {
+    organizationId: string;
+    environmentId: string;
+    projectId: string;
+    scheduleId: string;
+  }) {
+    const clickhouse = await clickhouseFactory.getClickhouseForOrganization(
+      organizationId,
+      "standard"
+    );
+    const runPresenter = new NextRunListPresenter(this.#prismaClient, clickhouse);
+    const { runs } = await runPresenter.call(organizationId, environmentId, {
+      projectId,
+      scheduleId,
+      pageSize: 5,
+      period: "31d",
+    });
+
+    return runs;
+  }
+
   public toJSONResponse(result: NonNullable<Awaited<ReturnType<ViewSchedulePresenter["call"]>>>) {
     const response: ScheduleObject = {
       id: result.schedule.friendlyId,

apps/webapp/app/routes/api.v1.schedules.$scheduleId.activate.ts

@@ -64,6 +64,7 @@ export async function action({ request, params }: ActionFunctionArgs) {
       projectId: authenticationResult.environment.projectId,
       friendlyId: parsedParams.data.scheduleId,
       environmentId: authenticationResult.environment.id,
+      includeRunHistory: false,
     });
 
     if (!result) {

apps/webapp/app/routes/api.v1.schedules.$scheduleId.deactivate.ts

@@ -64,6 +64,7 @@ export async function action({ request, params }: ActionFunctionArgs) {
       projectId: authenticationResult.environment.projectId,
       friendlyId: parsedParams.data.scheduleId,
       environmentId: authenticationResult.environment.id,
+      includeRunHistory: false,
     });
 
     if (!result) {

apps/webapp/app/routes/api.v1.schedules.$scheduleId.ts

@@ -178,6 +178,7 @@ export async function loader({ request, params }: LoaderFunctionArgs) {
     projectId: authenticationResult.environment.projectId,
     friendlyId: parsedParams.data.scheduleId,
     environmentId: authenticationResult.environment.id,
+    includeRunHistory: false,
   });
 
   if (!result) {

apps/webapp/app/v3/scheduleWindow.server.ts

@@ -54,6 +54,10 @@ export function formatScheduleWindow({
     return undefined;
   }
 
+  if (windowDurationSeconds === 0) {
+    return "0m";
+  }
+
   if (windowDurationSeconds % SECONDS_PER_UNIT.d === 0) {
     return `${windowDurationSeconds / SECONDS_PER_UNIT.d}d`;
   }

apps/webapp/test/scheduleWindow.test.ts

@@ -11,6 +11,10 @@ describe("schedule window persistence", () => {
       windowDurationSeconds: 1_800,
       windowPercentage: null,
     });
+    expect(normalizeScheduleWindow("0m")).toEqual({
+      windowDurationSeconds: 0,
+      windowPercentage: null,
+    });
     expect(normalizeScheduleWindow("30%")).toEqual({
       windowDurationSeconds: null,
       windowPercentage: 30,
@@ -22,6 +26,12 @@ describe("schedule window persistence", () => {
   });
 
   it("formats stored windows canonically", () => {
+    expect(
+      formatScheduleWindow({
+        windowDurationSeconds: 0,
+        windowPercentage: null,
+      })
+    ).toBe("0m");
     expect(
       formatScheduleWindow({
         windowDurationSeconds: 86_400,

internal-packages/run-engine/src/run-queue/tests/enqueueMessage.test.ts

@@ -179,58 +179,52 @@ describe("RunQueue.enqueueMessage fast path", () => {
     }
   );
 
-  redisTest(
-    "should not fast-path a future-scored message",
-    async ({ redisContainer }) => {
-      const queue = createQueue(redisContainer, "runqueue:fp-future-score:");
+  redisTest("should not fast-path a future-scored message", async ({ redisContainer }) => {
+    const queue = createQueue(redisContainer, "runqueue:fp-future-score:");
 
-      try {
-        await queue.updateEnvConcurrencyLimits(authenticatedEnvDev);
+    try {
+      await queue.updateEnvConcurrencyLimits(authenticatedEnvDev);
 
-        const futureMessage: InputPayload = {
-          ...messageDev,
-          runId: "r_future_score",
-          timestamp: Date.now() + 60_000,
-        };
+      const futureMessage: InputPayload = {
+        ...messageDev,
+        runId: "r_future_score",
+        timestamp: Date.now() + 60_000,
+      };
 
-        await queue.enqueueMessage({
-          env: authenticatedEnvDev,
-          message: futureMessage,
-          workerQueue: authenticatedEnvDev.id,
-          enableFastPath: true,
-        });
+      await queue.enqueueMessage({
+        env: authenticatedEnvDev,
+        message: futureMessage,
+        workerQueue: authenticatedEnvDev.id,
+        enableFastPath: true,
+      });
 
-        const queueLength = await queue.lengthOfQueue(
-          authenticatedEnvDev,
-          futureMessage.queue
-        );
-        const queueConcurrency = await queue.currentConcurrencyOfQueue(
-          authenticatedEnvDev,
-          futureMessage.queue
-        );
-        const dequeued = await queue.dequeueMessageFromWorkerQueue(
-          "test_12345",
-          authenticatedEnvDev.id,
-          { blockingPop: false }
-        );
+      const queueLength = await queue.lengthOfQueue(authenticatedEnvDev, futureMessage.queue);
+      const queueConcurrency = await queue.currentConcurrencyOfQueue(
+        authenticatedEnvDev,
+        futureMessage.queue
+      );
+      const dequeued = await queue.dequeueMessageFromWorkerQueue(
+        "test_12345",
+        authenticatedEnvDev.id,
+        { blockingPop: false }
+      );
 
-        expect({
-          // A future-scored message must remain in the sorted set until it is eligible.
-          queueLength,
-          // It must not claim concurrency before it becomes eligible.
-          queueConcurrency,
-          // It must not be visible to a worker before its timestamp.
-          dequeuedMessageId: dequeued?.messageId,
-        }).toEqual({
-          queueLength: 1,
-          queueConcurrency: 0,
-          dequeuedMessageId: undefined,
-        });
-      } finally {
-        await queue.quit();
-      }
+      expect({
+        // A future-scored message must remain in the sorted set until it is eligible.
+        queueLength,
+        // It must not claim concurrency before it becomes eligible.
+        queueConcurrency,
+        // It must not be visible to a worker before its timestamp.
+        dequeuedMessageId: dequeued?.messageId,
+      }).toEqual({
+        queueLength: 1,
+        queueConcurrency: 0,
+        dequeuedMessageId: undefined,
+      });
+    } finally {
+      await queue.quit();
     }
-  );
+  });
 
   redisTest("should take slow path when enableFastPath is false", async ({ redisContainer }) => {
     const queue = createQueue(redisContainer, "runqueue:fp2:");

internal-packages/schedule-engine/src/engine/scheduleTiming.test.ts

@@ -15,6 +15,9 @@ describe("parseScheduleWindow", () => {
     ["30m", { type: "duration", durationSeconds: 1_800 }],
     ["2h", { type: "duration", durationSeconds: 7_200 }],
     ["1d", { type: "duration", durationSeconds: 86_400 }],
+    ["0m", { type: "duration", durationSeconds: 0 }],
+    ["0h", { type: "duration", durationSeconds: 0 }],
+    ["0d", { type: "duration", durationSeconds: 0 }],
     ["0%", { type: "percentage", percentage: 0 }],
     ["12%", { type: "percentage", percentage: 12 }],
     ["100%", { type: "percentage", percentage: 100 }],
@@ -24,7 +27,7 @@ describe("parseScheduleWindow", () => {
 
   it.each([
     "",
-    "0m",
+    "00m",
     "01m",
     "1.5h",
     "30s",
@@ -51,6 +54,10 @@ describe("schedule window validation", () => {
     expect(() => validateScheduleWindow({ type: "percentage", percentage })).not.toThrow();
   });
 
+  it("allows a zero-duration window", () => {
+    expect(() => validateScheduleWindow({ type: "duration", durationSeconds: 0 })).not.toThrow();
+  });
+
   it("allows an absolute window equal to the nominal interval", () => {
     expect(() =>
       validateScheduleWindowForInterval({ type: "duration", durationSeconds: 300 }, 5 * 60_000)
@@ -64,7 +71,7 @@ describe("schedule window validation", () => {
   });
 
   it.each([
-    { type: "duration", durationSeconds: 0 },
+    { type: "duration", durationSeconds: -1 },
     { type: "duration", durationSeconds: 1.5 },
     { type: "percentage", percentage: -100 },
     { type: "percentage", percentage: 101 },

internal-packages/schedule-engine/src/engine/scheduleTiming.ts

@@ -31,11 +31,11 @@ export type EffectiveScheduleTime = {
 /**
  * Parses the public schedule-window syntax.
  *
- * Durations are positive whole minutes, hours, or days. Percentages are whole
- * numbers from 0% through 100%.
+ * Durations are non-negative whole minutes, hours, or days. Percentages are
+ * whole numbers from 0% through 100%.
  */
 export function parseScheduleWindow(value: string): NormalizedScheduleWindow {
-  const durationMatch = /^([1-9]\d*)([mhd])$/.exec(value);
+  const durationMatch = /^(0|[1-9]\d*)([mhd])$/.exec(value);
 
   if (durationMatch) {
     const amount = Number(durationMatch[1]);
@@ -57,18 +57,20 @@ export function parseScheduleWindow(value: string): NormalizedScheduleWindow {
   }
 
   throw new TypeError(
-    'Schedule window must be a positive duration such as "30m", "2h", or "1d", or a percentage such as "30%"'
+    'Schedule window must be a whole duration such as "30m", "2h", or "1d", or a percentage such as "30%"'
   );
 }
 
 export function validateScheduleWindow(window: NormalizedScheduleWindow): void {
   if (window.type === "duration") {
     if (
       !Number.isSafeInteger(window.durationSeconds) ||
-      window.durationSeconds <= 0 ||
+      window.durationSeconds < 0 ||
       window.durationSeconds > MAX_POSTGRES_INT
     ) {
-      throw new RangeError("Schedule window duration must be a positive integer number of seconds");
+      throw new RangeError(
+        "Schedule window duration must be a non-negative integer number of seconds"
+      );
     }
 
     return;