inngest 2.7.1 → 3.0.0

package/components/InngestCommHandler.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InngestCommHandler = void 0;
 const canonicalize_1 = __importDefault(require("canonicalize"));
+const debug_1 = __importDefault(require("debug"));
 const hash_js_1 = require("hash.js");
 const zod_1 = require("zod");
 const ServerTiming_1 = require("../helpers/ServerTiming");
@@ -13,10 +14,12 @@ const devserver_1 = require("../helpers/devserver");
 const env_1 = require("../helpers/env");
 const errors_1 = require("../helpers/errors");
 const functions_1 = require("../helpers/functions");
+const promises_1 = require("../helpers/promises");
 const stream_1 = require("../helpers/stream");
 const strings_1 = require("../helpers/strings");
+const types_1 = require("../types");
 const version_1 = require("../version");
-const NonRetriableError_1 = require("./NonRetriableError");
+const InngestExecution_1 = require("./execution/InngestExecution");
 /**
  * A schema for the response from Inngest when registering.
  */
@@ -62,108 +65,8 @@ const registerResSchema = zod_1.z.object({
  * @public
  */
 class InngestCommHandler {
-    constructor(
-    /**
-     * The name of the framework this handler is designed for. Should be
-     * lowercase, alphanumeric characters inclusive of `-` and `/`.
-     *
-     * This should never be defined by the user; a {@link ServeHandler} should
-     * abstract this.
-     */
-    frameworkName, 
-    /**
-     * The name of this serve handler, e.g. `"My App"`. It's recommended that this
-     * value represents the overarching app/service that this set of functions is
-     * being served from.
-     *
-     * This can also be an `Inngest` client, in which case the name given when
-     * instantiating the client is used. This is useful if you're sending and
-     * receiving events from the same service, as you can reuse a single
-     * definition of Inngest.
-     */
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    client, 
-    /**
-     * An array of the functions to serve and register with Inngest.
-     */
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    functions, options = {}, 
-    /**
-     * The `handler` is the function your framework requires to handle a
-     * request. For example, this is most commonly a function that is given a
-     * `Request` and must return a `Response`.
-     *
-     * The handler must map out any incoming parameters, then return a
-     * strictly-typed object to assess what kind of request is being made,
-     * collecting any relevant data as we go.
-     *
-     * @example
-     * ```
-     * return {
-     *   register: () => { ... },
-     *   run: () => { ... },
-     *   view: () => { ... }
-     * };
-     * ```
-     *
-     * Every key must be specified and must be a function that either returns
-     * a strictly-typed payload or `undefined` if the request is not for that
-     * purpose.
-     *
-     * This gives handlers freedom to choose how their platform of choice will
-     * trigger differing actions, whilst also ensuring all required information
-     * is given for each request type.
-     *
-     * See any existing handler for a full example.
-     *
-     * This should never be defined by the user; a {@link ServeHandler} should
-     * abstract this.
-     */
-    handler, 
-    /**
-     * The `transformRes` function receives the output of the Inngest SDK and
-     * can decide how to package up that information to appropriately return the
-     * information to Inngest.
-     *
-     * Mostly, this is taking the given parameters and returning a new
-     * `Response`.
-     *
-     * The function is passed an {@link ActionResponse} (an object containing a
-     * `status` code, a `headers` object, and a stringified `body`), as well as
-     * every parameter passed to the given `handler` function. This ensures you
-     * can appropriately handle the response, including use of any required
-     * parameters such as `res` in Express-/Connect-like frameworks.
-     *
-     * This should never be defined by the user; a {@link ServeHandler} should
-     * abstract this.
-     */
-    transformRes, 
-    /**
-     * The `streamTransformRes` function, if defined, declares that this handler
-     * supports streaming responses back to Inngest. This is useful for
-     * functions that are expected to take a long time, as edge streaming can
-     * often circumvent restrictive request timeouts and other limitations.
-     *
-     * If your handler does not support streaming, do not define this function.
-     *
-     * It receives the output of the Inngest SDK and can decide how to package
-     * up that information to appropriately return the information in a stream
-     * to Inngest.
-     *
-     * Mostly, this is taking the given parameters and returning a new
-     * `Response`.
-     *
-     * The function is passed an {@link ActionResponse} (an object containing a
-     * `status` code, a `headers` object, and `body`, a `ReadableStream`), as
-     * well as every parameter passed to the given `handler` function. This
-     * ensures you can appropriately handle the response, including use of any
-     * required parameters such as `res` in Express-/Connect-like frameworks.
-     *
-     * This should never be defined by the user; a {@link ServeHandler} should
-     * abstract this.
-     */
-    streamTransformRes) {
-        var _a, _b, _c;
+    constructor(options) {
+        var _a;
         /**
          * A property that can be set to indicate whether or not we believe we are in
          * production mode.
@@ -182,28 +85,36 @@ class InngestCommHandler {
          * to find and register functions when interacting with Inngest Cloud.
          */
         this.fns = {};
-        this.frameworkName =
-            (options === null || options === void 0 ? void 0 : options.frameworkName) || frameworkName;
-        this.client = client;
-        this.name = options.name || this.client.name;
-        this.handler = handler;
-        this.transformRes = transformRes;
-        this.streamTransformRes = streamTransformRes;
+        this.env = (0, env_1.allProcessEnv)();
+        /**
+         * v2 -> v3 migration error.
+         *
+         * If a serve handler is passed a client as the first argument, it'll be
+         * spread in to these options. We should be able to detect this by picking
+         * up a unique property on the object.
+         */
+        if (Object.prototype.hasOwnProperty.call(options, "eventKey")) {
+            throw new Error(`${consts_1.logPrefix} You've passed an Inngest client as the first argument to your serve handler. This is no longer supported in v3; please pass the Inngest client as the \`client\` property of an options object instead. See https://www.inngest.com/docs/sdk/migration`);
+        }
+        this.frameworkName = options.frameworkName;
+        this.client = options.client;
+        this.id = options.id || this.client.id;
+        this.handler = options.handler;
         /**
          * Provide a hidden option to allow expired signatures to be accepted during
          * testing.
          */
         this.allowExpiredSignatures = Boolean(
         // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, prefer-rest-params
-        (_a = arguments["3"]) === null || _a === void 0 ? void 0 : _a.__testingAllowExpiredSignatures);
+        (_a = arguments["0"]) === null || _a === void 0 ? void 0 : _a.__testingAllowExpiredSignatures);
         // Ensure we filter any undefined functions in case of missing imports.
-        this.rawFns = functions.filter(Boolean);
-        if (this.rawFns.length !== functions.length) {
+        this.rawFns = options.functions.filter(Boolean);
+        if (this.rawFns.length !== options.functions.length) {
             // TODO PrettyError
             console.warn(`Some functions passed to serve() are undefined and misconfigured.  Please check your imports.`);
         }
         this.fns = this.rawFns.reduce((acc, fn) => {
-            const configs = fn["getConfig"](new URL("https://example.com"), this.name);
+            const configs = fn["getConfig"](new URL("https://example.com"), this.id);
             const fns = configs.reduce((acc, { id }, index) => {
                 return Object.assign(Object.assign({}, acc), { [id]: { fn, onFailure: Boolean(index) } });
             }, {});
@@ -215,12 +126,34 @@ class InngestCommHandler {
             });
             return Object.assign(Object.assign({}, acc), fns);
         }, {});
-        this.inngestRegisterUrl = new URL(options.inngestRegisterUrl || "https://api.inngest.com/fn/register");
+        this.inngestRegisterUrl = new URL("/fn/register", options.baseUrl ||
+            this.env[consts_1.envKeys.InngestBaseUrl] ||
+            this.client["baseUrl"] ||
+            consts_1.defaultInngestBaseUrl);
         this.signingKey = options.signingKey;
-        this.serveHost = options.serveHost;
-        this.servePath = options.servePath;
-        this.logLevel = (_b = options.logLevel) !== null && _b !== void 0 ? _b : "info";
-        this.streaming = (_c = options.streaming) !== null && _c !== void 0 ? _c : false;
+        this.serveHost = options.serveHost || this.env[consts_1.envKeys.InngestServeHost];
+        this.servePath = options.servePath || this.env[consts_1.envKeys.InngestServePath];
+        const defaultLogLevel = "info";
+        this.logLevel = zod_1.z
+            .enum(types_1.logLevels)
+            .default(defaultLogLevel)
+            .catch((ctx) => {
+            this.log("warn", `Unknown log level passed: ${String(ctx.input)}; defaulting to ${defaultLogLevel}`);
+            return defaultLogLevel;
+        })
+            .parse(options.logLevel || this.env[consts_1.envKeys.InngestLogLevel]);
+        if (this.logLevel === "debug") {
+            debug_1.default.enable(`${consts_1.debugPrefix}:*`);
+        }
+        const defaultStreamingOption = false;
+        this.streaming = zod_1.z
+            .union([zod_1.z.enum(["allow", "force"]), zod_1.z.literal(false)])
+            .default(defaultStreamingOption)
+            .catch((ctx) => {
+            this.log("warn", `Unknown streaming option passed: ${String(ctx.input)}; defaulting to ${String(defaultStreamingOption)}`);
+            return defaultStreamingOption;
+        })
+            .parse(options.streaming || this.env[consts_1.envKeys.InngestStreaming]);
         this.fetch = (0, env_1.getFetch)(options.fetch || this.client["fetch"]);
     }
     // hashedSigningKey creates a sha256 checksum of the signing key with the
@@ -253,35 +186,54 @@ class InngestCommHandler {
      */
     createHandler() {
         return async (...args) => {
+            var _a, _b;
             const timer = new ServerTiming_1.ServerTiming();
             /**
              * We purposefully `await` the handler, as it could be either sync or
              * async.
              */
-            // eslint-disable-next-line @typescript-eslint/await-thenable
-            const rawActions = await timer.wrap("handler", () => this.handler(...args));
+            const rawActions = await timer
+                .wrap("handler", () => this.handler(...args))
+                .catch((0, errors_1.rethrowError)("Serve handler failed to run"));
             /**
-             * For each function within the actions returned, ensure that its value
-             * caches when run. This ensures that the function is only run once, even
-             * if it's called multiple times throughout this handler's invocation.
+             * Map over every `action` in `rawActions` and create a new `actions`
+             * object where each function is safely promisifed with each access
+             * requiring a reason.
              *
-             * Many frameworks have issues with multiple calls to req/res objects;
-             * reading a request's body multiple times is a common example. This makes
-             * sure to handle this without having to pass around references.
+             * This helps us provide high quality errors about what's going wrong for
+             * each access without having to wrap every access in a try/catch.
              */
-            const actions = Object.fromEntries(Object.entries(rawActions).map(([key, val]) => [
-                key,
-                typeof val === "function" ? (0, functions_1.cacheFn)(val) : val,
-            ]));
-            const getHeaders = () => (0, env_1.inngestHeaders)({
-                env: actions.env,
+            const actions = Object.entries(rawActions).reduce((acc, [key, value]) => {
+                if (typeof value !== "function") {
+                    return acc;
+                }
+                return Object.assign(Object.assign({}, acc), { [key]: (reason, ...args) => {
+                        const errMessage = [
+                            `Failed calling \`${key}\` from serve handler`,
+                            reason,
+                        ]
+                            .filter(Boolean)
+                            .join(" when ");
+                        const fn = () => value(...args);
+                        return (0, promises_1.runAsPromise)(fn)
+                            .catch((0, errors_1.rethrowError)(errMessage))
+                            .catch((err) => {
+                            this.log("error", err);
+                            throw err;
+                        });
+                    } });
+            }, {});
+            this.env =
+                (_b = (await ((_a = actions.env) === null || _a === void 0 ? void 0 : _a.call(actions, "starting to handle request")))) !== null && _b !== void 0 ? _b : (0, env_1.allProcessEnv)();
+            const getInngestHeaders = () => (0, env_1.inngestHeaders)({
+                env: this.env,
                 framework: this.frameworkName,
                 client: this.client,
                 extras: {
                     "Server-Timing": timer.getHeader(),
                 },
             });
-            const actionRes = timer.wrap("action", () => this.handleAction(actions, timer));
+            const actionRes = timer.wrap("action", () => this.handleAction(actions, timer, getInngestHeaders));
             /**
              * Prepares an action response by merging returned data to provide
              * trailing information such as `Server-Timing` headers.
@@ -289,34 +241,43 @@ class InngestCommHandler {
              * It should always prioritize the headers returned by the action, as
              * they may contain important information such as `Content-Type`.
              */
-            const prepareActionRes = (res) => (Object.assign(Object.assign({}, res), { headers: Object.assign(Object.assign({}, getHeaders()), res.headers) }));
+            const prepareActionRes = (res) => {
+                var _a;
+                return (Object.assign(Object.assign({}, res), { headers: Object.assign(Object.assign(Object.assign({}, getInngestHeaders()), res.headers), (res.version === null
+                        ? {}
+                        : {
+                            [consts_1.headerKeys.RequestVersion]: ((_a = res.version) !== null && _a !== void 0 ? _a : InngestExecution_1.PREFERRED_EXECUTION_VERSION).toString(),
+                        })) }));
+            };
             const wantToStream = this.streaming === "force" ||
                 (this.streaming === "allow" &&
-                    (0, env_1.platformSupportsStreaming)(this.frameworkName, actions.env));
-            if (wantToStream && this.streamTransformRes) {
-                const runRes = await actions.run();
-                if (runRes) {
+                    (0, env_1.platformSupportsStreaming)(this.frameworkName, this.env));
+            if (wantToStream && actions.transformStreamingResponse) {
+                const method = await actions.method("starting streaming response");
+                if (method === "POST") {
                     const { stream, finalize } = await (0, stream_1.createStream)();
                     /**
                      * Errors are handled by `handleAction` here to ensure that an
                      * appropriate response is always given.
                      */
-                    void actionRes.then((res) => finalize(prepareActionRes(res)));
+                    void actionRes.then((res) => {
+                        return finalize(prepareActionRes(res));
+                    });
                     return timer.wrap("res", () => {
                         var _a;
-                        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-                        return (_a = this.streamTransformRes) === null || _a === void 0 ? void 0 : _a.call(this, {
+                        return (_a = actions.transformStreamingResponse) === null || _a === void 0 ? void 0 : _a.call(actions, "starting streaming response", {
                             status: 201,
-                            headers: getHeaders(),
+                            headers: getInngestHeaders(),
                             body: stream,
-                        }, ...args);
+                            version: null,
+                        });
                     });
                 }
             }
             return timer.wrap("res", async () => {
-                return actionRes.then((res) => {
+                return actionRes.then(prepareActionRes).then((actionRes) => {
                     // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-                    return this.transformRes(prepareActionRes(res), ...args);
+                    return actions.transformResponse("sending back response", actionRes);
                 });
             });
         };
@@ -332,58 +293,111 @@ class InngestCommHandler {
      * will decide whether the UI should be visible based on the payload it has
      * found (e.g. env vars, options, etc).
      */
-    async handleAction(actions, timer) {
+    async handleAction(actions, timer, getInngestHeaders) {
         var _a, _b, _c;
-        const env = (_a = actions.env) !== null && _a !== void 0 ? _a : (0, env_1.allProcessEnv)();
-        const getHeaders = () => (0, env_1.inngestHeaders)({
-            env: env,
-            framework: this.frameworkName,
-            client: this.client,
-            extras: {
-                "Server-Timing": timer.getHeader(),
-            },
-        });
-        this._isProd = (_b = actions.isProduction) !== null && _b !== void 0 ? _b : (0, env_1.isProd)(env);
+        this._isProd =
+            (_b = (await ((_a = actions.isProduction) === null || _a === void 0 ? void 0 : _a.call(actions, "starting to handle request")))) !== null && _b !== void 0 ? _b : (0, env_1.isProd)(this.env);
         /**
          * If we've been explicitly passed an Inngest dev sever URL, assume that
          * we shouldn't skip the dev server.
          */
-        this._skipDevServer = (0, env_1.devServerHost)(env)
+        this._skipDevServer = (0, env_1.devServerHost)(this.env)
             ? false
-            : (_c = this._isProd) !== null && _c !== void 0 ? _c : (0, env_1.skipDevServer)(env);
+            : (_c = this._isProd) !== null && _c !== void 0 ? _c : (0, env_1.skipDevServer)(this.env);
+        this.upsertKeysFromEnv();
         try {
-            const runRes = await actions.run();
-            if (runRes) {
-                this.upsertKeysFromEnv(env);
-                this.validateSignature(runRes.signature, runRes.data);
-                this.client["inngestApi"].setSigningKey(this.signingKey);
-                const stepRes = await this.runStep(runRes.fnId, runRes.stepId, runRes.data, timer);
-                if (stepRes.status === 500 || stepRes.status === 400) {
-                    const headers = {
-                        "Content-Type": "application/json",
-                    };
-                    if (stepRes.status === 400) {
-                        headers[consts_1.headerKeys.NoRetry] = "true";
-                    }
-                    return {
-                        status: stepRes.status,
-                        body: (0, strings_1.stringify)(stepRes.error ||
-                            (0, errors_1.serializeError)(new Error("Unknown error; function failed but no error was returned"))),
-                        headers,
-                    };
+            const url = await actions.url("starting to handle request");
+            const method = await actions.method("starting to handle request");
+            const getQuerystring = async (reason, key) => {
+                var _a;
+                const ret = (await ((_a = actions.queryString) === null || _a === void 0 ? void 0 : _a.call(actions, reason, key, url))) ||
+                    url.searchParams.get(key) ||
+                    undefined;
+                return ret;
+            };
+            if (method === "POST") {
+                const signature = await actions.headers("checking signature for run request", consts_1.headerKeys.Signature);
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                const body = await actions.body("processing run request");
+                this.validateSignature(signature !== null && signature !== void 0 ? signature : undefined, body);
+                const fnId = await getQuerystring("processing run request", consts_1.queryKeys.FnId);
+                if (!fnId) {
+                    // TODO PrettyError
+                    throw new Error("No function ID found in request");
                 }
-                return {
-                    status: stepRes.status,
-                    body: (0, strings_1.stringify)(stepRes.body),
-                    headers: {
-                        "Content-Type": "application/json",
+                const stepId = (await getQuerystring("processing run request", consts_1.queryKeys.StepId)) ||
+                    null;
+                const { version, result } = this.runStep(fnId, stepId, body, timer);
+                const stepOutput = await result;
+                /**
+                 * Functions can return `undefined`, but we'll always convert this to
+                 * `null`, as this is appropriately serializable by JSON.
+                 */
+                const opDataUndefinedToNull = (op) => {
+                    const opData = zod_1.z.object({ data: zod_1.z.any() }).safeParse(op.data);
+                    if (opData.success) {
+                        op.data.data = (0, functions_1.undefinedToNull)(opData.data.data);
+                    }
+                    return op;
+                };
+                const resultHandlers = {
+                    "function-rejected": (result) => {
+                        return {
+                            status: result.retriable ? 500 : 400,
+                            headers: Object.assign({ "Content-Type": "application/json", [consts_1.headerKeys.NoRetry]: result.retriable ? "false" : "true" }, (typeof result.retriable === "string"
+                                ? { [consts_1.headerKeys.RetryAfter]: result.retriable }
+                                : {})),
+                            body: (0, strings_1.stringify)((0, functions_1.undefinedToNull)(result.error)),
+                            version,
+                        };
+                    },
+                    "function-resolved": (result) => {
+                        return {
+                            status: 200,
+                            headers: {
+                                "Content-Type": "application/json",
+                            },
+                            body: (0, strings_1.stringify)((0, functions_1.undefinedToNull)(result.data)),
+                            version,
+                        };
+                    },
+                    "step-not-found": (result) => {
+                        return {
+                            status: 500,
+                            headers: {
+                                "Content-Type": "application/json",
+                                [consts_1.headerKeys.NoRetry]: "false",
+                            },
+                            body: (0, strings_1.stringify)({
+                                error: `Could not find step "${result.step.id}" to run; timed out`,
+                            }),
+                            version,
+                        };
+                    },
+                    "step-ran": (result) => {
+                        const step = opDataUndefinedToNull(result.step);
+                        return {
+                            status: 206,
+                            headers: { "Content-Type": "application/json" },
+                            body: (0, strings_1.stringify)([step]),
+                            version,
+                        };
+                    },
+                    "steps-found": (result) => {
+                        const steps = result.steps.map(opDataUndefinedToNull);
+                        return {
+                            status: 206,
+                            headers: { "Content-Type": "application/json" },
+                            body: (0, strings_1.stringify)(steps),
+                            version,
+                        };
                     },
                 };
+                const handler = resultHandlers[stepOutput.type];
+                return await handler(stepOutput);
             }
-            const viewRes = await actions.view();
-            if (viewRes) {
-                this.upsertKeysFromEnv(env);
-                const registerBody = this.registerBody(this.reqUrl(actions.url));
+            if (method === "GET") {
+                const registerBody = this.registerBody(this.reqUrl(url));
                 const introspection = {
                     message: "Inngest endpoint configured correctly.",
                     hasEventKey: Boolean(this.client["eventKey"]),
@@ -396,18 +410,19 @@ class InngestCommHandler {
                     headers: {
                         "Content-Type": "application/json",
                     },
+                    version: undefined,
                 };
             }
-            const registerRes = await actions.register();
-            if (registerRes) {
-                this.upsertKeysFromEnv(env);
-                const { status, message, modified } = await this.register(this.reqUrl(actions.url), (0, strings_1.stringifyUnknown)(env[consts_1.envKeys.DevServerUrl]), registerRes.deployId, getHeaders);
+            if (method === "PUT") {
+                const deployId = await getQuerystring("processing deployment request", consts_1.queryKeys.DeployId);
+                const { status, message, modified } = await this.register(this.reqUrl(url), deployId, getInngestHeaders);
                 return {
                     status,
                     body: (0, strings_1.stringify)({ message, modified }),
                     headers: {
                         "Content-Type": "application/json",
                     },
+                    version: undefined,
                 };
             }
         }
@@ -418,6 +433,7 @@ class InngestCommHandler {
                 headers: {
                     "Content-Type": "application/json",
                 },
+                version: undefined,
             };
         }
         return {
@@ -428,104 +444,83 @@ class InngestCommHandler {
                 skipDevServer: this._skipDevServer,
             }),
             headers: {},
+            version: undefined,
         };
     }
-    async runStep(functionId, stepId, data, timer) {
-        var _a, _b;
-        try {
-            const fn = this.fns[functionId];
-            if (!fn) {
-                // TODO PrettyError
-                throw new Error(`Could not find function with ID "${functionId}"`);
-            }
-            const fndata = await (0, functions_1.parseFnData)(data, this.client["inngestApi"]);
-            if (!fndata.ok) {
-                throw new Error(fndata.error);
-            }
-            const { event, events, steps, ctx } = fndata.value;
-            /**
-             * TODO When the executor does support per-step errors, this map will need
-             * to adjust to ensure we're not double-stacking the op inside `data`.
-             */
-            const opStack = (_b = (_a = ctx === null || ctx === void 0 ? void 0 : ctx.stack) === null || _a === void 0 ? void 0 : _a.stack.slice(0, ctx.stack.current).map((opId) => {
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-                const step = steps === null || steps === void 0 ? void 0 : steps[opId];
-                if (typeof step === "undefined") {
-                    // TODO PrettyError
-                    throw new Error(`Could not find step with ID "${opId}"`);
-                }
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-                return { id: opId, data: step };
-            })) !== null && _b !== void 0 ? _b : [];
-            const ret = await fn.fn["runFn"]({ event, events, runId: ctx === null || ctx === void 0 ? void 0 : ctx.run_id, attempt: ctx === null || ctx === void 0 ? void 0 : ctx.attempt }, opStack, 
-            /**
-             * TODO The executor is sending `"step"` as the step ID when it is not
-             * wanting to run a specific step. This is not needed and we should
-             * remove this on the executor side.
-             */
-            stepId === "step" ? null : stepId || null, timer, fn.onFailure);
-            if (ret[0] === "complete") {
-                return {
-                    status: 200,
-                    body: ret[1],
-                };
-            }
-            /**
-             * If the function has run user code and is intending to return an error,
-             * interrupt this flow and instead throw a 500 to Inngest.
-             *
-             * The executor doesn't yet support per-step errors, so returning an
-             * `error` key here would cause the executor to misunderstand what is
-             * happening.
-             *
-             * TODO When the executor does support per-step errors, we can remove this
-             * comment and check and functionality should resume as normal.
-             */
-            if (ret[0] === "run" && ret[1].error) {
-                /**
-                 * We throw the `data` here instead of the `error` because we expect
-                 * `data` to be a prepared version of the error which may have been
-                 * altered by middleware, whereas `error` is the initial triggering
-                 * error.
-                 */
-                throw new errors_1.OutgoingResultError({
-                    data: ret[1].data,
-                    error: ret[1].error,
-                });
-            }
-            return {
-                status: 206,
-                body: Array.isArray(ret[1]) ? ret[1] : [ret[1]],
-            };
-        }
-        catch (unserializedErr) {
-            /**
-             * Always serialize the error before sending it back to Inngest. Errors,
-             * by default, do not niceley serialize to JSON, so we use the a package
-             * to do this.
-             *
-             * See {@link https://www.npmjs.com/package/serialize-error}
-             */
-            const isOutgoingOpError = unserializedErr instanceof errors_1.OutgoingResultError;
-            const error = (0, strings_1.stringify)((0, errors_1.serializeError)(isOutgoingOpError ? unserializedErr.result.data : unserializedErr));
-            const isNonRetriableError = isOutgoingOpError
-                ? unserializedErr.result.error instanceof NonRetriableError_1.NonRetriableError
-                : unserializedErr instanceof NonRetriableError_1.NonRetriableError;
-            /**
-             * If we've caught a non-retriable error, we'll return a 400 to Inngest
-             * to indicate that the error is not transient and should not be retried.
-             *
-             * The errors caught here are caught from the main function as well as
-             * inside individual steps, so this safely catches all areas.
-             */
-            return {
-                status: isNonRetriableError ? 400 : 500,
-                error,
-            };
+    runStep(functionId, stepId, data, timer) {
+        const fn = this.fns[functionId];
+        if (!fn) {
+            // TODO PrettyError
+            throw new Error(`Could not find function with ID "${functionId}"`);
         }
+        const immediateFnData = (0, functions_1.parseFnData)(data);
+        const { version } = immediateFnData;
+        const result = (0, promises_1.runAsPromise)(async () => {
+            const anyFnData = await (0, functions_1.fetchAllFnData)(immediateFnData, this.client["inngestApi"]);
+            if (!anyFnData.ok) {
+                throw new Error(anyFnData.error);
+            }
+            const executionStarters = ((s) => s)({
+                [InngestExecution_1.ExecutionVersion.V0]: ({ event, events, steps, ctx, version }) => {
+                    var _a, _b, _c;
+                    const stepState = Object.entries(steps !== null && steps !== void 0 ? steps : {}).reduce((acc, [id, data]) => {
+                        return Object.assign(Object.assign({}, acc), { 
+                            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                            [id]: { id, data } });
+                    }, {});
+                    return {
+                        version,
+                        partialOptions: {
+                            runId: (ctx === null || ctx === void 0 ? void 0 : ctx.run_id) || "",
+                            data: {
+                                event: event,
+                                events: events,
+                                runId: (ctx === null || ctx === void 0 ? void 0 : ctx.run_id) || "",
+                                attempt: (_a = ctx === null || ctx === void 0 ? void 0 : ctx.attempt) !== null && _a !== void 0 ? _a : 0,
+                            },
+                            stepState,
+                            requestedRunStep: stepId === "step" ? undefined : stepId || undefined,
+                            timer,
+                            isFailureHandler: fn.onFailure,
+                            stepCompletionOrder: (_c = (_b = ctx === null || ctx === void 0 ? void 0 : ctx.stack) === null || _b === void 0 ? void 0 : _b.stack) !== null && _c !== void 0 ? _c : [],
+                        },
+                    };
+                },
+                [InngestExecution_1.ExecutionVersion.V1]: ({ event, events, steps, ctx, version }) => {
+                    var _a, _b, _c;
+                    const stepState = Object.entries(steps !== null && steps !== void 0 ? steps : {}).reduce((acc, [id, result]) => {
+                        return Object.assign(Object.assign({}, acc), { [id]: result.type === "data"
+                                ? // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                                    { id, data: result.data }
+                                : { id, error: result.error } });
+                    }, {});
+                    return {
+                        version,
+                        partialOptions: {
+                            runId: (ctx === null || ctx === void 0 ? void 0 : ctx.run_id) || "",
+                            data: {
+                                event: event,
+                                events: events,
+                                runId: (ctx === null || ctx === void 0 ? void 0 : ctx.run_id) || "",
+                                attempt: (_a = ctx === null || ctx === void 0 ? void 0 : ctx.attempt) !== null && _a !== void 0 ? _a : 0,
+                            },
+                            stepState,
+                            requestedRunStep: stepId === "step" ? undefined : stepId || undefined,
+                            timer,
+                            isFailureHandler: fn.onFailure,
+                            disableImmediateExecution: ctx === null || ctx === void 0 ? void 0 : ctx.disable_immediate_execution,
+                            stepCompletionOrder: (_c = (_b = ctx === null || ctx === void 0 ? void 0 : ctx.stack) === null || _b === void 0 ? void 0 : _b.stack) !== null && _c !== void 0 ? _c : [],
+                        },
+                    };
+                },
+            });
+            const executionOptions = await executionStarters[anyFnData.value.version](anyFnData.value);
+            return fn.fn["createExecution"](executionOptions).start();
+        });
+        return { version, result };
     }
     configs(url) {
-        return Object.values(this.rawFns).reduce((acc, fn) => [...acc, ...fn["getConfig"](url, this.name)], []);
+        return Object.values(this.rawFns).reduce((acc, fn) => [...acc, ...fn["getConfig"](url, this.id)], []);
     }
     /**
      * Return an Inngest serve endpoint URL given a potential `path` and `host`.
@@ -535,14 +530,14 @@ class InngestCommHandler {
      */
     reqUrl(url) {
         let ret = new URL(url);
-        if (this.servePath)
-            ret.pathname = this.servePath;
-        if (this.serveHost)
-            ret = new URL(ret.pathname + ret.search, this.serveHost);
-        /**
-         * Remove any introspection query strings.
-         */
-        ret.searchParams.delete(consts_1.queryKeys.Introspect);
+        const serveHost = this.serveHost || this.env[consts_1.envKeys.InngestServeHost];
+        const servePath = this.servePath || this.env[consts_1.envKeys.InngestServePath];
+        if (servePath) {
+            ret.pathname = servePath;
+        }
+        if (serveHost) {
+            ret = new URL(ret.pathname + ret.search, serveHost);
+        }
         return ret;
     }
     registerBody(url) {
@@ -550,7 +545,7 @@ class InngestCommHandler {
             url: url.href,
             deployType: "ping",
             framework: this.frameworkName,
-            appName: this.name,
+            appName: this.id,
             functions: this.configs(url),
             sdk: `js:v${version_1.version}`,
             v: "0.1",
@@ -559,19 +554,20 @@ class InngestCommHandler {
         body.hash = (0, hash_js_1.sha256)().update((0, canonicalize_1.default)(body)).digest("hex");
         return body;
     }
-    async register(url, devServerHost, deployId, getHeaders) {
+    async register(url, deployId, getHeaders) {
         const body = this.registerBody(url);
         let res;
         // Whenever we register, we check to see if the dev server is up.  This
         // is a noop and returns false in production.
         let registerURL = this.inngestRegisterUrl;
         if (!this._skipDevServer) {
-            const hasDevServer = await (0, devserver_1.devServerAvailable)(devServerHost, this.fetch);
+            const host = (0, env_1.devServerHost)(this.env);
+            const hasDevServer = await (0, devserver_1.devServerAvailable)(host, this.fetch);
             if (hasDevServer) {
-                registerURL = (0, devserver_1.devServerUrl)(devServerHost, "/fn/register");
+                registerURL = (0, devserver_1.devServerUrl)(host, "/fn/register");
             }
         }
-        if (deployId) {
+        if (deployId && deployId !== "undefined") {
             registerURL.searchParams.set(consts_1.queryKeys.DeployId, deployId);
         }
         try {
@@ -618,12 +614,22 @@ class InngestCommHandler {
      * situations where environment variables are passed directly to handlers or
      * are otherwise difficult to access during initialization.
      */
-    upsertKeysFromEnv(env) {
-        if (!this.signingKey && env[consts_1.envKeys.SigningKey]) {
-            this.signingKey = String(env[consts_1.envKeys.SigningKey]);
+    upsertKeysFromEnv() {
+        if (this.env[consts_1.envKeys.InngestSigningKey]) {
+            if (!this.signingKey) {
+                this.signingKey = String(this.env[consts_1.envKeys.InngestSigningKey]);
+            }
+            this.client["inngestApi"].setSigningKey(this.signingKey);
+        }
+        if (!this.client["eventKey"] && this.env[consts_1.envKeys.InngestEventKey]) {
+            this.client.setEventKey(String(this.env[consts_1.envKeys.InngestEventKey]));
+        }
+        // v2 -> v3 migration warnings
+        if (this.env[consts_1.envKeys.InngestDevServerUrl]) {
+            this.log("warn", `Use of ${consts_1.envKeys.InngestDevServerUrl} has been deprecated in v3; please use ${consts_1.envKeys.InngestBaseUrl} instead. See https://www.inngest.com/docs/sdk/migration`);
         }
-        if (!this.client["eventKey"] && env[consts_1.envKeys.EventKey]) {
-            this.client.setEventKey(String(env[consts_1.envKeys.EventKey]));
+        if (this.env[consts_1.envKeys.InngestApiBaseUrl]) {
+            this.log("warn", `Use of ${consts_1.envKeys.InngestApiBaseUrl} has been deprecated in v3; please use ${consts_1.envKeys.InngestBaseUrl} instead. See https://www.inngest.com/docs/sdk/migration`);
         }
     }
     validateSignature(sig, body) {
@@ -639,7 +645,7 @@ class InngestCommHandler {
         // If we're here, we're in production; lack of a signing key is an error.
         if (!this.signingKey) {
             // TODO PrettyError
-            throw new Error(`No signing key found in client options or ${consts_1.envKeys.SigningKey} env var. Find your keys at https://app.inngest.com/secrets`);
+            throw new Error(`No signing key found in client options or ${consts_1.envKeys.InngestSigningKey} env var. Find your keys at https://app.inngest.com/secrets`);
         }
         // If we're here, we're in production; lack of a req signature is an error.
         if (!sig) {
@@ -677,10 +683,10 @@ class InngestCommHandler {
         const currentLevel = logLevels.indexOf(level);
         if (currentLevel >= logLevelSetting) {
             let logger = console.log;
-            if (Object.hasOwnProperty.call(console, level)) {
+            if (Object.prototype.hasOwnProperty.call(console, level)) {
                 logger = console[level];
             }
-            logger(`inngest ${level}: `, ...args);
+            logger(`${consts_1.logPrefix} ${level} -`, ...args);
         }
     }
 }