effect-genserver 0.1.0

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "effect-genserver",
+  "type": "module",
+  "version": "0.1.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": "./dist/index.js",
+    "./*": "./dist/*.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "license": "MIT",
+  "author": "Tim Smart <hello@timsmart.co>",
+  "homepage": "https://github.com/tim-smart/effect-genserver",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tim-smart/effect-genserver.git"
+  },
+  "dependencies": {},
+  "peerDependencies": {
+    "effect": "4.0.0-beta.48"
+  },
+  "devDependencies": {
+    "@changesets/changelog-github": "^0.6.0",
+    "@changesets/cli": "^2.29.8",
+    "@effect/language-service": "^0.85.1",
+    "@effect/vitest": "4.0.0-beta.48",
+    "@types/node": "^25.6.0",
+    "@typescript/native-preview": "7.0.0-dev.20260412.1",
+    "effect": "4.0.0-beta.48",
+    "husky": "^9.1.7",
+    "lint-staged": "^16.4.0",
+    "oxlint": "^1.57.0",
+    "prettier": "^3.8.2",
+    "typescript": "^6.0.2",
+    "vitest": "^4.1.1"
+  },
+  "lint-staged": {
+    "*.{ts,tsx}": [
+      "oxlint --fix",
+      "prettier --write"
+    ],
+    "*.{json,md,yml,yaml}": [
+      "prettier --write"
+    ]
+  },
+  "scripts": {
+    "check": "oxlint -c .oxlintrc.json --fix && pnpm tsc -b tsconfig.json",
+    "test": "vitest run",
+    "build": "tsc -b tsconfig.json"
+  }
+}

package/src/AtomGenServer.ts

@@ -0,0 +1,112 @@
+/**
+ * @since 1.0.0
+ */
+import type * as Rpc from "effect/unstable/rpc/Rpc"
+import * as Effect from "effect/Effect"
+import type * as Schema from "effect/Schema"
+import * as Layer from "effect/Layer"
+import * as GenServer from "./GenServer.ts"
+import * as Atom from "effect/unstable/reactivity/Atom"
+import { identity, pipe } from "effect/Function"
+import * as Stream from "effect/Stream"
+import * as AsyncResult from "effect/unstable/reactivity/AsyncResult"
+import * as Duration from "effect/Duration"
+
+/**
+ * @since 1.0.0
+ * @category Atom
+ */
+export const make = <
+  State extends Schema.Top,
+  Rpcs extends Rpc.Any,
+  E,
+  InitialState extends State["Type"] | undefined = undefined,
+>(
+  server: GenServer.GenServer<State, Rpcs>,
+  layer:
+    | Layer.Layer<
+        GenServer.ToHandler<Rpcs> | GenServer.InitialState,
+        E,
+        GenServer.SendDiscard
+      >
+    | ((
+        get: Atom.AtomContext,
+      ) => Layer.Layer<
+        GenServer.ToHandler<Rpcs> | GenServer.InitialState,
+        E,
+        GenServer.SendDiscard
+      >),
+  options?: {
+    readonly memoMap?: Layer.MemoMap | undefined
+    readonly idleTTL?: Duration.Input | undefined
+    readonly initialState?: InitialState | undefined
+  },
+): {
+  readonly actor: Atom.Atom<
+    AsyncResult.AsyncResult<GenServer.Actor<State, Rpcs>, E>
+  >
+  readonly send: <Tag extends Rpcs["_tag"]>(
+    tag: Tag,
+    options?: {
+      readonly concurrent?: boolean | undefined
+    },
+  ) => Atom.AtomResultFn<
+    Rpc.PayloadConstructor<Rpc.ExtractTag<Rpcs, Tag>>,
+    Rpc.Success<Rpc.ExtractTag<Rpcs, Tag>>,
+    E | Schema.Schema.Type<Rpc.ErrorSchema<Rpc.ExtractTag<Rpcs, Tag>>>
+  >
+  readonly state: Atom.Atom<
+    [InitialState] extends [undefined]
+      ? AsyncResult.AsyncResult<State["Type"], E>
+      : State["Type"]
+  >
+} => {
+  const memoMap = options?.memoMap ?? Atom.runtime.memoMap
+
+  const actor = Atom.make((get) => {
+    const layer_ = typeof layer === "function" ? layer(get) : layer
+    return GenServer.makeActor(server, layer_).pipe(
+      Effect.provideService(Layer.CurrentMemoMap, memoMap),
+    )
+  }).pipe(Atom.setIdleTTL(options?.idleTTL ?? Duration.zero))
+
+  const state = pipe(
+    Atom.make((get) =>
+      pipe(
+        get.result(actor),
+        Effect.map((actor) => actor.changes),
+        Stream.unwrap,
+      ),
+    ),
+    options?.initialState
+      ? Atom.map(AsyncResult.getOrElse(() => options.initialState))
+      : identity,
+  ) as Atom.Atom<AsyncResult.AsyncResult<State["Type"], E>>
+
+  const sendFamily = <
+    Tag extends Rpcs["_tag"],
+    Rpc = Rpc.ExtractTag<Rpcs, Tag>,
+  >([tag, concurrent]: [Tag, boolean]): Atom.AtomResultFn<
+    Rpc.PayloadConstructor<Rpc>,
+    Rpc.Success<Rpc>,
+    Rpc.Error<Rpc> | E
+  > => {
+    return Atom.fn(
+      (payload, get) =>
+        pipe(
+          get.result(actor),
+          Effect.flatMap((actor) => actor.send(tag, payload)),
+        ),
+      { concurrent },
+    )
+  }
+
+  const send = <Tag extends Rpcs["_tag"]>(
+    tag: Tag,
+    options?: {
+      readonly concurrent?: boolean | undefined
+    },
+  ) => sendFamily([tag, options?.concurrent ?? false])
+
+  return { actor, send, state }
+}

package/src/ClusterGenServer.ts

@@ -0,0 +1,96 @@
+/**
+ * @since 1.0.0
+ */
+import type * as Rpc from "effect/unstable/rpc/Rpc"
+import * as Effect from "effect/Effect"
+import type * as Schema from "effect/Schema"
+import type * as Layer from "effect/Layer"
+import type * as Scope from "effect/Scope"
+import * as Context from "effect/Context"
+import type * as RpcSchema from "effect/unstable/rpc/RpcSchema"
+import * as Entity from "effect/unstable/cluster/Entity"
+import type * as Envelope from "effect/unstable/cluster/Envelope"
+import * as GenServer from "./GenServer.ts"
+
+/**
+ * @since 1.0.0
+ * @category Entity
+ */
+export const entity = <
+  const Type extends string,
+  State extends Schema.Top,
+  Rpcs extends Rpc.Any,
+>(
+  type: Type,
+  schema: GenServer.GenServer<State, Rpcs>,
+): Entity.Entity<
+  Type,
+  | Rpcs
+  | Rpc.Rpc<
+      "GenServerChanges",
+      Schema.Void,
+      RpcSchema.Stream<State, Schema.Never>
+    >
+> =>
+  Entity.fromRpcGroup(
+    type,
+    schema.protocol.add(GenServer.RpcStateChanges(schema)),
+  )
+
+/**
+ * @since 1.0.0
+ * @category Entity
+ */
+export type EntityHandlersFrom<Rpcs extends Rpc.Any> = {
+  readonly [Current in Rpcs as Current["_tag"]]: (
+    envelope: Envelope.Request<Current>,
+  ) => Rpc.WrapperOr<Rpc.ResultFrom<Current, never>>
+}
+
+/**
+ * @since 1.0.0
+ * @category Entity
+ */
+export const entityHandlers = Effect.fnUntraced(function* <
+  State extends Schema.Top,
+  Rpcs extends Rpc.Any,
+  E,
+  R,
+>(
+  schema: GenServer.GenServer<State, Rpcs>,
+  layer: Layer.Layer<GenServer.ToHandler<Rpcs> | GenServer.InitialState, E, R>,
+): Effect.fn.Return<
+  EntityHandlersFrom<
+    | Rpcs
+    | Rpc.Rpc<
+        "GenServerChanges",
+        Schema.Void,
+        RpcSchema.Stream<State, Schema.Never>
+      >
+  >,
+  E,
+  Exclude<R, GenServer.SendDiscard> | Scope.Scope
+> {
+  const { handlers } = yield* GenServer.makeHandlers(schema, layer)
+  const entityHandlers: Record<
+    string,
+    (request: Envelope.Request<any>) => any
+  > = {}
+  for (const { rpc, handler } of handlers.values()) {
+    entityHandlers[rpc._tag] = (request: Envelope.Request<any>) =>
+      handler({
+        payload: request.payload,
+        context: ClusterRequest.context(request),
+      })
+  }
+  return entityHandlers as any
+})
+
+/**
+ * @since 1.0.0
+ * @category Entity
+ */
+export class ClusterRequest extends Context.Service<
+  ClusterRequest,
+  Envelope.Request<Rpc.AnyWithProps>
+>()("effect-genserver/ClusterGenServer/ClusterRequest") {}