@effect-app/infra 3.0.13 → 3.0.15

package/src/RequestFiberSet.ts

@@ -14,7 +14,7 @@ const getRootParentSpan = Effect.gen(function*() {
   return span
 })
 
-export const setRootParentSpan = <A, E, R>(self: Effect<A, E, R>) =>
+export const setRootParentSpan = <A, E, R>(self: Effect.Effect<A, E, R>) =>
   getRootParentSpan.pipe(Effect.andThen((span) => span ? Effect.withParentSpan(self, span) : self))
 
 const make = Effect.gen(function*() {
@@ -28,7 +28,7 @@ const make = Effect.gen(function*() {
     Effect.andThen(FiberSet.join(set))
   )
   const run = FiberSet.run(set)
-  const register = <A, E, R>(self: Effect<A, E, R>) =>
+  const register = <A, E, R>(self: Effect.Effect<A, E, R>) =>
     self.pipe(Effect.fork, Effect.tap(add), Effect.andThen(Fiber.join))
 
   // const waitUntilEmpty = Effect.gen(function*() {
@@ -51,7 +51,7 @@ const make = Effect.gen(function*() {
    *
    * Reports errors.
    */
-  function forkDaemonReport<R, E, A>(self: Effect<A, E, R>) {
+  function forkDaemonReport<R, E, A>(self: Effect.Effect<A, E, R>) {
     return self.pipe(
       reportRequestError,
       Effect.uninterruptible,
@@ -67,7 +67,7 @@ const make = Effect.gen(function*() {
    *
    * Reports unexpected errors.
    */
-  function forkDaemonReportUnexpected<R, E, A>(self: Effect<A, E, R>) {
+  function forkDaemonReportUnexpected<R, E, A>(self: Effect.Effect<A, E, R>) {
     return self
       .pipe(
         reportUnknownRequestError,
@@ -94,9 +94,10 @@ const make = Effect.gen(function*() {
  */
 export class RequestFiberSet extends Context.TagMakeId("RequestFiberSet", make)<RequestFiberSet>() {
   static readonly Live = this.toLayerScoped()
-  static readonly register = <A, E, R>(self: Effect<A, E, R>) => this.use((_) => _.register(self))
-  static readonly run = <A, E, R>(self: Effect<A, E, R>) => this.use((_) => _.run(self))
-  static readonly forkDaemonReport = <R, E, A>(self: Effect<A, E, R>) => this.use((_) => _.forkDaemonReport(self))
-  static readonly forkDaemonReportUnexpected = <R, E, A>(self: Effect<A, E, R>) =>
+  static readonly register = <A, E, R>(self: Effect.Effect<A, E, R>) => this.use((_) => _.register(self))
+  static readonly run = <A, E, R>(self: Effect.Effect<A, E, R>) => this.use((_) => _.run(self))
+  static readonly forkDaemonReport = <R, E, A>(self: Effect.Effect<A, E, R>) =>
+    this.use((_) => _.forkDaemonReport(self))
+  static readonly forkDaemonReportUnexpected = <R, E, A>(self: Effect.Effect<A, E, R>) =>
     this.use((_) => _.forkDaemonReportUnexpected(self))
 }

package/src/Store/Cosmos.ts

@@ -32,7 +32,7 @@ function makeCosmosStore({ prefix }: StorageConfig) {
       make: <IdKey extends keyof Encoded, Encoded extends FieldValues, R = never, E = never>(
         name: string,
         idKey: IdKey,
-        seed?: Effect<Iterable<Encoded>, E, R>,
+        seed?: Effect.Effect<Iterable<Encoded>, E, R>,
         config?: StoreConfig<Encoded>
       ) =>
         Effect.gen(function*() {

package/src/Store/Disk.ts

@@ -14,7 +14,7 @@ function makeDiskStoreInt<IdKey extends keyof Encoded, Encoded extends FieldValu
   namespace: string,
   dir: string,
   name: string,
-  seed?: Effect<Iterable<Encoded>, E, R>,
+  seed?: Effect.Effect<Iterable<Encoded>, E, R>,
   defaultValues?: Partial<Encoded>
 ) {
   type PM = PersistenceModelType<Encoded>
@@ -126,7 +126,7 @@ export function makeDiskStore({ prefix }: StorageConfig, dir: string) {
       make: <IdKey extends keyof Encoded, Encoded extends FieldValues, R, E>(
         name: string,
         idKey: IdKey,
-        seed?: Effect<Iterable<Encoded>, E, R>,
+        seed?: Effect.Effect<Iterable<Encoded>, E, R>,
         config?: StoreConfig<Encoded>
       ) =>
         Effect.gen(function*() {

package/src/Store/Memory.ts

@@ -97,7 +97,7 @@ export function makeMemoryStoreInt<IdKey extends keyof Encoded, Encoded extends
   modelName: string,
   idKey: IdKey,
   namespace: string,
-  seed?: Effect<Iterable<Encoded>, E, R>,
+  seed?: Effect.Effect<Iterable<Encoded>, E, R>,
   _defaultValues?: Partial<Encoded>
 ) {
   type PM = PersistenceModelType<Encoded>
@@ -243,7 +243,7 @@ export const makeMemoryStore = () => ({
   make: <IdKey extends keyof Encoded, Encoded extends FieldValues, R, E>(
     modelName: string,
     idKey: IdKey,
-    seed?: Effect<Iterable<Encoded>, E, R>,
+    seed?: Effect.Effect<Iterable<Encoded>, E, R>,
     config?: StoreConfig<Encoded>
   ) =>
     Effect.gen(function*() {

package/src/Store/service.ts

@@ -68,38 +68,38 @@ export interface FilterArgs<Encoded extends FieldValues, U extends keyof Encoded
 
 export type FilterFunc<Encoded extends FieldValues> = <U extends keyof Encoded = never>(
   args: FilterArgs<Encoded, U>
-) => Effect<(U extends undefined ? Encoded : Pick<Encoded, U>)[]>
+) => Effect.Effect<(U extends undefined ? Encoded : Pick<Encoded, U>)[]>
 
 export interface Store<
   IdKey extends keyof Encoded,
   Encoded extends FieldValues,
   PM extends PersistenceModelType<Encoded> = PersistenceModelType<Encoded>
 > {
-  all: Effect<PM[]>
+  all: Effect.Effect<PM[]>
   filter: FilterFunc<Encoded>
-  find: (id: Encoded[IdKey]) => Effect<Option<PM>>
-  set: (e: PM) => Effect<PM, OptimisticConcurrencyException>
+  find: (id: Encoded[IdKey]) => Effect.Effect<Option.Option<PM>>
+  set: (e: PM) => Effect.Effect<PM, OptimisticConcurrencyException>
   batchSet: (
     items: NonEmptyReadonlyArray<PM>
-  ) => Effect<NonEmptyReadonlyArray<PM>, OptimisticConcurrencyException>
+  ) => Effect.Effect<NonEmptyReadonlyArray<PM>, OptimisticConcurrencyException>
   bulkSet: (
     items: NonEmptyReadonlyArray<PM>
-  ) => Effect<NonEmptyReadonlyArray<PM>, OptimisticConcurrencyException>
+  ) => Effect.Effect<NonEmptyReadonlyArray<PM>, OptimisticConcurrencyException>
   /**
    * Requires the Encoded type, not Id, because various stores may need to calculate e.g partition keys.
    */
-  remove: (e: Encoded) => Effect<void>
+  remove: (e: Encoded) => Effect.Effect<void>
 
-  queryRaw: <Out>(query: RawQuery<Encoded, Out>) => Effect<readonly Out[]>
+  queryRaw: <Out>(query: RawQuery<Encoded, Out>) => Effect.Effect<readonly Out[]>
 }
 
 export class StoreMaker extends Context.TagId("effect-app/StoreMaker")<StoreMaker, {
   make: <IdKey extends keyof Encoded, Encoded extends FieldValues, R = never, E = never>(
     name: string,
     idKey: IdKey,
-    seed?: Effect<Iterable<Encoded>, E, R>,
+    seed?: Effect.Effect<Iterable<Encoded>, E, R>,
     config?: StoreConfig<Encoded>
-  ) => Effect<Store<IdKey, Encoded>, E, R>
+  ) => Effect.Effect<Store<IdKey, Encoded>, E, R>
 }>() {
 }
 

package/src/Store/utils.ts

@@ -14,7 +14,7 @@ export const makeETag = <E extends PersistenceModelType<{}>>(
 
 export const makeUpdateETag =
   (type: string) =>
-  <IdKey extends keyof E, E extends PersistenceModelType<{}>>(e: E, idKey: IdKey, current: Option<E>) =>
+  <IdKey extends keyof E, E extends PersistenceModelType<{}>>(e: E, idKey: IdKey, current: Option.Option<E>) =>
     Effect.gen(function*() {
       if (e._etag) {
         yield* Effect.mapError(

package/src/adapters/ServiceBus.ts

@@ -3,7 +3,7 @@ import { type OperationOptionsBase, type ProcessErrorArgs, ServiceBusClient, typ
 import { Cause, Context, Effect, Exit, FiberSet, Layer, type Scope } from "effect-app"
 import { InfraLogger } from "../logger.js"
 
-const withSpanAndLog = (name: string) => <A, E, R>(self: Effect<A, E, R>) =>
+const withSpanAndLog = (name: string) => <A, E, R>(self: Effect.Effect<A, E, R>) =>
   Effect.logInfo(name).pipe(
     Effect.zipRight(self),
     Effect.tap(Effect.logInfo(name + " done")),
@@ -77,7 +77,7 @@ const makeReceiver = (name: string) =>
     const serviceBusClient = yield* ServiceBusClientTag
 
     const makeReceiver = Effect.fnUntraced(
-      function*(queueName: string, waitTillEmpty: Effect<void>, sessionId?: string) {
+      function*(queueName: string, waitTillEmpty: Effect.Effect<void>, sessionId?: string) {
         return yield* Effect.acquireRelease(
           (sessionId
             ? Effect.promise(() => serviceBusClient.acceptSession(queueName, sessionId))
@@ -97,9 +97,10 @@ const makeReceiver = (name: string) =>
       }
     )
 
-    const make = (waitTillEmpty: Effect<void>) => makeReceiver(name, waitTillEmpty)
+    const make = (waitTillEmpty: Effect.Effect<void>) => makeReceiver(name, waitTillEmpty)
 
-    const makeSession = (sessionId: string, waitTillEmpty: Effect<void>) => makeReceiver(name, waitTillEmpty, sessionId)
+    const makeSession = (sessionId: string, waitTillEmpty: Effect.Effect<void>) =>
+      makeReceiver(name, waitTillEmpty, sessionId)
 
     return {
       name,
@@ -122,7 +123,7 @@ const makeReceiver = (name: string) =>
           )
           : make(wait)
 
-        const runEffect = <E>(effect: Effect<void, E, RMsg | RErr>) =>
+        const runEffect = <E>(effect: Effect.Effect<void, E, RMsg | RErr>) =>
           new Promise<void>((resolve, reject) =>
             fr(effect)
               .addObserver((exit) => {
@@ -158,15 +159,18 @@ const makeReceiver = (name: string) =>
             subscription.close.pipe(
               withSpanAndLog(`ServiceBus.subscription.close ${sessionId}`)
             )
-        ) as Effect<void, never, Scope> // wth is going on here
+        ) as Effect.Effect<void, never, Scope.Scope> // wth is going on here
       })
     }
   })
 
 export class Receiver extends Context.TagId("Receiver")<Receiver, {
   name: string
-  make: (waitTillEmpty: Effect<void>) => Effect<ServiceBusReceiver, never, Scope>
-  makeSession: (sessionId: string, waitTillEmpty: Effect<void>) => Effect<ServiceBusReceiver, never, Scope>
+  make: (waitTillEmpty: Effect.Effect<void>) => Effect.Effect<ServiceBusReceiver, never, Scope.Scope>
+  makeSession: (
+    sessionId: string,
+    waitTillEmpty: Effect.Effect<void>
+  ) => Effect.Effect<ServiceBusReceiver, never, Scope.Scope>
   subscribe<RMsg, RErr>(
     hndlr: MessageHandlers<RMsg, RErr>,
     sessionId?: string
@@ -195,11 +199,11 @@ export interface MessageHandlers<RMsg, RErr> {
    *
    * @param message - A message received from Service Bus.
    */
-  processMessage(message: ServiceBusReceivedMessage): Effect<void, never, RMsg>
+  processMessage(message: ServiceBusReceivedMessage): Effect.Effect<void, never, RMsg>
   /**
    * Handler that processes errors that occur during receiving.
    * @param args - The error and additional context to indicate where
    * the error originated.
    */
-  processError(args: ProcessErrorArgs): Effect<void, never, RErr>
+  processError(args: ProcessErrorArgs): Effect.Effect<void, never, RErr>
 }

package/src/adapters/cosmos-client.ts

@@ -6,7 +6,7 @@ const withClient = (url: string) => Effect.sync(() => new ComosClient_(url))
 export const makeCosmosClient = (url: string, dbName: string) =>
   Effect.map(withClient(url), (x) => ({ db: x.database(dbName) }))
 
-export interface CosmosClient extends Effect.Success<ReturnType<typeof makeCosmosClient>> {}
+export interface CosmosClient extends Effect.Effect.Success<ReturnType<typeof makeCosmosClient>> {}
 
 export const CosmosClient = Context.GenericTag<CosmosClient>("@services/CosmosClient")
 

package/src/adapters/mongo-client.ts

@@ -15,7 +15,7 @@ const withClient = (url: string) =>
 
 const makeMongoClient = (url: string, dbName?: string) => Effect.map(withClient(url), (x) => ({ db: x.db(dbName) }))
 
-export interface MongoClient extends Effect.Success<ReturnType<typeof makeMongoClient>> {}
+export interface MongoClient extends Effect.Effect.Success<ReturnType<typeof makeMongoClient>> {}
 
 export const MongoClient = Context.GenericTag<MongoClient>("@services/MongoClient")
 

package/src/adapters/redis-client.ts

@@ -17,7 +17,7 @@ export const makeRedisClient = (makeClient: () => Client) =>
 
         function get(key: string) {
           return Effect
-            .async<Option<string>, ConnectionException>((res) => {
+            .async<Option.Option<string>, ConnectionException>((res) => {
               client.get(key, (err, v) =>
                 err
                   ? res(new ConnectionException(err))
@@ -50,7 +50,7 @@ export const makeRedisClient = (makeClient: () => Client) =>
 
         function hget(key: string, field: string) {
           return Effect
-            .async<Option<string>, ConnectionException>((res) => {
+            .async<Option.Option<string>, ConnectionException>((res) => {
               client.hget(key, field, (err, v) =>
                 err
                   ? res(new ConnectionException(err))
@@ -60,7 +60,7 @@ export const makeRedisClient = (makeClient: () => Client) =>
         }
         function hmgetAll(key: string) {
           return Effect
-            .async<Option<{ [key: string]: string }>, ConnectionException>(
+            .async<Option.Option<{ [key: string]: string }>, ConnectionException>(
               (res) => {
                 client.hgetall(key, (err, v) =>
                   err
@@ -90,7 +90,7 @@ export const makeRedisClient = (makeClient: () => Client) =>
         .pipe(Effect.uninterruptible, Effect.orDie)
   )
 
-export interface RedisClient extends Effect.Success<ReturnType<typeof makeRedisClient>> {}
+export interface RedisClient extends Effect.Effect.Success<ReturnType<typeof makeRedisClient>> {}
 
 export const RedisClient = Context.GenericTag<RedisClient>("@services/RedisClient")
 

package/src/api/ContextProvider.ts

@@ -8,7 +8,7 @@ import { type YieldWrap } from "effect/Utils"
 import { type ContextTagWithDefault, type GetContext, type LayerUtils, mergeContexts } from "./layerUtils.js"
 
 // // the context provider provides additional stuff
-// export type ContextProviderShape<ContextProviderA, ContextProviderR> = Effect<
+// export type ContextProviderShape<ContextProviderA, ContextProviderR> = Effect.Effect<
 //   Context.Context<ContextProviderA>,
 //   never, // no errors are allowed
 //   ContextProviderR
@@ -18,7 +18,7 @@ export interface ContextProviderId {
   _tag: "ContextProvider"
 }
 
-//  ContextTagWithDefault.Base<Effect<Context.Context<infer _1>, never, infer _R> & { _tag: infer _2 }>
+//  ContextTagWithDefault.Base<Effect.Effect<Context.Context<infer _1>, never, infer _R> & { _tag: infer _2 }>
 
 /**
  * TDeps is an array of services with Default implementation
@@ -26,15 +26,15 @@ export interface ContextProviderId {
  */
 type TDepsArr<TDeps extends ReadonlyArray<any>> = {
   // the following freaking shit helps me with nested variance issues: it wasn't sufficient to use never/any/unknown for
-  // the various type parameters, not anymore because of () => Generator<YieldWrap<Effect craziness
+  // the various type parameters, not anymore because of () => Generator<YieldWrap<Effect.Effect craziness
   // existential types may help, and all the following usages of infer _ have that meaning: I do not care which is the
   // actual type in that position, I just wanna set the overall structure
   [K in keyof TDeps]: TDeps[K] extends //
   // E = never => the context provided cannot trigger errors
-  // TODO: remove HttpLayerRouter.Provided - it's not even relevant outside of Http context, while ContextProviders are for anywhere. Only support Scope?
+  // TODO: remove HttpLayerRouter.Provided - it's not even relevant outside of Http context, while ContextProviders are for anywhere. Only support Scope.Scope?
   //  _R extends HttpLayerRouter.Provided => the context provided can only have what HttpLayerRouter.Provided provides as requirements
   (
-    ContextTagWithDefault.Base<Effect<Context.Context<infer _1>, never, infer _R> & { _tag: infer _2 }>
+    ContextTagWithDefault.Base<Effect.Effect<Context.Context<infer _1>, never, infer _R> & { _tag: infer _2 }>
   ) ? [_R] extends [HttpLayerRouter.Provided] ? TDeps[K]
     : `HttpLayerRouter.Provided is the only requirement ${TDeps[K]["Service"][
       "_tag"
@@ -50,7 +50,7 @@ type TDepsArr<TDeps extends ReadonlyArray<any>> = {
       >
     ) // [_YW] extends [never] if no yield* is used and just some context is returned
       ? [_YW] extends [never] ? TDeps[K]
-      : [_YW] extends [YieldWrap<Effect<infer _2, never, infer _R>>]
+      : [_YW] extends [YieldWrap<Effect.Effect<infer _2, never, infer _R>>]
         ? [_R] extends [HttpLayerRouter.Provided] ? TDeps[K]
         : `HttpLayerRouter.Provided is the only requirement ${TDeps[K]["Service"][
           "_tag"
@@ -106,22 +106,22 @@ export const ContextProvider = <
   Dependencies extends NonEmptyReadonlyArray<Layer.Layer.Any>
 >(
   input: {
-    effect: Effect<
-      | Effect<ContextProviderA, never, ContextProviderR>
+    effect: Effect.Effect<
+      | Effect.Effect<ContextProviderA, never, ContextProviderR>
       | (() => Generator<
-        YieldWrap<Effect<any, never, ContextProviderR>>,
+        YieldWrap<Effect.Effect<any, never, ContextProviderR>>,
         ContextProviderA,
         any
       >),
       MakeContextProviderE,
-      MakeContextProviderR | Scope
+      MakeContextProviderR | Scope.Scope
     >
     dependencies?: Dependencies
   }
 ) => {
   const ctx = Context.GenericTag<
     ContextProviderId,
-    Effect<ContextProviderA, never, ContextProviderR>
+    Effect.Effect<ContextProviderA, never, ContextProviderR>
   >(
     "ContextProvider"
   )

package/src/api/internal/middlewares.ts

@@ -89,7 +89,7 @@ const toServerResponse = (err: NotLoggedInError) =>
 export const basicAuth = <_, R>(
   checkCredentials: (
     credentials: Middlewares.BasicAuthCredentials
-  ) => Effect<_, NotLoggedInError, R>,
+  ) => Effect.Effect<_, NotLoggedInError, R>,
   options?: Partial<{
     headerName: string
     skipPaths: readonly string[]

package/src/api/layerUtils.ts

@@ -39,7 +39,14 @@ export namespace ContextTagWithDefault {
 export type GetContext<T> = T extends Context.Context<infer Y> ? Y : never
 
 export const mergeContexts = Effect.fnUntraced(
-  function*<T extends readonly { maker: any; handle: Effect<Context<any> | Option<Context<any>>> }[]>(makers: T) {
+  function*<
+    T extends readonly {
+      maker: any
+      handle: Effect.Effect<Context.Context<any> | Option.Option<Context.Context<any>>>
+    }[]
+  >(
+    makers: T
+  ) {
     let context = Context.empty()
     for (const mw of makers) {
       const ctx = yield* mw.handle.pipe(Effect.provide(context))
@@ -52,6 +59,6 @@ export const mergeContexts = Effect.fnUntraced(
         context = Context.merge(context, moreContext.value)
       }
     }
-    return context as Context.Context<Effect.Success<T[number]["handle"]>>
+    return context as Context.Context<Effect.Effect.Success<T[number]["handle"]>>
   }
 )

package/src/api/middlewares.ts

@@ -76,7 +76,7 @@ export interface BasicAuthCredentials {
 export const basicAuth: <R2, _>(
   checkCredentials: (
     credentials: BasicAuthCredentials
-  ) => Effect<_, NotLoggedInError, R2>,
+  ) => Effect.Effect<_, NotLoggedInError, R2>,
   options?: Partial<{
     headerName: string
     skipPaths: readonly string[]

package/src/api/reportError.ts

@@ -4,7 +4,7 @@ import { logError, reportError } from "../errorReporter.js"
 // const onExitReportError = (name: string, unknownOnly?: boolean) => {
 //   const report = reportError(name)
 //   const log = logError(name)
-//   return <A, E, R>(self: Effect<A, E, R>) =>
+//   return <A, E, R>(self: Effect.Effect<A, E, R>) =>
 //     Effect.onExit(self, (exit) =>
 //       Exit.isFailure(exit)
 //         ? unknownOnly
@@ -17,7 +17,7 @@ import { logError, reportError } from "../errorReporter.js"
 const tapErrorCause = (name: string, unknownOnly?: boolean) => {
   const report = reportError(name)
   const log = logError(name)
-  return <A, E, R>(self: Effect<A, E, R>) =>
+  return <A, E, R>(self: Effect.Effect<A, E, R>) =>
     Effect.tapErrorCause(self, (cause) =>
       unknownOnly
         ? Cause.isFailure(cause)

package/src/api/routing/middleware/RouterMiddleware.ts

@@ -17,7 +17,7 @@ export type RouterMiddleware<
   _ContextProviderR, // what the context provider requires
   RequestContextId
 > =
-  & Effect<RpcMiddlewareWrap<ContextProviderA, ContextProviderE>, never, Self>
+  & Effect.Effect<RpcMiddlewareWrap<ContextProviderA, ContextProviderE>, never, Self>
   // makes error because of TagUnify :/
   // Context.Tag<Self, RpcMiddlewareWrap<ContextProviderA, ContextProviderE>>
   & {