@effect-app/infra 0.198.2 → 0.199.2

package/src/services/Store/Cosmos.ts

@@ -1,7 +1,10 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
+import { toNonEmptyArray } from "@effect-app/core/Array"
 import { CosmosClient, CosmosClientLayer } from "@effect-app/infra-adapters/cosmos-client"
-import { dropUndefinedT, omit, pick } from "effect-app/utils"
+import { Chunk, Duration, Effect, Layer, Option, ReadonlyArray, Secret } from "effect-app"
+import type { NonEmptyReadonlyArray } from "effect-app"
+import { dropUndefinedT, omit, pick, spread } from "effect-app/utils"
 import { OptimisticConcurrencyException } from "../../errors.js"
 import {
   buildCosmosQuery,
@@ -60,7 +63,7 @@ function makeCosmosStore({ prefix }: StorageConfig) {
                   (x) =>
                     [
                       x,
-                      Option.fromNullable(x._etag).match({
+                      Option.match(Option.fromNullable(x._etag), {
                         onNone: () =>
                           dropUndefinedT({
                             operationType: "Create" as const,
@@ -84,54 +87,58 @@ function makeCosmosStore({ prefix }: StorageConfig) {
                       })
                     ] as const
                 )
-                const batches = b.chunk(config?.maxBulkSize ?? 10).toReadonlyArray
+                const batches = Chunk.toReadonlyArray(ReadonlyArray.chunk_(b, config?.maxBulkSize ?? 10))
 
                 const batchResult = yield* $(
-                  batches
-                    .map((x, i) => [i, x] as const)
-                    .forEachEffect(
-                      ([i, batch]) =>
-                        Effect
-                          .promise(() => bulk(batch.map(([, op]) => op)))
-                          .delay(Duration.millis(i === 0 ? 0 : 1100))
-                          .flatMap((responses) =>
-                            Effect.gen(function*($) {
-                              const r = responses.find((x) => x.statusCode === 412 || x.statusCode === 404)
-                              if (r) {
-                                return yield* $(
-                                  Effect.fail(
-                                    new OptimisticConcurrencyException(
-                                      { type: name, id: JSON.stringify(r.resourceBody?.["id"]) }
+                  Effect.forEach(
+                    batches
+                      .map((x, i) => [i, x] as const),
+                    ([i, batch]) =>
+                      Effect
+                        .promise(() => bulk(batch.map(([, op]) => op)))
+                        .pipe(
+                          Effect
+                            .delay(Duration.millis(i === 0 ? 0 : 1100)),
+                          Effect
+                            .flatMap((responses) =>
+                              Effect.gen(function*($) {
+                                const r = responses.find((x) => x.statusCode === 412 || x.statusCode === 404)
+                                if (r) {
+                                  return yield* $(
+                                    Effect.fail(
+                                      new OptimisticConcurrencyException(
+                                        { type: name, id: JSON.stringify(r.resourceBody?.["id"]) }
+                                      )
                                     )
                                   )
+                                }
+                                const r2 = responses.find(
+                                  (x) => x.statusCode > 299 || x.statusCode < 200
                                 )
-                              }
-                              const r2 = responses.find(
-                                (x) => x.statusCode > 299 || x.statusCode < 200
-                              )
-                              if (r2) {
-                                return yield* $(
-                                  Effect.die(
-                                    new CosmosDbOperationError(
-                                      "not able to update record: " + r2.statusCode
+                                if (r2) {
+                                  return yield* $(
+                                    Effect.die(
+                                      new CosmosDbOperationError(
+                                        "not able to update record: " + r2.statusCode
+                                      )
                                     )
                                   )
-                                )
-                              }
-                              return batch.map(([e], i) => ({
-                                ...e,
-                                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                                _etag: responses[i]!.eTag
-                              }))
-                            })
-                          )
-                    )
+                                }
+                                return batch.map(([e], i) => ({
+                                  ...e,
+                                  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                                  _etag: responses[i]!.eTag
+                                }))
+                              })
+                            )
+                        )
+                  )
                 )
                 return batchResult.flat() as unknown as NonEmptyReadonlyArray<PM>
               })
-              .withSpan("Cosmos.bulkSet [effect-app/infra/Store]", {
+              .pipe(Effect.withSpan("Cosmos.bulkSet [effect-app/infra/Store]", {
                 attributes: { "repository.container_id": containerId, "repository.model_name": name }
-              })
+              }))
 
           const batchSet = (items: NonEmptyReadonlyArray<PM>) => {
             return Effect
@@ -140,13 +147,13 @@ function makeCosmosStore({ prefix }: StorageConfig) {
                   (x) =>
                     [
                       x,
-                      Option.fromNullable(x._etag).match({
+                      Option.match(Option.fromNullable(x._etag), {
                         onNone: () => ({
                           operationType: "Create" as const,
                           resourceBody: {
                             ...omit(x, "_etag"),
                             _partitionKey: config?.partitionValue(x)
-                          } as any
+                          }
                         }),
                         onSome: (eTag) => ({
                           operationType: "Replace" as const,
@@ -154,7 +161,7 @@ function makeCosmosStore({ prefix }: StorageConfig) {
                           resourceBody: {
                             ...omit(x, "_etag"),
                             _partitionKey: config?.partitionValue(x)
-                          } as any,
+                          },
                           ifMatch: eTag
                         })
                       })
@@ -165,7 +172,7 @@ function makeCosmosStore({ prefix }: StorageConfig) {
 
                 return Effect
                   .promise(() => execBatch(ex, ex[0]?.resourceBody._partitionKey))
-                  .flatMap((x) =>
+                  .pipe(Effect.flatMap((x) =>
                     Effect.gen(function*($) {
                       const result = x.result ?? []
                       const firstFailed = result.find(
@@ -191,11 +198,12 @@ function makeCosmosStore({ prefix }: StorageConfig) {
                         _etag: result[i]?.eTag
                       })) as unknown as NonEmptyReadonlyArray<PM>
                     })
-                  )
-              })
-              .withSpan("Cosmos.batchSet [effect-app/infra/Store]", {
-                attributes: { "repository.container_id": containerId, "repository.model_name": name }
+                  ))
               })
+              .pipe(Effect
+                .withSpan("Cosmos.batchSet [effect-app/infra/Store]", {
+                  attributes: { "repository.container_id": containerId, "repository.model_name": name }
+                }))
           }
 
           const s: Store<PM, Id> = {
@@ -204,53 +212,65 @@ function makeCosmosStore({ prefix }: StorageConfig) {
                 query: `SELECT * FROM ${name} f WHERE f.id != @id`,
                 parameters: [{ name: "@id", value: importedMarkerId }]
               }))
-              .tap((q) => logQuery(q))
-              .flatMap((q) =>
-                Effect.promise(() =>
-                  container
-                    .items
-                    .query<PM>(q)
-                    .fetchAll()
-                    .then(({ resources }) => resources)
-                )
-              )
-              .withSpan("Cosmos.all [effect-app/infra/Store]", {
-                attributes: { "repository.container_id": containerId, "repository.model_name": name }
-              }),
+              .pipe(
+                Effect
+                  .tap((q) => logQuery(q)),
+                Effect.flatMap((q) =>
+                  Effect.promise(() =>
+                    container
+                      .items
+                      .query<PM>(q)
+                      .fetchAll()
+                      .then(({ resources }) => resources)
+                  )
+                ),
+                Effect
+                  .withSpan("Cosmos.all [effect-app/infra/Store]", {
+                    attributes: { "repository.container_id": containerId, "repository.model_name": name }
+                  })
+              ),
             filterJoinSelect: <T extends object>(
               filter: FilterJoinSelect,
               cursor?: { skip?: number; limit?: number }
             ) =>
-              filter
-                .keys
-                .forEachEffect((k) =>
-                  Effect
-                    .sync(() => buildFilterJoinSelectCosmosQuery(filter, k, name, cursor?.skip, cursor?.limit))
-                    .tap((q) => logQuery(q))
-                    .flatMap((q) =>
-                      Effect.promise(() =>
-                        container
-                          .items
-                          .query<T>(q)
-                          .fetchAll()
-                          .then(({ resources }) => resources.map((_) => ({ ...defaultValues, ..._ })))
+              Effect
+                .forEach(
+                  filter
+                    .keys,
+                  (k) =>
+                    Effect
+                      .sync(() => buildFilterJoinSelectCosmosQuery(filter, k, name, cursor?.skip, cursor?.limit))
+                      .pipe(
+                        Effect
+                          .tap((q) => logQuery(q)),
+                        Effect.flatMap((q) =>
+                          Effect.promise(() =>
+                            container
+                              .items
+                              .query<T>(q)
+                              .fetchAll()
+                              .then(({ resources }) => resources.map((_) => ({ ...defaultValues, ..._ })))
+                          )
+                        )
                       )
-                    )
                 )
-                .map((a) => {
-                  const v = a
-                    .flatMap((_) => _)
-                    .map((x) =>
-                      spread(
-                        x,
-                        ({ r, ...rest }: any) => ({ ...rest, ...r } as T & { _rootId: string })
+                .pipe(
+                  Effect.map((a) => {
+                    const v = a
+                      .flatMap((_) => _)
+                      .map((x) =>
+                        spread(
+                          x,
+                          ({ r, ...rest }: any) => ({ ...rest, ...r } as T & { _rootId: string })
+                        )
                       )
-                    )
-                  return v
-                })
-                .withSpan("Cosmos.filterJoinSelect [effect-app/infra/Store]", {
-                  attributes: { "repository.container_id": containerId, "repository.model_name": name }
-                }),
+                    return v
+                  }),
+                  Effect
+                    .withSpan("Cosmos.filterJoinSelect [effect-app/infra/Store]", {
+                      attributes: { "repository.container_id": containerId, "repository.model_name": name }
+                    })
+                ),
             /**
              * May return duplicate results for "join_find", when matching more than once.
              */
@@ -265,23 +285,28 @@ function makeCosmosStore({ prefix }: StorageConfig) {
                 // This is a problem if one of the multiple joined arrays can be empty!
                 // https://stackoverflow.com/questions/60320780/azure-cosmosdb-sql-join-not-returning-results-when-the-child-contains-empty-arra
                 // so we use multiple queries instead.
-                ? filter
-                  .keys
-                  .forEachEffect((k) =>
-                    Effect
-                      .sync(() => buildFindJoinCosmosQuery(filter, k, name, skip, limit))
-                      .tap((q) => logQuery(q))
-                      .flatMap((q) =>
-                        Effect.promise(() =>
-                          container
-                            .items
-                            .query<M>(q)
-                            .fetchAll()
-                            .then(({ resources }) => resources.map((_) => ({ ...defaultValues, ..._ })))
+                ? Effect
+                  .forEach(
+                    filter
+                      .keys,
+                    (k) =>
+                      Effect
+                        .sync(() => buildFindJoinCosmosQuery(filter, k, name, skip, limit))
+                        .pipe(
+                          Effect.tap((q) => logQuery(q)),
+                          Effect
+                            .flatMap((q) =>
+                              Effect.promise(() =>
+                                container
+                                  .items
+                                  .query<M>(q)
+                                  .fetchAll()
+                                  .then(({ resources }) => resources.map((_) => ({ ...defaultValues, ..._ })))
+                              )
+                            )
                         )
-                      )
                   )
-                  .map((_) => _.flatMap((_) => _))
+                  .pipe(Effect.map((_) => _.flatMap((_) => _)))
                 : (filter.type === "new-kid"
                   ? Effect
                     .sync(() =>
@@ -296,39 +321,45 @@ function makeCosmosStore({ prefix }: StorageConfig) {
                         limit
                       )
                     )
-                    .tap((q) => logQuery(q))
-                    .flatMap((q) =>
-                      Effect.promise(() =>
-                        f.select
-                          ? container
-                            .items
-                            .query<M>(q)
-                            .fetchAll()
-                            .then(({ resources }) =>
-                              resources.map((_) => ({ ...pick(defaultValues, f.select!), ..._ }))
-                            )
-                          : container
-                            .items
-                            .query<{ f: M }>(q)
-                            .fetchAll()
-                            .then(({ resources }) => resources.map((_) => ({ ...defaultValues, ..._.f })))
-                      )
+                    .pipe(
+                      Effect.tap((q) => logQuery(q)),
+                      Effect
+                        .flatMap((q) =>
+                          Effect.promise(() =>
+                            f.select
+                              ? container
+                                .items
+                                .query<M>(q)
+                                .fetchAll()
+                                .then(({ resources }) =>
+                                  resources.map((_) => ({ ...pick(defaultValues, f.select!), ..._ }))
+                                )
+                              : container
+                                .items
+                                .query<{ f: M }>(q)
+                                .fetchAll()
+                                .then(({ resources }) => resources.map((_) => ({ ...defaultValues, ..._.f })))
+                          )
+                        )
                     )
                   : Effect
                     .sync(() => buildCosmosQuery(filter, name, importedMarkerId, defaultValues, skip, limit))
-                    .tap((q) => logQuery(q))
-                    .flatMap((q) =>
-                      Effect.promise(() =>
-                        container
-                          .items
-                          .query<{ f: M }>(q)
-                          .fetchAll()
-                          .then(({ resources }) => resources.map((_) => ({ ...defaultValues, ..._.f })))
-                      )
+                    .pipe(
+                      Effect.tap((q) => logQuery(q)),
+                      Effect
+                        .flatMap((q) =>
+                          Effect.promise(() =>
+                            container
+                              .items
+                              .query<{ f: M }>(q)
+                              .fetchAll()
+                              .then(({ resources }) => resources.map((_) => ({ ...defaultValues, ..._.f })))
+                          )
+                        )
                     )))
-                .withSpan("Cosmos.filter [effect-app/infra/Store]", {
+                .pipe(Effect.withSpan("Cosmos.filter [effect-app/infra/Store]", {
                   attributes: { "repository.container_id": containerId, "repository.model_name": name }
-                })
+                }))
             },
             find: (id) =>
               Effect
@@ -336,15 +367,19 @@ function makeCosmosStore({ prefix }: StorageConfig) {
                   container
                     .item(id, config?.partitionValue({ id } as PM))
                     .read<PM>()
-                    .then(({ resource }) => Option.fromNullable(resource).map((_) => ({ ...defaultValues, ..._ })))
+                    .then(({ resource }) =>
+                      Option.fromNullable(resource).pipe(Option.map((_) => ({ ...defaultValues, ..._ })))
+                    )
                 )
-                .withSpan("Cosmos.find [effect-app/infra/Store]", {
-                  attributes: { "repository.container_id": containerId, "repository.model_name": name }
-                }),
+                .pipe(Effect
+                  .withSpan("Cosmos.find [effect-app/infra/Store]", {
+                    attributes: { "repository.container_id": containerId, "repository.model_name": name }
+                  })),
             set: (e) =>
               Option
-                .fromNullable(e._etag)
                 .match(
+                  Option
+                    .fromNullable(e._etag),
                   {
                     onNone: () =>
                       Effect.promise(() =>
@@ -367,33 +402,38 @@ function makeCosmosStore({ prefix }: StorageConfig) {
                       )
                   }
                 )
-                .flatMap((x) => {
-                  if (x.statusCode === 412 || x.statusCode === 404) {
-                    return new OptimisticConcurrencyException({ type: name, id: e.id })
-                  }
-                  if (x.statusCode > 299 || x.statusCode < 200) {
-                    return Effect.die(
-                      new CosmosDbOperationError(
-                        "not able to update record: " + x.statusCode
-                      )
-                    )
-                  }
-                  return Effect.sync(() => ({
-                    ...e,
-                    _etag: x.etag
-                  }))
-                })
-                .withSpan("Cosmos.set [effect-app/infra/Store]", {
-                  attributes: { "repository.container_id": containerId, "repository.model_name": name }
-                }),
+                .pipe(
+                  Effect
+                    .flatMap((x) => {
+                      if (x.statusCode === 412 || x.statusCode === 404) {
+                        return new OptimisticConcurrencyException({ type: name, id: e.id })
+                      }
+                      if (x.statusCode > 299 || x.statusCode < 200) {
+                        return Effect.die(
+                          new CosmosDbOperationError(
+                            "not able to update record: " + x.statusCode
+                          )
+                        )
+                      }
+                      return Effect.sync(() => ({
+                        ...e,
+                        _etag: x.etag
+                      }))
+                    }),
+                  Effect
+                    .withSpan("Cosmos.set [effect-app/infra/Store]", {
+                      attributes: { "repository.container_id": containerId, "repository.model_name": name }
+                    })
+                ),
             batchSet,
             bulkSet,
             remove: (e: PM) =>
               Effect
                 .promise(() => container.item(e.id, config?.partitionValue(e)).delete())
-                .withSpan("Cosmos.remove [effect-app/infra/Store]", {
-                  attributes: { "repository.container_id": containerId, "repository.model_name": name }
-                })
+                .pipe(Effect
+                  .withSpan("Cosmos.remove [effect-app/infra/Store]", {
+                    attributes: { "repository.container_id": containerId, "repository.model_name": name }
+                  }))
           }
 
           // handle mock data
@@ -406,20 +446,21 @@ function makeCosmosStore({ prefix }: StorageConfig) {
             )
           )
 
-          if (!marker.isSome()) {
+          if (!Option.isSome(marker)) {
             console.log("Creating mock data for " + name)
             if (seed) {
               const m = yield* $(seed)
               yield* $(
-                Effect
-                  .succeed(m.toNonEmptyArray)
-                  .flatMapOpt((a) =>
-                    s
-                      .bulkSet(a)
-                      .orDie
-                      // we delay extra here, so that initial creation between Companies/POs also have an interval between them.
-                      .delay(Duration.millis(1100))
-                  )
+                Effect.flatMapOption(
+                  Effect.succeed(toNonEmptyArray([...m])),
+                  (a) =>
+                    s.bulkSet(a).pipe(
+                      Effect.orDie,
+                      Effect
+                        // we delay extra here, so that initial creation between Companies/POs also have an interval between them.
+                        .delay(Duration.millis(1100))
+                    )
+                )
               )
             }
             // Mark as imported
@@ -441,5 +482,5 @@ function makeCosmosStore({ prefix }: StorageConfig) {
 export function CosmosStoreLayer(cfg: StorageConfig) {
   return StoreMaker
     .toLayer(makeCosmosStore(cfg))
-    .provide(CosmosClientLayer(cfg.url.value, cfg.dbName))
+    .pipe(Layer.provide(CosmosClientLayer(Secret.value(cfg.url), cfg.dbName)))
 }