from and to can be Date or timestamps

Author: matt-aitken

packages/trigger-sdk/src/v3/query.ts

@@ -33,16 +33,16 @@ export type QueryOptions = {
   period?: string;
 
   /**
-   * Start of time range (ISO 8601 timestamp)
-   * Must be used with `to`
+   * Start of time range as a Date object or Unix timestamp in milliseconds.
+   * Must be used with `to`.
    */
-  from?: string;
+  from?: Date | number;
 
   /**
-   * End of time range (ISO 8601 timestamp)
-   * Must be used with `from`
+   * End of time range as a Date object or Unix timestamp in milliseconds.
+   * Must be used with `from`.
    */
-  to?: string;
+  to?: Date | number;
 
   /**
    * Response format
@@ -130,6 +130,9 @@ function execute<TRow extends Record<string, any> = Record<string, any>>(
 ): Promise<{ format: "json"; results: Array<TRow> } | { format: "csv"; results: string }> {
   const apiClient = apiClientManager.clientOrThrow();
 
+  const from = dateToISOString(options?.from);
+  const to = dateToISOString(options?.to);
+
   const $requestOptions = mergeRequestOptions(
     {
       tracer,
@@ -140,16 +143,40 @@ function execute<TRow extends Record<string, any> = Record<string, any>>(
         format: options?.format ?? "json",
         query,
         period: options?.period,
-        from: options?.from,
-        to: options?.to,
+        from,
+        to,
       },
     },
     requestOptions
   );
 
-  return apiClient.executeQuery(query, options, $requestOptions).then((response) => {
-    return response;
-  }) as Promise<{ format: "json"; results: Array<TRow> } | { format: "csv"; results: string }>;
+  return apiClient
+    .executeQuery(
+      query,
+      {
+        scope: options?.scope,
+        period: options?.period,
+        from,
+        to,
+        format: options?.format,
+      },
+      $requestOptions
+    )
+    .then((response) => {
+      return response;
+    }) as Promise<{ format: "json"; results: Array<TRow> } | { format: "csv"; results: string }>;
+}
+
+function dateToISOString(date: Date | number | undefined): string | undefined {
+  if (date === undefined) {
+    return undefined;
+  }
+
+  if (date instanceof Date) {
+    return date.toISOString();
+  }
+
+  return new Date(date).toISOString();
 }
 
 export const query = {

references/hello-world/src/trigger/query.ts

@@ -1,44 +1,62 @@
 import { logger, query, task } from "@trigger.dev/sdk";
 import type { QueryTable } from "@trigger.dev/sdk";
 
-// Simple query example - just the query string, all defaults
+// Simple query example - tests different from/to formats
 export const simpleQueryTask = task({
   id: "simple-query",
   run: async () => {
     logger.info("Running simple query example");
 
-    // Simplest usage - uses environment scope, json format, default period
-    const result = await query.execute("SELECT * FROM runs LIMIT 10");
-
-    logger.info("Query results (untyped)", {
-      format: result.format,
-      rowCount: result.results.length,
-      firstRow: result.results[0],
+    // 1. Default: no from/to, uses default period
+    const defaultResult = await query.execute("SELECT * FROM runs LIMIT 5");
+    logger.info("Default (no from/to)", {
+      rowCount: defaultResult.results.length,
+      firstRow: defaultResult.results[0],
     });
 
-    // Type-safe query using QueryTable with specific columns
-    const typedResult = await query.execute<
-      QueryTable<"runs", "run_id" | "status" | "triggered_at" | "total_duration">
-    >("SELECT run_id, status, triggered_at, total_duration FROM runs LIMIT 10");
+    // 2. Using Date objects for from/to
+    const withDates = await query.execute<
+      QueryTable<"runs", "run_id" | "status" | "triggered_at">
+    >("SELECT run_id, status, triggered_at FROM runs LIMIT 5", {
+      from: new Date("2025-01-01T00:00:00Z"),
+      to: new Date(),
+    });
+    logger.info("With Date objects", {
+      rowCount: withDates.results.length,
+      firstRow: withDates.results[0],
+    });
 
-    logger.info("Query results (typed)", {
-      format: typedResult.format,
-      rowCount: typedResult.results.length,
-      firstRow: typedResult.results[0],
+    // 3. Using Unix timestamps in milliseconds (Date.now() returns ms)
+    const now = Date.now();
+    const sevenDaysAgo = now - 7 * 24 * 60 * 60 * 1000;
+    const withTimestamps = await query.execute<
+      QueryTable<"runs", "run_id" | "status" | "triggered_at">
+    >("SELECT run_id, status, triggered_at FROM runs LIMIT 5", {
+      from: sevenDaysAgo,
+      to: now,
+    });
+    logger.info("With Unix timestamps (ms)", {
+      rowCount: withTimestamps.results.length,
+      firstRow: withTimestamps.results[0],
     });
 
-    // Full type safety on the rows - status is narrowly typed!
-    typedResult.results.forEach((row, index) => {
-      logger.info(`Run ${index + 1}`, {
-        run_id: row.run_id, // string
-        status: row.status, // RunFriendlyStatus ("Completed" | "Failed" | ...)
-        total_duration: row.total_duration, // number | null
-      });
+    // 4. Mixing Date and number
+    const mixed = await query.execute<
+      QueryTable<"runs", "run_id" | "status" | "triggered_at">
+    >("SELECT run_id, status, triggered_at FROM runs LIMIT 5", {
+      from: new Date("2025-01-01"),
+      to: Date.now(),
+    });
+    logger.info("Mixed Date + timestamp", {
+      rowCount: mixed.results.length,
+      firstRow: mixed.results[0],
     });
 
     return {
-      totalRows: typedResult.results.length,
-      rows: typedResult.results,
+      defaultRows: defaultResult.results.length,
+      dateRows: withDates.results.length,
+      timestampRows: withTimestamps.results.length,
+      mixedRows: mixed.results.length,
     };
   },
 });
@@ -136,8 +154,8 @@ export const orgQueryTask = task({
       LIMIT 50`,
       {
         scope: "organization", // Query across all projects
-        from: "2025-02-01T00:00:00Z", // Custom date range
-        to: "2025-02-11T23:59:59Z",
+        from: new Date("2025-02-01T00:00:00Z"), // Custom date range
+        to: new Date("2025-02-11T23:59:59Z"),
       }
     );