0.1.17 (#18)

Co-authored-by: Julien Valverdé <julien.valverde@mailo.com>
Reviewed-on: #18

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thilawyn/thilalib",
-  "version": "0.1.16",
+  "version": "0.1.17",
   "type": "module",
   "files": [
     "./dist"
@@ -8,68 +8,44 @@
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "import": {
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
     },
-      "require": {
+    "./Express": {
-        "types": "./dist/index.d.cts",
+      "types": "./dist/Express/index.d.ts",
-        "default": "./dist/index.cjs"
+      "default": "./dist/Express/index.js"
-      }
     },
-    "./Layers": {
+    "./TRPC": {
-      "import": {
+      "types": "./dist/TRPC/index.d.ts",
-        "types": "./dist/Layers/index.d.ts",
+      "default": "./dist/TRPC/index.js"
-        "default": "./dist/Layers/index.js"
-      },
-      "require": {
-        "types": "./dist/Layers/index.d.cts",
-        "default": "./dist/Layers/index.cjs"
-      }
-    },
-    "./Schema": {
-      "import": {
-        "types": "./dist/Schema/index.d.ts",
-        "default": "./dist/Schema/index.js"
-      },
-      "require": {
-        "types": "./dist/Schema/index.d.cts",
-        "default": "./dist/Schema/index.cjs"
-      }
-    },
-    "./Schema/MobX": {
-      "import": {
-        "types": "./dist/Schema/MobX/index.d.ts",
-        "default": "./dist/Schema/MobX/index.js"
-      },
-      "require": {
-        "types": "./dist/Schema/MobX/index.d.cts",
-        "default": "./dist/Schema/MobX/index.cjs"
-      }
-    },
-    "./Schema/TanStackForm": {
-      "import": {
-        "types": "./dist/Schema/TanStackForm/index.d.ts",
-        "default": "./dist/Schema/TanStackForm/index.js"
-      },
-      "require": {
-        "types": "./dist/Schema/TanStackForm/index.d.cts",
-        "default": "./dist/Schema/TanStackForm/index.cjs"
-      }
     },
     "./Types": {
-      "import": {
       "types": "./dist/Types/index.d.ts",
       "default": "./dist/Types/index.js"
     },
-      "require": {
+    "./Schema": {
-        "types": "./dist/Types/index.d.cts",
+      "types": "./dist/Schema/index.d.ts",
-        "default": "./dist/Types/index.cjs"
+      "default": "./dist/Schema/index.js"
-      }
+    },
+    "./Schema/MobX": {
+      "types": "./dist/Schema/MobX/index.d.ts",
+      "default": "./dist/Schema/MobX/index.js"
+    },
+    "./Schema/TanStackForm": {
+      "types": "./dist/Schema/TanStackForm/index.d.ts",
+      "default": "./dist/Schema/TanStackForm/index.js"
+    },
+    "./JSONWebToken": {
+      "types": "./dist/JSONWebToken.d.ts",
+      "default": "./dist/JSONWebToken.js"
+    },
+    "./OpenAIClient": {
+      "types": "./dist/OpenAIClient.d.ts",
+      "default": "./dist/OpenAIClient.js"
     }
   },
   "scripts": {
-    "build": "tsup",
+    "build": "tsc",
     "lint:tsc": "tsc --noEmit",
     "clean:cache": "rm -f tsconfig.tsbuildinfo",
     "clean:dist": "rm -rf dist",
@@ -80,18 +56,23 @@
     "type-fest": "^4.26.0"
   },
   "devDependencies": {
-    "@effect/schema": "^0.72.0",
+    "@effect/schema": "^0.72.3",
-    "@prisma/studio-server": "^0.502.0",
+    "@tanstack/form-core": "^0.32.0",
-    "@tanstack/form-core": "^0.30.0",
+    "@trpc/server": "^10.45.2",
+    "@types/express": "^4.17.21",
     "@types/jsonwebtoken": "^9.0.6",
-    "bun-types": "^1.1.26",
+    "@types/ws": "^8.5.12",
-    "effect": "^3.7.0",
+    "bun-types": "^1.1.27",
+    "effect": "^3.7.2",
+    "express": "^4.19.2",
     "jsonwebtoken": "^9.0.2",
-    "mobx": "^6.13.1",
+    "mobx": "^6.13.2",
     "npm-check-updates": "^17.1.1",
     "npm-sort": "^0.0.4",
+    "openai": "^4.58.1",
     "tsup": "^8.2.4",
     "tsx": "^4.19.0",
-    "typescript": "^5.5.4"
+    "typescript": "^5.5.4",
+    "ws": "^8.18.0"
   }
 }

src/Express/ExpressApp.ts

@@ -0,0 +1,22 @@
+import { Config, Context, Effect, Layer } from "effect"
+import type { Express } from "express"
+import { ImportError } from "../ImportError"
+
+
+export class ExpressApp extends Context.Tag("ExpressApp")<ExpressApp, Express>() {}
+
+
+const importExpress = Effect.tryPromise({
+    try: () => import("express"),
+    catch: cause => new ImportError({ path: "express", cause }),
+})
+
+export const ExpressAppLive = (
+    config: {
+        readonly trustProxy?: Config.Config<boolean | undefined>
+    } = {}
+) => Layer.effect(ExpressApp, Effect.gen(function*() {
+    const app = (yield* importExpress).default()
+    app.set("trust proxy", (yield* config.trustProxy ?? Config.succeed(undefined)) ?? false)
+    return app
+}))

src/Express/ExpressNodeHTTPServer.ts

@@ -0,0 +1,70 @@
+import { Config, Context, Effect, Layer, Match } from "effect"
+import type { Server } from "node:http"
+import type { AddressInfo } from "node:net"
+import { ImportError } from "../ImportError"
+import { ExpressApp } from "./ExpressApp"
+
+
+export class ExpressNodeHTTPServer extends Context.Tag("ExpressNodeHTTPServer")<ExpressNodeHTTPServer, Server>() {}
+
+
+const importNodeHTTP = Effect.tryPromise({
+    try: () => import("node:http"),
+    catch: cause => new ImportError({ path: "node:http", cause }),
+})
+
+const serverListeningMessage = Match.type<AddressInfo | string | null>().pipe(
+    Match.when(Match.null, () => "HTTP server listening"),
+    Match.when(Match.string, v => `HTTP server listening on ${ v }`),
+    Match.orElse(v => `HTTP server listening on ${ v.address === "::" ? "*" : v.address }:${ v.port }`),
+)
+
+export const ExpressNodeHTTPServerLive = (
+    config: {
+        readonly backlog?:      Config.Config<number | undefined>
+        readonly exclusive?:    Config.Config<boolean | undefined>
+        readonly host?:         Config.Config<string | undefined>
+        readonly ipv6Only?:     Config.Config<boolean | undefined>
+        readonly path?:         Config.Config<string | undefined>
+        readonly port?:         Config.Config<number | undefined>
+        readonly readableAll?:  Config.Config<boolean | undefined>
+        readonly signal?:       AbortSignal
+        readonly writableAll?:  Config.Config<boolean | undefined>
+    } = {}
+) => Layer.effect(ExpressNodeHTTPServer, Effect.acquireRelease(
+    Effect.gen(function*() {
+        const app  = yield* ExpressApp
+        const http = yield* importNodeHTTP
+
+        const options = {
+            backlog:      yield* config.backlog ?? Config.succeed(undefined),
+            exclusive:    yield* config.exclusive ?? Config.succeed(undefined),
+            host:         yield* config.host ?? Config.succeed(undefined),
+            ipv6Only:     yield* config.ipv6Only ?? Config.succeed(undefined),
+            path:         yield* config.path ?? Config.succeed(undefined),
+            port:         yield* config.port ?? Config.succeed(undefined),
+            readableAll:  yield* config.readableAll ?? Config.succeed(undefined),
+            signal:       config.signal,
+            writableAll:  yield* config.writableAll ?? Config.succeed(undefined),
+        } as const
+
+        return yield* Effect.async<Server>(resume => {
+            const server = http.createServer(app).listen(options,
+                () => resume(
+                    Effect.succeed(server).pipe(
+                        Effect.tap(Effect.logInfo(
+                            serverListeningMessage(server.address())
+                        ))
+                    )
+                )
+            )
+        })
+    }),
+
+    server => Effect.gen(function*() {
+        yield* Effect.logInfo("HTTP server is stopping. Waiting for existing connections to end...")
+        yield* Effect.async(resume => {
+            server.close(() => resume(Effect.logInfo("HTTP server closed")))
+        })
+    }),
+))

src/Express/example.ts

@@ -0,0 +1,17 @@
+import { Effect, Layer } from "effect"
+import { ExpressAppLive } from "./ExpressApp"
+import { ExpressNodeHTTPServerLive } from "./ExpressNodeHTTPServer"
+
+
+const AppLive = ExpressAppLive()
+const HTTPServerLive = ExpressNodeHTTPServerLive()
+
+const ServerLive = Layer.empty.pipe(
+    Layer.provideMerge(HTTPServerLive),
+    Layer.provideMerge(AppLive),
+)
+
+Layer.launch(ServerLive).pipe(
+    Effect.scoped,
+    Effect.runPromise,
+)

src/Express/index.ts

@@ -0,0 +1,2 @@
+export * as ExpressApp from "./ExpressApp"
+export * as ExpressNodeHTTPServer from "./ExpressNodeHTTPServer"

src/ImportError.ts

@@ -0,0 +1,11 @@
+import { Data } from "effect"
+
+
+export class ImportError extends Data.TaggedError("ImportError")<{
+    path:   string
+    cause:  unknown
+}> {
+    toString(): string {
+        return `Could not import '${ this.path }'`
+    }
+}

src/JSONWebToken.ts

@@ -1,8 +1,11 @@
 import { Context, Effect, Layer } from "effect"
 import type * as JWT from "jsonwebtoken"
+import { ImportError } from "./ImportError"
 
 
-export class JSONWebToken extends Context.Tag("JSONWebToken")<JSONWebToken, {
+export class JSONWebToken extends Context.Tag("JSONWebToken")<JSONWebToken, JSONWebTokenService>() {}
+
+export interface JSONWebTokenService {
     sign: (
         payload:             string | object | Buffer,
         secretOrPrivateKey:  JWT.Secret,
@@ -11,7 +14,7 @@ export class JSONWebToken extends Context.Tag("JSONWebToken")<JSONWebToken, {
         string,
         Error,
         never
-    >,
+    >
 
     verify: (
         token:              string,
@@ -21,13 +24,13 @@ export class JSONWebToken extends Context.Tag("JSONWebToken")<JSONWebToken, {
         string | JWT.Jwt | JWT.JwtPayload,
         JWT.VerifyErrors | Error,
         never
-    >,
+    >
-}>() {}
+}
 
 
 const importJWT = Effect.tryPromise({
     try: () => import("jsonwebtoken"),
-    catch: cause => new Error("Could not import 'jsonwebtoken'. Make sure it is installed.", { cause }),
+    catch: cause => new ImportError({ path: "jsonwebtoken", cause }),
 })
 
 export const JSONWebTokenLive = Layer.effect(JSONWebToken, importJWT.pipe(

src/Layers/index.ts

@@ -1,5 +0,0 @@
-/**
- * A wrapper around the jsonwebtoken library for Effect
- * Requires `effect`, `jsonwebtoken` and `@types/jsonwebtoken` to be installed
- */
-export * as JSONWebToken from "./JSONWebToken"

src/OpenAIClient.ts

@@ -0,0 +1,69 @@
+import { Config, Context, Effect, Layer } from "effect"
+import type { OpenAI } from "openai"
+import { ImportError } from "./ImportError"
+
+
+export class OpenAIClient extends Context.Tag("OpenAIClient")<OpenAIClient, OpenAIClientService>() {}
+
+export class OpenAIClientService {
+    constructor(
+        readonly openai: Effect.Effect.Success<typeof importOpenAI>,
+        readonly client: OpenAI,
+    ) {}
+
+    try<A>(
+        try_: (
+            client: OpenAI,
+            signal: AbortSignal,
+        ) => Promise<A>
+    ) {
+        return Effect.tryPromise({
+            try: signal => try_(this.client, signal),
+            catch: e => e instanceof this.openai.OpenAIError
+                ? e
+                : new Error(`Unknown OpenAIClient error: ${ e }`),
+        })
+    }
+}
+
+
+const importOpenAI = Effect.tryPromise({
+    try: () => import("openai"),
+    catch: cause => new ImportError({ path: "openai", cause }),
+})
+
+export const OpenAIClientLive = (
+    config: {
+        readonly apiKey:           Config.Config<string>
+        readonly organization?:    Config.Config<string | undefined>
+        readonly project?:         Config.Config<string | undefined>
+        readonly baseURL?:         Config.Config<string | undefined>
+        readonly timeout?:         Config.Config<number | undefined>
+        readonly maxRetries?:      Config.Config<number | undefined>
+
+        readonly httpAgent?:       any
+        readonly fetch?:           any
+        readonly defaultHeaders?:  { [x: string]: string }
+        readonly defaultQuery?:    { [x: string]: string }
+    }
+) => Layer.effect(OpenAIClient, Effect.gen(function*() {
+    const openai = yield* importOpenAI
+
+    return new OpenAIClientService(
+        openai,
+
+        new openai.OpenAI({
+            apiKey:          yield* config.apiKey,
+            organization:    (yield* config.organization ?? Config.succeed(undefined)) ?? null,
+            project:         (yield* config.project ?? Config.succeed(undefined)) ?? null,
+            baseURL:         (yield* config.baseURL ?? Config.succeed(undefined)) ?? "https://api.openai.com/v1",
+            timeout:         yield* config.timeout ?? Config.succeed(undefined),
+            maxRetries:      yield* config.maxRetries ?? Config.succeed(undefined),
+
+            httpAgent:       config.httpAgent,
+            fetch:           config.fetch,
+            defaultHeaders:  config.defaultHeaders,
+            defaultQuery:    config.defaultQuery,
+        }),
+    )
+}))

src/TRPC/TRPCBuilder.ts

@@ -0,0 +1,20 @@
+import { Context, Effect, Layer } from "effect"
+import { type TRPCContext } from "./TRPCContext"
+import { importTRPCServer } from "./importTRPCServer"
+
+
+const createTRPC = <R>() => importTRPCServer.pipe(Effect.map(({ initTRPC }) =>
+    initTRPC.context<TRPCContext<R>>().create()
+))
+
+export const Identifier = "@thilalib/TRPC/TRPCBuilder"
+export interface TRPCBuilder<R> extends Context.Tag<typeof Identifier, TRPCBuilderService<R>> {}
+export interface TRPCBuilderService<R> extends Effect.Effect.Success<ReturnType<typeof createTRPC<R>>> {}
+
+
+export const make = <R>() => {
+    const TRPCBuilder = Context.GenericTag<typeof Identifier, TRPCBuilderService<R>>(Identifier)
+    const TRPCBuilderLive = Layer.effect(TRPCBuilder, createTRPC())
+
+    return { TRPCBuilder, TRPCBuilderLive } as const
+}

src/TRPC/TRPCContext.ts

@@ -0,0 +1,38 @@
+import type { TRPCError } from "@trpc/server"
+import { Data, type Effect, type Runtime } from "effect"
+import type { RuntimeFiber } from "effect/Fiber"
+import type express from "express"
+import type { IncomingMessage } from "node:http"
+import type { WebSocket } from "ws"
+
+
+export interface TRPCContext<R> {
+    readonly runtime: Runtime.Runtime<R>
+
+    readonly run: <A, E>(
+        effect:    Effect.Effect<A, E, R>,
+        options?:  { readonly signal?: AbortSignal },
+    ) => Promise<A>
+
+    readonly fork: <A, E>(
+        effect:    Effect.Effect<A, E, R>,
+        options?:  Runtime.RunForkOptions,
+    ) => RuntimeFiber<A, TRPCError>
+
+    readonly transaction: TRPCContextTransaction
+}
+
+
+export type TRPCContextTransaction = Data.TaggedEnum<{
+    readonly Express: {
+        readonly req: express.Request
+        readonly res: express.Response
+    }
+
+    readonly WebSocket: {
+        readonly req: IncomingMessage
+        readonly res: WebSocket
+    }
+}>
+
+export const TRPCContextTransactionEnum = Data.taggedEnum<TRPCContextTransaction>()

src/TRPC/TRPCContextCreator.ts

@@ -0,0 +1,57 @@
+import type { CreateExpressContextOptions } from "@trpc/server/adapters/express"
+import type { CreateWSSContextFnOptions } from "@trpc/server/adapters/ws"
+import { Context, Effect, Layer, Runtime } from "effect"
+import { createTRCPErrorMapper } from "./createTRCPErrorMapper"
+import { TRPCContextTransactionEnum, type TRPCContext, type TRPCContextTransaction } from "./TRPCContext"
+
+
+export const Identifier = "@thilalib/TRPC/TRPCContextCreator"
+
+export interface TRPCContextCreator<R> extends Context.Tag<typeof Identifier, TRPCContextCreatorService<R>> {}
+
+export interface TRPCContextCreatorService<R> {
+    readonly createContext:           (transaction: TRPCContextTransaction)  => TRPCContext<R>
+    readonly createExpressContext:    (context: CreateExpressContextOptions) => TRPCContext<R>
+    readonly createWebSocketContext:  (context: CreateWSSContextFnOptions)   => TRPCContext<R>
+}
+
+export const TRPCUnknownContextCreator = Context.GenericTag<typeof Identifier, TRPCContextCreatorService<unknown>>(Identifier)
+
+
+export const make = <R>() => {
+    const TRPCContextCreator = Context.GenericTag<typeof Identifier, TRPCContextCreatorService<R>>(Identifier)
+
+    const TRPCContextCreatorLive = Layer.effect(TRPCContextCreator, Effect.gen(function*() {
+        const runtime   = yield* Effect.runtime<R>()
+        const mapErrors = yield* createTRCPErrorMapper
+
+        const run = <A, E>(
+            effect:    Effect.Effect<A, E, R>,
+            options?:  { readonly signal?: AbortSignal },
+        ) => Runtime.runPromise(runtime)(
+            effect.pipe(mapErrors),
+            options,
+        )
+
+        const fork = <A, E>(
+            effect:    Effect.Effect<A, E, R>,
+            options?:  Runtime.RunForkOptions,
+        ) => Runtime.runFork(runtime)(
+            effect.pipe(mapErrors),
+            options,
+        )
+
+        const createContext = (transaction: TRPCContextTransaction) => ({
+            runtime,
+            run,
+            fork,
+            transaction,
+        })
+        const createExpressContext = (context: CreateExpressContextOptions) => createContext(TRPCContextTransactionEnum.Express(context))
+        const createWebSocketContext = (context: CreateWSSContextFnOptions) => createContext(TRPCContextTransactionEnum.WebSocket(context))
+
+        return { createContext, createExpressContext, createWebSocketContext }
+    }))
+
+    return { TRPCContextCreator, TRPCContextCreatorLive } as const
+}

src/TRPC/TRPCExpressRoute.ts

@@ -0,0 +1,27 @@
+import { Config, Effect, Layer } from "effect"
+import { ExpressApp } from "../Express"
+import { ImportError } from "../ImportError"
+import { TRPCUnknownContextCreator } from "./TRPCContextCreator"
+import { TRPCAnyRouter } from "./TRPCRouter"
+
+
+const importTRPCServerExpressAdapter = Effect.tryPromise({
+    try: () => import("@trpc/server/adapters/express"),
+    catch: cause => new ImportError({ path: "@trpc/server/adapters/express", cause }),
+})
+
+export const TRPCExpressRouteLive = (
+    config: {
+        readonly root: Config.Config<string>
+    }
+) => Layer.effectDiscard(Effect.gen(function*() {
+    const { createExpressMiddleware } = yield* importTRPCServerExpressAdapter
+    const app = yield* ExpressApp.ExpressApp
+
+    app.use(yield* config.root,
+        createExpressMiddleware({
+            router:         yield* TRPCAnyRouter,
+            createContext:  (yield* TRPCUnknownContextCreator).createExpressContext,
+        })
+    )
+}))

src/TRPC/TRPCRouter.ts

@@ -0,0 +1,18 @@
+import type { AnyRouter } from "@trpc/server"
+import { Context, Effect, Layer } from "effect"
+
+
+export const Identifier = "@thilalib/TRPC/TRPCRouter"
+export interface TRPCRouter<T extends AnyRouter> extends Context.Tag<typeof Identifier, T> {}
+
+export const TRPCAnyRouter = Context.GenericTag<typeof Identifier, AnyRouter>(Identifier)
+
+
+export const make = <A extends AnyRouter, E, R>(
+    router: Effect.Effect<A, E, R>
+) => {
+    const TRPCRouter = Context.GenericTag<typeof Identifier, A>(Identifier)
+    const TRPCRouterLive = Layer.effect(TRPCRouter, router)
+
+    return { TRPCRouter, TRPCRouterLive } as const
+}

src/TRPC/TRPCWebSocketServer.ts

@@ -0,0 +1,66 @@
+import type { applyWSSHandler } from "@trpc/server/adapters/ws"
+import { Config, Context, Effect, Layer } from "effect"
+import type ws from "ws"
+import { ExpressNodeHTTPServer } from "../Express"
+import { ImportError } from "../ImportError"
+import { TRPCUnknownContextCreator } from "./TRPCContextCreator"
+import { TRPCAnyRouter } from "./TRPCRouter"
+
+
+export class TRPCWebSocketServer extends Context.Tag("@thilalib/TRPC/TRPCWebSocketServer")<TRPCWebSocketServer, TRPCWebSocketServerService>() {}
+
+export interface TRPCWebSocketServerService {
+    wss:      ws.Server
+    handler:  ReturnType<typeof applyWSSHandler>
+}
+
+
+const importWS = Effect.tryPromise({
+    try: () => import("ws"),
+    catch: cause => new ImportError({ path: "ws", cause }),
+})
+
+const importTRPCServerWSAdapter = Effect.tryPromise({
+    try: () => import("@trpc/server/adapters/ws"),
+    catch: cause => new ImportError({ path: "@trpc/server/adapters/ws", cause }),
+})
+
+export const TRPCWebSocketServerLive = (
+    config: {
+        readonly host: Config.Config<string>
+    }
+) => Layer.effect(TRPCWebSocketServer, Effect.gen(function*() {
+    const { WebSocketServer } = yield* importWS
+    const { applyWSSHandler } = yield* importTRPCServerWSAdapter
+
+    const host = yield* config.host
+
+    return yield* Effect.acquireRelease(
+        Effect.gen(function*() {
+            yield* Effect.logInfo(`WebSocket server started on ${ host }`)
+
+            const wss = new WebSocketServer({
+                server: yield* ExpressNodeHTTPServer.ExpressNodeHTTPServer,
+                host,
+            })
+
+            return {
+                wss,
+                handler: applyWSSHandler({
+                    wss,
+                    router:         yield* TRPCAnyRouter,
+                    createContext:  (yield* TRPCUnknownContextCreator).createWebSocketContext,
+                }),
+            }
+        }),
+
+        ({ wss, handler }) => Effect.gen(function*() {
+            yield* Effect.logInfo(`WebSocket server on ${ host } is stopping. Waiting for existing connections to end...`)
+
+            handler.broadcastReconnectNotification()
+            yield* Effect.async(resume => {
+                wss.close(() => resume(Effect.logInfo("WebSocket server closed")))
+            })
+        }),
+    )
+}))

src/TRPC/createTRCPErrorMapper.ts

@@ -0,0 +1,63 @@
+import { Effect, type Cause } from "effect"
+import { importTRPCServer } from "./importTRPCServer"
+
+
+export const createTRCPErrorMapper = importTRPCServer.pipe(Effect.map(({ TRPCError }) =>
+    <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.sandbox(effect).pipe(
+        Effect.catchTags({
+            Empty: cause => Effect.fail(
+                new TRPCError({
+                    code: "INTERNAL_SERVER_ERROR",
+                    cause: new TRPCErrorCause(cause),
+                })
+            ),
+
+            Fail: cause => Effect.fail(
+                cause.error instanceof TRPCError
+                    ? cause.error
+                    : new TRPCError({
+                        code: "INTERNAL_SERVER_ERROR",
+                        cause: new TRPCErrorCause(cause),
+                    })
+            ),
+
+            Die: cause => Effect.fail(
+                cause.defect instanceof TRPCError
+                    ? cause.defect
+                    : new TRPCError({
+                        code: "INTERNAL_SERVER_ERROR",
+                        cause: new TRPCErrorCause(cause),
+                    })
+            ),
+
+            Interrupt: cause => Effect.fail(
+                new TRPCError({
+                    code: "INTERNAL_SERVER_ERROR",
+                    cause: new TRPCErrorCause(cause),
+                })
+            ),
+
+            Sequential: cause => Effect.fail(
+                new TRPCError({
+                    code: "INTERNAL_SERVER_ERROR",
+                    cause: new TRPCErrorCause(cause),
+                })
+            ),
+
+            Parallel: cause => Effect.fail(
+                new TRPCError({
+                    code: "INTERNAL_SERVER_ERROR",
+                    cause: new TRPCErrorCause(cause),
+                })
+            ),
+        }),
+
+        Effect.tapError(Effect.logError),
+    )
+))
+
+class TRPCErrorCause<E> extends Error {
+    constructor(readonly cause: Cause.Cause<E>) {
+        super()
+    }
+}

src/TRPC/example.ts

@@ -0,0 +1,51 @@
+import { Config, Effect, Layer } from "effect"
+import * as TRPC from "."
+import { Express, JSONWebToken } from ".."
+
+
+// Context available to the router procedures
+type Services =
+    | JSONWebToken.JSONWebToken
+
+const ServicesLive = Layer.empty.pipe(
+    Layer.provideMerge(JSONWebToken.JSONWebTokenLive)
+)
+
+
+const { TRPCContextCreator, TRPCContextCreatorLive } = TRPC.TRPCContextCreator.make<Services>()
+const { TRPCBuilder, TRPCBuilderLive } = TRPC.TRPCBuilder.make<Services>()
+
+
+const router = TRPCBuilder.pipe(Effect.map(t => t.router({
+    ping: t.procedure.query(({ ctx }) => ctx.run(
+        Effect.succeed("pong")
+    )),
+})))
+const { TRPCRouter, TRPCRouterLive } = TRPC.TRPCRouter.make(router)
+
+
+const ServerLive = Layer.empty.pipe(
+    Layer.provideMerge(TRPC.TRPCExpressRoute.TRPCExpressRouteLive({
+        root: Config.succeed("/rpc")
+    })),
+    Layer.provideMerge(TRPC.TRPCWebSocketServer.TRPCWebSocketServerLive({
+        host: Config.succeed("/rpc")
+    })),
+
+    Layer.provideMerge(TRPCRouterLive),
+    Layer.provideMerge(TRPCBuilderLive),
+    Layer.provideMerge(TRPCContextCreatorLive),
+
+    Layer.provideMerge(Express.ExpressNodeHTTPServer.ExpressNodeHTTPServerLive({
+        port: Config.succeed(3000)
+    })),
+    Layer.provideMerge(Express.ExpressApp.ExpressAppLive())
+)
+
+await Effect.gen(function*() {
+    return yield* Layer.launch(ServerLive)
+}).pipe(
+    Effect.provide(ServicesLive),
+    Effect.scoped,
+    Effect.runPromise,
+)

src/TRPC/importTRPCServer.ts

@@ -0,0 +1,11 @@
+import { Effect } from "effect"
+import { ImportError } from "../ImportError"
+
+
+export const importTRPCServer: Effect.Effect<
+    typeof import("@trpc/server"),
+    ImportError
+> = Effect.tryPromise({
+    try: () => import("@trpc/server"),
+    catch: cause => new ImportError({ path: "@trpc/server", cause }),
+})

src/TRPC/index.ts

@@ -0,0 +1,7 @@
+export * from "./middlewares"
+export * as TRPCBuilder from "./TRPCBuilder"
+export * as TRPCContext from "./TRPCContext"
+export * as TRPCContextCreator from "./TRPCContextCreator"
+export * as TRPCExpressRoute from "./TRPCExpressRoute"
+export * as TRPCRouter from "./TRPCRouter"
+export * as TRPCWebSocketServer from "./TRPCWebSocketServer"

src/TRPC/middlewares.ts

@@ -0,0 +1,44 @@
+import { Effect, Match } from "effect"
+import type { TRPCContextTransaction } from "./TRPCContext"
+import { importTRPCServer } from "./importTRPCServer"
+
+
+export const ExpressOnly = importTRPCServer.pipe(Effect.map(({
+    experimental_standaloneMiddleware,
+    TRPCError,
+}) => experimental_standaloneMiddleware<{
+    ctx: { readonly transaction: TRPCContextTransaction }
+}>().create(opts =>
+    Match.value(opts.ctx.transaction).pipe(
+        Match.tag("Express", transaction =>
+            opts.next({ ctx: { transaction } })
+        ),
+
+        Match.orElse(() => {
+            throw new TRPCError({
+                code: "BAD_REQUEST",
+                message: "Only Express transport is supported by this procedure",
+            })
+        }),
+    )
+)))
+
+export const WebSocketOnly = importTRPCServer.pipe(Effect.map(({
+    experimental_standaloneMiddleware,
+    TRPCError,
+}) => experimental_standaloneMiddleware<{
+    ctx: { readonly transaction: TRPCContextTransaction }
+}>().create(opts =>
+    Match.value(opts.ctx.transaction).pipe(
+        Match.tag("WebSocket", transaction =>
+            opts.next({ ctx: { transaction } })
+        ),
+
+        Match.orElse(() => {
+            throw new TRPCError({
+                code: "BAD_REQUEST",
+                message: "Only WebSocket transport is supported by this procedure",
+            })
+        }),
+    )
+)))

src/index.ts

@@ -1,3 +1,6 @@
-export * as Layers from "./Layers"
+export * as Express from "./Express"
+export * from "./ImportError"
+export * as JSONWebToken from "./JSONWebToken"
+export * as OpenAIClient from "./OpenAIClient"
 export * as Schema from "./Schema"
 export * as Types from "./Types"

tsconfig.json

@@ -6,13 +6,13 @@
     "module": "ESNext",
     "moduleDetection": "force",
     "jsx": "react-jsx",
-    "allowJs": true,
+    // "allowJs": true,
 
     // Bundler mode
     "moduleResolution": "bundler",
-    "allowImportingTsExtensions": true,
+    // "allowImportingTsExtensions": true,
     "verbatimModuleSyntax": true,
-    "noEmit": true,
+    // "noEmit": true,
 
     // Best practices
     "strict": true,
@@ -22,6 +22,12 @@
     // Some stricter flags (disabled by default)
     "noUnusedLocals": false,
     "noUnusedParameters": false,
-    "noPropertyAccessFromIndexSignature": false
+    "noPropertyAccessFromIndexSignature": false,
-  }
+
+    // Build
+    "outDir": "./dist",
+    "declaration": true
+  },
+
+  "include": ["./src"]
 }

tsup.config.ts

@@ -4,13 +4,16 @@ import { defineConfig } from "tsup"
 export default defineConfig({
     entry: [
         "./src/index.ts",
-        "./src/Layers/index.ts",
+        "./src/Express/index.ts",
+        "./src/TRPC/index.ts",
+        "./src/Types/index.ts",
         "./src/Schema/index.ts",
         "./src/Schema/MobX/index.ts",
         "./src/Schema/TanStackForm/index.ts",
-        "./src/Types/index.ts",
+        "./src/JSONWebToken.ts",
+        "./src/OpenAIClient.ts",
     ],
-    format: ["esm", "cjs"],
+    format: ["esm"],
     skipNodeModulesBundle: true,
     dts: true,
     splitting: true,