chore: update

Author: joshunrau

apps/web/src/utils/upload.ts

@@ -600,87 +600,6 @@ function interpretZodObjectValue(
   }
 }
 
-function formatTypeInfo(s: string, isOptional: boolean) {
-  return isOptional ? `${s} (optional)` : s;
-}
-
-function generateSampleData({
-  enumValues,
-  isOptional,
-  multiKeys,
-  multiValues,
-  typeName
-}: Extract<Exclude<ZodTypeNameResult, 'ZodEffects'>, { success: true }>) {
-  switch (typeName) {
-    case 'ZodBoolean':
-      return formatTypeInfo('true/false', isOptional);
-    case 'ZodDate':
-      return formatTypeInfo('yyyy-mm-dd', isOptional);
-    case 'ZodNumber':
-      return formatTypeInfo('number', isOptional);
-    case 'ZodSet':
-      try {
-        if (enumValues) return formatTypeInfo(`SET(${enumValues.join('/')}, ...)`, isOptional);
-
-        return formatTypeInfo('SET(a,b,c)', isOptional);
-      } catch {
-        throw new Error(
-          `Failed to generate sample data for ZodSet / Échec de la génération de données d'exemple pour ZodSet`
-        );
-      }
-
-    case 'ZodString':
-      return formatTypeInfo('string', isOptional);
-    case 'ZodEnum':
-      try {
-        let possibleEnumOutputs = '';
-        for (const val of enumValues!) {
-          possibleEnumOutputs += val + '/';
-        }
-        possibleEnumOutputs = possibleEnumOutputs.slice(0, -1);
-        return formatTypeInfo(possibleEnumOutputs, isOptional);
-      } catch {
-        throw new Error('Invalid Enum error / Erreur Enum invalide');
-      }
-    case 'ZodArray':
-    case 'ZodObject':
-      try {
-        let multiString = 'RECORD_ARRAY( ';
-        if (multiValues && multiKeys) {
-          for (let i = 0; i < multiValues.length; i++) {
-            const inputData = multiValues[i];
-            // eslint-disable-next-line max-depth
-            if (!inputData?.success) {
-              console.error({ inputData });
-              throw new Error(
-                `input data is undefined or unsuccessful / les données d'entrée ne sont pas définies ou ne sont pas réussies`
-              );
-            }
-            // eslint-disable-next-line max-depth
-            if (i === multiValues.length - 1 && multiValues[i] !== undefined) {
-              multiString += multiKeys[i] + ':' + generateSampleData(inputData);
-            } else {
-              multiString += multiKeys[i] + ':' + generateSampleData(inputData) + ',';
-            }
-          }
-          multiString += ';)';
-        }
-        return multiString;
-      } catch (e) {
-        if (e instanceof Error && e.message.includes('input data is undefined or unsuccessful')) {
-          throw new Error(
-            "Unsuccessful input data transfer or undefined data / Transfert de données d'entrée non réussi ou données non définies"
-          );
-        }
-
-        throw new Error("Invalid Record Array Error / Erreur de tableau d'enregistrements invalide");
-      }
-    default:
-      throw new Error(
-        `Invalid zod schema: unexpected type name '${typeName satisfies never}' / Schéma zod invalide : nom de type inattendu '${typeName satisfies never}'`
-      );
-  }
-}
 function jsonToZod(givenType: unknown): RequiredZodTypeName {
   if (typeof givenType === 'string') {
     switch (givenType) {

apps/web/src/utils/upload2.ts

@@ -103,8 +103,38 @@ namespace Zod3 {
     return isZodArrayDef(def) && isZodObject(def.type);
   }
 
-  function interpetZodArray(..._args: any[]): ZodTypeNameResult {
-    return null!;
+  function interpretZodArray(def: ZodObjectArrayDef, isOptional?: boolean): ZodTypeNameResult {
+    const listOfZodElements: ZodTypeNameResult[] = [];
+    const listOfZodKeys: string[] = [];
+
+    const shape = def.type.shape as { [key: string]: z3.ZodTypeAny };
+
+    for (const [key, insideType] of Object.entries(shape)) {
+      const def: unknown = insideType._def;
+      if (isZodTypeDef(def)) {
+        const innerTypeName = getZodTypeName(insideType);
+        listOfZodElements.push(innerTypeName);
+        listOfZodKeys.push(key);
+      } else {
+        console.error({ def });
+        throw new UploadError({
+          en: `Unhandled case!`,
+          fr: `Cas non géré !`
+        });
+      }
+    }
+    if (listOfZodElements.length === 0) {
+      throw new UploadError({
+        en: 'Failure to interpret Zod Object or Array',
+        fr: "Échec de l'interprétation de l'objet ou du tableau Zod"
+      });
+    }
+    return {
+      isOptional: Boolean(isOptional),
+      multiKeys: listOfZodKeys,
+      multiValues: listOfZodElements,
+      typeName: def.typeName
+    };
   }
 
   function getZodTypeName(schema: z3.ZodTypeAny, isOptional?: boolean): ZodTypeNameResult {
@@ -121,7 +151,7 @@ namespace Zod3 {
         typeName: def.typeName
       };
     } else if (isZodObjectArrayDef(def)) {
-      return interpetZodArray(schema, def.typeName, isOptional);
+      return interpretZodArray(def, isOptional);
     } else if (isZodSetDef(def)) {
       const innerDef: unknown = def.valueType._def;
       if (!isZodTypeDef(innerDef)) {