Introduction

Effect.ts utilities for building robust applications with AI SDK, Drizzle, Inngest, and oRPC integrations

Overview

ff-effect is a utilities package that provides Effect.ts-first wrappers for popular libraries:

• AI SDK - Effectful wrappers for AI SDK’s generateText, streamText, and tool with automatic callback bridging
• Drizzle - Type-safe database operations with built-in transaction support
• Inngest - Background job orchestration with Effect-based function handlers
• oRPC - RPC procedures backed by Effect

All integrations preserve Effect’s composability, type-safety, and structured concurrency while making it seamless to use these libraries in an Effect-first codebase.

Installation

npm

npm install ff-effect effect

Peer Dependencies

Depending on which integrations you use, install the corresponding peer dependencies:

# For AI SDK integration
bun add ai

# For Drizzle integration
bun add drizzle-orm

# For Inngest integration
bun add inngest

# For oRPC integration
bun add @orpc/server @orpc/contract

Core Utilities

The package exports three core utilities:

extract

Extract services from an Effect function to move dependencies up the stack. This is particularly useful when building service containers that expose methods requiring services.

import { extract } from 'ff-effect';
import { Effect } from 'effect';

class MyService extends Effect.Service<MyService>()('MyService', {
  effect: Effect.gen(function* () {
    return {
      // Extract moves ServiceA dependency from getVal to Container
      getVal: yield* extract(function* () {
        return (yield* ServiceA).value;
      })
    };
  })
}) {}

runPromiseUnwrapped

Run an Effect as a Promise, automatically unwrapping errors from Cause to throw them directly.

import { runPromiseUnwrapped } from 'ff-effect';
import { Effect } from 'effect';

const result = await runPromiseUnwrapped(
  Effect.succeed('hello')
); // 'hello'

wrapClient

Wrap any Promise-based client with consistent Effect error handling.

import { wrapClient } from 'ff-effect';

class MyError extends Error {}

const wrap = wrapClient({
  client: myApiClient,
  error: ({ cause, message }) => new MyError(message)
});

const result = yield* wrap(
  (client) => client.fetchData(),
  { errorMessage: 'Failed to fetch data' }
);

Integration Modules

Each integration is available under a separate export path:

import { generateText, tool } from 'ff-effect/for/ai';
import { createDrizzle } from 'ff-effect/for/drizzle';
import { createInngest } from 'ff-effect/for/inngest';
import { createHandler } from 'ff-effect/for/orpc';

Explore the individual integration pages to learn more:

• AI SDK Integration - Effect wrappers for AI SDK functions
• Drizzle Integration - Database operations with transactions
• Inngest Integration - Background jobs with Effect
• oRPC Integration - RPC procedures with Effect handlers

Type Safety

All utilities preserve full type inference and provide compile-time safety:

• Service dependencies are tracked in the R type parameter
• Errors are represented in the E type parameter
• Success values flow through the A type parameter

Next Steps

extract

Learn how to extract service dependencies

AI SDK

Use AI SDK with Effect callbacks

Drizzle

Type-safe database operations

Inngest

Background job orchestration