feat: security (#491)

* refactor: Requirements -> Context type helper

* feat: security

Author: sukovanej

packages/effect-http-node/examples/example.ts

@@ -1,6 +1,6 @@
 import { Schema } from "@effect/schema"
 import { Context, Effect, Layer, pipe } from "effect"
-import { Api, RouterBuilder } from "effect-http"
+import { Api, RouterBuilder, Security } from "effect-http"
 
 import { NodeRuntime } from "@effect/platform-node"
 import { NodeServer } from "effect-http-node"
@@ -33,11 +33,7 @@ const dummyStuff = pipe(
 const getLesnek = Api.get("getLesnek", "/lesnek").pipe(
   Api.setResponseBody(Schema.string),
   Api.setRequestQuery(Lesnek),
-  Api.addSecurity("myAwesomeBearerAuth", {
-    type: "http",
-    options: { scheme: "bearer", bearerFormat: "JWT" },
-    schema: Schema.Secret
-  })
+  Api.setSecurity(Security.bearer({ name: "myAwesomeBearerAuth", bearerFormat: "JWT" }))
 )
 
 const api = pipe(

packages/effect-http-node/examples/new-api.ts

@@ -1,6 +1,6 @@
 import { Schema } from "@effect/schema"
 import { pipe } from "effect"
-import { Api, ApiGroup, ApiResponse, SecurityScheme } from "effect-http"
+import { Api, ApiGroup, ApiResponse, Security } from "effect-http"
 
 interface MyRequirement {}
 interface AnotherDep {}
@@ -31,12 +31,8 @@ const test = pipe(
   Api.get("test", "/test"),
   Api.setRequestBody(MyRequest),
   Api.setRequestPath(TestPathParams),
-  Api.addSecurity(
-    "mySecurity",
-    SecurityScheme.bearer({
-      description: "test",
-      tokenSchema: Schema.string
-    })
+  Api.setSecurity(
+    Security.bearer({ name: "mySecurity", description: "test" })
   ),
   Api.setResponseBody(MyRequest),
   Api.addResponse(ApiResponse.make(201, TestPathParams, MyRequest))

packages/effect-http-node/examples/readme-security.ts

@@ -1,34 +1,21 @@
 import { NodeRuntime } from "@effect/platform-node"
 import { Schema } from "@effect/schema"
 import { Effect } from "effect"
-import { Api, RouterBuilder } from "effect-http"
+import { Api, RouterBuilder, Security } from "effect-http"
 import { NodeServer } from "effect-http-node"
 
 const mySecuredEnpoint = Api.post("security", "/testSecurity", { description: "" }).pipe(
   Api.setResponseBody(Schema.string),
-  Api.addSecurity(
-    "myAwesomeBearerAuth", // arbitrary name for the security scheme
-    {
-      type: "http",
-      options: {
-        scheme: "bearer",
-        bearerFormat: "JWT"
-      },
-      // Schema<any, string> for decoding-encoding the significant part
-      // "Authorization: Bearer <significant part>"
-      schema: Schema.Secret
-    }
-  )
+  Api.setSecurity(Security.bearer())
 )
 
 const api = Api.make().pipe(
   Api.addEndpoint(mySecuredEnpoint)
 )
 
 const app = RouterBuilder.make(api).pipe(
-  RouterBuilder.handle("security", (_, security) => {
-    const token = security.myAwesomeBearerAuth.token // Secret
-    return Effect.succeed(`your token ${token}`)
+  RouterBuilder.handle("security", (_, token) => {
+    return Effect.succeed(`your token ${token}`) // Secret
   }),
   RouterBuilder.build
 )

packages/effect-http-node/test/server.test.ts

@@ -1,7 +1,8 @@
-import { HttpServer } from "@effect/platform"
+import { HttpClient, HttpServer } from "@effect/platform"
+import { Schema } from "@effect/schema"
 import * as it from "@effect/vitest"
-import { Context, Effect, Either, Layer, Option, pipe, ReadonlyArray } from "effect"
-import { Api, ApiResponse, ClientError, RouterBuilder, ServerError } from "effect-http"
+import { Context, Effect, Either, Encoding, Layer, Option, pipe, ReadonlyArray } from "effect"
+import { Api, ApiResponse, ClientError, RouterBuilder, Security, ServerError } from "effect-http"
 import { NodeTesting } from "effect-http-node"
 import { createHash } from "node:crypto"
 import { describe, expect, test } from "vitest"
@@ -286,7 +287,7 @@ it.scoped(
 
     const result = yield* _(
       NodeTesting.make(app, exampleApiOptional),
-      Effect.flatMap((client) => Effect.all(ReadonlyArray.map(params, client.hello)))
+      Effect.flatMap((client) => Effect.all(ReadonlyArray.map(params, (params) => client.hello(params))))
     )
 
     expect(result).toStrictEqual(params)
@@ -309,7 +310,7 @@ it.scoped(
 
     const result = yield* _(
       NodeTesting.make(app, exampleApiOptionalParams),
-      Effect.flatMap((client) => Effect.all(ReadonlyArray.map(params, client.hello)))
+      Effect.flatMap((client) => Effect.all(ReadonlyArray.map(params, (params) => client.hello(params))))
     )
 
     expect(result).toStrictEqual(params)
@@ -364,3 +365,113 @@ it.scoped(
     expect(result).toBe(undefined)
   })
 )
+
+it.scoped(
+  "optional parameters",
+  Effect.gen(function*(_) {
+    const app = pipe(
+      RouterBuilder.make(exampleApiOptionalParams),
+      RouterBuilder.handle("hello", ({ path }) => Effect.succeed({ path })),
+      RouterBuilder.build
+    )
+
+    const params = [
+      { path: { value: 12 } },
+      { path: { value: 12, another: "another" } }
+    ] as const
+
+    const result = yield* _(
+      NodeTesting.make(app, exampleApiOptionalParams),
+      Effect.flatMap((client) => Effect.all(ReadonlyArray.map(params, (params) => client.hello(params))))
+    )
+
+    expect(result).toStrictEqual(params)
+  })
+)
+
+it.scoped(
+  "single full response",
+  Effect.gen(function*(_) {
+    const app = pipe(
+      RouterBuilder.make(exampleApiFullResponse),
+      RouterBuilder.handle("hello", () =>
+        Effect.succeed({
+          body: 12,
+          headers: { "my-header": "test" },
+          status: 200 as const
+        })),
+      RouterBuilder.handle("another", () => Effect.succeed(12)),
+      RouterBuilder.build
+    )
+
+    const result = yield* _(
+      NodeTesting.make(app, exampleApiFullResponse),
+      Effect.flatMap((client) => Effect.all([client.hello({}), client.another({})]))
+    )
+
+    expect(result).toMatchObject([
+      {
+        status: 200,
+        body: 12,
+        headers: { "my-header": "test" }
+      },
+      12
+    ])
+  })
+)
+
+it.scoped(
+  "empty response",
+  Effect.gen(function*(_) {
+    const app = pipe(
+      RouterBuilder.make(exampleApiEmptyResponse),
+      RouterBuilder.handle("test", () => Effect.unit),
+      RouterBuilder.build
+    )
+
+    const result = yield* _(
+      NodeTesting.make(app, exampleApiEmptyResponse),
+      Effect.flatMap((client) => client.test({ body: "test" }))
+    )
+
+    expect(result).toBe(undefined)
+  })
+)
+
+it.scoped(
+  "complex security example",
+  Effect.gen(function*(_) {
+    class MyService extends Effect.Tag("MyService")<MyService, { value: string }>() {
+      static live = Layer.succeed(MyService, { value: "hello" })
+    }
+
+    const security = pipe(
+      Security.basic(),
+      Security.mapEffect((creds) => MyService.value.pipe(Effect.map((value) => `${value}-${creds.user}-${creds.pass}`)))
+    )
+
+    const api = Api.make().pipe(
+      Api.addEndpoint(
+        Api.post("test", "/test").pipe(Api.setResponseBody(Schema.string), Api.setSecurity(security))
+      )
+    )
+
+    const app = pipe(
+      RouterBuilder.make(api),
+      RouterBuilder.handle("test", (_, security) => Effect.succeed(security)),
+      RouterBuilder.build
+    )
+
+    const credentials = Encoding.encodeBase64("user:pass")
+
+    const result = yield* _(
+      NodeTesting.make(app, api),
+      Effect.flatMap((client) =>
+        client.test({}, HttpClient.request.setHeader("authorization", `basic ${credentials}`))
+      ),
+      Effect.provide(MyService.live)
+    )
+
+    expect(result).toBe("hello-user-pass")
+  })
+)