effect-inngest 0.1.1 → 0.1.3

package/dist/HttpApi.d.ts

@@ -24,20 +24,20 @@ declare class FunctionNotFoundError extends FunctionNotFoundError_base {}
  * @category api
  */
 declare const InngestApiGroup: HttpApiGroup.HttpApiGroup<"inngest", HttpApiEndpoint.HttpApiEndpoint<"introspect", "GET", never, never, never, never, ({
-  readonly mode: "cloud" | "dev";
   readonly function_count: number;
   readonly has_event_key: boolean;
   readonly has_signing_key: boolean;
   readonly has_signing_key_fallback: boolean;
+  readonly mode: "cloud" | "dev";
   readonly schema_version: "2024-05-24";
   readonly extra?: {
     readonly [x: string]: unknown;
   } | undefined;
 } & {
-  readonly env: string | null;
   readonly authentication_succeeded: true;
   readonly api_origin: string;
   readonly app_id: string;
+  readonly env: string | null;
   readonly event_api_origin: string;
   readonly event_key_hash: string | null;
   readonly framework: string;
@@ -48,11 +48,11 @@ declare const InngestApiGroup: HttpApiGroup.HttpApiGroup<"inngest", HttpApiEndpo
   readonly signing_key_fallback_hash: string | null;
   readonly signing_key_hash: string | null;
 }) | ({
-  readonly mode: "cloud" | "dev";
   readonly function_count: number;
   readonly has_event_key: boolean;
   readonly has_signing_key: boolean;
   readonly has_signing_key_fallback: boolean;
+  readonly mode: "cloud" | "dev";
   readonly schema_version: "2024-05-24";
   readonly extra?: {
     readonly [x: string]: unknown;

package/dist/internal/protocol.js

@@ -6,18 +6,14 @@ import * as Schema$1 from "effect/Schema";
 * Wire protocol schemas and opcode factories for Inngest communication.
 * @internal
 */
-const stripTags = (value) => {
-	if (Predicate.isRecord(value)) {
-		const stripped = Struct.omit(value, "_tag");
-		return Object.fromEntries(Object.entries(stripped).map(([k, v]) => [k, stripTags(v)]));
-	}
-	if (Array.isArray(value)) return value.map(stripTags);
+const stripTopLevelTag = (value) => {
+	if (Predicate.isRecord(value)) return Struct.omit(value, "_tag");
 	return value;
 };
 const WireUnknown = Schema$1.transform(Schema$1.Unknown, Schema$1.Unknown, {
 	strict: true,
 	decode: (value) => value,
-	encode: (value) => stripTags(value)
+	encode: (value) => stripTopLevelTag(value)
 });
 const Opcode = {
 	None: "None",

package/dist/internal/step.js

@@ -8,7 +8,7 @@ import * as Duration from "effect/Duration";
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
-import "effect/Schema";
+import * as Schema from "effect/Schema";
 import * as Predicate from "effect/Predicate";
 import * as Arr from "effect/Array";
 import * as HashMap from "effect/HashMap";
@@ -38,6 +38,11 @@ const errorOtelAttributes = (err) => {
 	} else attrs[OtelAttributes.ExceptionMessage] = String(err);
 	return attrs;
 };
+const encodeTaggedEvent = (event) => {
+	const ctor = event.constructor;
+	if (Schema.isSchema(ctor)) return Schema.encode(ctor)(event).pipe(Effect.orElseSucceed(() => event));
+	return Effect.succeed(event);
+};
 var Step = class extends Context.Tag("effect-inngest/Step")() {};
 const normalizeOpts = (opts) => typeof opts === "string" ? {
 	id: opts,
@@ -89,16 +94,20 @@ const createStepTools = (request, appName, stepIdCounts) => {
 		timeout: timeStr(options.timeout),
 		if: options.if
 	}))), Match.exhaustive));
-	const invoke = (opts, options) => Effect.flatMap(getInfo(opts), (info) => pipe(getMemo(info.hash), Match.value, Match.tag("MemoData", ({ data }) => Effect.succeed(data)), Match.tag("MemoError", ({ error }) => stepError(info.id, Predicate.hasProperty(error, "message") ? String(error.message) : "Invoke failed", { cause: error })), Match.tag("MemoTimeout", () => stepError(info.id, "Invoke timed out", { noRetry: true })), Match.tag("MemoInput", () => Effect.succeed(void 0)), Match.tag("MemoNone", () => Effect.fail(invokeInterrupt({
-		info,
-		functionId: `${appName}-${options.function._tag}`,
-		payload: {
-			data: Predicate.hasProperty(options, "data") ? options.data : void 0,
-			user: options.user ?? {},
-			v: options.v ?? "1"
-		},
-		timeout: options.timeout ? timeStr(options.timeout) : "365d"
-	}))), Match.exhaustive));
+	const invoke = (opts, options) => Effect.flatMap(getInfo(opts), (info) => pipe(getMemo(info.hash), Match.value, Match.tag("MemoData", ({ data }) => Effect.succeed(data)), Match.tag("MemoError", ({ error }) => stepError(info.id, Predicate.hasProperty(error, "message") ? String(error.message) : "Invoke failed", { cause: error })), Match.tag("MemoTimeout", () => stepError(info.id, "Invoke timed out", { noRetry: true })), Match.tag("MemoInput", () => Effect.succeed(void 0)), Match.tag("MemoNone", () => {
+		const rawData = Predicate.hasProperty(options, "data") ? options.data : void 0;
+		const encodeData = rawData ? encodeTaggedEvent(rawData) : Effect.succeed(void 0);
+		return Effect.flatMap(encodeData, (encodedData) => Effect.fail(invokeInterrupt({
+			info,
+			functionId: `${appName}-${options.function._tag}`,
+			payload: {
+				data: encodedData,
+				user: options.user ?? {},
+				v: options.v ?? "1"
+			},
+			timeout: options.timeout ? timeStr(options.timeout) : "365d"
+		})));
+	}), Match.exhaustive));
 	const run = (opts, effect) => Effect.flatMap(getInfo(opts), (info) => pipe(getMemo(info.hash), Match.value, Match.tag("MemoData", ({ data }) => Effect.succeed(data)), Match.tag("MemoError", ({ error }) => stepError(info.id, Predicate.hasProperty(error, "message") ? String(error.message) : "Step failed", { noRetry: true })), Match.tag("MemoTimeout", () => stepError(info.id, "Step timed out", { noRetry: true })), Match.tag("MemoInput", () => stepError(info.id, "Unexpected step result type: input")), Match.tag("MemoNone", () => {
 		if (isBlocked(info.hash) || !canExecute(info.hash)) return Effect.fail(plannedInterrupt({ info }));
 		return effect.pipe(Effect.withSpan(`inngest.step/run/${info.id}`, { attributes: {
@@ -132,17 +141,17 @@ const createStepTools = (request, appName, stepIdCounts) => {
 		events: []
 	}))), Match.tag("MemoInput", () => Effect.succeed({ ids: [] })), Match.tag("MemoNone", () => {
 		if (isBlocked(info.hash) || !canExecute(info.hash)) return Effect.fail(plannedInterrupt({ info }));
-		const eventPayloads = Arr.map(Arr.ensure(payload), (e) => ({
+		const events = Arr.ensure(payload);
+		return Effect.flatMap(Effect.forEach(events, (e) => Effect.map(encodeTaggedEvent(e), (encoded) => ({
 			name: e._tag,
-			data: e
-		}));
-		return Effect.flatMap(InngestClient, (client) => client.sendEvent(eventPayloads).pipe(Effect.withSpan(`inngest.step/sendEvent/${info.id}`, { attributes: {
+			data: encoded
+		}))), (eventPayloads) => Effect.flatMap(InngestClient, (client) => client.sendEvent(eventPayloads).pipe(Effect.withSpan(`inngest.step/sendEvent/${info.id}`, { attributes: {
 			[OtelAttributes.StepId]: info.id,
 			[OtelAttributes.StepType]: "sendEvent"
 		} }), Effect.flatMap((result) => Effect.fail(runInterrupt({
 			info,
 			data: result
-		})))));
+		}))))));
 	}), Match.exhaustive));
 	return {
 		run,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-inngest",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Native Effect client library for Inngest - build durable, type-safe workflows",
   "keywords": [
     "background-jobs",

package/src/internal/driver.ts

@@ -79,7 +79,7 @@ export const execute = <F extends InngestFunction.Any, R>(
     const context = buildHandlerContext<F>(fn, step, request);
     const headers = baseHeaders();
 
-    const result = yield* handler(context).pipe(
+    const result = yield* Effect.scoped(handler(context)).pipe(
       Effect.provideService(Step, step),
       Effect.map((value) => ExecutionResult.make({ status: 200, body: value, headers })),
       Effect.catchAll((error) => {

package/src/internal/protocol.ts

@@ -5,13 +5,9 @@
 import { Predicate, Struct } from "effect";
 import * as Schema from "effect/Schema";
 
-const stripTags = (value: unknown): unknown => {
+const stripTopLevelTag = (value: unknown): unknown => {
   if (Predicate.isRecord(value)) {
-    const stripped = Struct.omit(value as Record<string, unknown>, "_tag");
-    return Object.fromEntries(Object.entries(stripped).map(([k, v]) => [k, stripTags(v)]));
-  }
-  if (Array.isArray(value)) {
-    return value.map(stripTags);
+    return Struct.omit(value as Record<string, unknown>, "_tag");
   }
   return value;
 };
@@ -19,7 +15,7 @@ const stripTags = (value: unknown): unknown => {
 const WireUnknown = Schema.transform(Schema.Unknown, Schema.Unknown, {
   strict: true,
   decode: (value) => value,
-  encode: (value) => stripTags(value),
+  encode: (value) => stripTopLevelTag(value),
 });
 
 export const Opcode = {

package/src/internal/step.ts

@@ -86,6 +86,14 @@ type InvokeOptions<F extends InngestFunction.Any> = [InngestFunction.EventType<F
 type EventSchema = Schema.Schema.Any & { readonly _tag: string };
 type TaggedEvent = { readonly _tag: string };
 
+const encodeTaggedEvent = (event: TaggedEvent): Effect.Effect<unknown, never> => {
+  const ctor = event.constructor;
+  if (Schema.isSchema(ctor)) {
+    return Schema.encode(ctor as unknown as Schema.Schema.AnyNoContext)(event).pipe(Effect.orElseSucceed(() => event));
+  }
+  return Effect.succeed(event);
+};
+
 interface StepTools {
   readonly run: <A, Err, R>(
     id: StepOptionsOrId,
@@ -226,20 +234,24 @@ export const createStepTools = (
         ),
         Match.tag("MemoTimeout", () => stepError(info.id, "Invoke timed out", { noRetry: true })),
         Match.tag("MemoInput", () => Effect.succeed(undefined as InngestFunction.Success<F>)),
-        Match.tag("MemoNone", () =>
-          Effect.fail(
-            invokeInterrupt({
-              info,
-              functionId: `${appName}-${options.function._tag}`,
-              payload: {
-                data: Predicate.hasProperty(options, "data") ? options.data : undefined,
-                user: options.user ?? {},
-                v: options.v ?? "1",
-              },
-              timeout: options.timeout ? timeStr(options.timeout) : "365d",
-            }),
-          ),
-        ),
+        Match.tag("MemoNone", () => {
+          const rawData = Predicate.hasProperty(options, "data") ? (options.data as TaggedEvent) : undefined;
+          const encodeData = rawData ? encodeTaggedEvent(rawData) : Effect.succeed(undefined);
+          return Effect.flatMap(encodeData, (encodedData) =>
+            Effect.fail(
+              invokeInterrupt({
+                info,
+                functionId: `${appName}-${options.function._tag}`,
+                payload: {
+                  data: encodedData,
+                  user: options.user ?? {},
+                  v: options.v ?? "1",
+                },
+                timeout: options.timeout ? timeStr(options.timeout) : "365d",
+              }),
+            ),
+          );
+        }),
         Match.exhaustive,
       ),
     );
@@ -311,15 +323,20 @@ export const createStepTools = (
             return Effect.fail(plannedInterrupt({ info }));
           }
 
-          const eventPayloads = Arr.map(Arr.ensure(payload), (e) => ({ name: e._tag, data: e }));
-
-          return Effect.flatMap(InngestClient, (client) =>
-            client.sendEvent(eventPayloads).pipe(
-              Effect.withSpan(`inngest.step/sendEvent/${info.id}`, {
-                attributes: { [OtelAttributes.StepId]: info.id, [OtelAttributes.StepType]: "sendEvent" },
-              }),
-              Effect.flatMap((result) => Effect.fail(runInterrupt({ info, data: result }))),
+          const events = Arr.ensure(payload);
+          return Effect.flatMap(
+            Effect.forEach(events, (e) =>
+              Effect.map(encodeTaggedEvent(e), (encoded) => ({ name: e._tag, data: encoded })),
             ),
+            (eventPayloads) =>
+              Effect.flatMap(InngestClient, (client) =>
+                client.sendEvent(eventPayloads).pipe(
+                  Effect.withSpan(`inngest.step/sendEvent/${info.id}`, {
+                    attributes: { [OtelAttributes.StepId]: info.id, [OtelAttributes.StepType]: "sendEvent" },
+                  }),
+                  Effect.flatMap((result) => Effect.fail(runInterrupt({ info, data: result }))),
+                ),
+              ),
           );
         }),
         Match.exhaustive,