@trigger.dev/convex 0.0.1 → 4.8.3

package/dist/component/worker.d.ts

@@ -0,0 +1,14 @@
+export declare const tick: import("convex/server").RegisteredMutation<"internal", {
+    generation: number;
+    id: import("convex/values").GenericId<"runs">;
+}, Promise<null>>;
+export declare const step: import("convex/server").RegisteredAction<"internal", {
+    generation: number;
+    id: import("convex/values").GenericId<"runs">;
+}, Promise<null>>;
+export declare const recordError: import("convex/server").RegisteredMutation<"internal", {
+    generation: number;
+    id: import("convex/values").GenericId<"runs">;
+    message: string;
+    permanent: boolean;
+}, Promise<null>>;

package/dist/component/worker.js

@@ -0,0 +1,118 @@
+import { v } from "convex/values";
+import { internal } from "./api.js";
+import { internalAction, internalMutation } from "./server.js";
+import { pause, scheduleRefresh } from "./runs.js";
+import { ApiError, inlineValue, request } from "./apiClient.js";
+import { IDEMPOTENCY_TTL, MAX_SYNC_FAILURES, REQUEST_TIMEOUT_MS, SUBMISSION_WINDOW_MS, WATCHDOG_MARGIN_MS, pollDelay, } from "./shared.js";
+const jobArgs = { id: v.id("runs"), generation: v.number() };
+export const tick = internalMutation({
+    args: jobArgs,
+    returns: v.null(),
+    handler: async (ctx, { id, generation }) => {
+        const run = await ctx.db.get("runs", id);
+        if (!run ||
+            run.generation !== generation ||
+            run.syncStatus === "complete" ||
+            run.syncStatus === "paused")
+            return null;
+        if (!run.runId && Date.now() - run._creationTime >= SUBMISSION_WINDOW_MS) {
+            await pause(ctx, run, "Submission retry window expired; check Trigger before triggering again");
+            return null;
+        }
+        const nextGeneration = generation + 1;
+        await ctx.db.patch("runs", id, {
+            generation: nextGeneration,
+            checks: run.checks + 1,
+            checking: true,
+            refreshRequested: undefined,
+            lastCheckAt: run.runId ? Date.now() : run.lastCheckAt,
+        });
+        // Schedule the watchdog transactionally before starting an action that can be interrupted.
+        await ctx.scheduler.runAfter(Math.max(pollDelay(run.checks), REQUEST_TIMEOUT_MS + WATCHDOG_MARGIN_MS), internal.worker.tick, { id, generation: nextGeneration });
+        await ctx.scheduler.runAfter(0, internal.worker.step, { id, generation: nextGeneration });
+        return null;
+    },
+});
+export const step = internalAction({
+    args: jobArgs,
+    returns: v.null(),
+    handler: async (ctx, { id, generation }) => {
+        const loaded = await ctx.runQuery(internal.runs.load, { id });
+        if (!loaded ||
+            loaded.run.generation !== generation ||
+            loaded.run.syncStatus === "complete" ||
+            loaded.run.syncStatus === "paused")
+            return null;
+        const { run, request: saved } = loaded;
+        try {
+            if (!run.runId) {
+                const result = await request(saved.config, `/api/v1/tasks/${encodeURIComponent(run.taskId)}/trigger`, {
+                    payload: saved.payload,
+                    options: {
+                        ...saved.options,
+                        idempotencyKey: `convex:${id}`,
+                        idempotencyKeyTTL: IDEMPOTENCY_TTL,
+                    },
+                });
+                if (typeof result.id !== "string")
+                    throw new ApiError("Missing run ID in Trigger.dev response", true);
+                await ctx.runMutation(internal.runs.recordSubmission, { id, generation, runId: result.id });
+            }
+            else {
+                const result = await request(saved.config, `/api/v3/runs/${encodeURIComponent(run.runId)}`);
+                if (typeof result.status !== "string" || typeof result.isCompleted !== "boolean") {
+                    throw new ApiError("Missing run status in Trigger.dev response", true);
+                }
+                const output = inlineValue(result.output);
+                await ctx.runMutation(internal.runs.recordStatus, {
+                    id,
+                    generation,
+                    status: result.status,
+                    completed: result.isCompleted || result.status === "EXPIRED" || result.status === "TIMED_OUT",
+                    output: output.value,
+                    outputOmitted: output.omitted,
+                    outputPresignedUrl: typeof result.outputPresignedUrl === "string" ? result.outputPresignedUrl : undefined,
+                    error: inlineValue(result.error).value,
+                    metadata: inlineValue(result.metadata).value,
+                });
+            }
+        }
+        catch (error) {
+            await ctx.runMutation(internal.worker.recordError, {
+                id,
+                generation,
+                message: error instanceof ApiError
+                    ? error.message
+                    : "Run synchronization failed; inspect Convex function logs",
+                permanent: error instanceof ApiError && !error.retryable,
+            });
+            // Preserve diagnostic detail in server logs without including the request config.
+            console.error("Trigger.dev synchronization failed", {
+                id,
+                error: error instanceof Error ? error.name : "UnknownError",
+            });
+        }
+        return null;
+    },
+});
+export const recordError = internalMutation({
+    args: { ...jobArgs, message: v.string(), permanent: v.boolean() },
+    returns: v.null(),
+    handler: async (ctx, { id, generation, message, permanent }) => {
+        const run = await ctx.db.get("runs", id);
+        if (!run || run.generation !== generation || run.syncStatus === "complete")
+            return null;
+        const failures = run.failures + 1;
+        await ctx.db.patch("runs", id, {
+            failures,
+            syncError: message,
+            checking: undefined,
+            updatedAt: Date.now(),
+        });
+        if (permanent || failures >= MAX_SYNC_FAILURES)
+            await pause(ctx, run, message);
+        else
+            await scheduleRefresh(ctx, run);
+        return null;
+    },
+});

package/package.json

@@ -1,16 +1,49 @@
 {
   "name": "@trigger.dev/convex",
-  "version": "0.0.1",
+  "version": "4.8.3",
   "description": "Run Trigger.dev tasks from Convex mutations and query their results reactively",
   "license": "Apache-2.0",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
   "repository": {
     "type": "git",
     "url": "https://github.com/triggerdotdev/trigger.dev",
     "directory": "packages/convex"
   },
-  "homepage": "https://trigger.dev",
-  "publishConfig": {
-    "access": "public"
+  "files": [
+    "dist",
+    "src/component",
+    "!src/component/**/*.test.ts"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/client/index.d.ts",
+      "default": "./dist/client/index.js"
+    },
+    "./convex.config.js": {
+      "types": "./dist/component/convex.config.d.ts",
+      "default": "./dist/component/convex.config.js"
+    },
+    "./_generated/component.js": {
+      "types": "./dist/component/_generated/component.d.ts"
+    },
+    "./package.json": "./package.json"
+  },
+  "peerDependencies": {
+    "convex": "^1.48.0"
+  },
+  "devDependencies": {
+    "@types/node": "24.13.3",
+    "convex": "^1.48.0",
+    "convex-test": "^0.0.65",
+    "typescript": "7.0.2",
+    "vitest": "4.1.11"
   },
-  "files": ["README.md"]
-}
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.json",
+    "test": "vitest run",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  }
+}

package/src/component/_generated/component.ts

@@ -0,0 +1,18 @@
+import type { ApiFromModules, FilterApi, FunctionReference } from "convex/server";
+import type * as runs from "../runs.js";
+
+type PublicApi = FilterApi<ApiFromModules<{ runs: typeof runs }>, FunctionReference<any, "public">>;
+
+// Derive the component boundary from its functions, so it cannot drift from their validators.
+export type ComponentApi<Name extends string | undefined = string | undefined> = {
+  runs: {
+    [Key in keyof PublicApi["runs"]]: PublicApi["runs"][Key] extends FunctionReference<
+      infer Type,
+      any,
+      infer Args,
+      infer Result
+    >
+      ? FunctionReference<Type, "internal", Args, Result, Name>
+      : never;
+  };
+};

package/src/component/api.ts

@@ -0,0 +1,6 @@
+import { anyApi, type ApiFromModules, type FilterApi, type FunctionReference } from "convex/server";
+import type * as runs from "./runs.js";
+import type * as worker from "./worker.js";
+
+type Api = ApiFromModules<{ runs: typeof runs; worker: typeof worker }>;
+export const internal = anyApi as unknown as FilterApi<Api, FunctionReference<any, "internal">>;

package/src/component/apiClient.ts

@@ -0,0 +1,57 @@
+import { MAX_INLINE_BYTES, REQUEST_TIMEOUT_MS, type Config } from "./shared.js";
+
+export class ApiError extends Error {
+  constructor(
+    message: string,
+    public retryable: boolean
+  ) {
+    super(message);
+  }
+}
+
+export async function request(
+  config: Config,
+  path: string,
+  body?: unknown
+): Promise<Record<string, unknown>> {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+  try {
+    const response = await fetch(config.baseUrl + path, {
+      method: body === undefined ? "GET" : "POST",
+      headers: { Authorization: `Bearer ${config.secretKey}`, "Content-Type": "application/json" },
+      body: body === undefined ? undefined : JSON.stringify(body),
+      signal: controller.signal,
+      redirect: "error",
+    });
+    if (!response.ok) {
+      await response.body?.cancel();
+      const retryHeader = response.headers.get("x-should-retry");
+      // Never persist response bodies, which could contain credentials or payloads.
+      throw new ApiError(
+        `Trigger.dev API returned HTTP ${response.status}`,
+        retryHeader === "true" ||
+          (retryHeader !== "false" &&
+            (response.status === 408 ||
+              response.status === 409 ||
+              response.status === 429 ||
+              response.status >= 500))
+      );
+    }
+    const data: unknown = await response.json();
+    if (!data || typeof data !== "object" || Array.isArray(data)) {
+      throw new ApiError("Invalid Trigger.dev response", true);
+    }
+    return data as Record<string, unknown>;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+export function inlineValue(value: unknown): { value?: any; omitted: boolean } {
+  if (value === undefined) return { omitted: false };
+  if (new TextEncoder().encode(JSON.stringify(value)).byteLength > MAX_INLINE_BYTES) {
+    return { omitted: true };
+  }
+  return { value, omitted: false };
+}

package/src/component/convex.config.ts

@@ -0,0 +1,3 @@
+import { defineComponent } from "convex/server";
+
+export default defineComponent("trigger");