@effect/platform 0.55.6 → 0.56.0

package/src/Http/ClientRequest.ts

@@ -5,6 +5,7 @@ import type { ParseOptions } from "@effect/schema/AST"
 import type * as Schema from "@effect/schema/Schema"
 import type * as Effect from "effect/Effect"
 import type { Inspectable } from "effect/Inspectable"
+import type * as Option from "effect/Option"
 import type { Scope } from "effect/Scope"
 import type * as Stream from "effect/Stream"
 import type * as PlatformError from "../Error.js"
@@ -41,6 +42,7 @@ export interface ClientRequest
   readonly method: Method
   readonly url: string
   readonly urlParams: UrlParams.UrlParams
+  readonly hash: Option.Option<string>
   readonly headers: Headers.Headers
   readonly body: Body.Body
 }
@@ -51,8 +53,9 @@ export interface ClientRequest
  */
 export interface Options {
   readonly method?: Method | undefined
-  readonly url?: string | undefined
+  readonly url?: string | URL | undefined
   readonly urlParams?: UrlParams.Input | undefined
+  readonly hash?: string | undefined
   readonly headers?: Headers.Input | undefined
   readonly body?: Body.Body | undefined
   readonly accept?: string | undefined
@@ -204,7 +207,7 @@ export const acceptJson: (self: ClientRequest) => ClientRequest = internal.accep
  */
 export const setUrl: {
   (url: string | URL): (self: ClientRequest) => ClientRequest
-  (self: ClientRequest, url: string): ClientRequest
+  (self: ClientRequest, url: string | URL): ClientRequest
 } = internal.setUrl
 
 /**
@@ -212,7 +215,7 @@ export const setUrl: {
  * @category combinators
  */
 export const prependUrl: {
-  (path: string | URL): (self: ClientRequest) => ClientRequest
+  (path: string): (self: ClientRequest) => ClientRequest
   (self: ClientRequest, path: string): ClientRequest
 } = internal.prependUrl
 
@@ -238,25 +241,52 @@ export const updateUrl: {
  * @since 1.0.0
  * @category combinators
  */
-export const setUrlParam = internal.setUrlParam
+export const setUrlParam: {
+  (key: string, value: string): (self: ClientRequest) => ClientRequest
+  (self: ClientRequest, key: string, value: string): ClientRequest
+} = internal.setUrlParam
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const setUrlParams: {
+  (input: UrlParams.Input): (self: ClientRequest) => ClientRequest
+  (self: ClientRequest, input: UrlParams.Input): ClientRequest
+} = internal.setUrlParams
 
 /**
  * @since 1.0.0
  * @category combinators
  */
-export const setUrlParams = internal.setUrlParams
+export const appendUrlParam: {
+  (key: string, value: string): (self: ClientRequest) => ClientRequest
+  (self: ClientRequest, key: string, value: string): ClientRequest
+} = internal.appendUrlParam
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const appendUrlParams: {
+  (input: UrlParams.Input): (self: ClientRequest) => ClientRequest
+  (self: ClientRequest, input: UrlParams.Input): ClientRequest
+} = internal.appendUrlParams
 
 /**
  * @since 1.0.0
  * @category combinators
  */
-export const appendUrlParam = internal.appendUrlParam
+export const setHash: {
+  (hash: string): (self: ClientRequest) => ClientRequest
+  (self: ClientRequest, hash: string): ClientRequest
+} = internal.setHash
 
 /**
  * @since 1.0.0
  * @category combinators
  */
-export const appendUrlParams = internal.appendUrlParams
+export const removeHash: (self: ClientRequest) => ClientRequest = internal.removeHash
 
 /**
  * @since 1.0.0

package/src/Http/Headers.ts

@@ -8,7 +8,7 @@ import { globalValue } from "effect/GlobalValue"
 import type * as Option from "effect/Option"
 import * as Predicate from "effect/Predicate"
 import * as Record from "effect/Record"
-import * as Secret from "effect/Secret"
+import * as Redacted from "effect/Redacted"
 import * as String from "effect/String"
 import type { Mutable } from "effect/Types"
 
@@ -205,22 +205,30 @@ export const remove: {
  * @category combinators
  */
 export const redact: {
-  (key: string | RegExp | ReadonlyArray<string | RegExp>): (self: Headers) => Record<string, string | Secret.Secret>
-  (self: Headers, key: string | RegExp | ReadonlyArray<string | RegExp>): Record<string, string | Secret.Secret>
+  (
+    key: string | RegExp | ReadonlyArray<string | RegExp>
+  ): (self: Headers) => Record<string, string | Redacted.Redacted>
+  (
+    self: Headers,
+    key: string | RegExp | ReadonlyArray<string | RegExp>
+  ): Record<string, string | Redacted.Redacted>
 } = dual(
   2,
-  (self: Headers, key: string | RegExp | ReadonlyArray<string | RegExp>): Record<string, string | Secret.Secret> => {
-    const out: Record<string, string | Secret.Secret> = { ...self }
+  (
+    self: Headers,
+    key: string | RegExp | ReadonlyArray<string | RegExp>
+  ): Record<string, string | Redacted.Redacted> => {
+    const out: Record<string, string | Redacted.Redacted> = { ...self }
     const modify = (key: string | RegExp) => {
       if (typeof key === "string") {
         const k = key.toLowerCase()
         if (k in self) {
-          out[k] = Secret.fromString(self[k])
+          out[k] = Redacted.make(self[k])
         }
       } else {
         for (const name in self) {
           if (key.test(name)) {
-            out[name] = Secret.fromString(self[name])
+            out[name] = Redacted.make(self[name])
           }
         }
       }

package/src/Http/UrlParams.ts

@@ -207,7 +207,7 @@ export const toString = (self: UrlParams): string => new URLSearchParams(self as
  * @since 1.0.0
  * @category constructors
  */
-export const makeUrl = (url: string, params: UrlParams): Either.Either<URL, Error> => {
+export const makeUrl = (url: string, params: UrlParams, hash: Option.Option<string>): Either.Either<URL, Error> => {
   try {
     const urlInstance = new URL(url, baseUrl())
     for (let i = 0; i < params.length; i++) {
@@ -216,7 +216,9 @@ export const makeUrl = (url: string, params: UrlParams): Either.Either<URL, Erro
         urlInstance.searchParams.append(key, value)
       }
     }
-
+    if (hash._tag === "Some") {
+      urlInstance.hash = hash.value
+    }
     return Either.right(urlInstance)
   } catch (e) {
     return Either.left(e as Error)

package/src/Worker.ts

@@ -108,7 +108,6 @@ export declare namespace Worker {
     readonly transfers?: ((message: I) => ReadonlyArray<unknown>) | undefined
     readonly queue?: WorkerQueue<I> | undefined
     readonly initialMessage?: LazyArg<I> | undefined
-    readonly permits?: number | undefined
   }
 
   /**
@@ -157,10 +156,21 @@ export declare namespace WorkerPool {
    * @since 1.0.0
    * @category models
    */
-  export interface Options<I> extends Worker.Options<I> {
-    readonly onCreate?: (worker: Worker<I, unknown, unknown>) => Effect.Effect<void, WorkerError>
-    readonly size: number
-  }
+  export type Options<I> =
+    & Worker.Options<I>
+    & ({
+      readonly onCreate?: (worker: Worker<I, unknown, unknown>) => Effect.Effect<void, WorkerError>
+      readonly size: number
+      readonly concurrency?: number | undefined
+      readonly targetUtilization?: number | undefined
+    } | {
+      readonly onCreate?: (worker: Worker<I, unknown, unknown>) => Effect.Effect<void, WorkerError>
+      readonly minSize: number
+      readonly maxSize: number
+      readonly concurrency?: number | undefined
+      readonly targetUtilization?: number | undefined
+      readonly timeToLive: Duration.DurationInput
+    })
 }
 
 /**
@@ -270,7 +280,6 @@ export declare namespace SerializedWorker {
    * @category models
    */
   export interface BaseOptions<I> {
-    readonly permits?: number | undefined
     readonly queue?: WorkerQueue<I> | undefined
   }
 }
@@ -312,10 +321,14 @@ export declare namespace SerializedWorkerPool {
     & ({
       readonly onCreate?: (worker: Worker<I, unknown, unknown>) => Effect.Effect<void, WorkerError>
       readonly size: number
+      readonly concurrency?: number | undefined
+      readonly targetUtilization?: number | undefined
     } | {
       readonly onCreate?: (worker: Worker<I, unknown, unknown>) => Effect.Effect<void, WorkerError>
       readonly minSize: number
       readonly maxSize: number
+      readonly concurrency?: number | undefined
+      readonly targetUtilization?: number | undefined
       readonly timeToLive: Duration.DurationInput
     })
 }

package/src/internal/http/client.ts

@@ -126,7 +126,7 @@ export const makeDefault = (
         const scope = Context.unsafeGet(fiber.getFiberRef(FiberRef.currentContext), Scope.Scope)
         const controller = new AbortController()
         const addAbort = Scope.addFinalizer(scope, Effect.sync(() => controller.abort()))
-        const urlResult = UrlParams.makeUrl(request.url, request.urlParams)
+        const urlResult = UrlParams.makeUrl(request.url, request.urlParams, request.hash)
         if (urlResult._tag === "Left") {
           return Effect.fail(new Error.RequestError({ request, reason: "InvalidUrl", error: urlResult.left }))
         }

package/src/internal/http/clientRequest.ts

@@ -5,6 +5,7 @@ import * as Effect from "effect/Effect"
 import * as Effectable from "effect/Effectable"
 import { dual } from "effect/Function"
 import * as Inspectable from "effect/Inspectable"
+import * as Option from "effect/Option"
 import type * as Stream from "effect/Stream"
 import type * as PlatformError from "../../Error.js"
 import type * as FileSystem from "../../FileSystem.js"
@@ -35,6 +36,7 @@ const Proto = {
       method: this.method,
       url: this.url,
       urlParams: this.urlParams,
+      hash: this.hash,
       headers: this.headers,
       body: this.body.toJSON()
     }
@@ -45,6 +47,7 @@ function makeInternal(
   method: Method,
   url: string,
   urlParams: UrlParams.UrlParams,
+  hash: Option.Option<string>,
   headers: Headers.Headers,
   body: Body.Body
 ): ClientRequest.ClientRequest {
@@ -52,6 +55,7 @@ function makeInternal(
   self.method = method
   self.url = url
   self.urlParams = urlParams
+  self.hash = hash
   self.headers = headers
   self.body = body
   return self
@@ -66,6 +70,7 @@ export const empty: ClientRequest.ClientRequest = makeInternal(
   "GET",
   "",
   UrlParams.empty,
+  Option.none(),
   Headers.empty,
   internalBody.empty
 )
@@ -78,7 +83,7 @@ export const make = <M extends Method>(method: M) =>
 ) =>
   modify(empty, {
     method,
-    url: url.toString(),
+    url,
     ...(options ?? undefined)
   })
 
@@ -122,6 +127,9 @@ export const modify = dual<
   if (options.urlParams) {
     result = setUrlParams(result, options.urlParams)
   }
+  if (options.hash) {
+    result = setHash(result, options.hash)
+  }
   if (options.body) {
     result = setBody(result, options.body)
   }
@@ -144,6 +152,7 @@ export const setHeader = dual<
     self.method,
     self.url,
     self.urlParams,
+    self.hash,
     Headers.set(self.headers, key, value),
     self.body
   ))
@@ -157,6 +166,7 @@ export const setHeaders = dual<
     self.method,
     self.url,
     self.urlParams,
+    self.hash,
     Headers.setAll(self.headers, input),
     self.body
   ))
@@ -191,6 +201,7 @@ export const setMethod = dual<
     method,
     self.url,
     self.urlParams,
+    self.hash,
     self.headers,
     self.body
   ))
@@ -198,15 +209,32 @@ export const setMethod = dual<
 /** @internal */
 export const setUrl = dual<
   (url: string | URL) => (self: ClientRequest.ClientRequest) => ClientRequest.ClientRequest,
-  (self: ClientRequest.ClientRequest, url: string) => ClientRequest.ClientRequest
->(2, (self, url) =>
-  makeInternal(
+  (self: ClientRequest.ClientRequest, url: string | URL) => ClientRequest.ClientRequest
+>(2, (self, url) => {
+  if (typeof url === "string") {
+    return makeInternal(
+      self.method,
+      url,
+      self.urlParams,
+      self.hash,
+      self.headers,
+      self.body
+    )
+  }
+  const clone = new URL(url.toString())
+  const urlParams = UrlParams.fromInput(clone.searchParams)
+  const hash = clone.hash ? Option.some(clone.hash.slice(1)) : Option.none()
+  clone.search = ""
+  clone.hash = ""
+  return makeInternal(
     self.method,
-    url.toString(),
-    self.urlParams,
+    clone.toString(),
+    urlParams,
+    hash,
     self.headers,
     self.body
-  ))
+  )
+})
 
 /** @internal */
 export const appendUrl = dual<
@@ -215,21 +243,27 @@ export const appendUrl = dual<
 >(2, (self, url) =>
   makeInternal(
     self.method,
-    self.url + url,
+    self.url.endsWith("/") && url.startsWith("/") ?
+      self.url + url.slice(1) :
+      self.url + url,
     self.urlParams,
+    self.hash,
     self.headers,
     self.body
   ))
 
 /** @internal */
 export const prependUrl = dual<
-  (path: string | URL) => (self: ClientRequest.ClientRequest) => ClientRequest.ClientRequest,
+  (path: string) => (self: ClientRequest.ClientRequest) => ClientRequest.ClientRequest,
   (self: ClientRequest.ClientRequest, path: string) => ClientRequest.ClientRequest
 >(2, (self, url) =>
   makeInternal(
     self.method,
-    url.toString() + self.url,
+    url.endsWith("/") && self.url.startsWith("/") ?
+      url + self.url.slice(1) :
+      url + self.url,
     self.urlParams,
+    self.hash,
     self.headers,
     self.body
   ))
@@ -243,6 +277,7 @@ export const updateUrl = dual<
     self.method,
     f(self.url),
     self.urlParams,
+    self.hash,
     self.headers,
     self.body
   ))
@@ -256,6 +291,7 @@ export const appendUrlParam = dual<
     self.method,
     self.url,
     UrlParams.append(self.urlParams, key, value),
+    self.hash,
     self.headers,
     self.body
   ))
@@ -269,6 +305,7 @@ export const appendUrlParams = dual<
     self.method,
     self.url,
     UrlParams.appendAll(self.urlParams, input),
+    self.hash,
     self.headers,
     self.body
   ))
@@ -282,6 +319,7 @@ export const setUrlParam = dual<
     self.method,
     self.url,
     UrlParams.set(self.urlParams, key, value),
+    self.hash,
     self.headers,
     self.body
   ))
@@ -295,10 +333,36 @@ export const setUrlParams = dual<
     self.method,
     self.url,
     UrlParams.setAll(self.urlParams, input),
+    self.hash,
     self.headers,
     self.body
   ))
 
+/** @internal */
+export const setHash = dual<
+  (hash: string) => (self: ClientRequest.ClientRequest) => ClientRequest.ClientRequest,
+  (self: ClientRequest.ClientRequest, hash: string) => ClientRequest.ClientRequest
+>(2, (self, hash) =>
+  makeInternal(
+    self.method,
+    self.url,
+    self.urlParams,
+    Option.some(hash),
+    self.headers,
+    self.body
+  ))
+
+/** @internal */
+export const removeHash = (self: ClientRequest.ClientRequest): ClientRequest.ClientRequest =>
+  makeInternal(
+    self.method,
+    self.url,
+    self.urlParams,
+    Option.none(),
+    self.headers,
+    self.body
+  )
+
 /** @internal */
 export const setBody = dual<
   (body: Body.Body) => (self: ClientRequest.ClientRequest) => ClientRequest.ClientRequest,
@@ -322,6 +386,7 @@ export const setBody = dual<
     self.method,
     self.url,
     self.urlParams,
+    self.hash,
     headers,
     body
   )

package/src/internal/worker.ts

@@ -67,7 +67,6 @@ export const makeManager = Effect.gen(function*() {
     spawn<I, O, E>({
       encode,
       initialMessage,
-      permits = 1,
       queue,
       transfers = (_) => []
     }: Worker.Worker.Options<I>) {
@@ -75,7 +74,6 @@ export const makeManager = Effect.gen(function*() {
         const spawn = yield* _(Spawner)
         const id = idCounter++
         let requestIdCounter = 0
-        const semaphore = Effect.unsafeMakeSemaphore(permits)
         const requestMap = new Map<
           number,
           readonly [Queue.Queue<Exit.Exit<ReadonlyArray<O>, E | WorkerError>>, Deferred.Deferred<void>]
@@ -237,10 +235,9 @@ export const makeManager = Effect.gen(function*() {
             executeRelease
           )
 
-        yield* semaphore.take(1).pipe(
-          Effect.andThen(outbound.take),
+        yield* outbound.take.pipe(
           Effect.flatMap(([id, request, span]) =>
-            pipe(
+            Effect.fork(
               Effect.suspend(() => {
                 const result = requestMap.get(id)
                 if (!result) return Effect.void
@@ -260,14 +257,12 @@ export const makeManager = Effect.gen(function*() {
                   Effect.catchAllCause((cause) => Queue.offer(result[0], Exit.failCause(cause))),
                   Effect.zipRight(Deferred.await(result[1]))
                 )
-              }),
-              Effect.ensuring(semaphore.release(1)),
-              Effect.fork
+              })
             )
           ),
           Effect.forever,
-          Effect.interruptible,
-          Effect.forkScoped
+          Effect.forkScoped,
+          Effect.interruptible
         )
 
         if (initialMessage) {
@@ -299,11 +294,21 @@ export const makePool = <I, O, E>(
       Effect.tap((worker) => Effect.addFinalizer(() => Effect.sync(() => workers.delete(worker)))),
       options.onCreate ? Effect.tap(options.onCreate) : identity
     )
-    const backing = yield* Pool.make({
-      acquire,
-      size: options.size
-    })
-    const get = Effect.scoped(backing.get)
+    const backing = "minSize" in options ?
+      yield* Pool.makeWithTTL({
+        acquire,
+        min: options.minSize,
+        max: options.maxSize,
+        concurrency: options.concurrency,
+        targetUtilization: options.targetUtilization,
+        timeToLive: options.timeToLive
+      }) :
+      yield* Pool.make({
+        acquire,
+        size: options.size,
+        concurrency: options.concurrency,
+        targetUtilization: options.targetUtilization
+      })
     const pool: Worker.WorkerPool<I, O, E> = {
       backing,
       broadcast: (message: I) =>
@@ -311,12 +316,20 @@ export const makePool = <I, O, E>(
           concurrency: "unbounded",
           discard: true
         }),
-      execute: (message: I) => Stream.unwrap(Effect.map(get, (worker) => worker.execute(message))),
-      executeEffect: (message: I) => Effect.flatMap(get, (worker) => worker.executeEffect(message))
+      execute: (message: I) =>
+        Stream.unwrapScoped(Effect.map(
+          backing.get,
+          (worker) => worker.execute(message)
+        )),
+      executeEffect: (message: I) =>
+        Effect.scoped(Effect.flatMap(
+          backing.get,
+          (worker) => worker.executeEffect(message)
+        ))
     }
 
     // report any spawn errors
-    yield* get
+    yield* Effect.scoped(backing.get)
 
     return pool
   })
@@ -391,13 +404,16 @@ export const makePoolSerialized = <I extends Schema.TaggedRequest.Any>(
         acquire,
         min: options.minSize,
         max: options.maxSize,
+        concurrency: options.concurrency,
+        targetUtilization: options.targetUtilization,
         timeToLive: options.timeToLive
       }) :
       Pool.make({
         acquire,
-        size: options.size
+        size: options.size,
+        concurrency: options.concurrency,
+        targetUtilization: options.targetUtilization
       })
-    const get = Effect.scoped(backing.get)
     const pool: Worker.SerializedWorkerPool<I> = {
       backing,
       broadcast: <Req extends I>(message: Req) =>
@@ -406,13 +422,13 @@ export const makePoolSerialized = <I extends Schema.TaggedRequest.Any>(
           discard: true
         }) as any,
       execute: <Req extends I>(message: Req) =>
-        Stream.unwrap(Effect.map(get, (worker) => worker.execute(message))) as any,
+        Stream.unwrapScoped(Effect.map(backing.get, (worker) => worker.execute(message))) as any,
       executeEffect: <Req extends I>(message: Req) =>
-        Effect.flatMap(get, (worker) => worker.executeEffect(message)) as any
+        Effect.scoped(Effect.flatMap(backing.get, (worker) => worker.executeEffect(message))) as any
     }
 
     // report any spawn errors
-    yield* get
+    yield* Effect.scoped(backing.get)
 
     return pool
   })