effect-inngest 0.1.3 → 0.3.0-beta.0

package/dist/internal/handler.js

@@ -1,145 +1,177 @@
-import { Headers, RegisterResponse, SDKRequestBody, SDKRequestContext, UserError } from "./protocol.js";
+import { resolveConfig } from "./checkpoint/Config.js";
+import { Headers, RegisterServerResponse, SDKRequestBody, SDKRequestContext, UserError } from "./protocol.js";
+import "./serve/Signature.js";
 import { InngestClient } from "../Client.js";
-import { Signature, SignatureError } from "./signature.js";
+import { schemaBodyJson, verifySignature } from "./serve/Request.js";
 import { execute } from "./driver.js";
-import * as HttpClient from "@effect/platform/HttpClient";
-import "@effect/platform/HttpServerRequest";
-import "effect/Context";
-import * as Effect from "effect/Effect";
-import * as Schema from "effect/Schema";
-import * as HttpClientRequest from "@effect/platform/HttpClientRequest";
-import * as HttpClientResponse from "@effect/platform/HttpClientResponse";
-import * as Predicate from "effect/Predicate";
-
+import { Cause, Effect, Option, Predicate, Schema } from "effect";
+import * as HttpClient from "effect/unstable/http/HttpClient";
+import * as HttpClientRequest from "effect/unstable/http/HttpClientRequest";
+import * as HttpClientResponse from "effect/unstable/http/HttpClientResponse";
+import "effect/unstable/http/HttpServerRequest";
 //#region src/internal/handler.ts
-/**
-* Internal handler implementation.
-* @internal
-*/
-var InvalidRequestError = class extends Schema.TaggedError()("InvalidRequestError", { message: Schema.String }) {};
+var InvalidRequestError = class extends Schema.TaggedErrorClass()("InvalidRequestError", { message: Schema.String }) {};
 const SDK_VERSION = "2.0.0";
-const baseHeaders = () => ({
+const baseHeaders = (framework) => ({
 	"Content-Type": "application/json",
+	"User-Agent": `effect-inngest:v${SDK_VERSION}`,
 	[Headers.SDK]: `effect-inngest:v${SDK_VERSION}`,
-	[Headers.RequestVersion]: "1"
+	[Headers.SDKHandled]: "true",
+	[Headers.RequestVersion]: "2",
+	...framework ? { [Headers.Framework]: framework } : {}
 });
-const buildServeUrl = (requestUrl, serveHost, servePath) => {
-	const url = new URL(requestUrl);
-	if (servePath) url.pathname = servePath;
-	if (serveHost) return new URL(url.pathname + url.search, serveHost);
+const buildServeUrl = (args) => {
+	const url = new URL(args.requestUrl);
+	if (args.servePath) url.pathname = args.servePath;
+	if (args.serveHost) return new URL(url.pathname + url.search, args.serveHost);
 	return url;
 };
-const verifyAndParseRequestBody = (request) => Effect.gen(function* () {
-	const client = yield* InngestClient;
-	const sig = yield* Signature;
-	const config = client.config;
-	const isDev = client.mode === "dev";
-	const bodyText = yield* request.text.pipe(Effect.mapError((error) => new InvalidRequestError({ message: `Failed to read request body: ${String(error)}` })));
-	yield* sig.verify({
-		body: new TextEncoder().encode(bodyText),
-		signatureHeader: request.headers[Headers.Signature.toLowerCase()],
-		signingKey: config.signingKey,
-		signingKeyFallback: config.signingKeyFallback,
-		isDev
-	});
-	return yield* Schema.decodeUnknown(Schema.parseJson(SDKRequestBody))(bodyText).pipe(Effect.mapError((error) => new InvalidRequestError({ message: `Invalid request body: ${String(error)}` })));
+const verifyAndParseRequestBody = Effect.fn("effect-inngest/handler/verifyAndParseRequestBody")(function* (request) {
+	const body = yield* request.arrayBuffer.pipe(Effect.map((buffer) => new Uint8Array(buffer)), Effect.mapError((error) => {
+		return new InvalidRequestError({ message: `Failed to read request body: ${Predicate.hasProperty(error, "message") && Predicate.isString(error.message) ? error.message : "unknown"}` });
+	}));
+	yield* verifySignature(body, request);
+	return yield* schemaBodyJson(SDKRequestBody)(body).pipe(Effect.mapError((error) => new InvalidRequestError({ message: `Invalid request body: ${String(error)}` })));
 });
-const handleIntrospection = (group, _requestUrl) => Effect.gen(function* () {
+const handleIntrospection = Effect.fn("effect-inngest/handler/handleIntrospection")(function* (group, _requestUrl) {
 	const client = yield* InngestClient;
 	const config = client.config;
 	const body = {
+		extra: { native_crypto: globalThis.crypto?.subtle ? true : false },
+		has_event_key: Predicate.isNotUndefined(config.eventKey),
+		has_signing_key: Predicate.isNotUndefined(config.signingKey),
 		function_count: group.functions.size,
-		has_event_key: config.eventKey !== void 0,
-		has_signing_key: config.signingKey !== void 0,
-		has_signing_key_fallback: config.signingKeyFallback !== void 0,
 		mode: client.mode === "dev" ? "dev" : "cloud",
-		schema_version: "2024-05-24",
-		authentication_succeeded: null
+		schema_version: "2024-05-24"
 	};
 	return {
 		status: 200,
-		headers: baseHeaders(),
+		headers: baseHeaders(config.framework),
 		body
 	};
 });
-const RegisterRequest = Schema.Struct({
-	url: Schema.String,
-	v: Schema.String,
-	deployType: Schema.Literal("ping"),
-	sdk: Schema.String,
-	appName: Schema.String,
-	framework: Schema.String,
-	functions: Schema.Array(Schema.Unknown)
-});
-const handleRegistration = (group, requestUrl) => Effect.gen(function* () {
+const handleRegistration = Effect.fn("effect-inngest/handler/handleRegistration")(function* (group, requestUrl) {
 	const client = yield* InngestClient;
 	const httpClient = yield* HttpClient.HttpClient;
 	const config = client.config;
-	const url = buildServeUrl(requestUrl, config.serveHost, config.servePath);
+	const url = buildServeUrl({
+		requestUrl,
+		serveHost: config.serveHost,
+		servePath: config.servePath
+	});
 	const functions = Array.from(group.functions.values()).map((fn) => fn.toRegistration({
 		appId: config.id,
 		url: url.href
 	}));
+	const framework = config.framework;
 	const registerUrl = new URL("fn/register", client.apiBaseUrl).toString();
-	const response = yield* HttpClientRequest.post(registerUrl).pipe(HttpClientRequest.setHeaders({
-		...baseHeaders(),
-		Authorization: `Bearer ${config.signingKey ?? ""}`
-	}), HttpClientRequest.schemaBodyJson(RegisterRequest)({
+	const registerHeaders = baseHeaders(framework);
+	delete registerHeaders[Headers.RequestVersion];
+	const request = HttpClientRequest.post(registerUrl).pipe(HttpClientRequest.setHeaders({
+		...registerHeaders,
+		Authorization: `Bearer ${config.signingKey ?? ""}`,
+		[Headers.SyncKind]: "out_of_band"
+	}), HttpClientRequest.bodyJsonUnsafe({
 		url: url.href,
-		v: "0.1",
 		deployType: "ping",
-		sdk: `effect-inngest:v${SDK_VERSION}`,
+		...framework ? { framework } : {},
 		appName: config.id,
-		framework: "effect",
-		functions
-	})).pipe(Effect.flatMap(httpClient.execute), Effect.flatMap(HttpClientResponse.schemaBodyJson(RegisterResponse)), Effect.scoped, Effect.catchAll((error) => Effect.succeed({ message: `Registration failed: ${Predicate.hasProperty(error, "message") ? error.message : "Unknown error"}` })));
-	return {
-		status: 200,
-		headers: baseHeaders(),
-		body: response
-	};
+		functions,
+		sdk: `effect-inngest:v${SDK_VERSION}`,
+		v: "0.1",
+		capabilities: {
+			trust_probe: "v1",
+			connect: "v1"
+		}
+	}));
+	return yield* Effect.gen(function* () {
+		const response = yield* httpClient.execute(request).pipe(Effect.scoped);
+		const responseBody = yield* HttpClientResponse.schemaBodyJson(RegisterServerResponse)(response).pipe(Effect.catch((error) => Effect.succeed({ error: `Invalid registration response: ${String(error)}` })));
+		if (response.status !== 200 || !Predicate.hasProperty(responseBody, "ok")) return {
+			status: 500,
+			headers: baseHeaders(config.framework),
+			body: {
+				message: Predicate.hasProperty(responseBody, "error") && responseBody.error ? responseBody.error : `Registration failed with status ${response.status}`,
+				modified: false
+			}
+		};
+		return {
+			status: 200,
+			headers: {
+				...baseHeaders(config.framework),
+				[Headers.SyncKind]: "out_of_band"
+			},
+			body: {
+				message: "Successfully registered",
+				modified: responseBody.modified ?? false
+			}
+		};
+	}).pipe(Effect.catchCause((cause) => {
+		const errorOpt = Cause.findErrorOption(cause);
+		const dieReason = cause.reasons.find(Cause.isDieReason);
+		const message = Option.isSome(errorOpt) ? Predicate.hasProperty(errorOpt.value, "message") && Predicate.isString(errorOpt.value.message) ? errorOpt.value.message : "Registration failed" : dieReason ? Predicate.hasProperty(dieReason.defect, "message") && Predicate.isString(dieReason.defect.message) ? dieReason.defect.message : "Registration failed" : "Registration failed";
+		return Effect.succeed({
+			status: 500,
+			headers: baseHeaders(config.framework),
+			body: {
+				message,
+				modified: false
+			}
+		});
+	}));
 });
-const handleExecution = (group, fnId, urlStepId, body, traceHeaders = {}) => Effect.gen(function* () {
+const handleExecution = Effect.fn("effect-inngest/handler/handleExecution")(function* (args) {
 	const client = yield* InngestClient;
 	const context = yield* Effect.context();
-	const appId = client.config.id;
-	const prefix = `${appId}-`;
-	const fnTag = fnId.startsWith(prefix) ? fnId.slice(prefix.length) : fnId;
-	const fn = group.functions.get(fnTag);
-	const entry = fn ? context.unsafeMap.get(fn.key) : void 0;
+	const prefix = `${client.config.id}-`;
+	const fnTag = args.fnId.startsWith(prefix) ? args.fnId.slice(prefix.length) : args.fnId;
+	const fn = args.group.functions.get(fnTag);
+	const entry = fn ? context.mapUnsafe.get(fn.key) : void 0;
 	if (!fn || !entry) return {
-		status: 404,
+		status: 500,
 		headers: {
-			...baseHeaders(),
-			[Headers.NoRetry]: "true"
+			...baseHeaders(client.config.framework),
+			[Headers.NoRetry]: "false"
 		},
-		body: { error: UserError.make({
+		body: UserError.make({
 			name: "FunctionNotFoundError",
-			message: `Unknown function: ${fnId}`
-		}) }
+			message: `Unknown function: ${args.fnId}`
+		})
 	};
-	const effectiveBody = urlStepId && urlStepId !== body.ctx.step_id ? SDKRequestBody.make({
-		event: body.event,
-		events: body.events,
-		steps: body.steps,
+	const requestedStepId = args.urlStepId === "step" ? void 0 : args.urlStepId;
+	const effectiveBody = requestedStepId && requestedStepId !== args.body.ctx.step_id ? SDKRequestBody.make({
+		event: args.body.event,
+		events: args.body.events,
+		steps: args.body.steps,
 		ctx: SDKRequestContext.make({
-			fn_id: body.ctx.fn_id,
-			run_id: body.ctx.run_id,
-			step_id: urlStepId,
-			attempt: body.ctx.attempt,
-			disable_immediate_execution: body.ctx.disable_immediate_execution,
-			use_api: body.ctx.use_api,
-			stack: body.ctx.stack
+			fn_id: args.body.ctx.fn_id,
+			run_id: args.body.ctx.run_id,
+			env: args.body.ctx.env,
+			step_id: requestedStepId,
+			attempt: args.body.ctx.attempt,
+			max_attempts: args.body.ctx.max_attempts,
+			qi_id: args.body.ctx.qi_id,
+			...Predicate.isNotUndefined(args.body.ctx.request_id) ? { request_id: args.body.ctx.request_id } : {},
+			...Predicate.isNotUndefined(args.body.ctx.generation_id) ? { generation_id: args.body.ctx.generation_id } : {},
+			disable_immediate_execution: args.body.ctx.disable_immediate_execution,
+			use_api: args.body.ctx.use_api,
+			stack: args.body.ctx.stack
 		}),
-		use_api: body.use_api
-	}) : body;
-	const result = yield* Effect.provide(execute(fn, entry.handler, effectiveBody, appId, traceHeaders), entry.context);
+		version: args.body.version,
+		use_api: args.body.use_api
+	}) : args.body;
+	const checkpointConfig = !requestedStepId && effectiveBody.ctx.fn_id !== "" && !effectiveBody.ctx.disable_immediate_execution && effectiveBody.ctx.attempt === 0 ? Option.fromNullishOr(resolveConfig(fn.options.checkpointing, client.config.checkpointing)) : Option.none();
+	const result = yield* Effect.provide(execute({
+		fn,
+		handler: entry.handler,
+		request: effectiveBody,
+		checkpointConfig
+	}), entry.context);
 	return {
 		status: result.status,
 		headers: result.headers,
 		body: result.body
 	};
 });
-
 //#endregion
-export { InvalidRequestError, handleExecution, handleIntrospection, handleRegistration, verifyAndParseRequestBody };
+export { InvalidRequestError, handleExecution, handleIntrospection, handleRegistration, verifyAndParseRequestBody };

package/dist/internal/protocol.d.ts

@@ -1 +1,143 @@
-import "effect/Schema";
+import { StepInfo } from "./domain/StepInfo.js";
+import { Schema } from "effect";
+
+//#region src/internal/protocol.d.ts
+declare const Opcode: {
+  readonly None: "None";
+  readonly Step: "Step";
+  readonly StepRun: "StepRun";
+  readonly StepError: "StepError";
+  readonly StepPlanned: "StepPlanned";
+  readonly Sleep: "Sleep";
+  readonly WaitForEvent: "WaitForEvent";
+  readonly InvokeFunction: "InvokeFunction";
+  readonly AIGateway: "AIGateway";
+  readonly Gateway: "Gateway";
+  readonly WaitForSignal: "WaitForSignal";
+  readonly RunComplete: "RunComplete";
+  readonly StepFailed: "StepFailed";
+  readonly SyncRunComplete: "SyncRunComplete";
+  readonly DiscoveryRequest: "DiscoveryRequest";
+};
+type OpcodeValue = (typeof Opcode)[keyof typeof Opcode];
+declare const UserError_base: Schema.Class<UserError, Schema.Struct<{
+  readonly name: Schema.String;
+  readonly message: Schema.String;
+  readonly stack: Schema.optional<Schema.String>;
+  readonly data: Schema.optional<Schema.Unknown>;
+  readonly noRetry: Schema.optional<Schema.Boolean>;
+  readonly cause: Schema.optional<Schema.Unknown>;
+}>, {}>;
+declare class UserError extends UserError_base {
+  static fromUnknown(error: unknown): UserError;
+}
+declare const FunctionStack_base: Schema.Class<FunctionStack, Schema.Struct<{
+  readonly stack: Schema.$Array<Schema.String>;
+  readonly current: Schema.Number;
+}>, {}>;
+declare class FunctionStack extends FunctionStack_base {}
+declare const InngestEvent_base: Schema.Class<InngestEvent, Schema.Struct<{
+  readonly id: Schema.optional<Schema.String>;
+  readonly name: Schema.String;
+  readonly data: Schema.withDecodingDefaultType<Schema.NullOr<Schema.$Record<Schema.String, Schema.Unknown>>, never>;
+  readonly ts: Schema.optional<Schema.Number>;
+  readonly user: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+  readonly v: Schema.optional<Schema.String>;
+}>, {}>;
+declare class InngestEvent extends InngestEvent_base {}
+declare const SDKRequestContext_base: Schema.Class<SDKRequestContext, Schema.Struct<{
+  readonly fn_id: Schema.String;
+  readonly run_id: Schema.String;
+  readonly env: Schema.withDecodingDefault<Schema.String, never>;
+  readonly step_id: Schema.withDecodingDefault<Schema.String, never>;
+  readonly attempt: Schema.withDecodingDefault<Schema.Number, never>;
+  readonly max_attempts: Schema.withDecodingDefault<Schema.Number, never>;
+  readonly stack: Schema.withDecodingDefaultType<typeof FunctionStack, never>;
+  readonly qi_id: Schema.withDecodingDefault<Schema.String, never>;
+  readonly request_id: Schema.optionalKey<Schema.String>;
+  readonly generation_id: Schema.optionalKey<Schema.Number>;
+  readonly disable_immediate_execution: Schema.withDecodingDefault<Schema.Boolean, never>;
+  readonly use_api: Schema.withDecodingDefault<Schema.Boolean, never>;
+}>, {}>;
+declare class SDKRequestContext extends SDKRequestContext_base {}
+declare const SDKRequestBody_base: Schema.Class<SDKRequestBody, Schema.Struct<{
+  readonly event: typeof InngestEvent;
+  readonly events: Schema.$Array<typeof InngestEvent>;
+  readonly steps: Schema.withDecodingDefault<Schema.$Record<Schema.String, Schema.NullOr<Schema.$Record<Schema.String, Schema.Unknown>>>, never>;
+  readonly ctx: typeof SDKRequestContext;
+  readonly version: Schema.withDecodingDefault<Schema.Number, never>;
+  readonly use_api: Schema.withDecodingDefault<Schema.Boolean, never>;
+}>, {}>;
+declare class SDKRequestBody extends SDKRequestBody_base {}
+declare const GeneratorOpcode_base: Schema.Class<GeneratorOpcode, Schema.Struct<{
+  readonly op: Schema.Literals<readonly ["None", "Step", "StepRun", "StepError", "StepPlanned", "Sleep", "WaitForEvent", "InvokeFunction", "AIGateway", "Gateway", "WaitForSignal", "RunComplete", "StepFailed", "SyncRunComplete", "DiscoveryRequest"]>;
+  readonly id: Schema.String;
+  readonly name: Schema.optional<Schema.String>;
+  readonly mode: Schema.optional<Schema.Literals<readonly ["sync", "async"]>>;
+  readonly opts: Schema.optional<Schema.decodeTo<Schema.Unknown, Schema.Unknown, never, never>>;
+  readonly data: Schema.optional<Schema.decodeTo<Schema.Unknown, Schema.Unknown, never, never>>;
+  readonly error: Schema.optional<typeof UserError>;
+  readonly displayName: Schema.optional<Schema.String>;
+  readonly userland: Schema.optional<Schema.Struct<{
+    readonly id: Schema.String;
+  }>>;
+  readonly timing: Schema.optional<Schema.Struct<{
+    readonly a: Schema.Number;
+    readonly b: Schema.Number;
+  }>>;
+}>, {}>;
+declare class GeneratorOpcode extends GeneratorOpcode_base {
+  static makeStep(args: {
+    readonly info: StepInfo;
+    readonly op: OpcodeValue;
+    readonly extra?: object;
+  }): GeneratorOpcode;
+  static stepPlanned(info: StepInfo): GeneratorOpcode;
+  static sendEventStepPlanned(info: StepInfo): GeneratorOpcode;
+  static stepRun(args: {
+    readonly info: StepInfo;
+    readonly data: unknown;
+  }): GeneratorOpcode;
+  static sendEventStepRun(args: {
+    readonly info: StepInfo;
+    readonly data: unknown;
+    readonly rawPayload: unknown;
+  }): GeneratorOpcode;
+  static stepRunResponse(args: {
+    readonly info: StepInfo;
+    readonly data: unknown;
+  }): GeneratorOpcode;
+  static sendEventStepRunResponse(args: {
+    readonly info: StepInfo;
+    readonly data: unknown;
+  }): GeneratorOpcode;
+  static stepError(args: {
+    readonly info: StepInfo;
+    readonly error: UserError;
+    readonly noRetry?: boolean;
+  }): GeneratorOpcode;
+  static stepFailed(args: {
+    readonly info: StepInfo;
+    readonly error: UserError;
+  }): GeneratorOpcode;
+  static sleep(args: {
+    readonly info: StepInfo;
+    readonly duration: string;
+  }): GeneratorOpcode;
+  static waitForEvent(args: {
+    readonly info: StepInfo;
+    readonly event: string;
+    readonly timeout: string;
+    readonly if?: string;
+  }): GeneratorOpcode;
+  static invokeFunction(args: {
+    readonly info: StepInfo;
+    readonly functionId: string;
+    readonly payload: unknown;
+    readonly timeout?: string;
+  }): GeneratorOpcode;
+  static runComplete(data: unknown): GeneratorOpcode;
+  static discoveryRequest(): GeneratorOpcode;
+}
+//#endregion
+export { GeneratorOpcode, SDKRequestBody };