@trigger.dev/sdk 2.0.0-next.1 → 2.0.0-next.2

package/dist/index.js

@@ -64,7 +64,7 @@ __export(src_exports, {
   missingConnectionNotification: () => missingConnectionNotification,
   missingConnectionResolvedNotification: () => missingConnectionResolvedNotification,
   omit: () => omit,
-  secureString: () => secureString
+  redactString: () => redactString
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -104,12 +104,11 @@ var Job = class {
   get integrations() {
     return Object.keys(this.options.integrations ?? {}).reduce((acc, key) => {
       const integration = this.options.integrations[key];
-      if (!integration.client.usesLocalAuth) {
-        acc[key] = {
-          id: integration.id,
-          metadata: integration.metadata
-        };
-      }
+      acc[key] = {
+        id: integration.id,
+        metadata: integration.metadata,
+        authSource: integration.client.usesLocalAuth ? "LOCAL" : "HOSTED"
+      };
       return acc;
     }, {});
   }
@@ -146,18 +145,20 @@ var logLevels = [
   "info",
   "debug"
 ];
-var _name, _level, _filteredKeys;
+var _name, _level, _filteredKeys, _jsonReplacer;
 var _Logger = class {
-  constructor(name, level = "info", filteredKeys = []) {
+  constructor(name, level = "info", filteredKeys = [], jsonReplacer) {
     __privateAdd(this, _name, void 0);
     __privateAdd(this, _level, void 0);
     __privateAdd(this, _filteredKeys, []);
+    __privateAdd(this, _jsonReplacer, void 0);
     __privateSet(this, _name, name);
     __privateSet(this, _level, logLevels.indexOf(process.env.TRIGGER_LOG_LEVEL ?? level));
     __privateSet(this, _filteredKeys, filteredKeys);
+    __privateSet(this, _jsonReplacer, jsonReplacer);
   }
   filter(...keys) {
-    return new _Logger(__privateGet(this, _name), logLevels[__privateGet(this, _level)], keys);
+    return new _Logger(__privateGet(this, _name), logLevels[__privateGet(this, _level)], keys, __privateGet(this, _jsonReplacer));
   }
   log(...args) {
     if (__privateGet(this, _level) < 0)
@@ -188,7 +189,7 @@ var _Logger = class {
       message,
       args: structureArgs(safeJsonClone(args), __privateGet(this, _filteredKeys))
     };
-    console.debug(JSON.stringify(structuredLog, bigIntReplacer));
+    console.debug(JSON.stringify(structuredLog, createReplacer(__privateGet(this, _jsonReplacer))));
   }
 };
 var Logger = _Logger;
@@ -196,6 +197,19 @@ __name(Logger, "Logger");
 _name = new WeakMap();
 _level = new WeakMap();
 _filteredKeys = new WeakMap();
+_jsonReplacer = new WeakMap();
+function createReplacer(replacer) {
+  return (key, value) => {
+    if (typeof value === "bigint") {
+      return value.toString();
+    }
+    if (replacer) {
+      return replacer(key, value);
+    }
+    return value;
+  };
+}
+__name(createReplacer, "createReplacer");
 function bigIntReplacer(_key, value) {
   if (typeof value === "bigint") {
     return value.toString();
@@ -293,13 +307,17 @@ var ConnectionAuthSchema = import_zod3.z.object({
   additionalFields: import_zod3.z.record(import_zod3.z.string()).optional()
 });
 var IntegrationMetadataSchema = import_zod3.z.object({
-  key: import_zod3.z.string(),
-  title: import_zod3.z.string(),
-  icon: import_zod3.z.string()
+  id: import_zod3.z.string(),
+  name: import_zod3.z.string(),
+  instructions: import_zod3.z.string().optional()
 });
 var IntegrationConfigSchema = import_zod3.z.object({
   id: import_zod3.z.string(),
-  metadata: IntegrationMetadataSchema
+  metadata: IntegrationMetadataSchema,
+  authSource: import_zod3.z.enum([
+    "HOSTED",
+    "LOCAL"
+  ])
 });
 
 // ../internal/src/schemas/json.ts
@@ -404,7 +422,8 @@ var TaskSchema = import_zod7.z.object({
   output: DeserializedJsonSchema.optional().nullable(),
   error: import_zod7.z.string().optional().nullable(),
   parentId: import_zod7.z.string().optional().nullable(),
-  style: StyleSchema.optional().nullable()
+  style: StyleSchema.optional().nullable(),
+  operation: import_zod7.z.string().optional().nullable()
 });
 var ServerTaskSchema = TaskSchema.extend({
   idempotencyKey: import_zod7.z.string(),
@@ -527,9 +546,17 @@ var HttpSourceRequestHeadersSchema = import_zod9.z.object({
   "x-ts-http-method": import_zod9.z.string(),
   "x-ts-http-headers": import_zod9.z.string().transform((s) => import_zod9.z.record(import_zod9.z.string()).parse(JSON.parse(s)))
 });
-var PongResponseSchema = import_zod9.z.object({
-  message: import_zod9.z.literal("PONG")
+var PongSuccessResponseSchema = import_zod9.z.object({
+  ok: import_zod9.z.literal(true)
 });
+var PongErrorResponseSchema = import_zod9.z.object({
+  ok: import_zod9.z.literal(false),
+  error: import_zod9.z.string()
+});
+var PongResponseSchema = import_zod9.z.discriminatedUnion("ok", [
+  PongSuccessResponseSchema,
+  PongErrorResponseSchema
+]);
 var QueueOptionsSchema = import_zod9.z.object({
   name: import_zod9.z.string(),
   maxConcurrent: import_zod9.z.number().optional()
@@ -559,10 +586,10 @@ var SourceMetadataSchema = import_zod9.z.object({
     "SQS",
     "SMTP"
   ]),
+  integration: IntegrationConfigSchema,
   key: import_zod9.z.string(),
   params: import_zod9.z.any(),
-  events: import_zod9.z.array(import_zod9.z.string()),
-  clientId: import_zod9.z.string().optional()
+  events: import_zod9.z.array(import_zod9.z.string())
 });
 var DynamicTriggerEndpointMetadataSchema = import_zod9.z.object({
   id: import_zod9.z.string(),
@@ -571,7 +598,7 @@ var DynamicTriggerEndpointMetadataSchema = import_zod9.z.object({
     version: true
   }))
 });
-var GetEndpointDataResponseSchema = import_zod9.z.object({
+var IndexEndpointResponseSchema = import_zod9.z.object({
   jobs: import_zod9.z.array(JobMetadataSchema),
   sources: import_zod9.z.array(SourceMetadataSchema),
   dynamicTriggers: import_zod9.z.array(DynamicTriggerEndpointMetadataSchema),
@@ -714,8 +741,8 @@ var CreateRunResponseBodySchema = import_zod9.z.discriminatedUnion("ok", [
   CreateRunResponseOkSchema,
   CreateRunResponseErrorSchema
 ]);
-var SecureStringSchema = import_zod9.z.object({
-  __secureString: import_zod9.z.literal(true),
+var RedactStringSchema = import_zod9.z.object({
+  __redactedString: import_zod9.z.literal(true),
   strings: import_zod9.z.array(import_zod9.z.string()),
   interpolations: import_zod9.z.array(import_zod9.z.string())
 });
@@ -744,10 +771,13 @@ var RunTaskOptionsSchema = import_zod9.z.object({
   icon: import_zod9.z.string().optional(),
   displayKey: import_zod9.z.string().optional(),
   noop: import_zod9.z.boolean().default(false),
+  operation: import_zod9.z.enum([
+    "fetch"
+  ]).optional(),
   delayUntil: import_zod9.z.coerce.date().optional(),
   description: import_zod9.z.string().optional(),
   properties: import_zod9.z.array(DisplayPropertySchema).optional(),
-  params: SerializableJsonSchema.optional(),
+  params: import_zod9.z.any(),
   trigger: TriggerMetadataSchema.optional(),
   redact: RedactSchema.optional(),
   connectionKey: import_zod9.z.string().optional(),
@@ -833,9 +863,7 @@ var CommonMissingConnectionNotificationPayloadSchema = import_zod10.z.object({
     title: import_zod10.z.string(),
     scopes: import_zod10.z.array(import_zod10.z.string()),
     createdAt: import_zod10.z.coerce.date(),
-    updatedAt: import_zod10.z.coerce.date(),
-    integrationIdentifier: import_zod10.z.string(),
-    integrationAuthMethod: import_zod10.z.string()
+    updatedAt: import_zod10.z.coerce.date()
   }),
   authorizationUrl: import_zod10.z.string()
 });
@@ -881,6 +909,39 @@ var MissingConnectionResolvedNotificationPayloadSchema = import_zod10.z.discrimi
   MissingExternalConnectionResolvedNotificationPayloadSchema
 ]);
 
+// ../internal/src/schemas/fetch.ts
+var import_zod11 = require("zod");
+var FetchRetryHeadersStrategySchema = import_zod11.z.object({
+  strategy: import_zod11.z.literal("headers"),
+  limitHeader: import_zod11.z.string(),
+  remainingHeader: import_zod11.z.string(),
+  resetHeader: import_zod11.z.string()
+});
+var FetchRetryBackoffStrategySchema = RetryOptionsSchema.extend({
+  strategy: import_zod11.z.literal("backoff")
+});
+var FetchRetryStrategySchema = import_zod11.z.discriminatedUnion("strategy", [
+  FetchRetryHeadersStrategySchema,
+  FetchRetryBackoffStrategySchema
+]);
+var FetchRequestInitSchema = import_zod11.z.object({
+  method: import_zod11.z.string().optional(),
+  headers: import_zod11.z.record(import_zod11.z.union([
+    import_zod11.z.string(),
+    RedactStringSchema
+  ])).optional(),
+  body: import_zod11.z.union([
+    import_zod11.z.string(),
+    import_zod11.z.instanceof(ArrayBuffer)
+  ]).optional()
+});
+var FetchRetryOptionsSchema = import_zod11.z.record(FetchRetryStrategySchema);
+var FetchOperationSchema = import_zod11.z.object({
+  url: import_zod11.z.string(),
+  requestInit: FetchRequestInitSchema.optional(),
+  retry: import_zod11.z.record(FetchRetryStrategySchema).optional()
+});
+
 // ../internal/src/utils.ts
 function deepMergeFilters(filter, other) {
   const result = {
@@ -907,8 +968,40 @@ function deepMergeFilters(filter, other) {
 }
 __name(deepMergeFilters, "deepMergeFilters");
 
+// ../internal/src/retry.ts
+var DEFAULT_RETRY_OPTIONS = {
+  limit: 5,
+  factor: 1.8,
+  minTimeoutInMs: 1e3,
+  maxTimeoutInMs: 6e4,
+  randomize: true
+};
+function calculateRetryAt(retryOptions, attempts) {
+  const options = {
+    ...DEFAULT_RETRY_OPTIONS,
+    ...retryOptions
+  };
+  const retryCount = attempts + 1;
+  if (retryCount >= options.limit) {
+    return;
+  }
+  const random = options.randomize ? Math.random() + 1 : 1;
+  let timeoutInMs = Math.round(random * Math.max(options.minTimeoutInMs, 1) * Math.pow(options.factor, Math.max(attempts - 1, 0)));
+  timeoutInMs = Math.min(timeoutInMs, options.maxTimeoutInMs);
+  return new Date(Date.now() + timeoutInMs);
+}
+__name(calculateRetryAt, "calculateRetryAt");
+
+// ../internal/src/replacements.ts
+var currentDate = {
+  marker: "__CURRENT_DATE__",
+  replace({ data: { now } }) {
+    return now.toISOString();
+  }
+};
+
 // src/apiClient.ts
-var import_zod11 = require("zod");
+var import_zod12 = require("zod");
 var _apiUrl, _options, _logger, _apiKey, apiKey_fn;
 var ApiClient = class {
   constructor(options) {
@@ -1077,8 +1170,8 @@ var ApiClient = class {
     __privateGet(this, _logger).debug("unregistering schedule", {
       id
     });
-    const response = await zodfetch(import_zod11.z.object({
-      ok: import_zod11.z.boolean()
+    const response = await zodfetch(import_zod12.z.object({
+      ok: import_zod12.z.boolean()
     }), `${__privateGet(this, _apiUrl)}/api/v1/${client}/schedules/${id}/registrations/${encodeURIComponent(key)}`, {
       method: "DELETE",
       headers: {
@@ -1186,11 +1279,12 @@ function createIOWithIntegrations(io, auths, integrations) {
     return io;
   }
   const connections = Object.entries(integrations).reduce((acc, [connectionKey, integration]) => {
-    const connection = auths?.[connectionKey];
-    const client = "client" in integration.client ? integration.client.client : connection ? integration.client.clientFactory?.(connection) : void 0;
+    let auth = auths?.[connectionKey];
+    const client = integration.client.usesLocalAuth ? integration.client.client : auth ? integration.client.clientFactory?.(auth) : void 0;
     if (!client) {
       return acc;
     }
+    auth = integration.client.usesLocalAuth ? integration.client.auth : auth;
     const ioConnection = {
       client
     };
@@ -1202,7 +1296,7 @@ function createIOWithIntegrations(io, auths, integrations) {
           const options = authenticatedTask2.init(params);
           options.connectionKey = connectionKey;
           return await io.runTask(key, options, async (ioTask) => {
-            return authenticatedTask2.run(params, client, ioTask, io);
+            return authenticatedTask2.run(params, client, ioTask, io, auth);
           }, authenticatedTask2.onError);
         };
       });
@@ -1225,30 +1319,6 @@ function createIOWithIntegrations(io, auths, integrations) {
 }
 __name(createIOWithIntegrations, "createIOWithIntegrations");
 
-// src/retry.ts
-var DEFAULT_RETRY_OPTIONS = {
-  limit: 5,
-  factor: 1.8,
-  minTimeoutInMs: 1e3,
-  maxTimeoutInMs: 6e4,
-  randomize: true
-};
-function calculateRetryAt(retryOptions, attempts) {
-  const options = {
-    ...DEFAULT_RETRY_OPTIONS,
-    ...retryOptions
-  };
-  const retryCount = attempts + 1;
-  if (retryCount > options.limit) {
-    return;
-  }
-  const random = options.randomize ? Math.random() + 1 : 1;
-  let timeoutInMs = Math.round(random * Math.max(options.minTimeoutInMs, 1) * Math.pow(options.factor, Math.max(attempts - 1, 0)));
-  timeoutInMs = Math.min(timeoutInMs, options.maxTimeoutInMs);
-  return new Date(Date.now() + timeoutInMs);
-}
-__name(calculateRetryAt, "calculateRetryAt");
-
 // src/io.ts
 var _addToCachedTasks, addToCachedTasks_fn;
 var IO = class {
@@ -1325,6 +1395,37 @@ var IO = class {
     }, async (task) => {
     });
   }
+  async backgroundFetch(key, url, requestInit, retry) {
+    const urlObject = new URL(url);
+    return await this.runTask(key, {
+      name: `fetch ${urlObject.hostname}${urlObject.pathname}`,
+      params: {
+        url,
+        requestInit,
+        retry
+      },
+      operation: "fetch",
+      icon: "background",
+      noop: false,
+      properties: [
+        {
+          label: "url",
+          text: url,
+          url
+        },
+        {
+          label: "method",
+          text: requestInit?.method ?? "GET"
+        },
+        {
+          label: "background",
+          text: "true"
+        }
+      ]
+    }, async (task) => {
+      return task.output;
+    });
+  }
   async sendEvent(key, event, options) {
     return await this.runTask(key, {
       name: "sendEvent",
@@ -1540,6 +1641,13 @@ var IO = class {
       });
       throw new ResumeWithTaskError(task);
     }
+    if (task.status === "RUNNING" && typeof task.operation === "string") {
+      this._logger.debug("Task running operation", {
+        idempotencyKey,
+        task
+      });
+      throw new ResumeWithTaskError(task);
+    }
     const executeTask = /* @__PURE__ */ __name(async () => {
       try {
         const result = await callback(task, this);
@@ -1552,6 +1660,9 @@ var IO = class {
         });
         return result;
       } catch (error) {
+        if (isTriggerError(error)) {
+          throw error;
+        }
         if (onError) {
           const onErrorResult = onError(error, task, this);
           if (onErrorResult) {
@@ -1563,7 +1674,7 @@ var IO = class {
         }
         const parsedError = ErrorWithStackSchema.safeParse(error);
         if (options.retry) {
-          const retryAt = calculateRetryAt(options.retry, task.attempts);
+          const retryAt = calculateRetryAt(options.retry, task.attempts - 1);
           if (retryAt) {
             throw new RetryWithTaskError(parsedError.success ? parsedError.data : {
               message: "Unknown error"
@@ -1773,14 +1884,33 @@ var TriggerClient = class {
     }
     switch (action) {
       case "PING": {
+        const endpointId = request.headers.get("x-trigger-endpoint-id");
+        if (!endpointId) {
+          return {
+            status: 200,
+            body: {
+              ok: false,
+              message: "Missing endpoint ID"
+            }
+          };
+        }
+        if (this.id !== endpointId) {
+          return {
+            status: 200,
+            body: {
+              ok: false,
+              message: `Endpoint ID mismatch error. Expected ${this.id}, got ${endpointId}`
+            }
+          };
+        }
         return {
           status: 200,
           body: {
-            message: "PONG"
+            ok: true
           }
         };
       }
-      case "GET_ENDPOINT_DATA": {
+      case "INDEX_ENDPOINT": {
         const jobId = request.headers.get("x-trigger-job-id");
         if (jobId) {
           const job = __privateGet(this, _registeredJobs)[jobId];
@@ -1814,15 +1944,6 @@ var TriggerClient = class {
           body
         };
       }
-      case "INITIALIZE": {
-        await this.listen();
-        return {
-          status: 200,
-          body: {
-            message: "Initialized"
-          }
-        };
-      }
       case "INITIALIZE_TRIGGER": {
         const json = await request.json();
         const body = InitializeTriggerBodySchema.safeParse(json);
@@ -2003,7 +2124,11 @@ var TriggerClient = class {
         key: options.key,
         params: options.params,
         events: [],
-        clientId: !options.source.integration.usesLocalAuth ? options.source.integration.id : void 0
+        integration: {
+          id: options.source.integration.id,
+          metadata: options.source.integration.metadata,
+          authSource: options.source.integration.client.usesLocalAuth ? "LOCAL" : "HOSTED"
+        }
       };
     }
     registeredSource.events = Array.from(/* @__PURE__ */ new Set([
@@ -2079,12 +2204,6 @@ var TriggerClient = class {
   apiKey() {
     return __privateGet(this, _options3).apiKey ?? process.env.TRIGGER_API_KEY;
   }
-  async listen() {
-    await __privateGet(this, _client).registerEndpoint({
-      url: this.url,
-      name: this.id
-    });
-  }
 };
 __name(TriggerClient, "TriggerClient");
 _options3 = new WeakMap();
@@ -2454,7 +2573,11 @@ var DynamicTrigger = class {
         events: [
           this.event.name
         ],
-        clientId: !this.source.integration.usesLocalAuth ? this.source.integration.id : void 0
+        integration: {
+          id: this.source.integration.id,
+          metadata: this.source.integration.metadata,
+          authSource: this.source.integration.client.usesLocalAuth ? "LOCAL" : "HOSTED"
+        }
       }
     };
   }
@@ -2473,6 +2596,17 @@ _client2 = new WeakMap();
 _options4 = new WeakMap();
 
 // src/triggers/scheduled.ts
+var examples = [
+  {
+    id: "now",
+    name: "Now",
+    icon: "clock",
+    payload: {
+      ts: currentDate.marker,
+      lastTimestamp: currentDate.marker
+    }
+  }
+];
 var IntervalTrigger = class {
   constructor(options) {
     this.options = options;
@@ -2483,6 +2617,7 @@ var IntervalTrigger = class {
       title: "Schedule",
       source: "trigger.dev",
       icon: "schedule-interval",
+      examples,
       parsePayload: ScheduledPayloadSchema.parse,
       properties: [
         {
@@ -2524,6 +2659,7 @@ var CronTrigger = class {
       title: "Cron Schedule",
       source: "trigger.dev",
       icon: "schedule-cron",
+      examples,
       parsePayload: ScheduledPayloadSchema.parse,
       properties: [
         {
@@ -2569,6 +2705,7 @@ var DynamicSchedule = class {
       title: "Dynamic Schedule",
       source: "trigger.dev",
       icon: "schedule-dynamic",
+      examples,
       parsePayload: ScheduledPayloadSchema.parse
     };
   }
@@ -2690,14 +2827,14 @@ var MissingConnectionResolvedNotification = class {
 __name(MissingConnectionResolvedNotification, "MissingConnectionResolvedNotification");
 
 // src/index.ts
-function secureString(strings, ...interpolations) {
+function redactString(strings, ...interpolations) {
   return {
-    __secureString: true,
+    __redactedString: true,
     strings: strings.raw,
     interpolations
   };
 }
-__name(secureString, "secureString");
+__name(redactString, "redactString");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CronTrigger,
@@ -2721,6 +2858,6 @@ __name(secureString, "secureString");
   missingConnectionNotification,
   missingConnectionResolvedNotification,
   omit,
-  secureString
+  redactString
 });
 //# sourceMappingURL=index.js.map