[IP-387] Upgrade fp-ts

UserDataProcessingCheckLastStatusActivity/__tests__/handler.test.ts

@@ -16,7 +16,8 @@ import {
 } from "../handler";
 
 import { none, some } from "fp-ts/lib/Option";
-import { fromEither, fromLeft } from "fp-ts/lib/TaskEither";
+import * as TE from "fp-ts/lib/TaskEither";
+import * as E from "fp-ts/lib/Either";
 import { UserDataProcessingModel } from "@pagopa/io-functions-commons/dist/src/models/user_data_processing";
 import { toCosmosErrorResponse } from "@pagopa/io-functions-commons/dist/src/utils/cosmosdb_model";
 
@@ -26,7 +27,7 @@ describe("UserDataProcessingCheckLastStatusActivity", () => {
   it("should handle a result", async () => {
     const mockModel = ({
       findLastVersionByModelId: jest.fn(() =>
-        fromEither(right(some(aUserDataProcessing)))
+        TE.fromEither(right(some(aUserDataProcessing)))
       )
     } as any) as UserDataProcessingModel;
 
@@ -40,16 +41,18 @@ describe("UserDataProcessingCheckLastStatusActivity", () => {
     const result = await handler(contextMock, input);
 
     const decodedResult = ActivityResultSuccess.decode(result);
-    expect(decodedResult.isRight()).toBe(true);
-    expect(decodedResult.value).toEqual({
-      kind: "SUCCESS",
-      value: aUserDataProcessingStatus
-    });
+    expect(E.isRight(decodedResult)).toBe(true);
+    if (E.isRight(decodedResult)) {
+      expect(decodedResult.right).toEqual({
+        kind: "SUCCESS",
+        value: aUserDataProcessingStatus
+      });
+    }
   });
 
   it("should handle a record not found failure", async () => {
     const mockModel = ({
-      findLastVersionByModelId: jest.fn(() => fromEither(right(none)))
+      findLastVersionByModelId: jest.fn(() => TE.fromEither(right(none)))
     } as any) as UserDataProcessingModel;
 
     const handler = createUserDataProcessingCheckLastStatusActivityHandler(
@@ -61,13 +64,13 @@ describe("UserDataProcessingCheckLastStatusActivity", () => {
     };
     const result = await handler(contextMock, input);
 
-    expect(ActivityResultNotFoundFailure.decode(result).isRight()).toBe(true);
+    expect(E.isRight(ActivityResultNotFoundFailure.decode(result))).toBe(true);
   });
 
   it("should handle a query error", async () => {
     const mockModel = ({
       findLastVersionByModelId: jest.fn(() =>
-        fromLeft(toCosmosErrorResponse({ kind: "COSMOS_ERROR_RESPONSE" }))
+        TE.left(toCosmosErrorResponse({ kind: "COSMOS_ERROR_RESPONSE" }))
       )
     } as any) as UserDataProcessingModel;
 
@@ -80,12 +83,12 @@ describe("UserDataProcessingCheckLastStatusActivity", () => {
     };
     const result = await handler(contextMock, input);
 
-    expect(ActivityResultQueryFailure.decode(result).isRight()).toBe(true);
+    expect(E.isRight(ActivityResultQueryFailure.decode(result))).toBe(true);
   });
 
   it("should handle a rejection", async () => {
     const mockModel = ({
-      findLastVersionByModelId: jest.fn(() => fromEither(right(none)))
+      findLastVersionByModelId: jest.fn(() => TE.fromEither(right(none)))
     } as any) as UserDataProcessingModel;
 
     const handler = createUserDataProcessingCheckLastStatusActivityHandler(
@@ -97,7 +100,7 @@ describe("UserDataProcessingCheckLastStatusActivity", () => {
     };
     const result = await handler(contextMock, input);
 
-    expect(ActivityResultNotFoundFailure.decode(result).isRight()).toBe(true);
+    expect(E.isRight(ActivityResultNotFoundFailure.decode(result))).toBe(true);
   });
 
   it("should handle an invalid input", async () => {
@@ -112,7 +115,7 @@ describe("UserDataProcessingCheckLastStatusActivity", () => {
       invalid: "input"
     });
 
-    expect(ActivityResultInvalidInputFailure.decode(result).isRight()).toBe(
+    expect(E.isRight(ActivityResultInvalidInputFailure.decode(result))).toBe(
       true
     );
   });

UserDataProcessingCheckLastStatusActivity/handler.ts

@@ -7,8 +7,10 @@ import {
 } from "@pagopa/io-functions-commons/dist/src/models/user_data_processing";
 import { readableReport } from "@pagopa/ts-commons/lib/reporters";
 import { FiscalCode } from "@pagopa/ts-commons/lib/strings";
-import { identity } from "fp-ts/lib/function";
-import { fromEither, fromLeft, taskEither } from "fp-ts/lib/TaskEither";
+import { flow, pipe } from "fp-ts/lib/function";
+import * as O from "fp-ts/lib/Option";
+import * as E from "fp-ts/lib/Either";
+import * as TE from "fp-ts/lib/TaskEither";
 import * as t from "io-ts";
 import { getMessageFromCosmosErrors } from "../utils/conversions";
 
@@ -75,45 +77,47 @@ export const createUserDataProcessingCheckLastStatusActivityHandler = (
   _: Context,
   input: unknown
 ): Promise<ActivityResult> =>
-  fromEither(ActivityInput.decode(input))
-    .mapLeft<ActivityResultFailure>((reason: t.Errors) =>
+  pipe(
+    input,
+    ActivityInput.decode,
+    E.mapLeft((reason: t.Errors) =>
       ActivityResultInvalidInputFailure.encode({
         kind: "INVALID_INPUT_FAILURE",
         reason: readableReport(reason)
       })
-    )
-    .chain(({ choice, fiscalCode }) =>
-      userDataProcessingModel
-        .findLastVersionByModelId([
+    ),
+    TE.fromEither,
+    TE.chainW(({ choice, fiscalCode }) =>
+      pipe(
+        userDataProcessingModel.findLastVersionByModelId([
           makeUserDataProcessingId(choice, fiscalCode),
           fiscalCode
-        ])
-        .foldTaskEither<ActivityResultFailure, UserDataProcessingStatus>(
-          error =>
-            fromLeft(
-              ActivityResultQueryFailure.encode({
-                kind: "QUERY_FAILURE",
-                query: "findOneUserDataProcessingById",
-                reason: `${error.kind}, ${getMessageFromCosmosErrors(error)}`
+        ]),
+        TE.mapLeft(error =>
+          ActivityResultQueryFailure.encode({
+            kind: "QUERY_FAILURE",
+            query: "findOneUserDataProcessingById",
+            reason: `${error.kind}, ${getMessageFromCosmosErrors(error)}`
+          })
+        ),
+        TE.chainW(
+          flow(
+            O.map(r => r.status),
+            E.fromOption(() =>
+              ActivityResultNotFoundFailure.encode({
+                kind: "NOT_FOUND_FAILURE"
               })
             ),
-          maybeRecord =>
-            maybeRecord.fold(
-              fromLeft(
-                ActivityResultNotFoundFailure.encode({
-                  kind: "NOT_FOUND_FAILURE"
-                })
-              ),
-              r => taskEither.of(r.status)
-            )
+            TE.fromEither
+          )
         )
-    )
-    .map(status =>
+      )
+    ),
+    TE.map(status =>
       ActivityResultSuccess.encode({
         kind: "SUCCESS",
         value: status
       })
-    )
-    .mapLeft(identity)
-    .run()
-    .then(e => e.value);
+    ),
+    TE.toUnion
+  )();

UserDataProcessingFindFailureReasonActivity/__tests__/handler.test.ts

@@ -1,24 +1,16 @@
-import { right } from "fp-ts/lib/Either";
 import { context as contextMock } from "../../__mocks__/functions";
-import {
-  aFiscalCode,
-  aUserDataProcessing,
-  aUserDataProcessingStatus
-} from "../../__mocks__/mocks";
+import { aFiscalCode, aUserDataProcessing } from "../../__mocks__/mocks";
 
 import {
   ActivityInput,
   ActivityResultInvalidInputFailure,
   ActivityResultNotFoundFailure,
-  ActivityResultQueryFailure,
   ActivityResultSuccess,
   getFindFailureReasonActivityHandler
 } from "../handler";
 
-import { none, some } from "fp-ts/lib/Option";
-import { fromEither, fromLeft } from "fp-ts/lib/TaskEither";
+import * as E from "fp-ts/lib/Either";
 import { UserDataProcessingModel } from "@pagopa/io-functions-commons/dist/src/models/user_data_processing";
-import { toCosmosErrorResponse } from "@pagopa/io-functions-commons/dist/src/utils/cosmosdb_model";
 import { DurableOrchestrationStatus } from "durable-functions/lib/src/durableorchestrationstatus";
 
 const aChoice = aUserDataProcessing.choice;
@@ -59,11 +51,13 @@ describe("UserDataProcessingFindFailureReasonActivity", () => {
     );
 
     const decodedResult = ActivityResultSuccess.decode(result);
-    expect(decodedResult.isRight()).toBe(true);
-    expect(decodedResult.value).toEqual({
-      kind: "SUCCESS",
-      value: JSON.stringify(failedOrchestratorOutput, (key, value) => value)
-    });
+    expect(E.isRight(decodedResult)).toBe(true);
+    if (E.isRight(decodedResult)) {
+      expect(decodedResult.right).toEqual({
+        kind: "SUCCESS",
+        value: JSON.stringify(failedOrchestratorOutput, (key, value) => value)
+      });
+    }
   });
 
   it("should handle a record not found failure", async () => {
@@ -82,7 +76,7 @@ describe("UserDataProcessingFindFailureReasonActivity", () => {
       input
     );
 
-    expect(ActivityResultNotFoundFailure.decode(result).isRight()).toBe(true);
+    expect(E.isRight(ActivityResultNotFoundFailure.decode(result))).toBe(true);
   });
 
   it("should handle an invalid input", async () => {
@@ -93,7 +87,7 @@ describe("UserDataProcessingFindFailureReasonActivity", () => {
       invalid: "input"
     });
 
-    expect(ActivityResultInvalidInputFailure.decode(result).isRight()).toBe(
+    expect(E.isRight(ActivityResultInvalidInputFailure.decode(result))).toBe(
       true
     );
   });

UserDataProcessingFindFailureReasonActivity/handler.ts

@@ -6,9 +6,9 @@ import {
 } from "@pagopa/io-functions-commons/dist/generated/definitions/UserDataProcessingChoice";
 import { FiscalCode, NonEmptyString } from "@pagopa/ts-commons/lib/strings";
 import * as t from "io-ts";
-import { fromEither, tryCatch } from "fp-ts/lib/TaskEither";
-import { identity } from "fp-ts/lib/function";
-import { fromNullable } from "fp-ts/lib/Either";
+import * as TE from "fp-ts/lib/TaskEither";
+import { pipe } from "fp-ts/lib/function";
+import * as E from "fp-ts/lib/Either";
 import { makeOrchestratorId as makeDownloadOrchestratorId } from "../UserDataDownloadOrchestrator/utils";
 import { makeOrchestratorId as makeDeleteOrchestratorId } from "../UserDataDeleteOrchestrator/utils";
 
@@ -82,48 +82,54 @@ export type ActivityResult = t.TypeOf<typeof ActivityResult>;
 export const getFindFailureReasonActivityHandler = async (
   context: Context,
   input: unknown
-): Promise<ActivityResult> => {
-  const client = df.getClient(context);
-
-  return fromEither(ActivityInput.decode(input))
-    .mapLeft(_ =>
+): Promise<ActivityResult> =>
+  pipe(
+    input,
+    ActivityInput.decode,
+    TE.fromEither,
+    TE.mapLeft(_ =>
       ActivityResultFailure.encode({
         kind: "INVALID_INPUT_FAILURE",
         reason: "Input not valid for this activity"
       })
-    )
-    .chain(({ choice, fiscalCode }) => {
+    ),
+    TE.chain(({ choice, fiscalCode }) => {
       // create failed orchestrator id based on choice
       const failedUserDataProcessingOrchestratorId =
         choice === UserDataProcessingChoiceEnum.DELETE
           ? makeDeleteOrchestratorId(fiscalCode)
           : makeDownloadOrchestratorId(fiscalCode);
 
-      return tryCatch(
+      return TE.tryCatch(
         () =>
           // get the status of the failed orchestrator
-          client.getStatus(failedUserDataProcessingOrchestratorId),
+          df
+            .getClient(context)
+            .getStatus(failedUserDataProcessingOrchestratorId),
         () =>
           ActivityResultFailure.encode({
             kind: "NOT_FOUND_FAILURE"
           })
       );
-    })
-    .fold(identity, orchestratorStatus =>
-      fromNullable("No reason found")(orchestratorStatus.output)
-        .map(o =>
+    }),
+    TE.map(orchestratorStatus =>
+      pipe(
+        orchestratorStatus.output,
+        E.fromNullable("No reason found"),
+        E.map(o =>
           ActivityResultSuccess.encode({
             kind: "SUCCESS",
-            value: JSON.stringify(o, (key, value) => value) as NonEmptyString
+            value: JSON.stringify(o, (_, value) => value) as NonEmptyString
           })
-        )
-        .mapLeft(e =>
+        ),
+        E.mapLeft(e =>
           ActivityResultSuccess.encode({
             kind: "SUCCESS",
-            value: JSON.stringify(e, (key, value) => value) as NonEmptyString
+            value: JSON.stringify(e, (_, value) => value) as NonEmptyString
           })
-        )
-        .fold<ActivityResult>(identity, identity)
-    )
-    .run();
-};
+        ),
+        E.toUnion
+      )
+    ),
+    TE.toUnion
+  )();

UserDataProcessingProcessFailedRecords/__tests__/handler.test.ts

@@ -7,7 +7,7 @@ import { UserDataProcessingStatusEnum } from "@pagopa/io-functions-commons/dist/
 import { FiscalCode } from "@pagopa/ts-commons/lib/strings";
 import { processFailedUserDataProcessingHandler } from "../handler";
 import { SqlQuerySpec, FeedOptions } from "@azure/cosmos";
-import { tryCatch2v } from "fp-ts/lib/Either";
+import * as E from "fp-ts/lib/Either";
 import { Branded } from "io-ts";
 import { NonNegativeInteger } from "@pagopa/ts-commons/lib/numbers";
 import * as t from "io-ts";
@@ -137,7 +137,7 @@ const recordsIterator = (query: string | SqlQuerySpec) => ({
       // and keep the asynchrounous behaviour
       await new Promise(resolve => setTimeout(resolve, 100));
       yield [
-        tryCatch2v(
+        E.tryCatch(
           () =>
             recordMock(
               record.choice,