effect-cf - GitLite

KO | EN

gitlite — search

#python #hacktoberfest #ai #typescript #llm #golang #rust #deep-learning #docker #cli #vue #awesome-list #security #open-source

effect-cf

(★ 62)

Effect-native primitives for Cloudflare Workers and bindings.

파일 탐색기

최종 버전 다운로드 (.zip)

- config.json
- README.md
- - build-effect-apis
  - build-effect-clis
  - cloudflare
  - dev-kit
  - effect-architecture-audit
  - effect-atom-state
  - effect-cf-repo-pr-hygiene
  - effect-ts
  - open-pull-request
  - tdd
  - testing
- - check.yml
  - ci.yml
  - effect-agent-pr-review.yml
  - release.yml
- review-guidance.md
- pre-commit
- - README.md
- - README.md
- - README.md
- - README.md
- - README.md
- - README.md
- - README.md
- - README.md
- - .gitignore
  - CHANGELOG.md
  - LICENSE
  - package.json
  - README.md
  - tsconfig.json
  - vite.config.ts
- - .gitignore
  - CHANGELOG.md
  - LICENSE
  - package.json
  - README.md
  - tsconfig.json
  - vite.config.ts
- - package.json
.gitignore
AGENTS.md
bun.lock
CLAUDE.md
CONTRIBUTING.md
dev-kit.jsonc
dev-kit.lock.json
LICENSE
package.json
README.md
tsconfig.json
vite.config.ts

# 설치 가이드

1. 코드 내려받기

git clone https://github.com/danieljvdm/effect-cf

깃허브에서 프로젝트 코드 전체를 내 컴퓨터로 내려받습니다.

cd effect-cf

방금 내려받은 프로젝트 폴더 안으로 이동합니다.

2. Node.js

쉬움 추천

사전 준비물

Git GitHub에서 프로젝트 코드를 내려받으려면 필요합니다.
Node.js npm 명령어를 쓰려면 Node.js가 설치되어 있어야 합니다. LTS(장기지원) 버전을 추천합니다.

pnpm add effect-cf "effect@^4.0.0-beta.105"

이 명령어를 터미널에 그대로 입력해 실행하세요.

npm install effect-cf "effect@^4.0.0-beta.105"

package.json에 명시된 라이브러리들을 내려받아 설치합니다.

✅ 명령어 실행 후 터미널에 나타나는 주소(보통 http://localhost:3000 형태)를 브라우저에서 열어보세요.

이 레포의 README에 적힌 실제 명령어를 그대로 가져왔습니다.

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# effect-cf

Effect-native primitives for Cloudflare Workers, Durable Objects, bindings, Cache, KV, R2, Artifacts, Email, Analytics Engine, and Durable Object storage.

This monorepo also publishes [`effect-webtransport`](packages/effect-webtransport), a platform-generic Effect WebTransport library (sessions, streams, datagrams, `Socket`/RPC adapters, and WebSocket fallback selection). `effect-cf`'s `WebTransport` module documents the Cloudflare boundary: Workers cannot accept inbound WebTransport sessions today, so the module exposes typed capabilities and decoded HTTP/3 request metadata instead.

## Install

`effect-cf` targets Effect `^4.0.0-beta.105` and Cloudflare workerd `1.20260820.1`
(`@cloudflare/workers-types@5.20260820.1`, recommended `compatibility_date` `2026-08-20`).

```bash
bun add effect-cf "effect@^4.0.0-beta.105"
```

```bash
pnpm add effect-cf "effect@^4.0.0-beta.105"
```

```bash
npm install effect-cf "effect@^4.0.0-beta.105"
```

## Design

`effect-cf` keeps Cloudflare code inside Effect. Cloudflare services are modeled as `Context`, `Layer`, and `Effect` values, and runtime boundaries live at Worker and Durable Object entrypoints.

Binding types come from code-owned definitions such as `Worker.Tag(...)` and `DurableObject.Tag(...)`. Generated Wrangler types are only used as local config checks.

## A Taste

A Worker can route HTTP with Effect and call a Durable Object through a typed binding:

```ts
import { Effect, Layer, Schema as S } from "effect";
import { HttpRouter, HttpServerResponse } from "effect/unstable/http";
import { DurableObject, DurableObjectState, Worker } from "effect-cf";

class Counter extends DurableObject.Tag<Counter>()("Counter", {
  increment: DurableObject.method({ success: S.Number }),
}) {}

const CounterLive = Counter.make(Layer.empty, {
  rpc: {
    increment: () =>
      Effect.gen(function* () {
        const state = yield* DurableObjectState.DurableObjectState;
        const current = yield* state.storage.get<number>("count");
        const next = (current ?? 0) + 1;
        yield* state.storage.put("count", next);
        return next;
      }),
  },
});

export class CounterDurableObject extends CounterLive {}

const CounterLayer = Counter.layer({ binding: "COUNTER" });

const app = Effect.gen(function* () {
  const router = yield* HttpRouter.HttpRouter;
  const counters = yield* Counter;
  const counter = counters.byName("home");

return yield* router
    .get(
      "/",
      Effect.gen(function* () {
        const count = yield* counter.increment();
        return HttpServerResponse.text(`Viewed ${count} times`);
      }),
    )
    .asHttpEffect();
});

export default Worker.make(Layer.mergeAll(HttpRouter.layer, CounterLayer), app);
```

`COUNTER` is still declared in `wrangler.jsonc`, but the callable API is inferred from the `Counter` class. The Worker and Durable Object both run through `effect-cf` runtime boundaries.

## Examples

The `examples/` directory demonstrates package usage across Workers, Durable Objects, service bindings, and frontend consumers.

### Cloudflare AI and Browser Bindings

Workers AI embeddings:

```ts
import { Effect } from "effect";
import { WorkersAi } from "effect-cf";

class Ai extends WorkersAi.Tag<Ai>()("Ai") {}

const program = Effect.gen(function* () {
  const ai = yield* Ai;
  const embedding = yield* ai.runEmbedding("@cf/qwen/qwen3-embedding-0.6b", {
    text: "tomato soup with basil",
  });

return { data: embedding.data, shape: embedding.shape };
});
```

Vectorize upsert/query:

```ts
import { Effect } from "effect";
import { Vectorize } from "effect-cf";

class RecipeVectors extends Vectorize.Tag<RecipeVectors>()("RecipeVectors") {}

const program = Effect.gen(function* () {
  const vectors = yield* RecipeVectors;

yield* vectors.upsert([
    {
      id: "recipe:tomato-soup",
      values: [0.12, 0.34, 0.56],
      namespace: "recipes",
      metadata: { kind: "soup" },
    },
  ]);

return yield* vectors.query([0.12, 0.34, 0.56], {
    topK: 5,
    namespace: "recipes",
    returnMetadata: "all",
    returnValues: true,
    filter: { kind: "soup" },
  });
});
```

AI Gateway request:

```ts
import { Effect } from "effect";
import { AiGateway } from "effect-cf";

class Gateway extends AiGateway.Tag<Gateway>()("Gateway") {}

const program = Effect.gen(function* () {
  const gateway = yield* Gateway;

return yield* gateway.run({
    provider: "workers-ai",
    endpoint: "@cf/meta/llama-3.1-8b-instruct",
    headers: {},
    query: { prompt: "Write one sentence about soup." },
  });
});
```

Browser Rendering screenshot/content extraction:

```ts
import puppeteer from "@cloudflare/puppeteer";
import { Effect } from "effect";
import { BrowserRendering } from "effect-cf";

class Browser extends BrowserRendering.Tag<Browser>()("Browser") {}

const program = Effect.gen(function* () {
  const rendering = yield* Browser;
  const browser = yield* rendering.launchWith(puppeteer.launch);
  const page = yield* browser.newPage;

yield* page.goto("https://example.com");
  const content = yield* page.content;
  const screenshot = yield* page.screenshot<Uint8Array>({ type: "png" });

yield* browser.close;
  return { content, screenshot };
});
```

Analytics Engine event writes:

```ts
import { Effect } from "effect";
import { AnalyticsEngine } from "effect-cf";

class RequestAnalytics extends AnalyticsEngine.Tag<RequestAnalytics>()("RequestAnalytics") {}

const program = Effect.gen(function* () {
  const analytics = yield* RequestAnalytics;

yield* analytics.writeDataPoint({
    indexes: ["example.com"],
    blobs: ["/home", "US"],
    doubles: [1],
  });

yield* analytics.writeDataPoints(
    [
      { indexes: ["example.com"], blobs: ["/pricing", "US"], doubles: [1] },
      { indexes: ["example.com"], blobs: ["/docs", "CA"], doubles: [1] },
    ],
    { onInvalid: "drop" },
  );
});
```

Writes validate the Cloudflare Analytics Engine field, byte, and per-invocation limits before calling the native binding. Invalid writes fail with `AnalyticsEngineWriteValidationError` by default, or can be dropped with `onInvalid: "drop"` on the layer or per call.

Analytics Engine SQL queries with schema-decoded rows:

```ts
import { Effect, Layer, Schema as S } from "effect";
import { FetchHttpClient } from "effect/unstable/http";
import { AnalyticsEngine, WorkerConfig } from "effect-cf";

class AnalyticsQuery extends AnalyticsEngine.QueryTag<AnalyticsQuery>()("AnalyticsQuery") {}

const PageView = S.Struct({ path: S.String, views: S.Number });

const program = Effect.gen(function* () {
  const analytics = yield* AnalyticsQuery;

return yield* analytics.queryRows(
    PageView,
    "SELECT blob1 AS path, SUM(_sample_interval) AS views FROM request_metrics GROUP BY path",
  );
});

const layer = AnalyticsQuery.layerConfig(
  AnalyticsEngine.queryConfig({
    accountId: WorkerConfig.string("CLOUDFLARE_ACCOUNT_ID"),
    apiToken: WorkerConfig.redacted("CLOUDFLARE_API_TOKEN"),
  }),
).pipe(Layer.provide(FetchHttpClient.layer));
```

Email Service transactional sends:

```ts
import { Effect } from "effect";
import { Email } from "effect-cf";

class TransactionalEmail extends Email.Tag<TransactionalEmail>()("TransactionalEmail") {}

const program = Effect.gen(function* () {
  const email = yield* TransactionalEmail;

return yield* email.send({
    from: { name: "Example", email: "welcome@example.com" },
    to: "user@example.com",
    subject: "Welcome to Example",
    text: "Welcome! Thanks for signing up.",
    html: "<h1>Welcome!</h1><p>Thanks for signing up.</p>",
  });
});
```

Messages are validated against the documented Cloudflare Email Sending limits before the binding is called, so a bad recipient list or oversized header fails with `EmailValidationError` and no round trip. Cloudflare's `E_*` codes are reported on `EmailOperationError.code`. See [`examples/email/README.md`](examples/email/README.md) for the Wrangler configuration and domain onboarding steps.

## Changelog

See [packages/effect-cf/CHANGELOG.md](./packages/effect-cf/CHANGELOG.md).

## Contributing

See [CONTRIBUTING.md](./CONTRIBUTING.md).

## License

MIT