feat(BSDA/BSFF/BSPAOH/BSVHU): rework zod transformers (sirenify/recip…

…ify) to be consistent throughout the code and better optimized. Cleanup a bit.

back/src/bsda/validation/recipify.ts

@@ -1,9 +1,10 @@
 import { getTransporterCompanyOrgId } from "@td/constants";
-import { getSealedFields } from "./rules";
 import { ParsedZodBsda } from "./schema";
-import { BsdaValidationContext, ZodBsdaTransformer } from "./types";
 import { CompanyRole } from "../../common/validation/zod/schema";
-import { buildRecipify, RecipifyInputAccessor } from "../../companies/recipify";
+import {
+  buildRecipify,
+  RecipifyInputAccessor
+} from "../../common/validation/recipify";
 
 const recipifyBsdaAccessors = (
   bsd: ParsedZodBsda,
@@ -61,12 +62,4 @@ const recipifyBsdaAccessors = (
   }
 ];
 
-export const recipifyBsda: (
-  context: BsdaValidationContext
-) => ZodBsdaTransformer = context => {
-  return async bsda => {
-    const sealedFields = await getSealedFields(bsda, context);
-    const accessors = recipifyBsdaAccessors(bsda, sealedFields);
-    return buildRecipify(accessors, bsda);
-  };
-};
+export const recipifyBsda = buildRecipify<ParsedZodBsda>(recipifyBsdaAccessors);

back/src/bsda/validation/schema.ts

@@ -32,16 +32,16 @@ import {
   fillIntermediariesOrgIds,
   fillWasteConsistenceWhenForwarding,
   emptyWorkerCertificationWhenWorkerIsDisabled,
-  updateTransporterRecepisse
+  updateTransporterRecepisse,
+  runTransformers
 } from "./transformers";
-import { sirenifyBsda, sirenifyBsdaTransporter } from "./sirenify";
+import { sirenifyBsdaTransporter } from "./sirenify";
 import {
   CompanyRole,
   foreignVatNumberSchema,
   rawTransporterSchema,
   siretSchema
 } from "../../common/validation/zod/schema";
-import { recipifyBsda } from "./recipify";
 
 const ZodBsdaPackagingEnum = z.enum([
   "BIG_BAG",
@@ -291,8 +291,7 @@ export const contextualSchemaAsync = (context: BsdaValidationContext) => {
     ? // Transformations asynchrones qui ne sont pas
       // `enableCompletionTransformers=false`;
       transformedSyncSchema
-        .transform(sirenifyBsda(context))
-        .transform(recipifyBsda(context))
+        .transform((bsda: ParsedZodBsda) => runTransformers(bsda, context))
         .transform(fillWasteConsistenceWhenForwarding)
     : transformedSyncSchema;
 

back/src/bsda/validation/sirenify.ts

@@ -4,12 +4,7 @@ import {
   nextBuildSirenify,
   NextCompanyInputAccessor
 } from "../../companies/sirenify";
-import { getSealedFields } from "./rules";
-import {
-  BsdaValidationContext,
-  ZodBsdaTransformer,
-  ZodBsdaTransporterTransformer
-} from "./types";
+import { ZodBsdaTransporterTransformer } from "./types";
 
 const sirenifyBsdaAccessors = (
   bsda: ParsedZodBsda,
@@ -91,17 +86,9 @@ const sirenifyBsdaAccessors = (
   )
 ];
 
-export const sirenifyBsda: (
-  context: BsdaValidationContext
-) => ZodBsdaTransformer = context => {
-  return async bsda => {
-    const sealedFields = await getSealedFields(bsda, context);
-    return nextBuildSirenify<ParsedZodBsda>(sirenifyBsdaAccessors)(
-      bsda,
-      sealedFields
-    );
-  };
-};
+export const sirenifyBsda = nextBuildSirenify<ParsedZodBsda>(
+  sirenifyBsdaAccessors
+);
 
 const sirenifyBsdaTransporterAccessors = (
   bsdaTransporter: ParsedZodBsdaTransporter

back/src/bsda/validation/transformers.ts

@@ -1,6 +1,27 @@
 import { prisma } from "@td/prisma";
-import { ZodBsdaTransformer, ZodBsdaTransporterTransformer } from "./types";
+import {
+  BsdaValidationContext,
+  ZodBsdaTransformer,
+  ZodBsdaTransporterTransformer
+} from "./types";
 import { recipifyTransporter } from "../../common/validation/zod/transformers";
+import { ParsedZodBsda } from "./schema";
+import { sirenifyBsda } from "./sirenify";
+import { recipifyBsda } from "./recipify";
+import { getSealedFields } from "./rules";
+
+export const runTransformers = async (
+  bsda: ParsedZodBsda,
+  context: BsdaValidationContext
+): Promise<ParsedZodBsda> => {
+  const transformers = [sirenifyBsda, recipifyBsda];
+  const sealedFields = await getSealedFields(bsda, context);
+
+  for (const transformer of transformers) {
+    bsda = await transformer(bsda, sealedFields);
+  }
+  return bsda;
+};
 
 export const fillIntermediariesOrgIds: ZodBsdaTransformer = bsda => {
   bsda.intermediariesOrgIds = bsda.intermediaries

back/src/bsdasris/recipify.ts

@@ -3,10 +3,19 @@ import {
   BsdasriRecepisseInput
 } from "../generated/graphql/types";
 import { recipifyGeneric } from "../companies/recipify";
-import {
-  autocompletedRecepisse,
-  genericGetter
-} from "../common/validation/recipify";
+
+export const autocompletedRecepisse = (
+  input: BsdasriInput,
+  recepisseInput: BsdasriRecepisseInput
+) => ({
+  ...input.transporter?.recepisse,
+  ...recepisseInput
+});
+
+const genericGetter = (input: BsdasriInput) => () =>
+  input?.transporter?.recepisse?.isExempted !== true
+    ? input?.transporter?.company
+    : null;
 
 const dasriAccessors = (input: BsdasriInput) => [
   {

back/src/bsffs/validation/bsff/recipify.ts

@@ -1,11 +1,10 @@
 import { getTransporterCompanyOrgId } from "@td/constants";
 import { ParsedZodBsff } from "./schema";
-import { BsffValidationContext, ZodBsffTransformer } from "./types";
 import { CompanyRole } from "../../../common/validation/zod/schema";
 import {
   buildRecipify,
   RecipifyInputAccessor
-} from "../../../companies/recipify";
+} from "../../../common/validation/recipify";
 
 const recipifyBsffAccessors = (
   bsd: ParsedZodBsff
@@ -43,12 +42,4 @@ const recipifyBsffAccessors = (
   )
 ];
 
-export const recipifyBsff: (
-  context: BsffValidationContext
-) => ZodBsffTransformer = () => {
-  return async bsff => {
-    // const sealedFields = await getSealedFields(bsda, context);
-    const accessors = recipifyBsffAccessors(bsff);
-    return buildRecipify(accessors, bsff);
-  };
-};
+export const recipifyBsff = buildRecipify<ParsedZodBsff>(recipifyBsffAccessors);

back/src/bsffs/validation/bsff/schema.ts

@@ -14,17 +14,17 @@ import {
 import { BsffValidationContext } from "./types";
 import { weightSchema } from "../../../common/validation/weight";
 import { WeightUnits } from "../../../common/validation";
-import { sirenifyBsff, sirenifyBsffTransporter } from "./sirenify";
+import { sirenifyBsffTransporter } from "./sirenify";
 import {
   checkAndSetPreviousPackagings,
+  runTransformers,
   updateTransporterRecepisse
 } from "./transformers";
 import {
   CompanyRole,
   rawTransporterSchema,
   siretSchema
 } from "../../../common/validation/zod/schema";
-import { recipifyBsff } from "./recipify";
 
 export const ZodWasteCodeEnum = z
   .enum(BSFF_WASTE_CODES, {
@@ -194,8 +194,7 @@ export const contextualBsffSchema = (context: BsffValidationContext) => {
 export const contextualBsffSchemaAsync = (context: BsffValidationContext) => {
   return refinedBsffSchema
     .superRefine(checkCompanies)
-    .transform(sirenifyBsff(context))
-    .transform(recipifyBsff(context))
+    .transform((bsff: ParsedZodBsff) => runTransformers(bsff, context))
     .superRefine(
       // run le check sur les champs requis après les transformations
       // au cas où des transformations auto-complète certains champs

back/src/bsffs/validation/bsff/sirenify.ts

@@ -1,18 +1,16 @@
-import { nextBuildSirenify } from "../../../companies/sirenify";
+import {
+  nextBuildSirenify,
+  NextCompanyInputAccessor
+} from "../../../companies/sirenify";
 import { CompanyInput } from "../../../generated/graphql/types";
-import { getSealedFields } from "./rules";
 import { ParsedZodBsff, ParsedZodBsffTransporter } from "./schema";
-import {
-  BsffValidationContext,
-  ZodBsffTransformer,
-  ZodBsffTransporterTransformer
-} from "./types";
+import { ZodBsffTransporterTransformer } from "./types";
 
 const sirenifyBsffAccessors = (
   bsff: ParsedZodBsff,
   // Tranformations should not be run on sealed fields
   sealedFields: string[]
-) => [
+): NextCompanyInputAccessor<ParsedZodBsff>[] => [
   {
     siret: bsff?.emitterCompanySiret,
     skip: sealedFields.includes("emitterCompanySiret"),
@@ -41,17 +39,9 @@ const sirenifyBsffAccessors = (
   }))
 ];
 
-export const sirenifyBsff: (
-  context: BsffValidationContext
-) => ZodBsffTransformer = context => {
-  return async bsff => {
-    const sealedFields = await getSealedFields(bsff, context);
-    return nextBuildSirenify<ParsedZodBsff>(sirenifyBsffAccessors)(
-      bsff,
-      sealedFields
-    );
-  };
-};
+export const sirenifyBsff = nextBuildSirenify<ParsedZodBsff>(
+  sirenifyBsffAccessors
+);
 
 const sirenifyBsffTransporterAccessors = (
   bsffTransporter: ParsedZodBsffTransporter

back/src/bsffs/validation/bsff/transformers.ts

@@ -1,7 +1,28 @@
-import { ZodBsffTransformer, ZodBsffTransporterTransformer } from "./types";
+import {
+  BsffValidationContext,
+  ZodBsffTransformer,
+  ZodBsffTransporterTransformer
+} from "./types";
 import { BsffType } from "@prisma/client";
 import { checkPreviousPackagings } from "./refinements";
 import { recipifyTransporter } from "../../../common/validation/zod/transformers";
+import { ParsedZodBsff } from "./schema";
+import { sirenifyBsff } from "./sirenify";
+import { recipifyBsff } from "./recipify";
+import { getSealedFields } from "./rules";
+
+export const runTransformers = async (
+  bsff: ParsedZodBsff,
+  context: BsffValidationContext
+): Promise<ParsedZodBsff> => {
+  const transformers = [sirenifyBsff, recipifyBsff];
+  const sealedFields = await getSealedFields(bsff, context);
+
+  for (const transformer of transformers) {
+    bsff = await transformer(bsff, sealedFields);
+  }
+  return bsff;
+};
 
 /**
  * Applique les vérifications sur les contenants à réexpédier / grouper / reconditionner puis applique

back/src/bspaoh/validation/recipify.ts

@@ -0,0 +1,41 @@
+import { getTransporterCompanyOrgId } from "@td/constants";
+import { CompanyRole } from "../../common/validation/zod/schema";
+import {
+  buildRecipify,
+  RecipifyInputAccessor
+} from "../../common/validation/recipify";
+import { ZodFullBspaoh } from "./schema";
+
+const recipifyBspaohAccessors = (
+  bsd: ZodFullBspaoh,
+  // Tranformations should not be run on sealed fields
+  sealedFields: string[]
+): RecipifyInputAccessor<ZodFullBspaoh>[] => [
+  {
+    role: CompanyRole.Transporter,
+    skip: sealedFields.includes("transporterRecepisseNumber"),
+    orgIdGetter: () => {
+      const orgId = getTransporterCompanyOrgId({
+        transporterCompanySiret: bsd.transporterCompanySiret ?? null,
+        transporterCompanyVatNumber: bsd.transporterCompanyVatNumber ?? null
+      });
+      return orgId ?? null;
+    },
+    setter: async (bspaoh: ZodFullBspaoh, receipt) => {
+      if (bspaoh.transporterRecepisseIsExempted) {
+        bspaoh.transporterRecepisseNumber = null;
+        bspaoh.transporterRecepisseValidityLimit = null;
+        bspaoh.transporterRecepisseDepartment = null;
+      } else {
+        bspaoh.transporterRecepisseNumber = receipt?.receiptNumber ?? null;
+        bspaoh.transporterRecepisseValidityLimit =
+          receipt?.validityLimit ?? null;
+        bspaoh.transporterRecepisseDepartment = receipt?.department ?? null;
+      }
+    }
+  }
+];
+
+export const recipifyBspaoh = buildRecipify<ZodFullBspaoh>(
+  recipifyBspaohAccessors
+);

back/src/bspaoh/validation/sirenify.ts

@@ -1,4 +1,7 @@
-import { nextBuildSirenify } from "../../companies/sirenify";
+import {
+  nextBuildSirenify,
+  NextCompanyInputAccessor
+} from "../../companies/sirenify";
 import { CompanyInput } from "../../generated/graphql/types";
 
 import { ZodFullBspaoh } from "./schema";
@@ -10,7 +13,7 @@ type SiretInfos = {
 const accessors = (
   input: ZodFullBspaoh,
   sealedFields: string[] // Transformations should not be run on sealed fields
-) => {
+): NextCompanyInputAccessor<ZodFullBspaoh>[] => {
   return [
     {
       siret: input?.emitterCompanySiret,

back/src/bspaoh/validation/transformers.ts

@@ -1,7 +1,6 @@
-import { prisma } from "@td/prisma";
-import { ZodBspaohTransporter, ZodFullBspaoh } from "./schema";
+import { ZodFullBspaoh } from "./schema";
 import { sirenify } from "./sirenify";
-import { getTransporterCompanyOrgId } from "@td/constants";
+import { recipifyBspaoh } from "./recipify";
 
 /**
  *
@@ -12,40 +11,9 @@ export const runTransformers = async (
   val: ZodFullBspaoh,
   sealedFields: string[] // Transformations should not be run on sealed fields
 ): Promise<ZodFullBspaoh> => {
-  const transformers = [sirenify, recipisseTransporterTransformer];
+  const transformers = [sirenify, recipifyBspaoh];
   for (const transformer of transformers) {
     val = await transformer(val, sealedFields);
   }
   return val;
 };
-
-async function recipisseTransporterTransformer(
-  val: ZodBspaohTransporter,
-  sealedFields: string[]
-): Promise<ZodBspaohTransporter> {
-  if (sealedFields.includes("transporterCompanySiret")) {
-    return val;
-  }
-
-  const orgId = getTransporterCompanyOrgId({
-    transporterCompanySiret: val.transporterCompanySiret ?? null,
-    transporterCompanyVatNumber: val.transporterCompanyVatNumber ?? null
-  });
-
-  if (!val.transporterRecepisseIsExempted && orgId) {
-    const transporterReceipt = await prisma.company
-      .findUnique({
-        where: {
-          orgId
-        }
-      })
-      .transporterReceipt();
-
-    val.transporterRecepisseNumber = transporterReceipt?.receiptNumber ?? null;
-    val.transporterRecepisseValidityLimit =
-      transporterReceipt?.validityLimit ?? null;
-    val.transporterRecepisseDepartment = transporterReceipt?.department ?? null;
-  }
-
-  return val;
-}

back/src/bsvhu/validation/__tests__/validation.integration.ts

@@ -19,7 +19,6 @@ import { getCurrentSignatureType, prismaToZodBsvhu } from "../helpers";
 import { parseBsvhu, parseBsvhuAsync } from "..";
 import { ZodError } from "zod";
 import { CompanyRole } from "../../../common/validation/zod/schema";
-import { prisma } from "@td/prisma";
 
 const searchResult = (companyName: string) => {
   return {