@effect-app/infra 0.73.0 → 0.74.0

package/_src/services/Operations/service.ts

@@ -20,18 +20,16 @@ export abstract class Operations extends TagClass<OperationsId, Operations>() {
  * @tsplus getter effect/io/Effect forkOperation
  */
 export function forkOperation<R, E, A>(self: Effect<R, E, A>) {
-  return Debug.untraced(() =>
-    Operations.flatMap(
-      (Operations) =>
-        Scope
-          .make()
-          .flatMap((scope) =>
-            Operations
-              .register
-              .extend(scope)
-              .tap(() => self.use(scope).forkDaemonReportRequestUnexpected)
-          )
-    )
+  return Operations.flatMap(
+    (Operations) =>
+      Scope
+        .make()
+        .flatMap((scope) =>
+          Operations
+            .register
+            .extend(scope)
+            .tap(() => self.use(scope).forkDaemonReportRequestUnexpected)
+        )
   )
 }
 
@@ -39,25 +37,23 @@ export function forkOperation<R, E, A>(self: Effect<R, E, A>) {
  * @tsplus getter function forkOperation
  */
 export function forkOperationFunction<R, E, A, Inp>(fnc: (inp: Inp) => Effect<R, E, A>) {
-  return (inp: Inp) => Debug.untraced(() => fnc(inp).forkOperation)
+  return (inp: Inp) => fnc(inp).forkOperation
 }
 
 /**
  * @tsplus static effect/io/Effect.Ops forkOperation
  */
 export function forkOperation2<R, E, A>(self: (opId: OperationId) => Effect<R, E, A>) {
-  return Debug.untraced((restore) =>
-    Operations.flatMap(
-      (Operations) =>
-        Scope
-          .make()
-          .flatMap((scope) =>
-            Operations
-              .register
-              .extend(scope)
-              .tap((id) => restore(self)(id).use(scope).forkDaemonReportRequestUnexpected)
-          )
-    )
+  return Operations.flatMap(
+    (Operations) =>
+      Scope
+        .make()
+        .flatMap((scope) =>
+          Operations
+            .register
+            .extend(scope)
+            .tap((id) => self(id).use(scope).forkDaemonReportRequestUnexpected)
+        )
   )
 }
 
@@ -68,18 +64,16 @@ export function forkOperationWithEffect<R, R2, E, E2, A, A2>(
   self: (id: OperationId) => Effect<R, E, A>,
   fnc: (id: OperationId) => Effect<R2, E2, A2>
 ) {
-  return Debug.untraced((restore) =>
-    Operations.flatMap(
-      (Operations) =>
-        Scope
-          .make()
-          .flatMap((scope) =>
-            Operations
-              .register
-              .extend(scope)
-              .tap((opId) => restore(self)(opId).use(scope).forkDaemonReportRequestUnexpected)
-              .tap((opId) => restore(fnc)(opId).interruptible.forkScoped.extend(scope))
-          )
-    )
+  return Operations.flatMap(
+    (Operations) =>
+      Scope
+        .make()
+        .flatMap((scope) =>
+          Operations
+            .register
+            .extend(scope)
+            .tap((opId) => self(opId).use(scope).forkDaemonReportRequestUnexpected)
+            .tap((opId) => fnc(opId).interruptible.forkScoped.extend(scope))
+        )
   )
 }

package/_src/services/QueueMaker/errors.ts

@@ -42,8 +42,7 @@ export function reportNonInterruptedFailure(context?: Record<string, unknown>) {
       .exit
       .flatMap((result) =>
         result.match(
-          (cause) => report(cause).map(() => result),
-          () => Effect(result)
+          { onFailure: (cause) => report(cause).map(() => result), onSuccess: () => Effect(result) }
         )
       )
 }

package/_src/services/QueueMaker/memQueue.ts

@@ -66,7 +66,7 @@ export function makeMemQueue<
             .flatMap(({ body, meta }) =>
               Effect
                 .logDebug(`$$ [${queueDrainName}] Processing incoming message`)
-                .apply(Effect.logAnnotates({ body: body.$$.pretty, meta: meta.$$.pretty }))
+                .apply(Effect.annotateLogs({ body: body.$$.pretty, meta: meta.$$.pretty }))
                 .tap(() => restoreFromRequestContext)
                 .zipRight(handleEvent(body))
                 .apply(silenceAndReportError)

package/_src/services/QueueMaker/sbqueue.ts

@@ -58,7 +58,7 @@ export function makeServiceBusQueue<
             .flatMap(({ body, meta }) =>
               Effect
                 .logDebug(`$$ [${queueDrainName}] Processing incoming message`)
-                .apply(Effect.logAnnotates({ body: body.$$.pretty, meta: meta.$$.pretty }))
+                .apply(Effect.annotateLogs({ body: body.$$.pretty, meta: meta.$$.pretty }))
                 .tap(() => restoreFromRequestContext)
                 .zipRight(handleEvent(body))
                 .orDie
@@ -80,10 +80,10 @@ export function makeServiceBusQueue<
 
         return yield* $(
           subscribe({
-            processMessage: (x) => processMessage(x.body).uninterruptible.flatMap((_) => _.done),
+            processMessage: (x) => processMessage(x.body).uninterruptible,
             processError: (err) => Effect(captureException(err.error))
           })
-            .provideSomeLayer(receiverLayer)
+            .provide(receiverLayer)
         )
       }),
 

package/_src/services/Repository.ts

@@ -9,6 +9,7 @@ import { ContextMap } from "../services/Store.js"
 import type { Filter } from "../services/Store.js"
 import type { RequestContextContainer } from "./RequestContextContainer.js"
 
+export type RequestCTX = ContextMap | RequestContextContainer
 /**
  * @tsplus type Repository
  */
@@ -19,16 +20,16 @@ export interface Repository<
   ItemType extends string
 > {
   itemType: ItemType
-  find: (id: T["id"]) => Effect<ContextMap | RequestContextContainer, never, Option<T>>
+  find: (id: T["id"]) => Effect<RequestCTX, never, Option<T>>
   all: Effect<ContextMap, never, T[]>
   saveAndPublish: (
     items: Iterable<T>,
     events?: Iterable<Evt>
-  ) => Effect<ContextMap | RequestContextContainer, InvalidStateError | OptimisticConcurrencyException, void>
+  ) => Effect<RequestCTX, InvalidStateError | OptimisticConcurrencyException, void>
   removeAndPublish: (
     items: Iterable<T>,
     events?: Iterable<Evt>
-  ) => Effect<ContextMap | RequestContextContainer, never, void>
+  ) => Effect<RequestCTX, never, void>
   utils: {
     mapReverse: (
       pm: PM,
@@ -271,10 +272,8 @@ export function queryAndSavePureEffect<
   map: Effect<R, E, { filter: Filter<PM>; collect?: (t: T) => Option<S>; limit?: number; skip?: number }>
 ) {
   return <R2, A, E2, S2 extends T>(pure: Effect<FixEnv<R2, Evt, S[], S2[]>, E2, A>) =>
-    Debug.untraced((restore) =>
-      queryEffect(self, map)
-        .flatMap(restore((_) => self.saveManyWithPure_(_, pure)))
-    )
+    queryEffect(self, map)
+      .flatMap((_) => self.saveManyWithPure_(_, pure))
 }
 
 /**
@@ -401,12 +400,10 @@ export function saveAllWithEffectInt<
   self: Repository<T, PM, Evt, ItemType>,
   gen: Effect<R, E, readonly [Iterable<P>, Iterable<Evt>, A]>
 ) {
-  return Debug.untraced((restore) =>
-    gen
-      .flatMap(
-        ([items, events, a]) => restore(() => self.saveAndPublish(items, events))().map(() => a)
-      )
-  )
+  return gen
+    .flatMap(
+      ([items, events, a]) => self.saveAndPublish(items, events).map(() => a)
+    )
 }
 
 /**

package/_src/services/RepositoryBase.ts

@@ -1,5 +1,5 @@
 import type { ParserEnv } from "@effect-app/schema/custom/Parser"
-import type { Repository } from "./Repository.js"
+import type { Repository, RequestCTX } from "./Repository.js"
 import type { RequestContextContainer } from "./RequestContextContainer.js"
 import { ContextMap, StoreMaker } from "./Store.js"
 import type { Filter, StoreConfig, Where } from "./Store.js"
@@ -94,7 +94,7 @@ export function makeRepo<
     const mkStore = makeStore<PM>()(name, schema, mapTo)
 
     function make(
-      publishEvents: (evt: NonEmptyReadonlyArray<Evt>) => Effect<RequestContextContainer, never, void>,
+      publishEvents: (evt: NonEmptyReadonlyArray<Evt>) => Effect<RequestCTX, never, void>,
       makeInitial?: Effect<never, never, readonly T[]>,
       config?: Omit<StoreConfig<PM>, "partitionValue"> & {
         partitionValue?: (a: PM) => string
@@ -110,7 +110,9 @@ export function makeRepo<
           })
         )
 
-        const all = allE.flatMap((_) => _.forEachEffect(EParserFor(schema).condemnDie))
+        const parse = EParserFor(schema).condemnDie
+
+        const all = allE.flatMap((_) => _.forEachEffect((_) => parse(_)))
 
         function findE(id: T["id"]) {
           return store
@@ -311,7 +313,7 @@ export const RepositoryBaseImpl = <Service>() => {
     mapTo: (e: E, etag: string | undefined) => PM
   ): (abstract new() => Repository<T, PM, Evt, ItemType>) & Tag<Service, Service> & {
     make(
-      publishEvents: (evt: NonEmptyReadonlyArray<Evt>) => Effect<RequestContextContainer, never, void>,
+      publishEvents: (evt: NonEmptyReadonlyArray<Evt>) => Effect<RequestCTX, never, void>,
       makeInitial?: Effect<never, never, readonly T[]>,
       config?: Omit<StoreConfig<PM>, "partitionValue"> & {
         partitionValue?: (a: PM) => string
@@ -345,14 +347,14 @@ export const RepositoryDefaultImpl = <Service>() => {
       impl: Repository<T, PM, Evt, ItemType>
     ): Repository<T, PM, Evt, ItemType>
     make(
-      publishEvents: (evt: NonEmptyReadonlyArray<Evt>) => Effect<RequestContextContainer, never, void>,
+      publishEvents: (evt: NonEmptyReadonlyArray<Evt>) => Effect<RequestCTX, never, void>,
       makeInitial?: Effect<never, never, readonly T[]>,
       config?: Omit<StoreConfig<PM>, "partitionValue"> & {
         partitionValue?: (a: PM) => string
       }
     ): Effect<StoreMaker, never, Repository<T, PM, Evt, ItemType>>
     toLayer(
-      publishEvents: (evt: NonEmptyReadonlyArray<Evt>) => Effect<RequestContextContainer, never, void>,
+      publishEvents: (evt: NonEmptyReadonlyArray<Evt>) => Effect<RequestCTX, never, void>,
       makeInitial?: Effect<never, never, readonly T[]>,
       config?: Omit<StoreConfig<PM>, "partitionValue"> & {
         partitionValue?: (a: PM) => string
@@ -366,7 +368,7 @@ export const RepositoryDefaultImpl = <Service>() => {
   } => {
     return class extends RepositoryBaseImpl<Service>()<PM, Evt>()(itemType, schema, mapFrom, mapTo) {
       static toLayer(
-        publishEvents: (evt: NonEmptyReadonlyArray<Evt>) => Effect<RequestContextContainer, never, void>,
+        publishEvents: (evt: NonEmptyReadonlyArray<Evt>) => Effect<RequestCTX, never, void>,
         makeInitial?: Effect<never, never, readonly T[]>,
         config?: Omit<StoreConfig<PM>, "partitionValue"> & {
           partitionValue?: (a: PM) => string
@@ -383,6 +385,6 @@ export const RepositoryDefaultImpl = <Service>() => {
         super()
         Object.assign(this, impl)
       }
-    }
+    } as any // TODO: seems to be a compiler bug, it somehow says its missing toLayer and repo...
   }
 }

package/_src/services/Store/Cosmos.ts

@@ -53,25 +53,26 @@ export function makeCosmosStore({ prefix }: StorageConfig) {
                   (x) =>
                     [
                       x,
-                      Option.fromNullable(x._etag).match(
-                        () => ({
-                          operationType: "Create" as const,
-                          resourceBody: {
-                            ...omit(x, "_etag"),
-                            _partitionKey: config?.partitionValue(x)
-                          } as any,
-                          partitionKey: config?.partitionValue(x)
-                        }),
-                        (eTag) => ({
-                          operationType: "Replace" as const,
-                          id: x.id,
-                          resourceBody: {
-                            ...omit(x, "_etag"),
-                            _partitionKey: config?.partitionValue(x)
-                          } as any,
-                          ifMatch: eTag,
-                          partitionKey: config?.partitionValue(x)
-                        })
+                      Option.fromNullable(x._etag).match({
+                          onNone: () => ({
+                            operationType: "Create" as const,
+                            resourceBody: {
+                              ...omit(x, "_etag"),
+                              _partitionKey: config?.partitionValue(x)
+                            } as any,
+                            partitionKey: config?.partitionValue(x)
+                          }),
+                          onSome: (eTag) => ({
+                            operationType: "Replace" as const,
+                            id: x.id,
+                            resourceBody: {
+                              ...omit(x, "_etag"),
+                              _partitionKey: config?.partitionValue(x)
+                            } as any,
+                            ifMatch: eTag,
+                            partitionKey: config?.partitionValue(x)
+                          })
+                        }
                       )
                     ] as const
                 )
@@ -122,7 +123,7 @@ export function makeCosmosStore({ prefix }: StorageConfig) {
                 return batchResult.flat() as unknown as NonEmptyReadonlyArray<PM>
               })
               .instrument("cosmos.bulkSet")
-              .logAnnotate("cosmos.db", containerId)
+              .annotateLogs("cosmos.db", containerId)
 
           const batchSet = (items: NonEmptyReadonlyArray<PM>) => {
             return Effect
@@ -131,23 +132,24 @@ export function makeCosmosStore({ prefix }: StorageConfig) {
                   (x) =>
                     [
                       x,
-                      Option.fromNullable(x._etag).match(
-                        () => ({
-                          operationType: "Create" as const,
-                          resourceBody: {
-                            ...omit(x, "_etag"),
-                            _partitionKey: config?.partitionValue(x)
-                          } as any
-                        }),
-                        (eTag) => ({
-                          operationType: "Replace" as const,
-                          id: x.id,
-                          resourceBody: {
-                            ...omit(x, "_etag"),
-                            _partitionKey: config?.partitionValue(x)
-                          } as any,
-                          ifMatch: eTag
-                        })
+                      Option.fromNullable(x._etag).match({
+                          onNone: () => ({
+                            operationType: "Create" as const,
+                            resourceBody: {
+                              ...omit(x, "_etag"),
+                              _partitionKey: config?.partitionValue(x)
+                            } as any
+                          }),
+                          onSome: (eTag) => ({
+                            operationType: "Replace" as const,
+                            id: x.id,
+                            resourceBody: {
+                              ...omit(x, "_etag"),
+                              _partitionKey: config?.partitionValue(x)
+                            } as any,
+                            ifMatch: eTag
+                          })
+                        }
                       )
                     ] as const
                 )
@@ -185,7 +187,7 @@ export function makeCosmosStore({ prefix }: StorageConfig) {
                   )
               })
               .instrument("cosmos.batchSet")
-              .logAnnotate("cosmos.db", containerId)
+              .annotateLogs("cosmos.db", containerId)
           }
 
           const s: Store<PM, Id> = {
@@ -204,7 +206,7 @@ export function makeCosmosStore({ prefix }: StorageConfig) {
                 )
               )
               .instrument("cosmos.all")
-              .logAnnotate("cosmos.db", containerId),
+              .annotateLogs("cosmos.db", containerId),
             filterJoinSelect: <T extends object>(
               filter: FilterJoinSelect,
               cursor?: { skip?: number; limit?: number }
@@ -236,7 +238,7 @@ export function makeCosmosStore({ prefix }: StorageConfig) {
                   return v
                 })
                 .instrument("cosmos.filterJoinSelect")
-                .logAnnotate("cosmos.db", containerId),
+                .annotateLogs("cosmos.db", containerId),
             /**
              * May return duplicate results for "join_find", when matching more than once.
              */
@@ -277,7 +279,7 @@ export function makeCosmosStore({ prefix }: StorageConfig) {
                     )
                   ))
                 .instrument("cosmos.filter")
-                .logAnnotate("cosmos.db", containerId)
+                .annotateLogs("cosmos.db", containerId)
             },
             find: (id) =>
               Effect
@@ -288,30 +290,32 @@ export function makeCosmosStore({ prefix }: StorageConfig) {
                     .then(({ resource }) => Option.fromNullable(resource))
                 )
                 .instrument("cosmos.find")
-                .logAnnotate("cosmos.db", containerId),
+                .annotateLogs("cosmos.db", containerId),
             set: (e) =>
               Option
                 .fromNullable(e._etag)
                 .match(
-                  () =>
-                    Effect.promise(() =>
-                      container.items.create({
-                        ...e,
-                        _partitionKey: config?.partitionValue(e)
-                      })
-                    ),
-                  (eTag) =>
-                    Effect.promise(() =>
-                      container.item(e.id, config?.partitionValue(e)).replace(
-                        { ...e, _partitionKey: config?.partitionValue(e) },
-                        {
-                          accessCondition: {
-                            type: "IfMatch",
-                            condition: eTag
+                  {
+                    onNone: () =>
+                      Effect.promise(() =>
+                        container.items.create({
+                          ...e,
+                          _partitionKey: config?.partitionValue(e)
+                        })
+                      ),
+                    onSome: (eTag) =>
+                      Effect.promise(() =>
+                        container.item(e.id, config?.partitionValue(e)).replace(
+                          { ...e, _partitionKey: config?.partitionValue(e) },
+                          {
+                            accessCondition: {
+                              type: "IfMatch",
+                              condition: eTag
+                            }
                           }
-                        }
+                        )
                       )
-                    )
+                  }
                 )
                 .flatMap((x) => {
                   if (x.statusCode === 412 || x.statusCode === 404) {
@@ -330,14 +334,14 @@ export function makeCosmosStore({ prefix }: StorageConfig) {
                   })
                 })
                 .instrument("cosmos.set")
-                .logAnnotate("cosmos.db", containerId),
+                .annotateLogs("cosmos.db", containerId),
             batchSet,
             bulkSet,
             remove: (e: PM) =>
               Effect
                 .promise(() => container.item(e.id, config?.partitionValue(e)).delete())
                 .instrument("cosmos.remove")
-                .logAnnotate("cosmos.db", containerId)
+                .annotateLogs("cosmos.db", containerId)
           }
 
           // handle mock data
@@ -390,7 +394,7 @@ function logQuery(q: {
 }) {
   return Effect
     .logDebug("cosmos query")
-    .apply(Effect.logAnnotates({
+    .apply(Effect.annotateLogs({
       query: q.query,
       parameters: JSON.stringify(
         q.parameters.reduce((acc, v) => {

package/_src/services/Store/Memory.ts

@@ -31,7 +31,7 @@ export const restoreFromRequestContext = RequestContextContainer.get.flatMap((ct
 function logQuery(filter: any, cursor: any) {
   return Effect
     .logDebug("mem query")
-    .apply(Effect.logAnnotates({
+    .apply(Effect.annotateLogs({
       query: JSON.stringify(filter, undefined, 2),
       cursor: JSON.stringify(
         cursor,

package/_src/services/simpledb/cosmosdb.ts

@@ -90,51 +90,53 @@ WHERE (
 
         yield* $(
           currentVersion.match(
-            () =>
-              Effect
-                .tryPromise(() =>
-                  db.container(type).items.create({
-                    id: record.id,
-                    timestamp: new Date(),
-                    data
-                  })
-                )
-                .asUnit
-                .orDie,
-            (currentVersion) =>
-              Effect
-                .tryPromise(() =>
-                  db
-                    .container(type)
-                    .item(record.id)
-                    .replace(
-                      {
-                        id: record.id,
-                        timestamp: new Date(),
-                        data
-                      },
-                      {
-                        accessCondition: {
-                          type: "IfMatch",
-                          condition: currentVersion
+            {
+              onNone: () =>
+                Effect
+                  .tryPromise(() =>
+                    db.container(type).items.create({
+                      id: record.id,
+                      timestamp: new Date(),
+                      data
+                    })
+                  )
+                  .asUnit
+                  .orDie,
+              onSome: (currentVersion) =>
+                Effect
+                  .tryPromise(() =>
+                    db
+                      .container(type)
+                      .item(record.id)
+                      .replace(
+                        {
+                          id: record.id,
+                          timestamp: new Date(),
+                          data
+                        },
+                        {
+                          accessCondition: {
+                            type: "IfMatch",
+                            condition: currentVersion
+                          }
                         }
-                      }
-                    )
-                )
-                .orDie
-                .flatMap((x) => {
-                  if (x.statusCode === 412) {
-                    return Effect.fail(new OptimisticLockException(type, record.id))
-                  }
-                  if (x.statusCode > 299 || x.statusCode < 200) {
-                    return Effect.die(
-                      new CosmosDbOperationError(
-                        "not able to update record: " + x.statusCode
                       )
-                    )
-                  }
-                  return Effect.unit
-                })
+                  )
+                  .orDie
+                  .flatMap((x) => {
+                    if (x.statusCode === 412) {
+                      return Effect.fail(new OptimisticLockException(type, record.id))
+                    }
+                    if (x.statusCode > 299 || x.statusCode < 200) {
+                      return Effect.die(
+                        new CosmosDbOperationError(
+                          "not able to update record: " + x.statusCode
+                        )
+                      )
+                    }
+                    return Effect.unit
+                  })
+            }
           )
         )
         return { version, data: record } as CachedRecord<A>

package/_src/services/simpledb/diskdb.ts

@@ -78,10 +78,10 @@ export function createContext<TKey extends string, EA, A extends DBRecord<TKey>>
     function lockRecordOnDisk(type: string) {
       return (id: string) =>
         lockFile(getFilename(type, id))
-          .mapBoth(
-            (err) => new CouldNotAquireDbLockException(type, id, err as Error),
-            (release) => ({ release })
-          )
+          .mapBoth({
+            onFailure: (err) => new CouldNotAquireDbLockException(type, id, err as Error),
+            onSuccess: (release) => ({ release })
+          })
           .acquireRelease(
             (l) => l.release
           )
@@ -90,10 +90,10 @@ export function createContext<TKey extends string, EA, A extends DBRecord<TKey>>
     function lockIndexOnDisk(type: string) {
       return (id: string) =>
         lockFile(getIdxName(type, id))
-          .mapBoth(
-            (err) => new CouldNotAquireDbLockException(type, id, err as Error),
-            (release) => ({ release })
-          )
+          .mapBoth({
+            onFailure: (err) => new CouldNotAquireDbLockException(type, id, err as Error),
+            onSuccess: (release) => ({ release })
+          })
           .acquireRelease(
             (l) => l.release
           )
@@ -121,8 +121,7 @@ export function createContext<TKey extends string, EA, A extends DBRecord<TKey>>
       return tryRead(getIdxName(type, index.doc)).map(
         (_) =>
           _.match(
-            () => ({} as Record<string, TKey>),
-            (x) => JSON.parse(x) as Record<string, TKey>
+            { onNone: () => ({} as Record<string, TKey>), onSome: (x) => JSON.parse(x) as Record<string, TKey> }
           )
       )
     }