Function bulkSetInternal

packages/infra/src/Store/Cosmos.ts:193–299

(items: NonEmptyReadonlyArray<PM>, ns: string)

        yield* cached
      })
      const bulkSetInternal = (items: NonEmptyReadonlyArray<PM>, ns: string) =>
        Effect
          .gen(function*() {
            // TODO: disable batching if need atomicity
            // we delay and batch to keep low amount of RUs
            const b = [...items]
              .map(
                (x) =>
                  [
                    x,
                    Option.match(Option.fromNullishOr(x._etag), {
                      onNone: () =>
                        dropUndefinedT({
                          operationType: "Create" as const,
                          resourceBody: {
                            ...Struct.omit(x, ["_etag", idKey]),
                            id: x[idKey],
                            _partitionKey: nsPartitionValue(ns, x)
                          }
                          // don't use this or we get an error that the request and some item partition key dont match - makese no sense
                          // partitionKey: config?.partitionValue(x)
                        }),
                      onSome: (eTag) =>
                        dropUndefinedT({
                          operationType: "Replace" as const,
                          id: x[idKey],
                          resourceBody: {
                            ...Struct.omit(x, ["_etag", idKey]),
                            id: x[idKey],
                            _partitionKey: nsPartitionValue(ns, x)
                          },
                          ifMatch: eTag
                          // don't use this or we get an error that the request and some item partition key dont match - makese no sense
                          // partitionKey: config?.partitionValue(x)
                        })
                    })
                  ] as const
              )
            const batches = Array.chunksOf(b, config?.maxBulkSize ?? 10)

            const batchResult = yield* Effect.forEach(
              batches
                .map((x, i) => [i, x] as const),
              ([i, batch]) =>
                tryCosmos(() => bulk(batch.map(([, op]) => op)))
                  .pipe(
                    Effect
                      .delay(Duration.millis(i === 0 ? 0 : 150)),
                    Effect
                      .flatMap((responses) =>
                        Effect.gen(function*() {
                          const r = responses.find((x) =>
                            x.statusCode === 412 || x.statusCode === 404 || x.statusCode === 409
                          )
                          if (r) {
                            return yield* Effect.fail(
                              new OptimisticConcurrencyException(
                                {