@effect-app/infra 4.0.0-beta.98 → 4.0.0

package/src/test.ts

@@ -1,12 +1,12 @@
-import { S } from "effect-app"
+import * as S from "effect-app/Schema"
 import { copy } from "effect-app/utils"
-import { generate } from "./arbs.js"
+import { generateFromSchema } from "./arbs.ts"
 
 /**
  * Given the schema for an object-like structure, creates a function that generates random instances of that object with some values provided.
  */
 export const createRandomInstance = <A extends object, I, R>(s: S.Codec<A, I, R> & { fields: S.Struct.Fields }) => {
-  const gen = generate(S.toArbitrary(s))
+  const gen = generateFromSchema(s)
   return (overrides?: Partial<A>) => {
     const v = gen.value
     return overrides ? copy(v, overrides) : v
@@ -16,8 +16,8 @@ export const createRandomInstance = <A extends object, I, R>(s: S.Codec<A, I, R>
 /**
  * Like `createRandomInstance`, but takes encoded values rather than decoded ones.
  */
-export const createRandomInstanceI = <A extends object, I>(s: S.Codec<A, I, never> & { fields: S.Struct.Fields }) => {
-  const gen = generate(S.toArbitrary(s))
+export const createRandomInstanceI = <A extends object, I>(s: S.Codec<A, I> & { fields: S.Struct.Fields }) => {
+  const gen = generateFromSchema(s)
   const encode = S.encodeSync(s)
   const decode = S.decodeSync(s)
   return (overrides?: Partial<I>) => {
@@ -27,4 +27,4 @@ export const createRandomInstanceI = <A extends object, I>(s: S.Codec<A, I, neve
   }
 }
 
-export * from "./arbs.js"
+export * from "./arbs.ts"

package/src/vitest.ts

@@ -1,2 +1,2 @@
 export * from "@effect/vitest"
-export * from "./test.js"
+export * from "./test.ts"

package/test/arbs-magnitude.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, it } from "@effect/vitest"
+import * as S from "effect-app/Schema"
+import { generateFromSchema } from "../src/arbs.js"
+
+describe("generateFromSchema number magnitudes", () => {
+  it("keeps PositiveNumber and NonNegativeNumber samples realistic", () => {
+    const schema = S.Struct({ amount: S.PositiveNumber, weight: S.NonNegativeNumber })
+    for (let i = 0; i < 200; i++) {
+      const { amount, weight } = generateFromSchema(schema).value
+      expect(amount).toBeGreaterThan(0)
+      expect(weight).toBeGreaterThanOrEqual(0)
+      expect(Math.max(amount, weight)).toBeLessThanOrEqual(1_000_000)
+      expect(Number.isFinite(amount * weight)).toBe(true)
+    }
+  })
+
+  it("keeps Finite samples realistic", () => {
+    const schema = S.Struct({ amount: S.Finite, weight: S.Finite })
+    for (let i = 0; i < 200; i++) {
+      const { amount, weight } = generateFromSchema(schema).value
+      expect(Number.isFinite(amount)).toBe(true)
+      expect(Number.isFinite(weight)).toBe(true)
+      expect(Math.max(Math.abs(amount), Math.abs(weight))).toBeLessThanOrEqual(1_000_000)
+      expect(Number.isFinite(amount * weight)).toBe(true)
+    }
+  })
+
+  it("does not change the JSON Schema of the number schemas", () => {
+    expect(S.toJsonSchemaDocument(S.PositiveNumber).schema).not.toHaveProperty("maximum")
+    expect(S.toJsonSchemaDocument(S.NonNegativeNumber).schema).not.toHaveProperty("maximum")
+    expect(S.toJsonSchemaDocument(S.Finite).schema).not.toHaveProperty("maximum")
+  })
+})

package/test/arbs.test.ts

@@ -0,0 +1,41 @@
+import { describe, expect, it } from "@effect/vitest"
+import { RequestId } from "effect-app/ids"
+import * as S from "effect-app/Schema"
+import { generateFromSchema } from "../src/arbs.js"
+
+describe("generateFromSchema", () => {
+  it("yields a new sample on each call", () => {
+    const schema = S.Struct({ id: S.NonEmptyString255, amount: S.Finite })
+    const samples = Array.from({ length: 5 }, () => generateFromSchema(schema).value)
+    for (const sample of samples) {
+      expect(S.is(schema)(sample)).toBe(true)
+    }
+    expect(new Set(samples.map((sample) => JSON.stringify(sample))).size).toBeGreaterThan(1)
+  })
+
+  it("samples refined strings that native generation cannot invert (Email, PhoneNumber)", () => {
+    const schema = S.Struct({ email: S.Email, phone: S.PhoneNumber })
+    for (let i = 0; i < 10; i++) {
+      expect(S.is(schema)(generateFromSchema(schema).value)).toBe(true)
+    }
+  })
+
+  it("successive StringId samples are unique (count:1 jump, not attempt-0 edge strings)", () => {
+    const Item = S.Struct({ id: S.StringId, amount: S.Finite })
+    const ids = Array.from({ length: 20 }, () => generateFromSchema(Item).value.id)
+    expect(new Set(ids).size).toBe(20)
+  })
+
+  it("successive RequestId samples are unique", () => {
+    const ids = Array.from({ length: 20 }, () => generateFromSchema(RequestId).value)
+    expect(new Set(ids).size).toBe(20)
+  })
+
+  it("samples Url as https URLs", () => {
+    for (let i = 0; i < 10; i++) {
+      const url = generateFromSchema(S.Url).value
+      expect(url.startsWith("https://")).toBe(true)
+      expect(S.is(S.Url)(url)).toBe(true)
+    }
+  })
+})

package/test/auth.test.ts

@@ -0,0 +1,101 @@
+import { describe, expect, it } from "@effect/vitest"
+import * as Effect from "effect-app/Effect"
+import { HttpHeaders } from "effect-app/http"
+import { SignJWT } from "jose"
+import { checkJWTI, InvalidRequestError, InvalidTokenError, UnauthorizedError } from "../src/internal/auth.js"
+
+const issuer = "https://issuer.example.com/"
+const audience = "effect-app"
+const secret = "test-secret-test-secret-test-secret"
+
+const makeToken = () =>
+  new SignJWT({ scope: "read:all" })
+    .setProtectedHeader({ alg: "HS256", typ: "at+jwt" })
+    .setIssuer(issuer)
+    .setAudience(audience)
+    .setIssuedAt()
+    .setExpirationTime("10m")
+    .sign(new TextEncoder().encode(secret))
+
+describe("checkJWTI", () => {
+  it.effect(
+    "validates a bearer token from headers",
+    Effect.fnUntraced(function*() {
+      const token = yield* Effect.promise(() => makeToken())
+
+      yield* checkJWTI({
+        audience,
+        issuer,
+        secret,
+        strict: true,
+        tokenSigningAlg: "HS256"
+      })(HttpHeaders.fromRecordUnsafe({ authorization: `Bearer ${token}` }))
+    })
+  )
+
+  it.effect(
+    "fails on malformed authorization headers",
+    Effect.fnUntraced(function*() {
+      const error = yield* Effect.flip(
+        checkJWTI({
+          audience,
+          issuer,
+          secret,
+          tokenSigningAlg: "HS256"
+        })(HttpHeaders.fromRecordUnsafe({ authorization: "Basic abc" }))
+      )
+
+      expect(error).toBeInstanceOf(InvalidRequestError)
+      expect(error.status).toBe(400)
+    })
+  )
+
+  it.effect(
+    "fails when the token is missing",
+    Effect.fnUntraced(function*() {
+      const error = yield* Effect.flip(
+        checkJWTI({
+          audience,
+          issuer,
+          secret,
+          tokenSigningAlg: "HS256"
+        })(HttpHeaders.empty)
+      )
+
+      expect(error).toBeInstanceOf(UnauthorizedError)
+      expect(error.status).toBe(401)
+    })
+  )
+
+  it.effect(
+    "allows missing tokens when auth is optional",
+    Effect.fnUntraced(function*() {
+      yield* checkJWTI({
+        audience,
+        authRequired: false,
+        issuer,
+        secret,
+        tokenSigningAlg: "HS256"
+      })(HttpHeaders.empty)
+    })
+  )
+
+  it.effect(
+    "fails when the token signature is invalid",
+    Effect.fnUntraced(function*() {
+      const token = yield* Effect.promise(() => makeToken())
+
+      const error = yield* Effect.flip(
+        checkJWTI({
+          audience,
+          issuer,
+          secret: "wrong-secret-wrong-secret-wrong-secret",
+          tokenSigningAlg: "HS256"
+        })(HttpHeaders.fromRecordUnsafe({ authorization: `Bearer ${token}` }))
+      )
+
+      expect(error).toBeInstanceOf(InvalidTokenError)
+      expect(error.status).toBe(401)
+    })
+  )
+})