effect-inngest 0.1.0 → 0.1.1

package/README.md

@@ -124,11 +124,12 @@ class UserWelcomeSent extends Schema.TaggedClass<UserWelcomeSent>()("user/welcom
 // 2. Define your functions
 const ProcessSignup = InngestFunction.make("process-signup", {
   trigger: { event: UserSignup },
-  success: { welcomed: Schema.Boolean },
+  success: Schema.Struct({ welcomed: Schema.Boolean }),
 });
 
 const DailyDigest = InngestFunction.make("daily-digest", {
   trigger: { cron: "0 9 * * *" },
+  success: Schema.Void,
 });
 
 // 3. Create function group and implement handlers
@@ -161,15 +162,13 @@ const Client = InngestClient.layer({
   mode: "dev",
 }).pipe(Layer.provide(FetchHttpClient.layer));
 
-const Server = Layer.unwrapEffect(
-  Effect.gen(function* () {
-    const app = yield* InngestGroup.toHttpApp(App);
-    return HttpServer.serve(app, HttpMiddleware.logger).pipe(
-      HttpServer.withLogAddress,
-      Layer.provide(BunHttpServer.layer({ port: 3000 })),
-    );
-  }),
-).pipe(Layer.provide(Handlers), Layer.provide(Client), Layer.provide(FetchHttpClient.layer));
+const Server = HttpServer.serve(InngestGroup.toHttpApp(App), HttpMiddleware.logger).pipe(
+  HttpServer.withLogAddress,
+  Layer.provide(BunHttpServer.layer({ port: 3000 })),
+  Layer.provide(Handlers),
+  Layer.provide(Client),
+  Layer.provide(FetchHttpClient.layer),
+);
 
 // Run it
 BunRuntime.runMain(Layer.launch(Server));
@@ -187,6 +186,78 @@ bunx inngest-cli@latest dev -u http://localhost:3000
 
 Open http://localhost:8288 to trigger events and watch your functions run.
 
+### Using HttpApiBuilder
+
+For more complex applications, you can compose Inngest into an existing `HttpApi`:
+
+```typescript
+import * as HttpApi from "@effect/platform/HttpApi";
+import * as HttpApiBuilder from "@effect/platform/HttpApiBuilder";
+import { FetchHttpClient } from "@effect/platform";
+import { BunHttpServer, BunRuntime } from "@effect/platform-bun";
+import { Duration, Effect, Layer, Schema } from "effect";
+import { InngestApiGroup, layerGroup } from "effect-inngest/HttpApi";
+import { InngestClient, InngestFunction, InngestGroup } from "effect-inngest";
+
+// 1. Define your events
+class UserSignup extends Schema.TaggedClass<UserSignup>()("user/signup", {
+  userId: Schema.String,
+  email: Schema.String,
+}) {}
+
+class UserWelcomeSent extends Schema.TaggedClass<UserWelcomeSent>()("user/welcome-sent", {
+  userId: Schema.String,
+}) {}
+
+// 2. Define functions
+const ProcessSignup = InngestFunction.make("process-signup", {
+  trigger: { event: UserSignup },
+  success: Schema.Struct({ welcomed: Schema.Boolean }),
+});
+
+const DailyDigest = InngestFunction.make("daily-digest", {
+  trigger: { cron: "0 9 * * *" },
+  success: Schema.Void,
+});
+
+// 3. Create group and handlers
+const App = InngestGroup.make(ProcessSignup, DailyDigest);
+
+const Handlers = App.toLayer({
+  "process-signup": ({ event, step }) =>
+    Effect.gen(function* () {
+      yield* Effect.log(`Processing signup for ${event.email}`);
+      const user = yield* step.run("create-user", Effect.succeed({ id: event.userId, email: event.email }));
+      yield* step.sleep("welcome-delay", Duration.seconds(5));
+      yield* step.sendEvent("notify", new UserWelcomeSent({ userId: user.id }));
+      return { welcomed: true };
+    }),
+  "daily-digest": ({ step }) => step.run("send-digest", Effect.log("Sending daily digest...")),
+});
+
+// 4. Create client
+const Client = InngestClient.layer({
+  id: "my-app",
+  mode: "dev",
+}).pipe(Layer.provide(FetchHttpClient.layer));
+
+// 5. Create API with Inngest group at /inngest prefix
+const MyApi = HttpApi.make("my-api").add(InngestApiGroup.prefix("/inngest"));
+
+// 6. Build API layer
+const ApiLive = HttpApiBuilder.api(MyApi).pipe(
+  Layer.provide(layerGroup(MyApi, App)),
+  Layer.provide(Handlers),
+  Layer.provide(Client),
+  Layer.provide(FetchHttpClient.layer),
+);
+
+// 7. Serve
+const Server = HttpApiBuilder.serve().pipe(Layer.provide(ApiLive), Layer.provide(BunHttpServer.layer({ port: 3000 })));
+
+BunRuntime.runMain(Layer.launch(Server));
+```
+
 ---
 
 ## Getting Started
@@ -217,12 +288,13 @@ import { InngestFunction } from "effect-inngest";
 // Event-triggered function
 const ProcessSignup = InngestFunction.make("process-signup", {
   trigger: [{ event: UserSignup }], // pass multiple triggers as Array.
-  success: { welcomeEmailSent: Schema.Boolean },
+  success: Schema.Struct({ welcomeEmailSent: Schema.Boolean }),
 });
 
 // Cron-triggered function
 const DailyReport = InngestFunction.make("daily-report", {
   trigger: { cron: "0 9 * * *" },
+  success: Schema.Void,
 });
 ```
 
@@ -420,19 +492,6 @@ yield * new RetryAfterError({ message: "Rate limited", retryAfter: 60000 });
 
 See the [`examples/`](./examples) directory:
 
-| Example                                     | Description                                    |
-| ------------------------------------------- | ---------------------------------------------- |
-| [simple.ts](./examples/simple.ts)           | Minimal hello world with parallel steps        |
-| [KitchenSink.ts](./examples/KitchenSink.ts) | Complete e-commerce workflow with all features |
-
-```bash
-# Run an example
-bun examples/simple.ts
-
-# Start Inngest dev server
-bunx inngest-cli@latest dev -u http://localhost:9999
-```
-
 ---
 
 ## Current Limitations
@@ -447,11 +506,6 @@ This library is under active development. The following Inngest features are **n
 
 ---
 
-## Requirements
-
-- **TypeScript** 5.4+ with `strict: true`
-- **Effect** 3.x
-
 ## License
 
 MIT

package/dist/Function.d.ts

@@ -313,6 +313,40 @@ interface FunctionRegistration {
     start?: string;
     finish?: string;
   };
+  readonly rateLimit?: {
+    readonly key?: string;
+    readonly limit: number;
+    readonly period: string;
+  };
+  readonly throttle?: {
+    readonly key?: string;
+    readonly limit: number;
+    readonly period: string;
+    readonly burst?: number;
+  };
+  readonly debounce?: {
+    readonly key?: string;
+    readonly period: string;
+    readonly timeout?: string;
+  };
+  readonly concurrency?: ReadonlyArray<{
+    readonly key?: string;
+    readonly limit: number;
+    readonly scope?: string;
+  }>;
+  readonly priority?: {
+    readonly run?: string;
+  };
+  readonly singleton?: {
+    readonly key?: string;
+    readonly mode: string;
+  };
+  readonly batchEvents?: {
+    readonly maxSize: number;
+    readonly timeout: string;
+    readonly key?: string;
+  };
+  readonly idempotency?: string;
 }
 /**
  * An Inngest function definition.

package/dist/Function.js

@@ -35,6 +35,38 @@ const Proto = {
 			start: opts.timeouts.start ? timeStr(opts.timeouts.start) : void 0,
 			finish: opts.timeouts.finish ? timeStr(opts.timeouts.finish) : void 0
 		} : void 0;
+		const rateLimit = opts.rateLimit ? {
+			key: opts.rateLimit.key,
+			limit: opts.rateLimit.limit,
+			period: timeStr(opts.rateLimit.period)
+		} : void 0;
+		const throttle = opts.throttle ? {
+			key: opts.throttle.key,
+			limit: opts.throttle.limit,
+			period: timeStr(opts.throttle.period),
+			burst: opts.throttle.burst
+		} : void 0;
+		const debounce = opts.debounce ? {
+			key: opts.debounce.key,
+			period: timeStr(opts.debounce.period),
+			timeout: opts.debounce.timeout ? timeStr(opts.debounce.timeout) : void 0
+		} : void 0;
+		const concurrency = opts.concurrency != null ? typeof opts.concurrency === "number" ? [{ limit: opts.concurrency }] : Array.ensure(opts.concurrency).map((c) => ({
+			key: c.key,
+			limit: c.limit,
+			scope: c.scope
+		})) : void 0;
+		const priority = opts.priority ? { run: opts.priority.run } : void 0;
+		const singleton = opts.singleton ? {
+			key: opts.singleton.key,
+			mode: opts.singleton.mode
+		} : void 0;
+		const batchEvents = opts.batchEvents ? {
+			maxSize: opts.batchEvents.maxSize,
+			timeout: timeStr(opts.batchEvents.timeout),
+			key: opts.batchEvents.key
+		} : void 0;
+		const idempotency = opts.idempotency;
 		const fnId = `${config.appId}-${this._tag}`;
 		const stepUrl = new URL(config.url);
 		stepUrl.searchParams.set("fnId", fnId);
@@ -53,7 +85,15 @@ const Proto = {
 				retries: { attempts: opts.retries ?? 3 }
 			} },
 			cancel: cancel && cancel.length > 0 ? cancel : void 0,
-			timeouts
+			timeouts,
+			rateLimit,
+			throttle,
+			debounce,
+			concurrency,
+			priority,
+			singleton,
+			batchEvents,
+			idempotency
 		};
 	}
 };

package/dist/Group.d.ts

@@ -143,9 +143,8 @@ declare const toHttpApp: (group: InngestGroup.Any) => HttpApp.Default<never, Inn
  */
 declare const toWebHandler: <R, E>(group: InngestGroup.Any, options: {
   readonly layer: Layer.Layer<InngestClient | HttpClient.HttpClient | R, E, never>;
-  readonly memoMap?: Layer.MemoMap;
 }) => {
-  readonly handler: (request: Request) => Promise<Response>;
+  readonly handler: (request: Request, context?: Context.Context<never>) => Promise<Response>;
   readonly dispose: () => Promise<void>;
 };
 //#endregion

package/dist/Group.js

@@ -158,7 +158,7 @@ const toHttpApp = (group) => Effect.gen(function* () {
 * process.on("SIGTERM", dispose)
 * ```
 */
-const toWebHandler = (group, options) => HttpApp.toWebHandlerLayer(toHttpApp(group), Layer.mergeAll(options.layer, Layer.scope), { memoMap: options.memoMap });
+const toWebHandler = (group, options) => HttpApp.toWebHandlerLayer(toHttpApp(group), Layer.mergeAll(options.layer, Layer.scope));
 
 //#endregion
 export { Group_exports, TypeId, make, toHttpApp, toWebHandler };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-inngest",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Native Effect client library for Inngest - build durable, type-safe workflows",
   "keywords": [
     "background-jobs",
@@ -23,9 +23,6 @@
     "type": "git",
     "url": "https://github.com/erikshestopal/effect-inngest.git"
   },
-  "workspaces": [
-    "examples"
-  ],
   "files": [
     "dist/**/*.d.ts",
     "dist/**/*.d.ts.map",
@@ -106,16 +103,21 @@
   "devDependencies": {
     "@changesets/changelog-github": "^0.5.2",
     "@changesets/cli": "^2.29.8",
+    "@effect/cluster": "^0.56.1",
     "@effect/language-service": "0.72.0",
+    "@effect/platform": "^0.94.2",
+    "@effect/platform-bun": "^0.87.0",
     "@types/bun": "1.3.6",
     "@typescript/native-preview": "^7.0.0-dev.20260124.1",
+    "effect": "^3.15.0",
     "oxfmt": "0.26.0",
     "oxlint": "1.41.0",
     "oxlint-tsgolint": "0.11.1",
-    "tsdown": "0.20.1"
+    "tsdown": "0.20.1",
+    "typescript": "^5.9.3"
   },
   "peerDependencies": {
-    "@effect/platform": ">=0.80.0",
-    "effect": ">=3.14.0"
+    "@effect/platform": ">=0.87.0",
+    "effect": ">=3.15.0"
   }
 }

package/src/Function.ts

@@ -331,7 +331,11 @@ interface RegistrationConfig {
 interface FunctionRegistration {
   readonly id: string;
   readonly name: string;
-  readonly triggers: ReadonlyArray<{ event?: string; cron?: string; expression?: string }>;
+  readonly triggers: ReadonlyArray<{
+    event?: string;
+    cron?: string;
+    expression?: string;
+  }>;
   readonly steps: {
     readonly step: {
       readonly id: string;
@@ -340,8 +344,41 @@ interface FunctionRegistration {
       readonly retries?: { readonly attempts: number };
     };
   };
-  readonly cancel?: ReadonlyArray<{ event: string; if?: string; timeout?: string }>;
+  readonly cancel?: ReadonlyArray<{
+    event: string;
+    if?: string;
+    timeout?: string;
+  }>;
   readonly timeouts?: { start?: string; finish?: string };
+  readonly rateLimit?: {
+    readonly key?: string;
+    readonly limit: number;
+    readonly period: string;
+  };
+  readonly throttle?: {
+    readonly key?: string;
+    readonly limit: number;
+    readonly period: string;
+    readonly burst?: number;
+  };
+  readonly debounce?: {
+    readonly key?: string;
+    readonly period: string;
+    readonly timeout?: string;
+  };
+  readonly concurrency?: ReadonlyArray<{
+    readonly key?: string;
+    readonly limit: number;
+    readonly scope?: string;
+  }>;
+  readonly priority?: { readonly run?: string };
+  readonly singleton?: { readonly key?: string; readonly mode: string };
+  readonly batchEvents?: {
+    readonly maxSize: number;
+    readonly timeout: string;
+    readonly key?: string;
+  };
+  readonly idempotency?: string;
 }
 
 /**
@@ -392,7 +429,11 @@ const Proto = {
   [TypeId]: TypeId,
 
   toRegistration(this: InngestFunction.Any, config: RegistrationConfig): FunctionRegistration {
-    const triggers: Array<{ event?: string; cron?: string; expression?: string }> = [];
+    const triggers: Array<{
+      event?: string;
+      cron?: string;
+      expression?: string;
+    }> = [];
 
     for (const t of this.triggers) {
       if (isEventTrigger(t)) {
@@ -416,6 +457,54 @@ const Proto = {
           }
         : undefined;
 
+    const rateLimit = opts.rateLimit
+      ? {
+          key: opts.rateLimit.key,
+          limit: opts.rateLimit.limit,
+          period: timeStr(opts.rateLimit.period),
+        }
+      : undefined;
+
+    const throttle = opts.throttle
+      ? {
+          key: opts.throttle.key,
+          limit: opts.throttle.limit,
+          period: timeStr(opts.throttle.period),
+          burst: opts.throttle.burst,
+        }
+      : undefined;
+
+    const debounce = opts.debounce
+      ? {
+          key: opts.debounce.key,
+          period: timeStr(opts.debounce.period),
+          timeout: opts.debounce.timeout ? timeStr(opts.debounce.timeout) : undefined,
+        }
+      : undefined;
+
+    const concurrency =
+      opts.concurrency != null
+        ? typeof opts.concurrency === "number"
+          ? [{ limit: opts.concurrency }]
+          : Arr.ensure(opts.concurrency).map((c) => ({
+              key: c.key,
+              limit: c.limit,
+              scope: c.scope,
+            }))
+        : undefined;
+
+    const priority = opts.priority ? { run: opts.priority.run } : undefined;
+    const singleton = opts.singleton ? { key: opts.singleton.key, mode: opts.singleton.mode } : undefined;
+    const batchEvents = opts.batchEvents
+      ? {
+          maxSize: opts.batchEvents.maxSize,
+          timeout: timeStr(opts.batchEvents.timeout),
+          key: opts.batchEvents.key,
+        }
+      : undefined;
+
+    const idempotency = opts.idempotency;
+
     const fnId = `${config.appId}-${this._tag}`;
     const stepUrl = new URL(config.url);
     stepUrl.searchParams.set("fnId", fnId);
@@ -435,6 +524,14 @@ const Proto = {
       },
       cancel: cancel && cancel.length > 0 ? cancel : undefined,
       timeouts,
+      rateLimit,
+      throttle,
+      debounce,
+      concurrency,
+      priority,
+      singleton,
+      batchEvents,
+      idempotency,
     };
   },
 };

package/src/Group.ts

@@ -303,12 +303,8 @@ export const toWebHandler = <R, E>(
   group: InngestGroup.Any,
   options: {
     readonly layer: Layer.Layer<InngestClient | HttpClient.HttpClient | R, E, never>;
-    readonly memoMap?: Layer.MemoMap;
   },
 ): {
-  readonly handler: (request: Request) => Promise<Response>;
+  readonly handler: (request: Request, context?: Context.Context<never>) => Promise<Response>;
   readonly dispose: () => Promise<void>;
-} =>
-  HttpApp.toWebHandlerLayer(toHttpApp(group), Layer.mergeAll(options.layer, Layer.scope), {
-    memoMap: options.memoMap,
-  });
+} => HttpApp.toWebHandlerLayer(toHttpApp(group), Layer.mergeAll(options.layer, Layer.scope));