@trigger.dev/sdk 3.3.17 → 4.0.0-v4-beta.0

package/dist/esm/triggerClient.js

@@ -1,1359 +0,0 @@
-import { API_VERSIONS, ErrorWithStackSchema, HttpEndpointRequestHeadersSchema, HttpSourceRequestHeadersSchema, InitializeTriggerBodySchema, PreprocessRunBodySchema, REGISTER_SOURCE_EVENT_V2, REGISTER_WEBHOOK, RegisterSourceEventSchemaV2, RegisterWebhookPayloadSchema, RequestWithRawBodySchema, RunJobBodySchema, WebhookSourceRequestHeadersSchema, } from "@trigger.dev/core";
-import { Logger } from "@trigger.dev/core/logger";
-import EventEmitter from "node:events";
-import { env } from "node:process";
-import { ApiClient } from "./apiClient.js";
-import { ConcurrencyLimit } from "./concurrencyLimit.js";
-import { AutoYieldExecutionError, AutoYieldRateLimitError, AutoYieldWithCompletedTaskExecutionError, CanceledWithTaskError, ErrorWithTask, ParsedPayloadSchemaError, ResumeWithParallelTaskError, ResumeWithTaskError, RetryWithTaskError, YieldExecutionError, } from "./errors.js";
-import { httpEndpoint } from "./httpEndpoint.js";
-import { IO } from "./io.js";
-import { createIOWithIntegrations } from "./ioWithIntegrations.js";
-import { Job } from "./job.js";
-import { runLocalStorage } from "./runLocalStorage.js";
-import { KeyValueStore } from "./store/keyValueStore.js";
-import { DynamicTrigger } from "./triggers/dynamic.js";
-import { EventTrigger } from "./triggers/eventTrigger.js";
-import { DynamicSchedule } from "./triggers/scheduled.js";
-import { formatSchemaErrors } from "./utils/formatSchemaErrors.js";
-import { VERSION } from "./version.js";
-const parseRequestPayload = (rawPayload) => {
-    const result = RequestWithRawBodySchema.safeParse(rawPayload);
-    if (!result.success) {
-        throw new ParsedPayloadSchemaError(formatSchemaErrors(result.error.issues));
-    }
-    return new Request(new URL(result.data.url), {
-        method: result.data.method,
-        headers: result.data.headers,
-        body: result.data.rawBody,
-    });
-};
-const registerWebhookEvent = (key) => ({
-    name: `${REGISTER_WEBHOOK}.${key}`,
-    title: "Register Webhook",
-    source: "internal",
-    icon: "webhook",
-    parsePayload: RegisterWebhookPayloadSchema.parse,
-});
-const registerSourceEvent = {
-    name: REGISTER_SOURCE_EVENT_V2,
-    title: "Register Source",
-    source: "internal",
-    icon: "register-source",
-    parsePayload: RegisterSourceEventSchemaV2.parse,
-};
-/** A [TriggerClient](https://trigger.dev/docs/documentation/concepts/client-adaptors) is used to connect to a specific [Project](https://trigger.dev/docs/documentation/concepts/projects) by using an [API Key](https://trigger.dev/docs/documentation/concepts/environments-apikeys). */
-export class TriggerClient {
-    #options;
-    #registeredJobs = {};
-    #registeredSources = {};
-    #registeredWebhooks = {};
-    #registeredHttpSourceHandlers = {};
-    #registeredWebhookSourceHandlers = {};
-    #registeredDynamicTriggers = {};
-    #jobMetadataByDynamicTriggers = {};
-    #registeredSchedules = {};
-    #registeredHttpEndpoints = {};
-    #authResolvers = {};
-    #envStore;
-    #eventEmitter = new EventEmitter();
-    #client;
-    #internalLogger;
-    id;
-    constructor(options) {
-        this.id = options.id;
-        this.#options = options;
-        this.#internalLogger = new Logger("trigger.dev", this.#options.verbose ? "debug" : "log", [
-            "output",
-            "noopTasksSet",
-        ]);
-        this.#client = new ApiClient({
-            logLevel: this.#options.verbose ? "debug" : "log",
-            ...this.#options,
-        });
-        this.#envStore = new KeyValueStore(this.#client);
-    }
-    on = this.#eventEmitter.on.bind(this.#eventEmitter);
-    async handleRequest(request, timeOrigin = performance.now()) {
-        this.#internalLogger.debug("handling request", {
-            url: request.url,
-            headers: Object.fromEntries(request.headers.entries()),
-            method: request.method,
-        });
-        const apiKey = request.headers.get("x-trigger-api-key");
-        const triggerVersion = request.headers.get("x-trigger-version");
-        const authorization = this.authorized(apiKey);
-        switch (authorization) {
-            case "authorized": {
-                break;
-            }
-            case "missing-client": {
-                return {
-                    status: 401,
-                    body: {
-                        message: "Unauthorized: client missing apiKey",
-                    },
-                    headers: this.#standardResponseHeaders(timeOrigin),
-                };
-            }
-            case "missing-header": {
-                return {
-                    status: 401,
-                    body: {
-                        message: "Unauthorized: missing x-trigger-api-key header",
-                    },
-                    headers: this.#standardResponseHeaders(timeOrigin),
-                };
-            }
-            case "unauthorized": {
-                return {
-                    status: 401,
-                    body: {
-                        message: `Forbidden: client apiKey mismatch: Make sure you are using the correct API Key for your environment`,
-                    },
-                    headers: this.#standardResponseHeaders(timeOrigin),
-                };
-            }
-        }
-        if (request.method !== "POST") {
-            return {
-                status: 405,
-                body: {
-                    message: "Method not allowed (only POST is allowed)",
-                },
-                headers: this.#standardResponseHeaders(timeOrigin),
-            };
-        }
-        const action = request.headers.get("x-trigger-action");
-        if (!action) {
-            return {
-                status: 400,
-                body: {
-                    message: "Missing x-trigger-action header",
-                },
-                headers: this.#standardResponseHeaders(timeOrigin),
-            };
-        }
-        switch (action) {
-            case "PING": {
-                const endpointId = request.headers.get("x-trigger-endpoint-id");
-                if (!endpointId) {
-                    return {
-                        status: 200,
-                        body: {
-                            ok: false,
-                            error: "Missing endpoint ID",
-                        },
-                        headers: this.#standardResponseHeaders(timeOrigin),
-                    };
-                }
-                if (this.id !== endpointId) {
-                    return {
-                        status: 200,
-                        body: {
-                            ok: false,
-                            error: `Endpoint ID mismatch error. Expected ${this.id}, got ${endpointId}`,
-                        },
-                        headers: this.#standardResponseHeaders(timeOrigin),
-                    };
-                }
-                return {
-                    status: 200,
-                    body: {
-                        ok: true,
-                    },
-                    headers: this.#standardResponseHeaders(timeOrigin),
-                };
-            }
-            case "INDEX_ENDPOINT": {
-                const body = {
-                    jobs: this.#buildJobsIndex(),
-                    sources: Object.values(this.#registeredSources),
-                    webhooks: Object.values(this.#registeredWebhooks),
-                    dynamicTriggers: Object.values(this.#registeredDynamicTriggers).map((trigger) => ({
-                        id: trigger.id,
-                        jobs: this.#jobMetadataByDynamicTriggers[trigger.id] ?? [],
-                        registerSourceJob: {
-                            id: dynamicTriggerRegisterSourceJobId(trigger.id),
-                            version: trigger.source.version,
-                        },
-                    })),
-                    dynamicSchedules: Object.entries(this.#registeredSchedules).map(([id, jobs]) => ({
-                        id,
-                        jobs,
-                    })),
-                    httpEndpoints: Object.entries(this.#registeredHttpEndpoints).map(([id, endpoint]) => endpoint.toJSON()),
-                };
-                // if the x-trigger-job-id header is not set, we return all jobs
-                return {
-                    status: 200,
-                    body,
-                    headers: this.#standardResponseHeaders(timeOrigin),
-                };
-            }
-            case "INITIALIZE_TRIGGER": {
-                const json = await request.json();
-                const body = InitializeTriggerBodySchema.safeParse(json);
-                if (!body.success) {
-                    return {
-                        status: 400,
-                        body: {
-                            message: "Invalid trigger body",
-                        },
-                    };
-                }
-                const dynamicTrigger = this.#registeredDynamicTriggers[body.data.id];
-                if (!dynamicTrigger) {
-                    return {
-                        status: 404,
-                        body: {
-                            message: "Dynamic trigger not found",
-                        },
-                    };
-                }
-                return {
-                    status: 200,
-                    body: dynamicTrigger.registeredTriggerForParams(body.data.params),
-                    headers: this.#standardResponseHeaders(timeOrigin),
-                };
-            }
-            case "EXECUTE_JOB": {
-                const json = await request.json();
-                const execution = RunJobBodySchema.safeParse(json);
-                if (!execution.success) {
-                    return {
-                        status: 400,
-                        body: {
-                            message: "Invalid execution",
-                        },
-                    };
-                }
-                const job = this.#registeredJobs[execution.data.job.id];
-                if (!job) {
-                    return {
-                        status: 404,
-                        body: {
-                            message: "Job not found",
-                        },
-                    };
-                }
-                const results = await this.#executeJob(execution.data, job, timeOrigin, triggerVersion);
-                this.#internalLogger.debug("executed job", {
-                    results,
-                    job: job.id,
-                    version: job.version,
-                    triggerVersion,
-                });
-                const standardHeaders = this.#standardResponseHeaders(timeOrigin);
-                standardHeaders["x-trigger-run-metadata"] = this.#serializeRunMetadata(job);
-                return {
-                    status: 200,
-                    body: results,
-                    headers: standardHeaders,
-                };
-            }
-            case "PREPROCESS_RUN": {
-                const json = await request.json();
-                const body = PreprocessRunBodySchema.safeParse(json);
-                if (!body.success) {
-                    return {
-                        status: 400,
-                        body: {
-                            message: "Invalid body",
-                        },
-                    };
-                }
-                const job = this.#registeredJobs[body.data.job.id];
-                if (!job) {
-                    return {
-                        status: 404,
-                        body: {
-                            message: "Job not found",
-                        },
-                    };
-                }
-                const results = await this.#preprocessRun(body.data, job);
-                return {
-                    status: 200,
-                    body: {
-                        abort: results.abort,
-                        properties: results.properties,
-                    },
-                    headers: this.#standardResponseHeaders(timeOrigin),
-                };
-            }
-            case "DELIVER_HTTP_SOURCE_REQUEST": {
-                const headers = HttpSourceRequestHeadersSchema.safeParse(Object.fromEntries(request.headers.entries()));
-                if (!headers.success) {
-                    return {
-                        status: 400,
-                        body: {
-                            message: "Invalid headers",
-                        },
-                    };
-                }
-                const sourceRequestNeedsBody = headers.data["x-ts-http-method"] !== "GET";
-                const sourceRequestInit = {
-                    method: headers.data["x-ts-http-method"],
-                    headers: headers.data["x-ts-http-headers"],
-                    body: sourceRequestNeedsBody ? request.body : undefined,
-                };
-                if (sourceRequestNeedsBody) {
-                    try {
-                        // @ts-ignore
-                        sourceRequestInit.duplex = "half";
-                    }
-                    catch (error) {
-                        // ignore
-                    }
-                }
-                const sourceRequest = new Request(headers.data["x-ts-http-url"], sourceRequestInit);
-                const key = headers.data["x-ts-key"];
-                const dynamicId = headers.data["x-ts-dynamic-id"];
-                const secret = headers.data["x-ts-secret"];
-                const params = headers.data["x-ts-params"];
-                const data = headers.data["x-ts-data"];
-                const auth = headers.data["x-ts-auth"];
-                const inputMetadata = headers.data["x-ts-metadata"];
-                const source = {
-                    key,
-                    dynamicId,
-                    secret,
-                    params,
-                    data,
-                    auth,
-                    metadata: inputMetadata,
-                };
-                const { response, events, metadata } = await this.#handleHttpSourceRequest(source, sourceRequest);
-                return {
-                    status: 200,
-                    body: {
-                        events,
-                        response,
-                        metadata,
-                    },
-                    headers: this.#standardResponseHeaders(timeOrigin),
-                };
-            }
-            case "DELIVER_HTTP_ENDPOINT_REQUEST_FOR_RESPONSE": {
-                const headers = HttpEndpointRequestHeadersSchema.safeParse(Object.fromEntries(request.headers.entries()));
-                if (!headers.success) {
-                    return {
-                        status: 400,
-                        body: {
-                            message: "Invalid headers",
-                        },
-                    };
-                }
-                const sourceRequestNeedsBody = headers.data["x-ts-http-method"] !== "GET";
-                const sourceRequestInit = {
-                    method: headers.data["x-ts-http-method"],
-                    headers: headers.data["x-ts-http-headers"],
-                    body: sourceRequestNeedsBody ? request.body : undefined,
-                };
-                if (sourceRequestNeedsBody) {
-                    try {
-                        // @ts-ignore
-                        sourceRequestInit.duplex = "half";
-                    }
-                    catch (error) {
-                        // ignore
-                    }
-                }
-                const sourceRequest = new Request(headers.data["x-ts-http-url"], sourceRequestInit);
-                const key = headers.data["x-ts-key"];
-                const { response } = await this.#handleHttpEndpointRequestForResponse({
-                    key,
-                }, sourceRequest);
-                return {
-                    status: 200,
-                    body: response,
-                    headers: this.#standardResponseHeaders(timeOrigin),
-                };
-            }
-            case "DELIVER_WEBHOOK_REQUEST": {
-                const headers = WebhookSourceRequestHeadersSchema.safeParse(Object.fromEntries(request.headers.entries()));
-                if (!headers.success) {
-                    return {
-                        status: 400,
-                        body: {
-                            message: "Invalid headers",
-                        },
-                    };
-                }
-                const sourceRequestNeedsBody = headers.data["x-ts-http-method"] !== "GET";
-                const sourceRequestInit = {
-                    method: headers.data["x-ts-http-method"],
-                    headers: headers.data["x-ts-http-headers"],
-                    body: sourceRequestNeedsBody ? request.body : undefined,
-                };
-                if (sourceRequestNeedsBody) {
-                    try {
-                        // @ts-ignore
-                        sourceRequestInit.duplex = "half";
-                    }
-                    catch (error) {
-                        // ignore
-                    }
-                }
-                const webhookRequest = new Request(headers.data["x-ts-http-url"], sourceRequestInit);
-                const key = headers.data["x-ts-key"];
-                const secret = headers.data["x-ts-secret"];
-                const params = headers.data["x-ts-params"];
-                const ctx = {
-                    key,
-                    secret,
-                    params,
-                };
-                const { response, verified, error } = await this.#handleWebhookRequest(webhookRequest, ctx);
-                return {
-                    status: 200,
-                    body: {
-                        response,
-                        verified,
-                        error,
-                    },
-                    headers: this.#standardResponseHeaders(timeOrigin),
-                };
-            }
-            case "VALIDATE": {
-                return {
-                    status: 200,
-                    body: {
-                        ok: true,
-                        endpointId: this.id,
-                    },
-                    headers: this.#standardResponseHeaders(timeOrigin),
-                };
-            }
-            case "PROBE_EXECUTION_TIMEOUT": {
-                const json = await request.json();
-                // Keep this request open for max 15 minutes so the server can detect when the function execution limit is exceeded
-                const timeout = json?.timeout ?? 15 * 60 * 1000;
-                await new Promise((resolve) => setTimeout(resolve, timeout));
-                return {
-                    status: 200,
-                    body: {
-                        ok: true,
-                    },
-                    headers: this.#standardResponseHeaders(timeOrigin),
-                };
-            }
-            case "RUN_NOTIFICATION": {
-                const rawJson = await request.json();
-                const runNotification = rawJson;
-                if (runNotification.ok) {
-                    await this.#deliverSuccessfulRunNotification(runNotification);
-                }
-                else {
-                    await this.#deliverFailedRunNotification(runNotification);
-                }
-                return {
-                    status: 200,
-                    body: {
-                        ok: true,
-                    },
-                    headers: this.#standardResponseHeaders(timeOrigin),
-                };
-            }
-        }
-        return {
-            status: 405,
-            body: {
-                message: "Method not allowed",
-            },
-            headers: this.#standardResponseHeaders(timeOrigin),
-        };
-    }
-    defineJob(options) {
-        const existingRegisteredJob = this.#registeredJobs[options.id];
-        if (existingRegisteredJob && options.__internal !== true) {
-            console.warn(`[@trigger.dev/sdk] Warning: The Job "${existingRegisteredJob.id}" you're attempting to define has already been defined. Please assign a different ID to the job.`);
-        }
-        const job = new Job(options);
-        this.attach(job);
-        return job;
-    }
-    defineAuthResolver(integration, resolver) {
-        this.#authResolvers[integration.id] = resolver;
-        return this;
-    }
-    defineDynamicSchedule(options) {
-        return new DynamicSchedule(this, options);
-    }
-    defineDynamicTrigger(options) {
-        return new DynamicTrigger(this, options);
-    }
-    /**
-     * An [HTTP endpoint](https://trigger.dev/docs/documentation/concepts/http-endpoints) allows you to create a [HTTP Trigger](https://trigger.dev/docs/documentation/concepts/triggers/http), which means you can trigger your Jobs from any webhooks.
-     * @param options The Endpoint options
-     * @returns An HTTP Endpoint, that can be used to create an HTTP Trigger.
-     * @link https://trigger.dev/docs/documentation/concepts/http-endpoints
-     */
-    defineHttpEndpoint(options, suppressWarnings = false) {
-        const existingHttpEndpoint = this.#registeredHttpEndpoints[options.id];
-        if (!suppressWarnings && existingHttpEndpoint) {
-            console.warn(`[@trigger.dev/sdk] Warning: The HttpEndpoint "${existingHttpEndpoint.id}" you're attempting to define has already been defined. Please assign a different ID to the HttpEndpoint.`);
-        }
-        const endpoint = httpEndpoint(options);
-        this.#registeredHttpEndpoints[endpoint.id] = endpoint;
-        return endpoint;
-    }
-    defineConcurrencyLimit(options) {
-        return new ConcurrencyLimit(options);
-    }
-    attach(job) {
-        this.#registeredJobs[job.id] = job;
-        job.trigger.attachToJob(this, job);
-        job.client = this;
-    }
-    attachDynamicTrigger(trigger) {
-        this.#registeredDynamicTriggers[trigger.id] = trigger;
-        this.defineJob({
-            id: dynamicTriggerRegisterSourceJobId(trigger.id),
-            name: `Register dynamic trigger ${trigger.id}`,
-            version: trigger.source.version,
-            trigger: new EventTrigger({
-                event: registerSourceEvent,
-                filter: { dynamicTriggerId: [trigger.id] },
-            }),
-            integrations: {
-                integration: trigger.source.integration,
-            },
-            run: async (event, io, ctx) => {
-                const updates = await trigger.source.register(event.source.params, event, io, ctx);
-                if (!updates) {
-                    // TODO: do something here?
-                    return;
-                }
-                return await io.updateSource("update-source", {
-                    key: event.source.key,
-                    ...updates,
-                });
-            },
-            __internal: true,
-        });
-    }
-    attachJobToDynamicTrigger(job, trigger) {
-        const jobs = this.#jobMetadataByDynamicTriggers[trigger.id] ?? [];
-        jobs.push({ id: job.id, version: job.version });
-        this.#jobMetadataByDynamicTriggers[trigger.id] = jobs;
-    }
-    attachSource(options) {
-        this.#registeredHttpSourceHandlers[options.key] = async (s, r) => {
-            return await options.source.handle(s, r, this.#internalLogger);
-        };
-        let registeredSource = this.#registeredSources[options.key];
-        if (!registeredSource) {
-            registeredSource = {
-                version: "2",
-                channel: options.source.channel,
-                key: options.key,
-                params: options.params,
-                options: {},
-                integration: {
-                    id: options.source.integration.id,
-                    metadata: options.source.integration.metadata,
-                    authSource: options.source.integration.authSource,
-                },
-                registerSourceJob: {
-                    id: options.key,
-                    version: options.source.version,
-                },
-            };
-        }
-        //combined the previous source options with this one, making sure to include event
-        const newOptions = deepMergeOptions({
-            event: typeof options.event.name === "string" ? [options.event.name] : options.event.name,
-        }, options.options ?? {});
-        registeredSource.options = deepMergeOptions(registeredSource.options, newOptions);
-        this.#registeredSources[options.key] = registeredSource;
-        this.defineJob({
-            id: options.key,
-            name: options.key,
-            version: options.source.version,
-            trigger: new EventTrigger({
-                event: registerSourceEvent,
-                filter: { source: { key: [options.key] } },
-            }),
-            integrations: {
-                integration: options.source.integration,
-            },
-            run: async (event, io, ctx) => {
-                const updates = await options.source.register(options.params, event, io, ctx);
-                if (!updates) {
-                    // TODO: do something here?
-                    return;
-                }
-                return await io.updateSource("update-source", {
-                    key: options.key,
-                    ...updates,
-                });
-            },
-            __internal: true,
-        });
-    }
-    attachDynamicSchedule(key) {
-        const jobs = this.#registeredSchedules[key] ?? [];
-        this.#registeredSchedules[key] = jobs;
-    }
-    attachDynamicScheduleToJob(key, job) {
-        const jobs = this.#registeredSchedules[key] ?? [];
-        jobs.push({ id: job.id, version: job.version });
-        this.#registeredSchedules[key] = jobs;
-    }
-    attachWebhook(options) {
-        const { source } = options;
-        this.#registeredWebhookSourceHandlers[options.key] = {
-            verify: source.verify.bind(source),
-            generateEvents: source.generateEvents.bind(source),
-        };
-        let registeredWebhook = this.#registeredWebhooks[options.key];
-        if (!registeredWebhook) {
-            registeredWebhook = {
-                key: options.key,
-                params: options.params,
-                config: options.config,
-                integration: {
-                    id: source.integration.id,
-                    metadata: source.integration.metadata,
-                    authSource: source.integration.authSource,
-                },
-                httpEndpoint: {
-                    id: options.key,
-                },
-            };
-        }
-        else {
-            registeredWebhook.config = deepMergeOptions(registeredWebhook.config, options.config);
-        }
-        this.#registeredWebhooks[options.key] = registeredWebhook;
-        this.defineJob({
-            id: `webhook.register.${options.key}`,
-            name: `webhook.register.${options.key}`,
-            version: source.version,
-            trigger: new EventTrigger({
-                event: registerWebhookEvent(options.key),
-            }),
-            integrations: {
-                integration: source.integration,
-            },
-            run: async (registerPayload, io, ctx) => {
-                return await io.try(async () => {
-                    this.#internalLogger.debug("[webhook.register] Start");
-                    const crudOptions = {
-                        io,
-                        // this is just a more strongly typed payload
-                        ctx: registerPayload,
-                    };
-                    if (!registerPayload.active) {
-                        this.#internalLogger.debug("[webhook.register] Not active, run create");
-                        await io.try(async () => {
-                            await source.crud.create(crudOptions);
-                        }, async (error) => {
-                            this.#internalLogger.debug("[webhook.register] Error during create, re-trying with delete first", { error });
-                            await io.runTask("create-retry", async () => {
-                                await source.crud.delete(crudOptions);
-                                await source.crud.create(crudOptions);
-                            });
-                        });
-                        return await io.updateWebhook("update-webhook-success", {
-                            key: options.key,
-                            active: true,
-                            config: registerPayload.config.desired,
-                        });
-                    }
-                    this.#internalLogger.debug("[webhook.register] Already active, run update");
-                    if (source.crud.update) {
-                        await source.crud.update(crudOptions);
-                    }
-                    else {
-                        this.#internalLogger.debug("[webhook.register] Run delete and create instead of update");
-                        await source.crud.delete(crudOptions);
-                        await source.crud.create(crudOptions);
-                    }
-                    return await io.updateWebhook("update-webhook-success", {
-                        key: options.key,
-                        active: true,
-                        config: registerPayload.config.desired,
-                    });
-                }, async (error) => {
-                    this.#internalLogger.debug("[webhook.register] Error", { error });
-                    await io.updateWebhook("update-webhook-error", {
-                        key: options.key,
-                        active: false,
-                    });
-                    throw error;
-                });
-            },
-            __internal: true,
-        });
-    }
-    async registerTrigger(id, key, options, idempotencyKey) {
-        return this.#client.registerTrigger(this.id, id, key, options, idempotencyKey);
-    }
-    async getAuth(id) {
-        return this.#client.getAuth(this.id, id);
-    }
-    /** You can call this function from anywhere in your backend to send an event. The other way to send an event is by using [`io.sendEvent()`](https://trigger.dev/docs/sdk/io/sendevent) from inside a `run()` function.
-     * @param event The event to send.
-     * @param options Options for sending the event.
-     * @returns A promise that resolves to the event details
-     */
-    async sendEvent(event, options) {
-        return this.#client.sendEvent(event, options);
-    }
-    /** You can call this function from anywhere in your backend to send multiple events. The other way to send multiple events is by using [`io.sendEvents()`](https://trigger.dev/docs/sdk/io/sendevents) from inside a `run()` function.
-     * @param events The events to send.
-     * @param options Options for sending the events.
-     * @returns A promise that resolves to an array of event details
-     */
-    async sendEvents(events, options) {
-        return this.#client.sendEvents(events, options);
-    }
-    async cancelEvent(eventId) {
-        return this.#client.cancelEvent(eventId);
-    }
-    async cancelRunsForEvent(eventId) {
-        return this.#client.cancelRunsForEvent(eventId);
-    }
-    async updateStatus(runId, id, status) {
-        return this.#client.updateStatus(runId, id, status);
-    }
-    async registerSchedule(id, key, schedule) {
-        return this.#client.registerSchedule(this.id, id, key, schedule);
-    }
-    async unregisterSchedule(id, key) {
-        return this.#client.unregisterSchedule(this.id, id, key);
-    }
-    async getEvent(eventId) {
-        return this.#client.getEvent(eventId);
-    }
-    async getRun(runId, options) {
-        return this.#client.getRun(runId, options);
-    }
-    async cancelRun(runId) {
-        return this.#client.cancelRun(runId);
-    }
-    async getRuns(jobSlug, options) {
-        return this.#client.getRuns(jobSlug, options);
-    }
-    async getRunStatuses(runId) {
-        return this.#client.getRunStatuses(runId);
-    }
-    async invokeJob(jobId, payload, options) {
-        return this.#client.invokeJob(jobId, payload, options);
-    }
-    async cancelRunsForJob(jobId) {
-        return this.#client.cancelRunsForJob(jobId);
-    }
-    async createEphemeralEventDispatcher(payload) {
-        return this.#client.createEphemeralEventDispatcher(payload);
-    }
-    get store() {
-        return {
-            env: this.#envStore,
-        };
-    }
-    authorized(apiKey) {
-        if (typeof apiKey !== "string") {
-            return "missing-header";
-        }
-        const localApiKey = this.#options.apiKey ?? env.TRIGGER_API_KEY;
-        if (!localApiKey) {
-            return "missing-client";
-        }
-        return apiKey === localApiKey ? "authorized" : "unauthorized";
-    }
-    apiKey() {
-        return this.#options.apiKey ?? env.TRIGGER_API_KEY;
-    }
-    async #preprocessRun(body, job) {
-        const context = this.#createPreprocessRunContext(body);
-        const parsedPayload = job.trigger.event.parsePayload(body.event.payload ?? {});
-        const properties = job.trigger.event.runProperties?.(parsedPayload) ?? [];
-        return {
-            abort: false,
-            properties,
-        };
-    }
-    async #executeJob(body, job, timeOrigin, triggerVersion) {
-        this.#internalLogger.debug("executing job", {
-            execution: body,
-            job: job.id,
-            version: job.version,
-            triggerVersion,
-        });
-        const context = this.#createRunContext(body);
-        const io = new IO({
-            id: body.run.id,
-            jobId: job.id,
-            cachedTasks: body.tasks,
-            cachedTasksCursor: body.cachedTaskCursor,
-            yieldedExecutions: body.yieldedExecutions ?? [],
-            noopTasksSet: body.noopTasksSet,
-            apiClient: this.#client,
-            logger: this.#internalLogger,
-            client: this,
-            context,
-            jobLogLevel: job.logLevel ?? this.#options.logLevel ?? "info",
-            jobLogger: this.#options.ioLogLocalEnabled
-                ? new Logger(job.id, job.logLevel ?? this.#options.logLevel ?? "info")
-                : undefined,
-            serverVersion: triggerVersion,
-            timeOrigin,
-            executionTimeout: body.runChunkExecutionLimit,
-        });
-        const resolvedConnections = await this.#resolveConnections(context, job.options.integrations, body.connections);
-        if (!resolvedConnections.ok) {
-            return {
-                status: "UNRESOLVED_AUTH_ERROR",
-                issues: resolvedConnections.issues,
-            };
-        }
-        const ioWithConnections = createIOWithIntegrations(io, resolvedConnections.data, job.options.integrations);
-        try {
-            const parsedPayload = job.trigger.event.parsePayload(body.event.payload ?? {});
-            if (!context.run.isTest) {
-                const verified = await job.trigger.verifyPayload(parsedPayload);
-                if (!verified.success) {
-                    return {
-                        status: "ERROR",
-                        error: { message: `Payload verification failed. ${verified.reason}` },
-                    };
-                }
-            }
-            const output = await runLocalStorage.runWith({ io, ctx: context }, () => {
-                return job.options.run(parsedPayload, ioWithConnections, context);
-            });
-            if (this.#options.verbose) {
-                this.#logIOStats(io.stats);
-            }
-            return { status: "SUCCESS", output };
-        }
-        catch (error) {
-            if (this.#options.verbose) {
-                this.#logIOStats(io.stats);
-            }
-            if (error instanceof ResumeWithParallelTaskError) {
-                return {
-                    status: "RESUME_WITH_PARALLEL_TASK",
-                    task: error.task,
-                    childErrors: error.childErrors.map((childError) => {
-                        return this.#convertErrorToExecutionResponse(childError, body);
-                    }),
-                };
-            }
-            return this.#convertErrorToExecutionResponse(error, body);
-        }
-    }
-    #convertErrorToExecutionResponse(error, body) {
-        if (error instanceof AutoYieldExecutionError) {
-            return {
-                status: "AUTO_YIELD_EXECUTION",
-                location: error.location,
-                timeRemaining: error.timeRemaining,
-                timeElapsed: error.timeElapsed,
-                limit: body.runChunkExecutionLimit,
-            };
-        }
-        if (error instanceof AutoYieldWithCompletedTaskExecutionError) {
-            return {
-                status: "AUTO_YIELD_EXECUTION_WITH_COMPLETED_TASK",
-                id: error.id,
-                properties: error.properties,
-                output: error.output,
-                data: {
-                    ...error.data,
-                    limit: body.runChunkExecutionLimit,
-                },
-            };
-        }
-        if (error instanceof AutoYieldRateLimitError) {
-            return {
-                status: "AUTO_YIELD_RATE_LIMIT",
-                reset: error.resetAtTimestamp,
-            };
-        }
-        if (error instanceof YieldExecutionError) {
-            return { status: "YIELD_EXECUTION", key: error.key };
-        }
-        if (error instanceof ParsedPayloadSchemaError) {
-            return { status: "INVALID_PAYLOAD", errors: error.schemaErrors };
-        }
-        if (error instanceof ResumeWithTaskError) {
-            return { status: "RESUME_WITH_TASK", task: error.task };
-        }
-        if (error instanceof RetryWithTaskError) {
-            return {
-                status: "RETRY_WITH_TASK",
-                task: error.task,
-                error: error.cause,
-                retryAt: error.retryAt,
-            };
-        }
-        if (error instanceof CanceledWithTaskError) {
-            return {
-                status: "CANCELED",
-                task: error.task,
-            };
-        }
-        if (error instanceof ErrorWithTask) {
-            const errorWithStack = ErrorWithStackSchema.safeParse(error.cause.output);
-            if (errorWithStack.success) {
-                return {
-                    status: "ERROR",
-                    error: errorWithStack.data,
-                    task: error.cause,
-                };
-            }
-            return {
-                status: "ERROR",
-                error: { message: JSON.stringify(error.cause.output) },
-                task: error.cause,
-            };
-        }
-        if (error instanceof RetryWithTaskError) {
-            const errorWithStack = ErrorWithStackSchema.safeParse(error.cause);
-            if (errorWithStack.success) {
-                return {
-                    status: "ERROR",
-                    error: errorWithStack.data,
-                    task: error.task,
-                };
-            }
-            return {
-                status: "ERROR",
-                error: { message: "Unknown error" },
-                task: error.task,
-            };
-        }
-        const errorWithStack = ErrorWithStackSchema.safeParse(error);
-        if (errorWithStack.success) {
-            return { status: "ERROR", error: errorWithStack.data };
-        }
-        const message = typeof error === "string" ? error : JSON.stringify(error);
-        return {
-            status: "ERROR",
-            error: { name: "Unknown error", message },
-        };
-    }
-    #createRunContext(execution) {
-        const { event, organization, project, environment, job, run, source } = execution;
-        return {
-            event: {
-                id: event.id,
-                name: event.name,
-                context: event.context,
-                timestamp: event.timestamp,
-            },
-            organization,
-            project: project ?? { id: "unknown", name: "unknown", slug: "unknown" }, // backwards compat with old servers
-            environment,
-            job,
-            run,
-            account: execution.account,
-            source,
-        };
-    }
-    #createPreprocessRunContext(body) {
-        const { event, organization, environment, job, run, account } = body;
-        return {
-            event: {
-                id: event.id,
-                name: event.name,
-                context: event.context,
-                timestamp: event.timestamp,
-            },
-            organization,
-            environment,
-            job,
-            run,
-            account,
-        };
-    }
-    async #handleHttpSourceRequest(source, sourceRequest) {
-        this.#internalLogger.debug("Handling HTTP source request", {
-            source,
-        });
-        if (source.dynamicId) {
-            const dynamicTrigger = this.#registeredDynamicTriggers[source.dynamicId];
-            if (!dynamicTrigger) {
-                this.#internalLogger.debug("No dynamic trigger registered for HTTP source", {
-                    source,
-                });
-                return {
-                    response: {
-                        status: 200,
-                        body: {
-                            ok: true,
-                        },
-                    },
-                    events: [],
-                };
-            }
-            const results = await dynamicTrigger.source.handle(source, sourceRequest, this.#internalLogger);
-            if (!results) {
-                return {
-                    events: [],
-                    response: {
-                        status: 200,
-                        body: {
-                            ok: true,
-                        },
-                    },
-                };
-            }
-            return {
-                events: results.events,
-                response: results.response ?? {
-                    status: 200,
-                    body: {
-                        ok: true,
-                    },
-                },
-                metadata: results.metadata,
-            };
-        }
-        const handler = this.#registeredHttpSourceHandlers[source.key];
-        if (!handler) {
-            this.#internalLogger.debug("No handler registered for HTTP source", {
-                source,
-            });
-            return {
-                response: {
-                    status: 200,
-                    body: {
-                        ok: true,
-                    },
-                },
-                events: [],
-            };
-        }
-        const results = await handler(source, sourceRequest);
-        if (!results) {
-            return {
-                events: [],
-                response: {
-                    status: 200,
-                    body: {
-                        ok: true,
-                    },
-                },
-            };
-        }
-        return {
-            events: results.events,
-            response: results.response ?? {
-                status: 200,
-                body: {
-                    ok: true,
-                },
-            },
-            metadata: results.metadata,
-        };
-    }
-    async #handleHttpEndpointRequestForResponse(data, sourceRequest) {
-        this.#internalLogger.debug("Handling HTTP Endpoint request for response", {
-            data,
-        });
-        const httpEndpoint = this.#registeredHttpEndpoints[data.key];
-        if (!httpEndpoint) {
-            this.#internalLogger.debug("No handler registered for HTTP Endpoint", {
-                data,
-            });
-            return {
-                response: {
-                    status: 200,
-                    body: {
-                        ok: true,
-                    },
-                },
-            };
-        }
-        const handledResponse = await httpEndpoint.handleRequest(sourceRequest);
-        if (!handledResponse) {
-            this.#internalLogger.debug("There's no HTTP Endpoint respondWith.handler()", {
-                data,
-            });
-            return {
-                response: {
-                    status: 200,
-                    body: {
-                        ok: true,
-                    },
-                },
-            };
-        }
-        let body;
-        try {
-            body = await handledResponse.text();
-        }
-        catch (error) {
-            this.#internalLogger.error(`Error reading httpEndpoint ${httpEndpoint.id} respondWith.handler Response`, {
-                error,
-            });
-        }
-        const response = {
-            status: handledResponse.status,
-            headers: handledResponse.headers
-                ? Object.fromEntries(handledResponse.headers.entries())
-                : undefined,
-            body,
-        };
-        this.#internalLogger.info(`httpEndpoint ${httpEndpoint.id} respondWith.handler response`, {
-            response,
-        });
-        return {
-            response,
-        };
-    }
-    async #handleWebhookRequest(request, ctx) {
-        this.#internalLogger.debug("Handling webhook request", {
-            ctx,
-        });
-        const okResponse = {
-            status: 200,
-            body: {
-                ok: true,
-            },
-        };
-        const handlers = this.#registeredWebhookSourceHandlers[ctx.key];
-        if (!handlers) {
-            this.#internalLogger.debug("No handler registered for webhook", {
-                ctx,
-            });
-            return {
-                response: okResponse,
-                verified: false,
-            };
-        }
-        const { verify, generateEvents } = handlers;
-        const verifyResult = await verify(request, this, ctx);
-        if (!verifyResult.success) {
-            return {
-                response: okResponse,
-                verified: false,
-                error: verifyResult.reason,
-            };
-        }
-        await generateEvents(request, this, ctx);
-        return {
-            response: okResponse,
-            verified: true,
-        };
-    }
-    async #resolveConnections(ctx, integrations, connections) {
-        if (!integrations) {
-            return { ok: true, data: {} };
-        }
-        const resolvedAuthResults = await Promise.all(Object.keys(integrations).map(async (key) => {
-            const integration = integrations[key];
-            const auth = (connections ?? {})[key];
-            const result = await this.#resolveConnection(ctx, integration, auth);
-            if (result.ok) {
-                return {
-                    ok: true,
-                    auth: result.auth,
-                    key,
-                };
-            }
-            else {
-                return {
-                    ok: false,
-                    error: result.error,
-                    key,
-                };
-            }
-        }));
-        const allResolved = resolvedAuthResults.every((result) => result.ok);
-        if (allResolved) {
-            return {
-                ok: true,
-                data: resolvedAuthResults.reduce((acc, result) => {
-                    acc[result.key] = result.auth;
-                    return acc;
-                }, {}),
-            };
-        }
-        else {
-            return {
-                ok: false,
-                issues: resolvedAuthResults.reduce((acc, result) => {
-                    if (result.ok) {
-                        return acc;
-                    }
-                    const integration = integrations[result.key];
-                    acc[result.key] = { id: integration.id, error: result.error };
-                    return acc;
-                }, {}),
-            };
-        }
-    }
-    async #resolveConnection(ctx, integration, auth) {
-        if (auth) {
-            return { ok: true, auth };
-        }
-        const authResolver = this.#authResolvers[integration.id];
-        if (!authResolver) {
-            if (integration.authSource === "HOSTED") {
-                return {
-                    ok: false,
-                    error: `Something went wrong: Integration ${integration.id} is missing auth credentials from Trigger.dev`,
-                };
-            }
-            return {
-                ok: true,
-                auth: undefined,
-            };
-        }
-        try {
-            const resolvedAuth = await authResolver(ctx, integration);
-            if (!resolvedAuth) {
-                return {
-                    ok: false,
-                    error: `Auth could not be resolved for ${integration.id}: auth resolver returned null or undefined`,
-                };
-            }
-            return {
-                ok: true,
-                auth: resolvedAuth.type === "apiKey"
-                    ? {
-                        type: "apiKey",
-                        accessToken: resolvedAuth.token,
-                        additionalFields: resolvedAuth.additionalFields,
-                    }
-                    : {
-                        type: "oauth2",
-                        accessToken: resolvedAuth.token,
-                        additionalFields: resolvedAuth.additionalFields,
-                    },
-            };
-        }
-        catch (resolverError) {
-            if (resolverError instanceof Error) {
-                return {
-                    ok: false,
-                    error: `Auth could not be resolved for ${integration.id}: auth resolver threw. ${resolverError.name}: ${resolverError.message}`,
-                };
-            }
-            else if (typeof resolverError === "string") {
-                return {
-                    ok: false,
-                    error: `Auth could not be resolved for ${integration.id}: auth resolver threw an error: ${resolverError}`,
-                };
-            }
-            return {
-                ok: false,
-                error: `Auth could not be resolved for ${integration.id}: auth resolver threw an unknown error: ${JSON.stringify(resolverError)}`,
-            };
-        }
-    }
-    #buildJobsIndex() {
-        return Object.values(this.#registeredJobs).map((job) => this.#buildJobIndex(job));
-    }
-    #buildJobIndex(job) {
-        const internal = job.options.__internal;
-        return {
-            id: job.id,
-            name: job.name,
-            version: job.version,
-            event: job.trigger.event,
-            trigger: job.trigger.toJSON(),
-            integrations: this.#buildJobIntegrations(job),
-            startPosition: "latest", // job is deprecated, leaving job for now to make sure newer clients work with older servers
-            enabled: job.enabled,
-            preprocessRuns: job.trigger.preprocessRuns,
-            internal,
-            concurrencyLimit: typeof job.options.concurrencyLimit === "number"
-                ? job.options.concurrencyLimit
-                : typeof job.options.concurrencyLimit === "object"
-                    ? { id: job.options.concurrencyLimit.id, limit: job.options.concurrencyLimit.limit }
-                    : undefined,
-        };
-    }
-    #buildJobIntegrations(job) {
-        return Object.keys(job.options.integrations ?? {}).reduce((acc, key) => {
-            const integration = job.options.integrations[key];
-            acc[key] = this.#buildJobIntegration(integration);
-            return acc;
-        }, {});
-    }
-    #buildJobIntegration(integration) {
-        const authSource = this.#authResolvers[integration.id] ? "RESOLVER" : integration.authSource;
-        return {
-            id: integration.id,
-            metadata: integration.metadata,
-            authSource,
-        };
-    }
-    #logIOStats(stats) {
-        this.#internalLogger.debug("IO stats", {
-            stats,
-        });
-    }
-    #standardResponseHeaders(start) {
-        return {
-            "Trigger-Version": API_VERSIONS.LAZY_LOADED_CACHED_TASKS,
-            "Trigger-SDK-Version": VERSION,
-            "X-Trigger-Request-Timing": `dur=${performance.now() - start / 1000.0}`,
-        };
-    }
-    #serializeRunMetadata(job) {
-        const metadata = {};
-        if (this.#eventEmitter.listenerCount("runSucceeeded") > 0 ||
-            typeof job.options.onSuccess === "function") {
-            metadata["successSubscription"] = true;
-        }
-        if (this.#eventEmitter.listenerCount("runFailed") > 0 ||
-            typeof job.options.onFailure === "function") {
-            metadata["failedSubscription"] = true;
-        }
-        return JSON.stringify(metadata);
-    }
-    async #deliverSuccessfulRunNotification(notification) {
-        this.#internalLogger.debug("delivering successful run notification", {
-            notification,
-        });
-        this.#eventEmitter.emit("runSucceeeded", notification);
-        const job = this.#registeredJobs[notification.job.id];
-        if (!job) {
-            return;
-        }
-        if (typeof job.options.onSuccess === "function") {
-            await job.options.onSuccess(notification);
-        }
-    }
-    async #deliverFailedRunNotification(notification) {
-        this.#internalLogger.debug("delivering failed run notification", {
-            notification,
-        });
-        this.#eventEmitter.emit("runFailed", notification);
-        const job = this.#registeredJobs[notification.job.id];
-        if (!job) {
-            return;
-        }
-        if (typeof job.options.onFailure === "function") {
-            await job.options.onFailure(notification);
-        }
-    }
-}
-function dynamicTriggerRegisterSourceJobId(id) {
-    return `register-dynamic-trigger-${id}`;
-}
-function deepMergeOptions(obj1, obj2) {
-    const mergedOptions = { ...obj1 };
-    for (const key in obj2) {
-        if (obj2.hasOwnProperty(key)) {
-            if (key in mergedOptions) {
-                // @ts-expect-error
-                mergedOptions[key] = [...mergedOptions[key], ...obj2[key]];
-            }
-            else {
-                // @ts-expect-error
-                mergedOptions[key] = obj2[key];
-            }
-        }
-    }
-    return mergedOptions;
-}
-//# sourceMappingURL=triggerClient.js.map